

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á.

# Etapa 3: criar e implantar um livro de receitas personalizado
<a name="other-services-redis-cookbook"></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).

Do jeito que está, a pilha não é muito funcional ainda. É necessário habilitar seu aplicativo para acessar o servidor Redis. A abordagem mais flexível é colocar um arquivo YAML com as informações de acesso na subpasta `config` do aplicativo. Então, o aplicativo pode obter as informações do arquivo. Usando essa abordagem, você pode alterar as informações de conexão sem reescrever e reimplantar o aplicativo. Para este exemplo, o arquivo deve ser chamado `redis.yml`e conter o nome do host e a porta do cluster do ElastiCache , da seguinte forma:

```
host: cache-cluster-hostname
port: cache-cluster-port
```

Você pode copiar manualmente esse arquivo para seus servidores, mas uma abordagem melhor é implementar uma *receita* do Chef para gerar o arquivo e fazer com que o OpsWorks Stacks execute a receita em cada servidor. As receitas do Chef são aplicativos Ruby especializados que o OpsWorks Stacks usa para realizar tarefas em instâncias, como instalar pacotes ou criar arquivos de configuração. Receitas são incluídos em um *livro de receitas*, que pode conter várias receitas e arquivos relacionados, como modelos para arquivos de configuração. O livro de receitas é colocado em um repositório, como GitHub, e deve ter uma estrutura de diretórios padrão. Se você ainda não tem um repositório personalizado de livros de receitas, consulte [Repositórios de livro de receitas](workingcookbook-installingcustom-repo.md) para informações sobre como configurar um.

Para este exemplo, adicione um livro de receitas chamado `redis-config` em seu repositório de livros de receitas com o seguinte conteúdo:

```
my_cookbook_repository
  redis-config
    recipes
      generate.rb
    templates
      default
        redis.yml.erb
```

A pasta `recipes` contém uma receita chamada `generate.rb`, que gera o arquivo de configuração do aplicativo a partir de `redis.yml.erb`, da seguinte forma:

```
node[:deploy].each do |app_name, deploy_config|
  # determine root folder of new app deployment
  app_root = "#{deploy_config[:deploy_to]}/current"

  # use template 'redis.yml.erb' to generate 'config/redis.yml'
  template "#{app_root}/config/redis.yml" do
    source "redis.yml.erb"
    cookbook "redis-config"

    # set mode, group and owner of generated file
    mode "0660"
    group deploy_config[:group]
    owner deploy_config[:user]

    # define variable “@redis” to be used in the ERB template
    variables(
      :redis => deploy_config[:redis] || {}
    )

    # only generate a file if there is Redis configuration
    not_if do
      deploy_config[:redis].blank?
    end
  end
end
```

A receita depende dos dados do objeto [JSON de configuração e implantação da pilha OpsWorks Stacks](workingcookbook-json.md), que é instalado em cada instância e contém informações detalhadas sobre a pilha e quaisquer aplicativos implantados. O nó `deploy` do objeto tem a seguinte estrutura:

```
{
   ...
  "deploy": {
    "app1": {
      "application" : "short_name",
      ...
    }
    "app2": {
      ...
    }
    ...
  }
}
```

O nó de implantação contém um conjunto de objetos JSON incorporados, um para cada aplicativo implementado, que é chamado pelo nome curto do aplicativo. Cada objeto do aplicativo contém um conjunto de atributos que definem a configuração do aplicativo, como a raiz do documento e o tipo de aplicativo. Para uma lista de atributos de implantação, consulte [Atributos deploy](attributes-json-deploy.md). As receitas podem usar a sintaxe de atributos do Chef para representar valores JSON de configuração e implantação da pilha. Por exemplo,`[:deploy][:app1][:application]` representa o nome curto do aplicativo app1. 

Para cada aplicativo em `[:deploy]`, a receita executa o bloco de código associado, em que `deploy_config` representa o atributo do aplicativo. A receita define primeiro `app_root` para o diretório raiz do aplicativo, `[:deploy][:app_name][:deploy_to]/current`. Em seguida, usa um [modelo de recurso](https://docs.chef.io/chef/resources.html#template) do Chef para gerar um arquivo de configuração a partir de `redis.yml.erb` e colocá-lo em `app_root/config`.

 Os arquivos de configuração normalmente são criados a partir de modelos, com muitas, se não a maioria, das configurações definidas pelos *atributos* do Chef. Com atributos personalizados, você pode alterar as configurações usando JSON personalizado, conforme descrito posteriormente, em vez de reescrever o arquivo de modelo. O modelo `redis.yml.erb` contém o seguinte:

```
host: <%= @redis[:host] %>
port: <%= @redis[:port] || 6379 %>
```

Os elementos <%... %> são espaços reservados que representam um valor de atributo.
+ `<%= @redis[:host] %>` representa o valor de `redis[:host]`, que é o nome de host do cluster de cache.
+ `<%= @redis[:port] || 6379 %>` representa o valor de `redis[:port]` ou, se esse atributo não estiver definido, o valor da porta padrão, 6379.

O recurso `template` funciona da seguinte forma:
+ `source` e `cookbook` especificam o modelo e os nomes de livros de receitas, respectivamente.
+ `mode`, `group`e `owner` fornecem o arquivo de configuração os mesmos direitos de acesso do aplicativo.
+ A seção `variables` define a variável `@redis` usada no modelo, para o valor do atributo `[:redis]` do aplicativo.

  Os valores do atributo `[:redis]` são definidos usando um JSON personalizado, conforme descrito posteriormente. Ele não é um dos atributos de aplicativo padrão.
+ A diretiva `not_if` garante que a receita não gere um arquivo de configuração se já existir outro.

Depois de criar o livro de receitas, você deve implantá-lo no cache do livro de receitas de cada instância. Essa operação não executa a receita; ela simplesmente instala o novo livro de receitas nas instâncias da pilha. Normalmente, você executa uma receita atribuindo-a a um evento de ciclo de vida da camada , conforme descrito posteriormente.

**Para implantar seu livro de receitas personalizado**

1. **Na página OpsWorks Stacks **Stack**, clique em **Configurações da pilha e depois** em Editar.**

1. Na seção **Configuration Management**, defina **Use custom Chef cookbooks** como **Yes**, insira as informações do repositório do livro de receitas e clique em **Save** para atualizar as configurações da pilha.  
![\[Configuration form for custom Chef cookbooks with repository details and options.\]](http://docs.aws.amazon.com/pt_br/opsworks/latest/userguide/images/redis_walkthrough_cookbook.png)

1. Na página **Stack**, clique em **Run Command**, selecione o comando de pilha **Update Custom Cookbooks** e clique em **Update Custom Cookbooks** para instalar o novo livro de receitas nos caches de livros de receitas das instâncias.   
![\[Run Command interface showing Update Custom Cookbooks option and instance selection for Rails App Server.\]](http://docs.aws.amazon.com/pt_br/opsworks/latest/userguide/images/redis_walkthrough_command.png)

Se você modificar seu livro de receitas, basta executar **Update Custom Cookbooks** novamente para instalar a versão atualizada. Para obter mais informações sobre esse procedimento, consulte [Instalação de livros de receitas personalizados](workingcookbook-installingcustom-enable.md).