Configurar o SDK

No AWS SDK para Go V2, você pode definir configurações comuns para clientes de serviço, como o logger, o nível do log e a configuração de novas tentativas. A maioria das configurações é opcional. No entanto, para cada cliente de serviço, você deve especificar uma região da AWS e suas credenciais. O SDK usa esses valores para enviar solicitações à região correta e assinar solicitações com as credenciais corretas. Você pode especificar esses valores de forma programática no código ou por meio do ambiente de execução.

Carregar arquivos de configuração compartilhados da AWS

Há várias maneiras de inicializar um cliente de API de serviço, mas o padrão mais comum recomendado aos usuários é o indicado a seguir.

Para configurar o SDK para usar os arquivos de configuração compartilhados da AWS, use o seguinte código:

import (
  "context"
  "log"
  "github.com/aws/aws-sdk-go-v2/config"
)

// ...

cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
  log.Fatalf("failed to load configuration, %v", err)
}

config.LoadDefaultConfig(context.TODO()) construirá um aws.Config usando as origens de configuração compartilhadas da AWS. Isso inclui configurar um provedor de credenciais, configurar a região da AWS e carregar a configuração específica do serviço. Os clientes de serviço podem ser construídos usando o aws.Config carregado, fornecendo um padrão consistente para a construção de clientes.

Consulte mais informações sobre arquivos de configuração compartilhados da AWS em Configuração no Guia de referência de AWS SDKs e ferramentas.

Especificar a região da AWS

Ao especificar a região, você determina para onde enviar solicitações, como us-west-2 ou us-east-2. Consulte uma lista de regiões para cada serviço em Cotas e endpoints de serviço na Referência geral da Amazon Web Services.

O SDK não tem uma região padrão. Como especificar uma região:

REVISÃO: se você definir uma região usando todas essas técnicas, o SDK usará a região que você especificou explicitamente.

Configurar a região com variável de ambiente

Linux, macOS ou Unix

export AWS_REGION=us-west-2

Windows

set AWS_REGION=us-west-2

Especificar a região de forma programática

cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))

Especificação de credenciais

As credenciais necessárias do AWS SDK para Go (uma chave de acesso e uma chave de acesso secreta) para assinar solicitações para a AWS. É possível especificar as credenciais em vários locais, dependendo do caso de uso específico. Consulte mais informações sobre como obter as credenciais em Conceitos básicos do AWS SDK para Go.

Quando você inicializa uma instância aws.Config usando config.LoadDefaultConfig, o SDK usa sua cadeia de credenciais padrão para encontrar credenciais da AWS. Essa cadeia de credenciais padrão procura credenciais na seguinte ordem:

O SDK detecta e usa os provedores integrados automaticamente, sem exigir configurações manuais. Por exemplo, se você usa perfis do IAM para instâncias do Amazon EC2, as aplicações usam automaticamente as credenciais da instância. Você não precisa configurar credenciais manualmente na aplicação.

Como prática recomendada, a AWS sugere especificar credenciais na seguinte ordem:

Funções do IAM para tarefas

Se a aplicação usa uma definição de tarefa do Amazon ECS ou a operação RunTask, use Perfis do IAM para tarefas para especificar um perfil do IAM que pode ser usado pelos contêineres em uma tarefa.

Perfis do IAM para instâncias do Amazon EC2

Se estiver executando a aplicação em uma instância do Amazon EC2, use o perfil do IAM da instância para obter credenciais de segurança temporárias a fim de fazer chamadas para a AWS.

Se você configurou a instância para usar perfis do IAM, o SDK usa essas credenciais para a aplicação automaticamente. Você não precisa especificar essas credenciais manualmente.

Credenciais e configurações compartilhadas

Os arquivos de configurações e credenciais compartilhados podem ser usados para compartilhar configurações comuns entre AWS SDKs e outras ferramentas. Se usar credenciais diferentes para diferentes ferramentas ou aplicativos, você poderá usar perfis para configurar várias chaves de acesso no mesmo arquivo de configuração.

Você pode fornecer vários locais de arquivos de configurações ou credenciais usando config.LoadOptions, por padrão, o SDK carrega arquivos armazenados nos locais padrão mencionados em Especificação de credenciais.

