

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

# Usar o SDK for Ruby em uma Instância do Vagrant
<a name="cookbooks-101-opsworks-s3-vagrant"></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).

Este tópico descreve como uma receita em execução em uma instância do Vagrant pode usar o [AWS SDK para Ruby](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/) para fazer download de um arquivo do Amazon S3. Antes de começar, você deve primeiro ter um conjunto de AWS credenciais — uma chave de acesso e uma chave de acesso secreta — que permitam que a receita acesse o Amazon S3.

**Importante**  
Recomendamos enfaticamente que você não use credenciais da conta raiz para essa finalidade. Em vez disso, crie um usuário com uma política adequada e forneça essas credenciais à receita.   
Tenha cuidado para não colocar credenciais, nem mesmo credenciais de usuário do IAM, em um local acessível ao público, por exemplo, fazendo o upload de um arquivo contendo as credenciais para um repositório público ou do Bitbucket. GitHub Isso expõe as credenciais e pode comprometer a segurança da conta.  
 As receitas executadas em uma EC2 instância EC2 da Amazon podem usar uma abordagem ainda melhor, uma função do IAM, conforme descrito em[Usando o SDK para Ruby em uma instância do Stacks OpsWorks Linux](cookbooks-101-opsworks-s3-opsworks.md).  
O conteúdo entregue aos buckets do Amazon S3 pode conter conteúdo do cliente. Para obter mais informações sobre a remoção de dados confidenciais, consulte [Como faço para esvaziar um bucket do S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/empty-bucket.html) ou [Como faço para excluir um bucket do S3?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html).

Se você ainda não tem um usuário do apropriado, crie um usuário conforme os procedimentos a seguir. Para obter mais informações, consulte [O que é o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/Introduction.html).

**Atenção**  
Os usuários do IAM têm credenciais de longo prazo, o que representa um risco de segurança. Para ajudar a reduzir esse risco, recomendamos que você forneça a esses usuários somente as permissões necessárias para realizar a tarefa e que você os remova quando não forem mais necessários.

**Para criar um usuário do IAM**

1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. No painel de navegação, selecione **Usuários** e, se necessário, escolha **Adicionar usuários** para criar um novo usuário administrativo.

1. Na página **Definir permissões**, selecione **Anexar políticas diretamente**.

1. Digite **S3** na caixa de pesquisa **Políticas de permissão** para exibir as políticas do Amazon S3.

   Escolha **Amazon ReadOnlyAccess** S3. Se preferir, você pode especificar uma política que conceda permissões mais amplas, como o **AmazonS3 FullAccess**, mas a prática padrão é conceder somente as permissões necessárias. Nesse caso, a receita só baixará um arquivo, portanto, o acesso somente leitura é suficiente.

1. Escolha **Próximo**.

1. Escolha **Criar usuário**

1.  seguir, crie chaves de acesso para seu usuário. Para obter mais informações sobre a criação de chaves de acesso, consulte [Gerenciar chaves de acesso para usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) no *Guia do usuário do IAM*.

Em seguida, forneça um arquivo para download. Este exemplo pressupõe que você colocará um arquivo chamado `myfile.txt` em um bucket do S3 recém-criado, chamado `cookbook_bucket`. 

**Para fornecer um arquivo para download**

1. Crie um arquivo chamado `myfile.txt` com o seguinte texto e salve-o em um local conveniente na sua estação de trabalho.

   ```
   This is the file that you just downloaded from Amazon S3.
   ```

