

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Fórmulas
<a name="workingcookbook-installingcustom-components-recipes"></a>

**Importante**  
O AWS OpsWorks Stacks serviço chegou ao fim da vida útil em 26 de maio de 2024 e foi desativado para clientes novos e existentes. É altamente recomendável que os clientes migrem suas cargas de trabalho para outras soluções o mais rápido possível. Se você tiver dúvidas sobre migração, entre em contato com a AWS Support equipe no [AWS re:POST](https://repost.aws/) ou por meio do Premium [AWS Support](https://aws.amazon.com/support).

Receitas são aplicações Ruby que definem a configuração de um sistema. Elas instalam pacotes, criam arquivos de configuração a partir de modelos, executam comandos de shell, criam arquivos e diretórios, e assim por diante. Normalmente, você faz com que OpsWorks as pilhas executem receitas automaticamente quando um [evento de ciclo](workingcookbook-events.md) de vida ocorre na instância, mas você também pode executá-las explicitamente a qualquer momento usando o comando [Execute Recipes](workingcookbook-executing.md) stack. Para obter mais informações, consulte [Sobre receitas](http://docs.chef.io/recipes.html).

Uma receita geralmente consiste em grande parte *de uma série de recursos*, cada um dos quais representa o estado desejado de um aspecto do sistema. Cada recurso inclui um conjunto de atributos que define o estado desejado e especifica qual ação deve ser executada. O Chef associa cada recurso a um *provedor apropriado* que executa a ação. Para obter mais informações, consulte [Referência de recursos e provedores](https://docs.chef.io/resource.html).

Um recurso `package` ajuda a gerenciar pacotes de software em instâncias do Linux. O exemplo a seguir instala o pacote do Apache.

```
...
package 'apache2' do
  case node[:platform]
  when 'centos','redhat','fedora','amazon'
    package_name 'httpd'
  when 'debian','ubuntu'
    package_name 'apache2'
  end
  action :install
end
...
```

O Chef usa o provedor de pacote apropriado para a plataforma. Muitas vezes, um valor é atribuído aos recursos de atributo, mas é possível usar as operações lógicas de Ruby para executar atribuições condicionais. O exemplo mostra um operador `case` que utiliza `node[:platform]` para identificar a instância do sistema operacional e define o atributo `package_name` apropriadamente. Os atributos podem ser inseridos em uma receita, usando a sintaxe do nó padrão do Chef e o Chef a substitui com o valor associado. Além dos atributos de receita, qualquer atributo pode ser utilizado no nó do objeto.

Após determinar o nome do pacote, o segmento de código termina com uma ação `install` que instala o pacote. Outras ações para este recurso incluem `upgrade` e `remove`. Para obter mais informações, consulte: [pacote](https://docs.chef.io/chef/resources.html#id150).

Muitas vezes é útil separar tarefas complexas de instalação e configuração em uma ou mais subtarefas, cada uma implementada como uma receita separada para executar sua receita primária no momento apropriado. O exemplo a seguir mostra a linha de código que segue o exemplo anterior:

```
include_recipe 'apache2::service'
```

Para que uma receita execute uma receita criança, use a palavra-chave `include_recipe` seguida pelo nome da receita. As receitas são identificadas através da utilização da sintaxe padrão do Chef `CookbookName::RecipeName`, em que `RecipeName` omite a extensão `.rb`.

**nota**  
Uma declaração `include_recipe` executa efetivamente a receita nessa etapa na receita principal. No entanto, o que de fato acontece é que o Chef substitui cada declaração `include_recipe` com o código especificado da receita, antes que ele execute a receita principal.

Um recurso `directory` representa um diretório, como aquele que contém os arquivos do pacote. O seguinte recurso `default.rb` cria um diretório de log do Linux.

```
directory node[:apache][:log_dir] do
    mode 0755
    action :create
end
```

O diretório de log é definido em um dos arquivos de atributo de receitas. O recurso especifica o modo do diretório como 0755, e usa uma ação `create` para criar o diretório. Para obter mais informações, consulte [diretório](https://docs.chef.io/chef/resources.html#directory). Esse recurso também pode ser usado com instâncias do Windows.

O recurso `execute` representa comandos, tais como comandos de shell ou scripts. O exemplo a seguir gera arquivos de module.load.

```
execute 'generate-module-list' do
  if node[:kernel][:machine] == 'x86_64'
    libdir = 'lib64'
  else
    libdir = 'lib'
  end
  command "/usr/local/bin/apache2_module_conf_generate.pl /usr/#{libdir}/httpd/modules /etc/httpd/mods-available"
  action :run
end
```

O primeiro recurso determina o tipo de CPU. `[:kernel][:machine]` é outro atributo automático que o Chef gera para representar diversas propriedades do sistema, nesse caso, o tipo de CPU. Em seguida, ele especifica o comando, um script Perl e usa uma ação `run` para executar o script, o que gera arquivos de module.load. Para obter mais informações, consulte [execute](https://docs.chef.io/chef/resources.html#execute).

Um recurso `template` representa um arquivo, normalmente um arquivo de configuração, que deve ser gerado a partir de um dos arquivos de modelo do livro de receitas. O exemplo a seguir cria um arquivo de configuração `httpd.conf` a partir do modelo `apache2.conf.erb`, discutido em [Modelos](workingcookbook-installingcustom-components-templates.md).

```
template 'apache2.conf' do
  case node[:platform]
  when 'centos','redhat','fedora','amazon'
    path "#{node[:apache][:dir]}/conf/httpd.conf"
  when 'debian','ubuntu'
    path "#{node[:apache][:dir]}/apache2.conf"
  end
  source 'apache2.conf.erb'
  owner 'root'
  group 'root'
  mode 0644
  notifies :restart, resources(:service => 'apache2')
end
```

O recurso determina o nome e a localização do arquivo gerado, baseando-se na instância do sistema operacional. Em seguida, ele especifica `apache2.conf.erb` como o modelo a ser usado para gerar o arquivo e define o proprietário do arquivo, o grupo, e o modo. Ele executa a ação `notify` para notificar o recurso `service` que representa o servidor Apache para reiniciar o servidor. Para obter mais informações, consulte [modelo](https://docs.chef.io/chef/resources.html#template).