import (
    "context"
    "github.com/aws/aws-sdk-go-v2/config"    
)

// ...

cfg , err := config.LoadDefaultConfig(context.TODO(), 
    config.WithSharedCredentialsFiles(
    []string{"test/credentials", "data/credentials"},
    ), 
    config.WithSharedConfigFiles(
        []string{"test/config", "data/config"},
    )   
) 

Ao trabalhar com arquivos de configurações e credenciais compartilhados, se perfis duplicados forem especificados, eles serão combinados para resolver um perfil. Em caso de conflito de combinação,

Se necessário, você pode habilitar LogConfigurationWarnings em config.LoadOptions e registrar em log as etapas de resolução do perfil.

Criar o arquivo de credenciais

Se você não tem um arquivo de credenciais compartilhado (.aws/credentials), use qualquer editor de texto para criar um em seu diretório inicial. Adicione o conteúdo a seguir ao arquivo de credenciais, substituindo <YOUR_ACCESS_KEY_ID> e <YOUR_SECRET_ACCESS_KEY> por suas credenciais.

[default]
aws_access_key_id = <YOUR_ACCESS_KEY_ID>
aws_secret_access_key = <YOUR_SECRET_ACCESS_KEY>

O cabeçalho [default] define as credenciais do perfil padrão, que o SDK usará a menos que você o configure para usar outro perfil.

Você também pode usar credenciais de segurança temporárias adicionando os tokens da sessão ao perfil, conforme mostrado no seguinte exemplo:

[temp]
aws_access_key_id = <YOUR_TEMP_ACCESS_KEY_ID>
aws_secret_access_key = <YOUR_TEMP_SECRET_ACCESS_KEY>
aws_session_token = <YOUR_SESSION_TOKEN>

O nome da seção de um perfil não padrão em um arquivo de credenciais não deve começar com a palavra profile. Você pode ler mais no Guia de referência de AWS SDKs e ferramentas.

Criar o arquivo de configurações

Se você não tem um arquivo de credenciais compartilhado (.aws/config), use qualquer editor de texto para criar um em seu diretório inicial. Adicione o conteúdo a seguir ao arquivo de configuração, substituindo<REGION> pela região desejada.

[default]
region = <REGION>

O cabeçalho [default] define as configurações do perfil padrão, que o SDK usará a menos que você o configure para usar outro perfil.

Você pode usar perfis nomeados, conforme mostrado no seguinte exemplo:

[profile named-profile]
region = <REGION>

O nome da seção de um perfil não padrão em um arquivo de configurações deve sempre começar com a palavra profile, seguida pelo nome do perfil pretendido. Você pode ler mais no Guia de referência de AWS SDKs e ferramentas.

Especificar perfis

Você pode incluir várias chaves de acesso no mesmo arquivo de configuração associando cada conjunto de chaves de acesso a um perfil. Por exemplo, no arquivo de credenciais, você pode declarar vários perfis, conforme indicado a seguir.

[default]
aws_access_key_id = <YOUR_DEFAULT_ACCESS_KEY_ID>
aws_secret_access_key = <YOUR_DEFAULT_SECRET_ACCESS_KEY>

[test-account]
aws_access_key_id = <YOUR_TEST_ACCESS_KEY_ID>
aws_secret_access_key = <YOUR_TEST_SECRET_ACCESS_KEY>

[prod-account]
; work profile
aws_access_key_id = <YOUR_PROD_ACCESS_KEY_ID>
aws_secret_access_key = <YOUR_PROD_SECRET_ACCESS_KEY>

Por padrão, o SDK verifica a variável de ambiente AWS_PROFILE para determinar qual perfil usar. Se nenhuma variável AWS_PROFILE for definida, o SDK usará o perfil default.

Às vezes, você pode querer usar um perfil diferente com a aplicação. Por exemplo, você quer usar as credenciais test-account com a aplicação myapp. Você pode usar esse perfil utilizando o seguinte comando:

$ AWS_PROFILE=test-account myapp

Você também pode instruir o SDK a selecionar um perfil chamando os.Setenv("AWS_PROFILE", "test-account") antes de chamar config.LoadDefaultConfig ou passando um perfil explícito como um argumento, conforme mostrado no seguinte exemplo:

