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á.
# Introdução ao AWS SDK for Ruby
Saiba como instalar, configurar e usar o SDK para criar um aplicativo Ruby para acessar um AWS recurso programaticamente.
**Topics**
+ [Autenticando com AWS](credentials.md)
+ [Instalação do SDK](setup-install.md)
+ [Criar uma aplicação simples](hello.md)
# Autenticação com o AWS uso do AWS SDK for Ruby
Você deve estabelecer como seu código é autenticado AWS ao desenvolver com Serviços da AWS. Você pode configurar o acesso programático aos AWS recursos de maneiras diferentes, dependendo do ambiente e do AWS acesso disponível para você.
Para escolher seu método de autenticação e configurá-lo para o SDK, consulte [Autenticação e acesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) no *Guia de referência de ferramentas AWS SDKs e ferramentas*.
## Usando credenciais do console
Para o desenvolvimento local, recomendamos que os novos usuários usem suas credenciais de login do AWS Management Console existentes para acesso programático aos serviços. AWS Após a autenticação baseada em navegador, AWS gera credenciais temporárias que funcionam com ferramentas de desenvolvimento locais, como a Interface de Linha de AWS Comando (AWS CLI) e o SDK for Ruby. AWS
Se você escolher esse método, siga as instruções para [fazer login para desenvolvimento AWS local usando as credenciais do console usando a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html).
O AWS SDK para Ruby não precisa que gems adicionais (`aws-sdk-signin`como) sejam adicionadas ao seu aplicativo para usar o login com as credenciais do console.
## Usando a autenticação do IAM Identity Center
Se você escolher esse método, conclua o procedimento para [autenticação do IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) no *Guia de referência de ferramentas AWS SDKs e ferramentas*. Depois disso, seu ambiente deverá conter os seguintes elementos:
+ O AWS CLI, que você usa para iniciar uma sessão do portal de AWS acesso antes de executar seu aplicativo.
+ Um [arquivo AWS`config` compartilhado](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) com um perfil de `[default]` com um conjunto de valores de configuração que podem ser referenciados a partir do SDK. Para encontrar a localização desse arquivo, consulte [Localização dos arquivos compartilhados no](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html) *Guia de referência de ferramentas AWS SDKs e ferramentas*.
+ O arquivo `config` compartilhado define a configuração do [https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html). Isso define o padrão Região da AWS que o SDK usa para AWS solicitações. Essa região é usada para solicitações de serviço do SDK que não são fornecidas com uma Região específica para uso.
+ O SDK usa a [configuração do provedor do token de SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#feature-sso-credentials-profile) do perfil para adquirir credenciais antes de enviar solicitações para a AWS. O `sso_role_name` valor, que é uma função do IAM conectada a um conjunto de permissões do IAM Identity Center, permite acesso ao Serviços da AWS usado em seu aplicativo.
O arquivo `config` de amostra a seguir mostra um perfil padrão configurado com o provedor de token de SSO. A configuração `sso_session` do perfil se refere à [seção do `sso-session`](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#section-session). A `sso-session` seção contém configurações para iniciar uma sessão do portal de AWS acesso.
```
[default]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
region = us-east-1
output = json
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://provided-domain.awsapps.com/start
sso_registration_scopes = sso:account:access
```
O AWS SDK para Ruby não precisa que gems adicionais (`aws-sdk-sso``aws-sdk-ssooidc`como e) sejam adicionados ao seu aplicativo para usar a autenticação do IAM Identity Center.
### Iniciar uma sessão do portal de AWS acesso
Antes de executar um aplicativo que acessa Serviços da AWS, você precisa de uma sessão ativa do portal de AWS acesso para que o SDK use a autenticação do IAM Identity Center para resolver as credenciais. Dependendo da duração da sessão configurada, o seu acesso acabará expirando e o SDK encontrará um erro de autenticação. Para entrar no portal de AWS acesso, execute o seguinte comando no AWS CLI.
```
aws sso login
```
Se você seguiu as orientações e tem um perfil padrão configurado, não precisará chamar o comando com uma opção de `--profile`. Se a configuração do provedor de token de SSO estiver usando um perfil nomeado, o comando será `aws sso login --profile named-profile`.
Para, como opção, testar se você já tem uma sessão ativa, execute o seguinte comando da AWS CLI .
```
aws sts get-caller-identity
```
Se a sua sessão estiver ativa, a resposta a este comando relata a conta do IAM Identity Center e o conjunto de permissões configurados no arquivo `config` compartilhado.
**nota**
Se você já tiver uma sessão ativa do portal de AWS acesso e executá-la`aws sso login`, não será necessário fornecer credenciais.
O processo de login pode solicitar que você permita o AWS CLI acesso aos seus dados. Como o AWS CLI é criado com base no SDK para Python, as mensagens de permissão podem conter variações do `botocore` nome.
## Mais informações de autenticação
Os usuários humanos, também conhecidos como *identidades humanas,* são as pessoas, os administradores, os desenvolvedores, os operadores e os consumidores de suas aplicações. Eles devem ter uma identidade para acessar seus AWS ambientes e aplicativos. Usuários humanos que são membros da sua organização (ou seja, você, o desenvolvedor) são conhecidos como *identidades da força de trabalho*.
Use credenciais temporárias ao acessar AWS. Você pode usar um provedor de identidade para seus usuários humanos para fornecer acesso federado às AWS contas assumindo funções que fornecem credenciais temporárias. Para gerenciamento de acesso centralizado, recomendamos que você use o Centro de Identidade do AWS IAM (IAM Identity Center) para gerenciar o acesso às suas contas e as permissões nessas contas. Para obter mais alternativas, consulte as informações a seguir.
+ Para saber mais sobre as práticas recomendadas, consulte [Práticas recomendadas de segurança no IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) no *Guia do usuário do IAM*.
+ Para criar AWS credenciais de curto prazo, consulte [Credenciais de segurança temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no Guia do *usuário do IAM*.
+ Para saber mais sobre a cadeia de fornecedores de credenciais do AWS SDK for Ruby e como diferentes métodos de autenticação são tentados automaticamente pelo SDK em uma sequência, consulte. [Cadeia de provedores de credenciais](credential-providers.md#credchain)
+ Para as configurações do provedor de credenciais do AWS SDK, consulte [Provedores de credenciais padronizados](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) no Guia de referência de ferramentas *AWS SDKs e* ferramentas.
# Instalando o AWS SDK para Ruby
Esta seção inclui pré-requisitos e instruções de instalação do AWS SDK para Ruby.
## Pré-requisitos
Antes de usar o AWS SDK for Ruby, você deve se autenticar com. AWS Para obter informações sobre a configuração da autenticação, consulte [Autenticação com o AWS uso do AWS SDK for Ruby](credentials.md).
## Instalar o SDK
Você pode instalar o AWS SDK for Ruby como faria com qualquer gem do Ruby. As joias estão disponíveis em. [RubyGems](https://rubygems.org/gems/aws-sdk/) O AWS SDK para Ruby foi projetado para ser modular e é separado por. AWS service (Serviço da AWS) A instalação de todo o gem `aws-sdk` é grande e pode levar mais de uma hora.
Recomendamos instalar apenas as gemas Serviços da AWS que você usa. Eles são nomeados como `aws-sdk-service_abbreviation` e a lista completa é encontrada na tabela [Serviços suportados](https://github.com/aws/aws-sdk-ruby/#supported-services) do arquivo README do AWS SDK for Ruby. Por exemplo, o gem para interface com o serviço Amazon S3 está disponível diretamente em [https://rubygems.org/gems/aws-sdk-s3](https://rubygems.org/gems/aws-sdk-s3).
### Gerenciador de versões do Ruby
Em vez de usar o sistema Ruby, recomendamos usar um gerenciador de versões do Ruby, como o seguinte:
+ [RVM](http://rvm.io/)
+ [chruby](https://github.com/postmodern/chruby)
+ [rbenv](https://github.com/rbenv/rbenv)
Por exemplo, se você estiver usando um sistema operacional Amazon Linux 2, os comandos a seguir podem ser usados para atualizar o RVM, listar as versões disponíveis do Ruby e, em seguida, escolher a versão que você deseja usar para desenvolvimento com o SDK for AWS Ruby. A versão mínima exigida do Ruby é 2.5.
```
$ rvm get head
$ rvm list known
$ rvm install ruby-3.1.3
$ rvm --default use 3.1.3
```
### Bundler
Se você usa o [Bundler](http://bundler.io/), os comandos a seguir instalam a gem AWS SDK for Ruby para Amazon S3:
1. Instale o Bundler e crie o `Gemfile`:
```
$ gem install bundler
$ bundle init
```
1. Abra o criado `Gemfile` e adicione uma `gem` linha para cada gem AWS de serviço que seu código usará. Para acompanhar o exemplo do Amazon S3, adicione a seguinte linha ao final do arquivo:
```
gem "aws-sdk-s3"
```
1. Salve o Gemfile.
1. Instale as dependências especificadas em seu `Gemfile`:
```
$ bundle install
```
# Criação de um aplicativo simples usando o AWS SDK for Ruby
Diga olá ao Amazon S3 usando o AWS SDK para Ruby. O exemplo a seguir mostra uma lista dos seus buckets do Amazon S3.
## Escrever o código
Copie e cole o código a seguir em um novo arquivo fonte. Nomeie o arquivo `hello-s3.rb`.
```
require 'aws-sdk-s3'
# Wraps Amazon S3 resource actions.
class BucketListWrapper
attr_reader :s3_resource
# @param s3_resource [Aws::S3::Resource] An Amazon S3 resource.
def initialize(s3_resource)
@s3_resource = s3_resource
end
# Lists buckets for the current account.
#
# @param count [Integer] The maximum number of buckets to list.
def list_buckets(count)
puts 'Found these buckets:'
@s3_resource.buckets.each do |bucket|
puts "\t#{bucket.name}"
count -= 1
break if count.zero?
end
true
rescue Aws::Errors::ServiceError => e
puts "Couldn't list buckets. Here's why: #{e.message}"
false
end
end
# Example usage:
def run_demo
wrapper = BucketListWrapper.new(Aws::S3::Resource.new)
wrapper.list_buckets(25)
end
run_demo if $PROGRAM_NAME == __FILE__
```
AWS O SDK for Ruby foi projetado para ser modular e é separado por. AWS service (Serviço da AWS) Depois que o gem é instalado, a instrução do `require` na parte superior do arquivo fonte do Ruby importa as classes e os métodos do AWS SDK para o serviço Amazon S3. Para obter uma lista completa dos AWS service gems disponíveis, consulte a tabela de [serviços suportados](https://github.com/aws/aws-sdk-ruby/#supported-services) do arquivo README do AWS SDK for Ruby.
```
require 'aws-sdk-s3'
```
## Execução do programa
Abra um prompt de comando para executar seu programa Ruby. A sintaxe de comando típica para executar um programa Ruby é:
```
ruby [source filename] [arguments...]
```
Esse código de amostra não usa argumentos. Para executar esse código, insira o seguinte no prompt de comando:
```
$ ruby hello-s3.rb
```
## Observação para usuários do Windows
Quando você usar certificados SSL no Windows e executar o código Ruby, verá um erro semelhante ao seguinte.
```
C:\Ruby>ruby buckets.rb
C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:921:in `connect': SSL_connect returned=1 errno=0 state=SSLv3 read server certificate B: certificate verify failed (Seahorse::Client::NetworkingError)
from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:921:in `block in connect'
from C:/Ruby200-x64/lib/ruby/2.0.0/timeout.rb:66:in `timeout'
from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:921:in `connect'
from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:862:in `do_start'
from C:/Ruby200-x64/lib/ruby/2.0.0/net/http.rb:857:in `start'
...
```
Para corrigir esse problema, adicione a seguinte linha ao arquivo fonte do Ruby, em algum lugar antes da primeira AWS chamada.
```
Aws.use_bundled_cert!
```
Se você estiver usando somente o gem `aws-sdk-s3` em seu programa Ruby e se deseja usar o certificado incluso, também precisará adicionar o gem `aws-sdk-core`.
## Próximas etapas
Para testar muitas outras operações do Amazon S3, confira o [Repositório de exemplos de AWS código](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/ruby/example_code//s3) em. GitHub