1. No [console do Amazon S3](https://console.aws.amazon.com/s3/), crie um bucket chamado `cookbook_bucket` na região **Padrão** e faça upload de `myfile.txt` no bucket.

Defina o livro de receitas da seguinte maneira.

**Para configurar o livro de receitas**

1. Crie um diretório em `opsworks_cookbooks` chamado `s3bucket` e navegue até ele.

1. Inicialize e configure o Test Kitchen, conforme descrito em [Exemplo 1: Instalação de pacotes](cookbooks-101-basics-packages.md).

1. Substitua o texto em `.kitchen.yml` pelo seguinte conteúdo.

   ```
   ---
   driver:
     name: vagrant
   
   provisioner:
     name: chef_solo
     environments_path: ./environments
   
   platforms:
     - name: ubuntu-14.04
   
   suites:
     - name: s3bucket
       provisioner:
         solo_rb:
           environment: test
       run_list:
         - recipe[s3bucket::default]
       attributes:
   ```

1. Adicione dois diretórios a `s3bucket`: `recipes` e `environments`.

1. Crie um arquivo de ambiente chamado `test.json` em que a seguinte seção `default_attributes` substitui os valores `access_key` e `secret_key` pelas chaves correspondentes para o usuário do . Salve o arquivo na pasta `environments` do livro de receitas.

   ```
   {
     "default_attributes" : {
       "cookbooks_101" : {
         "access_key": "AKIAIOSFODNN7EXAMPLE",
         "secret_key" : "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
       }
     },
     "chef_type" : "environment",
     "json_class" : "Chef::Environment"
   }
   ```

Há diversas maneiras de fornecer credenciais a uma receita em execução em uma instância. A principal consideração é limitar as chances de expor acidentalmente as chaves e comprometer a segurança de sua conta. Por esse motivo, não recomendamos usar valores de chave explícitos em seu código. O exemplo coloca os valores de chave no objeto de nó, o que permite que a receita faça referência a eles usando a sintaxe de nó em vez de expor valores literais. Você deve ter privilégios de raiz para acessar o objeto de nó, o que limita a possibilidade de que as chaves sejam expostas. Para obter mais informações, consulte [Práticas recomendadas de gerenciamento de chaves de acesso da AWS](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html).

**nota**  
Observe que o exemplo usa atributos aninhados, com `cookbooks_101` como o primeiro elemento. Essa prática limita a chance de um conflito de nomes caso haja outros atributos `access_key` ou `secret_key` no objeto de nó.

A receita a seguir faz download de `myfile.text` no bucket `cookbook_bucket`.

```
gem_package "aws-sdk ~> 3" do
  action :install
end

ruby_block "download-object" do
  block do
    require 'aws-sdk'

    s3 = Aws::S3::Client.new(
          :access_key_id => "#{node['cookbooks_101']['access_key']}",
          :secret_access_key => "#{node['cookbooks_101']['secret_key']}")

    myfile = s3.bucket['cookbook_bucket'].objects['myfile.txt']
    Dir.chdir("/tmp")
    File.open("myfile.txt", "w") do |f|
      f.write(myfile.read)
      f.close
    end
  end
  action :run
end
```

A primeira parte da receita instala o SDK for Ruby, que é um pacote de gem. O recurso [gem\$1package](https://docs.chef.io/chef/resources.html#gem-package) instala gems que serão usados por receitas ou outros aplicativos.

**nota**  
Em geral, sua instância tem duas instâncias Ruby, que normalmente têm versões diferentes. Uma é uma instância dedicada que é usada pelo cliente do Chef. A outra é usada por aplicativos e receitas em execução na instância. É importante entender essa distinção ao instalar pacotes de gem, porque há dois recursos para instalar gems: [gem\$1package](https://docs.chef.io/chef/resources.html#gem-package) e [chef\$1gem](https://docs.chef.io/chef/resources.html#chef-gem). Se o pacote de gem for usado por aplicativos ou receitas, instale-o com `gem_package`; `chef_gem` é apenas para pacotes de gem usados pelo cliente Chef.

O restante da receita é um recurso [ruby\$1block](https://docs.chef.io/chef/resources.html#ruby-block) que contém o código Ruby, que faz download do arquivo. Talvez você pense que, como uma receita é um aplicativo Ruby, é possível colocar o código diretamente na receita. No entanto, uma execução do Chef compila todo esse código antes de executar qualquer recurso. Se você colocar o código de exemplo diretamente na receita, o Ruby tentará resolver a instrução `require 'aws-sdk'` antes de executar o recurso `gem_package`. Como o SDK for Ruby ainda não foi instalado, a compilação falhará.

O código em um recurso `ruby_block` não é compilado até que esse recurso seja executado. Neste exemplo, o recurso `ruby_block` é executado após o recurso `gem_package` ter concluído a instalação do SDK for Ruby, então, o código será executado com êxito.

O código no `ruby_block` funciona da seguinte maneira. 

1. Cria um novo objeto [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3.html](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3.html), que fornece a interface do serviço.

   As chaves de acesso e as chaves secretas são especificadas por referência aos valores armazenados no objeto de nó.

1. Chama a associação `bucket.objects` do objeto `S3`, que retorna um objeto [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html) chamado `myfile` que representa `myfile.txt`.

1. Usa `Dir.chdir` para definir o diretório de trabalho como `/tmp`.

1. Abre um arquivo chamado `myfile.txt`, grava o conteúdo de `myfile` no arquivo e fecha o arquivo.

**Para executar a receita**

1. Crie um arquivo chamado `default.rb` com a receita de exemplo e salve-o no diretório `recipes`.

1. Executar `kitchen converge`.

1. Execute `kitchen login` para fazer login na instância e execute `ls /tmp`. Você deverá ver `myfile.txt`, junto com vários arquivos e diretórios do Test Kitchen.

   ```
   vagrant@s3bucket-ubuntu-1204:~$ ls /tmp
   install.sh  kitchen  myfile.txt  stderr
   ```

   Você também pode executar `cat /tmp/myfile.txt` para verificar se o conteúdo do arquivo está correto.

Quando terminar, execute `kitchen destroy` para encerrar a instância.