cfg, err := config.LoadDefaultConfig(context.TODO(), 
    config.WithSharedConfigProfile("test-account"))

Variáveis de ambiente

Por padrão, o SDK detecta as credenciais da AWS definidas em seu ambiente e as usa para assinar solicitações para a AWS. Dessa maneira, você não precisa gerenciar credenciais nas aplicações.

O SDK procura credenciais nas seguintes variáveis de ambiente:

Os exemplos a seguir mostram como configurar as variáveis de ambiente.

Linux, OSX ou UNIX

$ export AWS_ACCESS_KEY_ID=YOUR_AKID
$ export AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
$ export AWS_SESSION_TOKEN=TOKEN

Windows

> set AWS_ACCESS_KEY_ID=YOUR_AKID
> set AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY
> set AWS_SESSION_TOKEN=TOKEN

Especificar credenciais de forma programática

O config.LoadDefaultConfig permite fornecer um aws.CredentialProvider explícito ao carregar as origens de configurações compartilhadas. Para passar um provedor de credencial explícito ao carregar as configurações compartilhadas, use config.WithCredentialsProvider. Por exemplo, se customProvider fizer referência a uma instância de implementação aws.CredentialProvider, ela poderá ser passada durante o carregamento da configuração da seguinte forma:

cfg, err := config.LoadDefaultConfig(context.TODO(), 
    config.WithCredentialsProvider(customProvider))

Se você fornecer credenciais explicitamente, como neste exemplo, o SDK usará somente essas credenciais.

Credenciais estáticas

Você pode fazer a codificação rígida de credenciais na aplicação usando o provedor de credenciais credentials.NewStaticCredentialsProvider para definir explicitamente as chaves de acesso a serem usadas. Por exemplo:

cfg, err := config.LoadDefaultConfig(context.TODO(), 
    config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider("AKID", "SECRET_KEY", "TOKEN")),
)

Credenciais de autenticação única

O SDK fornece um provedor de credenciais para recuperar credenciais temporárias da AWS usando o AWS IAM Identity Center. Com o AWS CLI, você se autentica com o portal de acesso da AWS e autoriza o acesso às credenciais temporárias da AWS. Depois, você configura a aplicação para carregar o perfil de autenticação única (SSO), e o SDK usa as credenciais de SSO para recuperar credenciais temporárias da AWS que serão renovadas automaticamente se expirarem. Se as credenciais de SSO expirarem, você deverá renová-las explicitamente fazendo login em sua conta do Centro de Identidade do IAM novamente usando a AWS CLI.

Por exemplo, você pode criar um perfil, dev-profile, autenticar e autorizar esse perfil usando a AWS CLI e configurar a aplicação conforme mostrado abaixo.

[profile dev-profile]
sso_session = dev-session
sso_account_id = 012345678901
sso_role_name = Developer
region = us-east-1

[sso-session dev-session]
sso_region = us-west-2
sso_start_url = https://company-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access

$ aws --profile dev-profile sso login 
Attempting to automatically open the SSO authorization page in your default browser.
If the browser does not open or you wish to use a different device to authorize this request, open the following URL:

https://device.sso.us-west-2.amazonaws.com/

Then enter the code:

ABCD-EFGH
Successully logged into Start URL: https://company-sso-portal.awsapps.com/start

import "github.com/aws/aws-sdk-go-v2/config"

// ...

cfg, err := config.LoadDefaultConfig(
    context.Background(),
    config.WithSharedConfigProfile("dev-profile"),
)
if err != nil {
    return err
}

Consulte mais informações sobre como configurar perfis de SSO e autenticar usando a AWS CLI em Configurar a AWS CLI para usar o AWS IAM Identity Center no Guia do usuário do AWS CLI. Consulte mais informações sobre a construção programática do provedor de credenciais de SSO na documentação de referência da API ssocreds.

Outros provedores de credenciais

O SDK fornece outros métodos para recuperar credenciais no módulo de credenciais. Por exemplo, é possível recuperar credenciais de segurança temporárias da AWS Security Token Service ou credenciais do armazenamento criptografado.

Provedores de credenciais disponíveis: