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á.
# Usando provedores de credenciais da AWS SDK para PHP versão 3
Para obter informações de referência sobre os mecanismos de credenciais disponíveis para o AWS SDKs, consulte [Credenciais e acesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) no AWS SDKs Guia de *referência de ferramentas*.
**Importante**
Por motivos de segurança, é *altamente recomendável* que você **não** use a conta root para AWS acessar. Sempre consulte as [melhores práticas de segurança no IAM no](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) *Guia do usuário do IAM* para obter as recomendações de segurança mais recentes.
A função de um provedor de credenciais na AWS SDK para PHP versão 3 é fornecer e fornecer credenciais aos clientes do SDK. AWS service (Serviço da AWS) O SDK usa as credenciais que ele gera para se autenticar no serviço assinando criptograficamente cada solicitação. As credenciais geralmente consistem em chaves de acesso; uma combinação do ID de uma chave de acesso e uma chave de acesso secreta.
Quando você usa credenciais temporárias, como quando [configura a autenticação do IAM Identity Center](credentials.md#use-idc-for-auth) ou configura seu tempo de execução para [assumir uma função do IAM](assumerole-provider.md), um token de sessão é adicionado às chaves de acesso, fornecendo acesso aos AWS recursos por tempo limitado.
## O que é um provedor de credenciais na AWS SDK para PHP versão 3?
Um provedor de credenciais é uma função que retorna uma `GuzzleHttp\Promise\PromiseInterface` que é cumprida com uma instância de `Aws\Credentials\CredentialsInterface` ou rejeitada com uma `Aws\Exception\CredentialsException`. O [SDK fornece várias implementações](built-in-providers-in-the-sdk.md) de funções de provedor de credenciais, mas você pode [implementar sua própria](creating-a-custom-provider.md) lógica personalizada para criar credenciais ou otimizar o carregamento de credenciais.
Os provedores de credenciais são passados para a opção do construtor de clientes `credentials`. Os provedores de credenciais são assíncronos, o que os força a serem avaliados lentamente a cada vez que uma operação de API é invocada. Como tal, a passagem de uma função de provedor de credenciais para um construtor de cliente do SDK não valida imediatamente as credenciais. Se o provedor de credenciais não retornar um objeto de credenciais, uma operação da API será rejeitada com uma `Aws\Exception\CredentialsException`.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
// Use the ECS credential provider.
$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials.
$memoizedProvider = CredentialProvider::memoize($provider);
// Pass the provider to the client
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
# Entendendo a cadeia de provedores de credenciais padrão na AWS SDK para PHP versão 3
A cadeia de provedores de credenciais padrão é composta por uma série de provedores de credenciais integrados que o SDK invoca. Ela é implementada pela função de provedor de credenciais [defaultProvider](defaultprovider-provider.md) sem parâmetros. Depois que as credenciais válidas são encontradas, a pesquisa é interrompida.
Ele AWS SDK para PHP executa os provedores de credenciais na seguinte ordem:
+ [**Provedor `env`**](env-provider.md): o SDK procura as [chaves de acesso da AWS que foram definidas como variáveis de ambiente](https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html).
+ [**Provedor `assumeRoleWithWebIdentityCredentialProvider`**](assume-role-with-web-identity-provider.md): o SDK procura o perfil do IAM e as configurações do arquivo de token de identidade da web.
+ Nesse ponto da cadeia, o SDK procura a configuração nos `credentials` arquivos compartilhados AWS `config` e. O SDK procura a configuração no perfil “padrão”, mas se a variável de ambiente `AWS_PROFILE` estiver definida, o SDK usará seu valor de perfil nomeado.
+ [**Provedor `sso`**](sso-provider.md): o SDK procura as [definições de configuração do Centro de Identidade do IAM](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) no arquivo `config` compartilhado.
+ [**`login provider`**](login-provider.md)- O SDK procura as configurações da sessão de login do AWS console no `config` arquivo compartilhado.
+ [**Provedor `process`**](process-provider.md): o SDK procura a configuração `credential_process` no arquivo `credentials` compartilhado.
+ [**`ini`provider**](ini-provider.md) — o SDK procura as AWS credenciais ou as informações da função do IAM no arquivo compartilhado`credentials`.
+ [**Provedor `process`**](process-provider.md): o SDK procura a configuração `credential_process` no arquivo `config` compartilhado.
+ [**`ini`provider**](ini-provider.md) — o SDK procura as AWS credenciais ou as informações da função do IAM no arquivo compartilhado`config`.
+ [**Provedor `ecsCredentials`**](ecscredentials-provider.md): o SDK procura as variáveis de ambiente `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI ` ou `AWS_CONTAINER_CREDENTIALS_FULL_URI` que fornecem informações para adquirir credenciais temporárias.
+ [**Provedor `instanceProfile`**](instanceprofile-provider.md): o SDK usa o serviço de metadados da instância do EC2 para obter o perfil do IAM especificado no perfil de instância. Usando as informações de perfil, o SDK adquire credenciais temporárias.
**nota**
O resultado do provedor padrão é automaticamente memoizado.
Você pode revisar o código da cadeia no GitHub [código-fonte](https://github.com/aws/aws-sdk-php/blob/0a99dab427f0a1c082775301141aeac3558691ad/src/Credentials/CredentialProvider.php#L77).
# Provedores de credenciais integrados na AWS SDK para PHP versão 3
O SDK fornece vários provedores de credenciais integrados que você pode usar individualmente ou combinar em uma [cadeia de provedores de credenciais personalizados](chaining-providers.md).
Quando você especifica um provedor de credenciais durante a criação do cliente de serviço, o SDK tenta carregar as credenciais usando somente o provedor de credenciais especificado. A [cadeia de provedores de credenciais padrão](guide_credentials_default_chain.md) não é usada. Se o que você deseja é que um cliente de serviço use o provedor `instanceProfile`, é possível ignorar a cadeia padrão especificando o provedor `instanceProfile` no construtor do cliente de serviço:
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::instanceProfile();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $memoizedProvider // The default credential provider chain is not used.
]);
```
**Importante**
Os provedores de credenciais são invocados sempre que uma operação da API é realizada. Se o carregamento de credenciais for uma tarefa cara (por exemplo, o carregamento do disco ou de um recurso de rede) ou se as credenciais não estiverem armazenadas em cache pelo provedor, considere dispor o provedor de credenciais em uma função `Aws\Credentials\CredentialProvider::memoize`. O provedor de credenciais padrão usado pelo SDK é automaticamente memoizado.
**Topics**
+ [Provedor `login` no SDK para PHP](login-provider.md)
+ [Provedor `assumeRole` no SDK para PHP](assumerole-provider.md)
+ [Provedor `sso` no SDK para PHP](sso-provider.md)
+ [Provedor `defaultProvider` no SDK para PHP](defaultprovider-provider.md)
+ [Provedor `ecsCredentials` no SDK para PHP](ecscredentials-provider.md)
+ [Provedor `env` no SDK para PHP](env-provider.md)
+ [Provedor `assumeRoleWithWebIdentityCredentialProvider` no SDK para PHP](assume-role-with-web-identity-provider.md)
+ [Provedor `ini` no SDK para PHP](ini-provider.md)
+ [Provedor `process` no SDK para PHP](process-provider.md)
+ [Provedor `instanceProfile` no SDK para PHP](instanceprofile-provider.md)
# Provedor `login` no SDK para PHP
`Aws\Credentials\CredentialProvider::login`tenta carregar credenciais configuradas por uma sessão de login baseada em navegador facilitada por ferramentas como a CLI. AWS Após a autenticação, AWS gera credenciais temporárias que funcionam em todas as ferramentas AWS SDKs e locais.
Com esse processo, você pode se autenticar usando credenciais raiz criadas durante a configuração inicial da conta, um usuário do IAM ou uma identidade federada do seu provedor de identidade, e o SDK para AWS PHP gerencia automaticamente as credenciais temporárias para você. Essa abordagem aprimora a segurança ao eliminar a necessidade de armazenar credenciais de longo prazo localmente.
Ao executar o comando `aws login`, você pode selecionar entre suas sessões ativas do console ou fazer login por meio do fluxo de autenticação baseado em navegador para que sejam geradas credenciais temporárias automaticamente. O AWS SDK for PHP atualizará automaticamente essas credenciais, usando o serviço de login, por até 12 horas.
O provedor de login tenta carregar o token de acesso gerado pelo fluxo de trabalho da sessão de login mencionado anteriormente, com base no perfil fornecido. Se nenhum perfil for fornecido ao chamar o provedor, ele tentará resolver um perfil verificando primeiro a variável de `AWS_PROFILE` ambiente, antes de retornar ao perfil`default`. A configuração do código de entrada pode ser passada para o provedor, onde ele procurará um `region` valor para o cliente do serviço de login usado para atualizar as credenciais. Se nenhuma região for fornecida na matriz de configuração, o provedor tentará resolver uma região verificando a variável de `AWS_REGION` ambiente e, em seguida, um valor de região definido no perfil resolvido. Se nenhuma região for encontrada, o provedor retornará uma promessa rejeitada com instruções sobre como configurar uma região.
O provedor é chamado como parte da cadeia padrão e pode ser chamado diretamente.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::login(, ['region' => ]);
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
Por padrão, se nenhuma configuração de credenciais for fornecida no cliente de serviço que você deseja usar, esse provedor será chamado como parte da cadeia de `defaultProvider()` credenciais. Nesse cenário, a região do cliente do serviço é automaticamente passada para o `login()` provedor. Também nesse cenário, o valor do perfil passado para o provedor de login será resolvido verificando a variável de `AWS_PROFILE` ambiente, antes de retornar ao perfil`default`.
# Provedor `assumeRole` no SDK para PHP
Se você usar `Aws\Credentials\AssumeRoleCredentialProvider` para criar credenciais assumindo uma função, você precisa fornecer `'client'` informações com um objeto `StsClient` e detalhes de `'assume_role_params'`, conforme mostrado.
**nota**
Para evitar a busca desnecessária de AWS STS credenciais em cada operação de API, você pode usar a `memoize` função para gerenciar a atualização automática das credenciais quando elas expirarem. Consulte o código a seguir para ver um exemplo.
```
use Aws\Credentials\CredentialProvider;
use Aws\Credentials\InstanceProfileProvider;
use Aws\Credentials\AssumeRoleCredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
// Passing Aws\Credentials\AssumeRoleCredentialProvider options directly
$profile = new InstanceProfileProvider();
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$assumeRoleCredentials = new AssumeRoleCredentialProvider([
'client' => new StsClient([
'region' => 'us-east-2',
'version' => '2011-06-15',
'credentials' => $profile
]),
'assume_role_params' => [
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
],
]);
// To avoid unnecessarily fetching STS credentials on every API operation,
// the memoize function handles automatically refreshing the credentials when they expire
$provider = CredentialProvider::memoize($assumeRoleCredentials);
$client = new S3Client([
'region' => 'us-east-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Para obter mais informações sobre`'assume_role_params'`, consulte [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole).
# Provedor `sso` no SDK para PHP
`Aws\Credentials\CredentialProvider::sso` é o provedor de credenciais de autenticação única. Esse provedor também é conhecido como provedor de Centro de Identidade do AWS IAM credenciais.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$credentials = CredentialProvider::sso('profile default');
$s3 = new Aws\S3\S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Se você usar um perfil nomeado, substitua o nome do seu perfil por “`default`” no exemplo anterior. Para saber mais sobre como configurar perfis nomeados, consulte [Compartilhados `config` e `credentials` arquivos](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) no *Guia de referência de ferramentas AWS SDKs e ferramentas*. Como alternativa, você pode usar a variável de ambiente [https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) para especificar quais configurações do perfil usar.
Para entender mais como o provedor do IAM Identity Center funciona, consulte [Compreender a autenticação do IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) no *Guia de referência de ferramentas AWS SDKs e ferramentas*.
# Provedor `defaultProvider` no SDK para PHP
`Aws\Credentials\CredentialProvider::defaultProvider` é o provedor de credenciais padrão e também é chamado de [cadeia de provedores de credenciais padrão](guide_credentials_default_chain.md). Esse provedor é usado se você omitir uma opção `credentials` ao criar um cliente. Por exemplo, se você criar um S3Client conforme mostrado no trecho a seguir, o SDK usará o provedor padrão:
```
$client = new S3Client([
'region' => 'us-west-2'
]);
```
Você também pode usar defaultProvider no código se desejar fornecer parâmetros para provedores de credenciais específicos na cadeia. Por exemplo, a amostra a seguir fornece configurações personalizadas de tempo limite de conexão e novas tentativas caso a função de provedor `ecsCredentials` seja usada.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::defaultProvider([
'timeout' => '1.5',
'retries' => 5
]);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
# Provedor `ecsCredentials` no SDK para PHP
`Aws\Credentials\CredentialProvider::ecsCredentials` tenta carregar credenciais por uma solicitação `GET`, cujo URI é especificado pela variável de ambiente `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` no contêiner.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
# Provedor `env` no SDK para PHP
O uso de variáveis de ambiente para conter suas credenciais evita que você compartilhe acidentalmente sua AWS chave de acesso secreta. Recomendamos que você nunca adicione suas chaves de AWS acesso diretamente ao cliente em nenhum arquivo de produção.
Para fazer a autenticação no Amazon Web Services, o SDK verifica primeiro a existência de credenciais nas variáveis de ambiente. O SDK usa a função `getenv()` para procurar o `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` e as variáveis de ambiente do `AWS_SESSION_TOKEN`. Essas credenciais são conhecidas como credenciais de ambiente. Para obter instruções sobre como obter esses valores, consulte [Autenticar usando credenciais de curto prazo no Guia](https://docs.aws.amazon.com/sdkref/latest/guide/access-temp-idc.html) de *referência de ferramentas AWS SDKs e ferramentas*.
Se você estiver hospedando seu aplicativo em [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_PHP_eb.html), poderá definir as variáveis de `AWS_SESSION_TOKEN` ambiente `AWS_ACCESS_KEY_ID``AWS_SECRET_KEY`,, e [por meio do AWS Elastic Beanstalk console](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-softwaresettings.html#environments-cfg-softwaresettings-console) para que o SDK possa usar essas credenciais automaticamente.
Para obter mais informações sobre como definir variáveis de ambiente, consulte [Suporte a variáveis de ambiente](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) no *Guia de referência de ferramentas AWS SDKs e ferramentas*. Além disso, para obter uma lista de todas as variáveis de ambiente suportadas pela maioria AWS SDKs, consulte [Lista de variáveis de ambiente](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings).
Você também pode definir variáveis de ambiente na linha de comando, como mostrado aqui.
**Linux**
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your Conta da AWS.
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Conta da AWS.
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Conta da AWS.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs other than PHP.
```
**Windows**
```
C:\> SET AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your Conta da AWS.
C:\> SET AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Conta da AWS.
C:\> SET AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Conta da AWS.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs besides PHP.
```
`Aws\Credentials\CredentialProvider::env` tenta carregar credenciais a partir de variáveis de ambiente.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => CredentialProvider::env()
]);
```
# Provedor `assumeRoleWithWebIdentityCredentialProvider` no SDK para PHP
`Aws\Credentials\CredentialProvider::assumeRoleWithWebIdentityCredentialProvider` tenta carregar credenciais assumindo uma função. Se as variáveis de ambiente `AWS_ROLE_ARN` e `AWS_WEB_IDENTITY_TOKEN_FILE` estiverem presentes, o provedor tentará assumir a função especificada no `AWS_ROLE_ARN` usando o token no disco no caminho completo especificado em `AWS_WEB_IDENTITY_TOKEN_FILE`. Se as variáveis de ambiente forem usadas, o provedor tentará definir a sessão na variável de ambiente `AWS_ROLE_SESSION_NAME`.
Se as variáveis de ambiente não estiverem definidas, o provedor usará o perfil padrão ou o definido como `AWS_PROFILE`. O provedor lê perfis de `~/.aws/credentials` e `~/.aws/config` por padrão, e pode ler de perfis especificados na opção de configuração `filename`. O provedor assumirá a função no `role_arn` do perfil lendo um token do caminho completo definido no `web_identity_token_file`. O `role_session_name` será usado se definido no perfil.
O provedor será chamado como parte da cadeia padrão e poderá ser chamado diretamente.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Por padrão, esse provedor de credenciais herdará a região configurada que será usada pelo StsClient para assumir a função. Opcionalmente, um completo StsClient pode ser fornecido. As credenciais devem ser definidas conforme `false` as fornecidas StsClient.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
$stsClient = new StsClient([
'region' => 'us-west-2',
'version' => 'latest',
'credentials' => false
])
$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider([
'stsClient' => $stsClient
]);
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# Provedor `ini` no SDK para PHP
`Aws\Credentials\CredentialProvider::ini` tenta carregar credenciais dos arquivos de `config` e `credentials` compartilhados. Por padrão, o SDK tenta carregar o perfil “padrão” do AWS `credentials` arquivo compartilhado localizado em`~/.aws/credentials`. Se o SDK encontrar a variável de `AWS_SDK_LOAD_NONDEFAULT_CONFIG` ambiente, ele também verificará se há um perfil “padrão” no AWS `config` arquivo compartilhado localizado em`~/.aws/config`.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::ini();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Você pode usar um perfil personalizado ou o local de um arquivo .ini fornecendo argumentos à função que cria o provedor.
```
$profile = 'production';
$path = '/full/path/to/credentials.ini';
$provider = CredentialProvider::ini($profile, $path);
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# Provedor `process` no SDK para PHP
`Aws\Credentials\CredentialProvider::process`tenta carregar credenciais executando o `credential_process` valor especificado em um perfil em um arquivo de [AWS configuração compartilhado](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
Por padrão, o SDK tenta carregar primeiro o perfil “padrão” a partir do AWS `credentials` arquivo compartilhado localizado em`~/.aws/credentials`. Se o perfil “padrão” não for encontrado no arquivo `credentials` compartilhado, o SDK procurará o perfil padrão no arquivo `config` compartilhado. Veja a seguir um exemplo de configuração para o arquivo `credentials` compartilhado.
```
[default]
credential_process = /path/to/file/credential_returning_executable.sh --custom-command custom_parameter
```
O SDK chamará o comando `credential_process` exatamente como fornecido usando a função `shell_exec` do PHP e, em seguida, lerá dados JSON de stdout. O comando `credential_process` deve gravar as credenciais em stdout no seguinte formato:
```
{
"Version": 1,
"AccessKeyId": "",
"SecretAccessKey": "",
"SessionToken": "",
"Expiration": ""
}
```
`SessionToken` e `Expiration` são opcionais. Se presente, as credenciais serão tratadas como temporárias.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::process();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Você pode usar um perfil personalizado ou o local de um arquivo .ini fornecendo argumentos à função que cria o provedor.
```
$profile = 'production';
$path = '/full/path/to/credentials.ini';
$provider = CredentialProvider::process($profile, $path);
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# Provedor `instanceProfile` no SDK para PHP
`Aws\Credentials\CredentialProvider::instanceProfile` tenta carregar credenciais de um perfil do IAM especificado em um perfil de instância do Amazon EC2.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::instanceProfile();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
Por padrão, o provedor de credenciais tentará obter as credenciais três vezes. O número de novas tentativas pode ser definido com a opção `retries` e totalmente desabilitado definindo a opção como `0`, como mostrado no código a seguir.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile([
'retries' => 0
]);
$memoizedProvider = CredentialProvider::memoize($provider);
```
Se a variável de ambiente `AWS_METADATA_SERVICE_NUM_ATTEMPTS` estiver disponível, seu valor terá precedência sobre a opção de novas tentativas mostrada anteriormente.
**nota**
Você pode desabilitar essa tentativa de carga em perfis de instâncias do Amazon EC2 definindo a variável de ambiente `AWS_EC2_METADATA_DISABLED` como `true`.
# Encadear provedores de credenciais no SDK para PHP
Você pode encadear os provedores de credenciais usando a função `Aws\Credentials\CredentialProvider::chain()`. Essa função aceita um número de argumentos variadic, cada um dos quais são funções do provedor de credenciais. Essa função retorna uma nova função que é a composição das funções fornecidas, de forma que elas sejam invocadas uma depois da outra, até que um dos provedores retorne uma promessa que seja cumprida com êxito.
O `defaultProvider` usa essa composição para verificar vários provedores antes de falhar. A origem do `defaultProvider` demonstra o uso da função `chain`.
```
// This function returns a provider
public static function defaultProvider(array $config = [])
{
// This function is the provider, which is actually the composition
// of multiple providers. Notice that we are also memoizing the result by
// default.
return self::memoize(
self::chain(
self::env(),
self::ini(),
self::instanceProfile($config)
)
);
}
```
# Criar um provedor de credenciais personalizado a ser usado com o SDK para PHP
Os provedores de credenciais são simplesmente funções que quando invocadas retornam uma promessa (`GuzzleHttp\Promise\PromiseInterface`) que é cumprida com um objeto `Aws\Credentials\CredentialsInterface` ou rejeitada com uma `Aws\Exception\CredentialsException`.
Uma prática recomendada para criar provedores é criar uma função que é invocada para criar o provedor de credenciais real. Como exemplo, veja a origem do provedor `env` (levemente modificada para fins de exemplo). Observe que é uma função que retorna a função do provedor real. Isso permite que você componha facilmente provedores de credenciais e distribua-os como valores.
```
use GuzzleHttp\Promise;
use GuzzleHttp\Promise\RejectedPromise;
// This function CREATES a credential provider
public static function env()
{
// This function IS the credential provider
return function () {
// Use credentials from environment variables, if available
$key = getenv(self::ENV_KEY);
$secret = getenv(self::ENV_SECRET);
if ($key && $secret) {
return Create::promise_for(
new Credentials($key, $secret, getenv(self::ENV_SESSION))
);
}
$msg = 'Could not find environment variable '
. 'credentials in ' . self::ENV_KEY . '/' . self::ENV_SECRET;
return new RejectedPromise(new CredentialsException($msg));
};
}
```
# Memoizar credenciais no SDK para PHP
Às vezes, pode ser necessário criar um provedor de credenciais que lembre o valor de retorno anterior. Isso pode ser útil para o desempenho quando o carregamento de credenciais é uma operação cara ou ao usar a classe `Aws\Sdk` para compartilhar um provedor de credenciais entre vários clientes. Você pode adicionar memoização a um provedor de credenciais integrando a função de provedor de credenciais em uma função `memoize`.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile();
// Wrap the actual provider in a memoize function
$provider = CredentialProvider::memoize($provider);
// Pass the provider into the Sdk class and share the provider
// across multiple clients. Each time a new client is constructed,
// it will use the previously returned credentials as long as
// they haven't yet expired.
$sdk = new Aws\Sdk(['credentials' => $provider]);
$s3 = $sdk->getS3(['region' => 'us-west-2', 'version' => 'latest']);
$ec2 = $sdk->getEc2(['region' => 'us-west-2', 'version' => 'latest']);
assert($s3->getCredentials() === $ec2->getCredentials());
```
Quando as credenciais memoizadas expiram, o wrapper de memoização invoca o provedor encapsulado em uma tentativa de atualizar as credenciais.
# Assuma uma função do IAM usando a AWS SDK para PHP versão 3
## Uso de perfis do IAM para credenciais variáveis da instância do Amazon EC2
Se você estiver executando seu aplicativo em uma instância do Amazon EC2, a forma preferida de fornecer credenciais para fazer chamadas AWS é usar uma [função do IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) para obter credenciais de segurança temporárias.
Quando você usa perfis do IAM, não há a necessidade de se preocupar com o gerenciamento de credenciais na aplicação. Eles permitem que uma instância “assuma” um perfil recuperando credenciais temporárias do servidor de metadados da instância do Amazon EC2.
As credenciais temporárias, geralmente conhecidas como **credenciais de perfil de instância**, permitem acesso a ações e recursos que a política do perfil permite. O Amazon EC2 controla todo o trabalho de autenticação de instâncias com segurança para que o serviço IAM assuma o perfil e, periodicamente, atualiza as credenciais dos perfis recuperadas. Isso mantém o aplicativo seguro com praticamente nenhum trabalho de sua parte. Para obter uma lista de serviços que aceitam credenciais de segurança temporárias, consulte os [serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
**nota**
Para evitar acessar o serviço de metadados sempre, é possível passar uma instância de `Aws\CacheInterface` como a opção `'credentials'` para um construtor de cliente. Isso permite que o SDK use credenciais de perfil de instância em cache no lugar. Para obter detalhes, consulte [Configuração do AWS SDK para PHP Versão 3](guide_configuration.md).
Para obter mais informações sobre o desenvolvimento de aplicativos do Amazon EC2 usando o SDKs, consulte [Usando funções do IAM para instâncias do Amazon EC2 AWS](https://docs.aws.amazon.com/sdkref/latest/guide/access-iam-roles-for-ec2.html) *SDKs no* Guia de referência de ferramentas.
### Criar e atribuir o perfil do IAM a uma instância do Amazon EC2
1. Crie um cliente do IAM.
**Importações**
```
require 'vendor/autoload.php';
use Aws\Iam\IamClient;
```
**Código de exemplo**
```
$client = new IamClient([
'region' => 'us-west-2',
'version' => '2010-05-08'
]);
```
1. Crie um perfil do IAM com as permissões das ações e dos recursos que você usará.
**Código de exemplo**
```
$result = $client->createRole([
'AssumeRolePolicyDocument' => 'IAM JSON Policy', // REQUIRED
'Description' => 'Description of Role',
'RoleName' => 'RoleName', // REQUIRED
]);
```
1. Crie um perfil de instância do IAM e armazene o nome do recurso da Amazon (ARN) do resultado.
**nota**
Se você usar o console do IAM em vez do AWS SDK para PHP, o console cria um perfil de instância automaticamente e dá a ele o mesmo nome da função à qual ele corresponde.
**Código de exemplo**
```
$IPN = 'InstanceProfileName';
$result = $client->createInstanceProfile([
'InstanceProfileName' => $IPN ,
]);
$ARN = $result['Arn'];
$InstanceID = $result['InstanceProfileId'];
```
1. Crie um cliente do Amazon EC2.
**Importações**
```
require 'vendor/autoload.php';
use Aws\Ec2\Ec2Client;
```
**Código de exemplo**
```
$ec2Client = new Ec2Client([
'region' => 'us-west-2',
'version' => '2016-11-15',
]);
```
1. Adicione o perfil de instância a uma instância do Amazon EC2 em execução ou interrompida. Use o nome do perfil de instância do seu perfil do IAM.
**Código de exemplo**
```
$result = $ec2Client->associateIamInstanceProfile([
'IamInstanceProfile' => [
'Arn' => $ARN,
'Name' => $IPN,
],
'InstanceId' => $InstanceID
]);
```
Para obter mais informações, consulte [Funções do IAM para o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) no *Guia do usuário do Amazon EC2*.
## Usar perfis do IAM para tarefas do Amazon ECS
Uma tarefa no Amazon Elastic Container Service (Amazon ECS) pode assumir uma função do IAM para AWS fazer chamadas de API. Essa é uma estratégia de gerenciar credenciais para as aplicações usarem, semelhante à forma como os perfis de instância do Amazon EC2 fornecem credenciais para instâncias do Amazon EC2.
[Em vez de criar e distribuir AWS credenciais de longo prazo para contêineres ou usar a função da instância do Amazon EC2, você pode associar uma função do IAM que usa credenciais temporárias a uma definição de tarefa ou operação de API do ECS. `RunTask`](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-ecs-2014-11-13.html#runtask)
Para obter mais informações sobre o uso dos perfis do IAM que as tarefas de contêiner podem assumir, consulte o tópico da [Perfil do IAM de tarefa](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) no *Guia do desenvolvedor do Amazon ECS*. Para obter exemplos de uso do perfil do IAM da tarefa na forma de um `taskRoleArn` nas definições de tarefas, consulte [Exemplos de definições de tarefas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-example-taskdefs.html) também no *Guia do desenvolvedor do Amazon ECS*.
## Assumindo uma função do IAM em outra Conta da AWS
Quando você trabalha em uma Conta da AWS (Conta A) e quer assumir uma função em outra conta (Conta B), você deve primeiro criar uma função do IAM na Conta B. Essa função permite que entidades na sua conta (Conta A) realizem ações específicas na Conta B. Para obter mais informações sobre o acesso entre contas, consulte [Tutorial: Delegar acesso entre AWS contas usando funções do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html).
Depois de criar um perfil na Conta B, registre o ARN do perfil. Você usará esse ARN ao assumir a função da Conta A. Você assume a função usando as AWS credenciais associadas à sua entidade na Conta A.
Crie um AWS STS cliente com credenciais para o seu Conta da AWS. No exemplo a seguir, usamos um perfil de credenciais, mas é possível usar qualquer método. Com o cliente AWS STS recém-criado, chame assume-role e forneça um sessionName personalizado. Recupere as novas credenciais temporárias do resultado. Por padrão, as credenciais duram uma hora.
**Código de exemplo**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$result = $stsClient->AssumeRole([
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Para obter mais informações, consulte [Como usar funções do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) ou [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)na Referência AWS SDK para PHP da API.
## Usar um perfil do IAM com identidade da web
O Web Identity Federation permite que os clientes usem provedores de identidade terceirizados para autenticação ao acessar AWS recursos. Antes de assumir um perfil com identidade da web, você deve criar um perfil do IAM e configurar um provedor de identidades (IdP) da web. Para obter mais informações, consulte [Criar uma função para identidades da web ou federação do OpenID Connect (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html).
Depois de [criar um provedor de identidade](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) e [criar uma função para sua identidade na web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html), use um AWS STS cliente para autenticar um usuário. Forneça o webIdentityToken e ProviderId para sua identidade e o ARN da função do IAM com permissões para o usuário.
**Código de exemplo**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$duration = 3600;
$result = $stsClient->AssumeRoleWithWebIdentity([
'WebIdentityToken' => "FACEBOOK_ACCESS_TOKEN",
'ProviderId' => "graph.facebook.com",
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Para obter mais informações, consulte [AssumeRoleWithWebIdentity—Federação por meio de um provedor de identidade baseado na Web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity.html) ou [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerolewithwebidentity)na Referência da AWS SDK para PHP API.
## Assumir função com perfil
### Definir perfis em `~/.aws/credentials`
Você pode configurar o AWS SDK para PHP para usar uma função do IAM definindo um perfil em`~/.aws/credentials`.
Crie um perfil com a configuração do `role_arn` para o perfil que você assumirá. Inclua também a configuração `source_profile` para um perfil com credenciais que tenham permissões para assumir o perfil do IAM. Para obter mais detalhes sobre essas configurações, consulte [Assumir credenciais de função](https://docs.aws.amazon.com/sdkref/latest/guide/feature-assume-role-credentials.html) no *Guia de referência de ferramentas AWS SDKs e ferramentas*.
Por exemplo, no `~/.aws/credentials` seguinte, o perfil `project1` define o `role_arn` e especifica o perfil `default` como a fonte das credenciais para verificar se a entidade associada a elas pode assumir o perfil.
```
[project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Ao definir a variável de ambiente `AWS_PROFILE` ou usar o parâmetro `profile` ao instanciar um cliente de serviço, o perfil especificado em `project1` será assumido, usando o perfil `default` como as credenciais de origem.
O trecho a seguir mostra o uso do parâmetro `profile` em um construtor do `S3Client`. O `S3Client` terá as permissões associadas à função associada ao perfil `project1`.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
### Definir perfis em `~/.aws/config`
O arquivo `~/.aws/config` também pode conter perfis que você deseja que sejam assumidos. Se você definir a variável de ambiente `AWS_SDK_LOAD_NONDEFAULT_CONFIG`, o SDK for PHP carregará perfis do arquivo `config`. Quando `AWS_SDK_LOAD_NONDEFAULT_CONFIG` estiver configurado, o SDK carrega perfis de `~/.aws/config` e `~/.aws/credentials`. Os perfis de `~/.aws/credentials` são carregados por último e têm precedência sobre um perfil de `~/.aws/config` com o mesmo nome. Perfis de qualquer um desses locais podem servir como o `source_profile` ou o perfil a ser assumido.
O exemplo a seguir usa o perfil `project1` definido no arquivo `config` e o perfil `default` no arquivo `credentials`. O `AWS_SDK_LOAD_NONDEFAULT_CONFIG` também está definido.
```
# Profile in ~/.aws/config.
[profile project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
```
```
# Profile in ~/.aws/credentials.
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Quando o construtor do `S3Client` executa o trecho a seguir, a função definida no perfil `project1` será assumida usando as credenciais associadas ao perfil `default`.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
# Use credenciais AWS STS temporárias do SDK for PHP
AWS Security Token Service (AWS STS) permite que você solicite privilégios limitados e **credenciais temporárias** para usuários do IAM ou para usuários que você autentica por meio da federação de identidades. Para uma compreensão mais profunda, 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*. Você pode usar credenciais de segurança temporárias para acessar a maioria dos AWS serviços. Para obter uma lista de serviços que aceitam credenciais de segurança temporárias, consulte os [serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
Um caso de uso comum para credenciais temporárias é conceder aos aplicativos móveis ou do lado do cliente acesso aos AWS recursos autenticando usuários por meio de provedores de identidade terceirizados (consulte [Web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html) Identity Federation).
## Obtenção de credenciais temporárias
AWS STS tem várias operações que retornam credenciais temporárias, mas a `GetSessionToken` operação é a mais simples de demonstrar. O trecho a seguir recupera credenciais temporárias chamando o método `getSessionToken` do cliente STS do SDK do PHP.
```
$sdk = new Aws\Sdk([
'region' => 'us-east-1',
]);
$stsClient = $sdk->createSts();
$result = $stsClient->getSessionToken();
```
O resultado de `GetSessionToken` e as outras AWS STS operações sempre contêm um `'Credentials'` valor. Se você imprimir o `$result` (por exemplo, usando `print_r($result)`), ele será semelhante ao seguinte.
```
Array
(
...
[Credentials] => Array
(
[SessionToken] => ''
[SecretAccessKey] => ''
[Expiration] => 2013-11-01T01:57:52Z
[AccessKeyId] => ''
)
...
)
```
## Fornecendo credenciais temporárias ao AWS SDK para PHP
Você pode usar credenciais temporárias com outro AWS cliente instanciando o cliente e transmitindo os valores recebidos diretamente. AWS STS
```
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Você também pode construir um objeto `Aws\Credentials\Credentials` e usá-lo ao instanciar o cliente.
```
use Aws\Credentials\Credentials;
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$credentials = new Credentials(
$result['Credentials']['AccessKeyId'],
$result['Credentials']['SecretAccessKey'],
$result['Credentials']['SessionToken']
);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
No entanto, a *melhor* maneira de fornecer credenciais temporárias é usar o método auxiliar `createCredentials()` incluído com o `StsClient`. Esse método extrai os dados de um AWS STS resultado e cria o `Credentials` objeto para você.
```
$result = $stsClient->getSessionToken();
$credentials = $stsClient->createCredentials($result);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Para obter mais informações sobre por que você pode precisar usar credenciais temporárias em seu aplicativo ou projeto, consulte [Cenários para conceder acesso temporário](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) na AWS STS documentação.
# Criar clientes anônimos no SDK para PHP
Em alguns casos, talvez você queira criar um cliente que não está associado a todas as credenciais. Isso permite que você faça solicitações anônimas para um serviço.
Por exemplo, os objetos do Amazon S3 e os domínios do Amazon CloudSearch podem ser configurados para permitir acesso anônimo.
Para criar um cliente anônimo, você pode definir a opção `'credentials'` como `false`.
```
$s3Client = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'credentials' => false
]);
// Makes an anonymous request. The object would need to be publicly
// readable for this to succeed.
$result = $s3Client->getObject([
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'my-key',
]);
```