

O AWS SDK para JavaScript v2 chegou ao fim do suporte. Recomendamos migrar para o [AWS SDK para JavaScript v3](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/). Para ver detalhes e informações sobre como migrar, consulte este [anúncio](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/).

# Definir credenciais
<a name="setting-credentials"></a>

A AWS usa credenciais para identificar quem está chamando serviços e se o acesso aos recursos solicitados é permitido. 

Independentemente da execução em um navegador da Web ou em um servidor Node.js, o código JavaScript deve obter credenciais válidas para acessar serviços por meio da API. As credenciais podem ser definidas globalmente no objeto de configuração usando `AWS.Config`, ou por serviço, passando credenciais diretamente para um objeto de serviço.

Há várias maneiras de definir credenciais diferentes entre Node.js e JavaScript em navegadores da web. Os tópicos nesta seção descrevem como definir credenciais em Node.js ou navegadores da web. Em cada caso, as opções são apresentadas na ordem recomendada.

## Melhores práticas para credenciais
<a name="credentials-best-practices"></a>

A definição de credenciais apropriada garante que o aplicativo ou o script de navegador possa acessar os serviços e os recursos necessários ao mesmo tempo que minimiza a exposição a problemas de segurança que possam afetar aplicativos de missão crítica ou comprometer dados confidenciais.

Um princípio importante a ser aplicado durante a definição de credenciais é sempre conceder o menor privilégio necessário para a tarefa. É mais seguro fornecer permissões mínimas nos recursos e adicionar mais permissões adicionais conforme necessário, em vez de fornecer permissões que excedam o menor privilégio e, dessa forma, precisar corrigir problemas de segurança que possam ser descobertos depois. Por exemplo, a menos que você precise ler e gravar recursos individuais, como objetos em um bucket do Amazon S3 ou uma tabela do DynamoDB, defina essas permissões como somente leitura.

Para obter mais informações sobre como conceder o privilégio mínimo, consulte a seção [Conceder privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) do tópico Melhores práticas no *Guia do usuário do IAM*.

**Atenção**  
Embora seja possível fazer isso, recomendamos não codificar credenciais dentro de um aplicativo ou de um script de navegador. As credenciais de codificação física representam o risco de expor informações confidenciais.

Para obter mais informações sobre como gerenciar as chaves de acesso, consulte [ Práticas recomendadas para gerenciar chaves de acesso](https://docs.aws.amazon.com/general/latest/gr/aws-access-keys-best-practices.html) da AWS na Referência geral da AWS.

**Topics**
+ [Melhores práticas para credenciais](#credentials-best-practices)
+ [Definir credenciais em Node.js](setting-credentials-node.md)
+ [Definir credenciais em um navegador da Web](setting-credentials-browser.md)

# Definir credenciais em Node.js
<a name="setting-credentials-node"></a>

Há várias maneiras em Node.js de fornecer as credenciais para o SDK. Algumas dessas são mais seguras e outras oferecem mais comodidade durante o desenvolvimento de aplicativos. Ao obter credenciais em Node.js, tome cuidado ao confiar em mais de uma origem como uma variável de ambiente e um arquivo JSON carregado. Altere as permissões em que o código é executado sem perceber a alteração que aconteceu.

Aqui estão as maneiras como é possível fornecer as credenciais em ordem de recomendação:

1. Carregado a partir dos perfis do AWS Identity and Access Management (IAM) para o Amazon EC2

1. Carregadas a partir do arquivo de credenciais compartilhado (`~/.aws/credentials`)

1. Carregadas de variáveis de ambiente

1. Carregadas de um arquivo JSON no disco

1. Outras classes de provedor de credenciais fornecidas pelo SDK do JavaScript

Se mais de uma fonte de credenciais estiver disponível para o SDK, a precedência padrão da seleção será a seguinte:

1. Credenciais que são explicitamente definidas por meio do construtor do cliente de serviço

1. Variáveis de ambiente

1. O arquivo de credenciais compartilhado

1. Credenciais carregadas do provedor de credenciais do ECS (se aplicável)

1. Credenciais obtidas por meio de um processo de credenciais especificado no arquivo de configuração da AWS compartilhado ou no arquivo de credenciais compartilhado. Para ter mais informações, consulte [Carregamento de credenciais no Node.js usando um processo de credenciais configuradas](loading-node-credentials-configured-credential-process.md).

1. Credenciais carregadas do IAM da AWS usando o provedor de credenciais da instância do Amazon EC2 (se configurado nos metadados da instância).

Para obter mais informações, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Credentials.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Credentials.html) e [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CredentialProviderChain.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CredentialProviderChain.html) na Referência da API do .

**Atenção**  
Embora seja possível fazer isso, não recomendamos codificar as credenciais da AWS no aplicativo. Codificar credenciais oferece um risco de expor o ID de chave de acesso e a chave de acesso secreta.

Os tópicos nesta seção descrevem como carregar credenciais em Node.js.

**Topics**
+ [Carregar credenciais em Node.js de perfis do IAM para o Amazon EC2](loading-node-credentials-iam.md)
+ [Carregar credenciais de uma função do Lambda de Node.js](loading-node-credentials-lambda.md)
+ [Carregar credenciais em Node.js do arquivo de credenciais compartilhado](loading-node-credentials-shared.md)
+ [Carregar credenciais em Node.js de variáveis de ambiente.](loading-node-credentials-environment.md)
+ [Carregar credenciais em Node.js de um arquivo JSON](loading-node-credentials-json-file.md)
+ [Carregamento de credenciais no Node.js usando um processo de credenciais configuradas](loading-node-credentials-configured-credential-process.md)

# Carregar credenciais em Node.js de perfis do IAM para o Amazon EC2
<a name="loading-node-credentials-iam"></a>

Se executar o aplicativo Node.js em uma instância do Amazon EC2, você poderá aproveitar perfis do IAM para o Amazon EC2 fornecer credenciais automaticamente para a instância. Se você configurar a instância para usar perfis do IAM, o SDK selecionará automaticamente as credenciais do do aplicativo, eliminando a necessidade de fornecer credenciais manualmente.

Para obter mais informações sobre como adicionar perfis do IAM a uma instância do Amazon EC2, consulte [Como usar funções do IAM para instâncias do Amazon EC2](https://docs.aws.amazon.com/sdkref/latest/guide/access-iam-roles-for-ec2.html) no AWS Guia de referência dos *SDKs* e Ferramentas.

# Carregar credenciais de uma função do Lambda de Node.js
<a name="loading-node-credentials-lambda"></a>

Ao criar uma função do AWS Lambda, você deve criar um perfil do IAM especial com permissão para executar a função. Essa função é chamada de *função de execução*. Ao configurar uma função do Lambda, você deve especificar o perfil do IAM que criou como a função de execução correspondente.

A função de execução fornece a função do Lambda com as credenciais de que precisa para executar e invocar outros serviços da web. Dessa maneira, você não precisa fornecer credenciais para o código Node.js gravado em uma função do Lambda.

Para obter mais informações sobre como configurar uma função de execução do Lambda, consulte [Gerenciar permissões](https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role): usar uma perfil do IAM (prtfil de execução) no *Guia do desenvolvedor do AWS Lambda*.

# Carregar credenciais em Node.js do arquivo de credenciais compartilhado
<a name="loading-node-credentials-shared"></a>

Mantenha os dados das credenciais do AWS em um arquivo compartilhado usado por SDKs e a interface de linha de comando. Quando o SDK para JavaScript carregar, ele pesquisará automaticamente o arquivo de credenciais compartilhado, que é chamado "credentials". Onde você mantém o arquivo de credenciais compartilhado depende do sistema operacional:
+ O arquivo de credenciais compartilhado no Linux, Unix e macOS: `~/.aws/credentials`
+ O arquivo de credenciais compartilhado no Windows: `C:\Users\USER_NAME\.aws\credentials`

Se você ainda não tiver um arquivo de credenciais compartilhadas, consulte [Autenticação do SDK com AWS](getting-your-credentials.md). Após seguir essas instruções, você verá um texto semelhante ao seguinte no arquivo de credenciais, em que *<YOUR\$1ACCESS\$1KEY\$1ID>* é o ID de chave de acesso e *<YOUR\$1SECRET\$1ACCESS\$1KEY>* é a chave de acesso secreta:

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

Para obter um exemplo que mostra este arquivo sendo usado, consulte [Conceitos básicos de Node.js](getting-started-nodejs.md).

O título da seção `[default]` especifica um perfil padrão e os valores associados das credenciais. Crie perfis adicionais no mesmo arquivo de configuração compartilhado, cada um com as próprias informações de credencial. O seguinte exemplo mostra um arquivo de configuração com o perfil padrão e dois perfis adicionais:

```
[default] ; default profile
aws_access_key_id = <DEFAULT_ACCESS_KEY_ID>
aws_secret_access_key = <DEFAULT_SECRET_ACCESS_KEY>
    
[personal-account] ; personal account profile
aws_access_key_id = <PERSONAL_ACCESS_KEY_ID>
aws_secret_access_key = <PERSONAL_SECRET_ACCESS_KEY>
    
[work-account] ; work account profile
aws_access_key_id = <WORK_ACCESS_KEY_ID>
aws_secret_access_key = <WORK_SECRET_ACCESS_KEY>
```

Por padrão, o SDK verifica a variável de ambiente `AWS_PROFILE` para determinar qual perfil usar. Se a variável `AWS_PROFILE` não estiver definida no ambiente, o SDK usará as credenciais do perfil `[default]`. Para usar um dos perfis alternativos, configure ou altere o valor da variável de ambiente `AWS_PROFILE`. Por exemplo, considerando o arquivo de configuração mostrado acima, para usar as credenciais da conta de serviço, defina a variável de ambiente `AWS_PROFILE` como `work-account` (conforme adequado para seu sistema operacional).

**nota**  
Ao definir variáveis de ambiente, lembre-se de tomar as medidas adequadas posteriormente (de acordo com as necessidades do seu sistema operacional) para disponibilizar as variáveis no ambiente de comando ou shell.

Depois de definir a variável de ambiente (se necessário), você pode executar um arquivo de JavaScript que usa o SDK como uma arquivo chamado `script.js`, por exemplo.

```
$ node script.js
```

Também selecione explicitamente o perfil usado pelo SDK definindo `process.env.AWS_PROFILE` antes de carregar o SDK ou selecionando o provedor de credenciais, conforme mostrado no seguinte exemplo:

```
var credentials = new AWS.SharedIniFileCredentials({profile: 'work-account'});
AWS.config.credentials = credentials;
```

# Carregar credenciais em Node.js de variáveis de ambiente.
<a name="loading-node-credentials-environment"></a>

O SDK detecta automaticamente credenciais da AWS definidas como variáveis no ambiente e as usa em solicitações do SDK, eliminando a necessidade de gerenciar credenciais no aplicativo. As variáveis de ambiente definidas para fornecer as credenciais são:
+ `AWS_ACCESS_KEY_ID`
+ `AWS_SECRET_ACCESS_KEY`
+ `AWS_SESSION_TOKEN`

Para obter mais detalhes sobre a configuração de 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 AWS SDKs e Ferramentas*.

# Carregar credenciais em Node.js de um arquivo JSON
<a name="loading-node-credentials-json-file"></a>

Carregue a configuração e as credenciais de um documento JSON no disco usando `AWS.config.loadFromPath`. O caminho especificado é relativo ao diretório de trabalho atual do processo. Por exemplo, para carregar credenciais de um arquivo `'config.json'` com o seguinte conteúdo:

```
{ "accessKeyId": <YOUR_ACCESS_KEY_ID>, "secretAccessKey": <YOUR_SECRET_ACCESS_KEY>, "region": "us-east-1" }
```

Depois, use o seguinte código:

```
var AWS = require("aws-sdk");
AWS.config.loadFromPath('./config.json');
```

**nota**  
Carregar dados de configuração de um documento JSON redefine todos os dados de configuração existentes. Adicione dados de configuração depois de usar essa técnica. Carregar credenciais de um documento JSON não é suportado em scripts de navegador.

# Carregamento de credenciais no Node.js usando um processo de credenciais configuradas
<a name="loading-node-credentials-configured-credential-process"></a>

É possível obter credenciais usando um método que não é baseado no SDK. Para fazê-lo, especifique um processo de credenciais no arquivo de configuração da AWS compartilhado ou no arquivo de credenciais compartilhado. Se a variável de ambiente `AWS_SDK_LOAD_CONFIG` for definida como qualquer valor, o SDK preferirá o processo especificado no arquivo de configuração em vez de o processo especificado no arquivo de credenciais (se houver).

Para obter detalhes sobre como especificar um processo de credenciais no arquivo de configuração da AWS compartilhado ou no arquivo de credenciais compartilhado, consulte o *Command Reference AWS CLI*, especificamente as informações sobre [Obtenção de credenciais a partir de processos externos](https://docs.aws.amazon.com/cli/latest/topic/config-vars.html#sourcing-credentials-from-external-processes).

Para obter informações sobre como usar a variável de ambiente `AWS_SDK_LOAD_CONFIG`, consulte [Usar um arquivo de configuração compartilhado](setting-region.md#setting-region-config-file) neste documento.

# Definir credenciais em um navegador da Web
<a name="setting-credentials-browser"></a>

Há várias maneiras de fornecer as credenciais para o SDK de scripts de navegador. Algumas dessas são mais seguras e outras oferecem mais comodidade durante o desenvolvimento de scripts. Aqui estão as maneiras como é possível fornecer as credenciais em ordem de recomendação:

1. Usar o Amazon Cognito Identity para autenticar usuários e fornecer credenciais

1. Usar identidade federada da web

1. Codificada no script

**Atenção**  
Não recomendamos codificar as credenciais da AWS nos scripts. A codificação rígida de credenciais oferece um risco de expor o ID de chave de acesso e a chave de acesso secreta.

**Topics**
+ [Usando do Amazon Cognito Identity para autenticar usuários](loading-browser-credentials-cognito.md)
+ [Usar identidade federada da web para autenticar usuários](loading-browser-credentials-federated-id.md)
+ [Exemplos de identidades federadas da Web](config-web-identity-examples.md)

# Usando do Amazon Cognito Identity para autenticar usuários
<a name="loading-browser-credentials-cognito"></a>

A forma recomendada de obter credenciais da AWS para os scripts do seu navegador é usar o objeto de credenciais do Amazon Cognito Identity, `AWS.CognitoIdentityCredentials`. O Amazon Cognito permite a autenticação de usuários por meio de provedores de identidade terceirizados.

Para usar o Amazon Cognito Identity, você deve primeiro criar um banco de identidades no console do Amazon Cognito. Um grupo de identidades representa o grupo de identidades fornecido pelo aplicativo para os usuários. As identidades atribuídas a usuários identificam com exclusividade cada conta de usuário. As identidades do Amazon Cognito não são credenciais. Elas são trocadas por credenciais usando o suporte à federação de identidades da web no AWS Security Token Service (AWS STS).

O Amazon Cognito ajuda a gerenciar a abstração de identidades entre vários provedores de identidade com o objeto `AWS.CognitoIdentityCredentials`. A identidade carregada acaba sendo trocada por credenciais no AWS STS.

## Configuração do objeto de credenciais do Amazon Cognito Identity
<a name="browser-cognito-configuration"></a>

Se você ainda não tiver criado um, crie um banco de identidades a ser usado com os scripts do navegador no [Console do Amazon Cognito](https://console.aws.amazon.com/cognito) antes de configurar o `AWS.CognitoIdentityCredentials`. Criar e associar os perfis do IAM autenticados e não autenticados para o grupo de identidades.

Usuários não autenticados não têm a identidade verificada, tornando essa função apropriada para usuários convidados de seu aplicativo ou nos casos em que não importa se os usuários têm suas identidades verificadas. Os usuários autenticados fazem login no aplicativo por meio de um provedor de identidade de terceiros que verifica as identidades. Certifique-se de definir o escopo das permissões dos recursos de forma apropriada para que você não conceda acesso a eles a partir de usuários não autenticados.

Depois de configurar um grupo de identidades com provedores de identidade anexados, você poderá usar `AWS.CognitoIdentityCredentials` para autenticar usuários. Para configurar as credenciais de seu aplicativo para usar `AWS.CognitoIdentityCredentials`, defina a propriedade `credentials` do `AWS.Config` ou uma configuração por serviço. O exemplo a seguir usa `AWS.Config`:

```
AWS.config.credentials = new AWS.CognitoIdentityCredentials({
  IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030',
  Logins: { // optional tokens, used for authenticated login
    'graph.facebook.com': 'FBTOKEN',
    'www.amazon.com': 'AMAZONTOKEN',
    'accounts.google.com': 'GOOGLETOKEN'
  }
});
```

A propriedade opcional `Logins` é um mapa de nomes de provedor de identidade para os tokens de identidade para esses provedores. Como você obtém o token do seu provedor de identidade depende do provedor que usa. Por exemplo, se o Facebook for um de seus provedores de identidade, você poderá usar a `FB.login` função do [Facebook SDK](https://developers.facebook.com/docs/facebook-login/web) para obter um token de provedor de identidade:

```
FB.login(function (response) {
  if (response.authResponse) { // logged in
    AWS.config.credentials = new AWS.CognitoIdentityCredentials({
      IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030',
      Logins: {
        'graph.facebook.com': response.authResponse.accessToken
      }
    });

    s3 = new AWS.S3; // we can now create our service object

    console.log('You are now logged in.');
  } else {
    console.log('There was a problem logging you in.');
  }
});
```

## Alternar usuários não autenticados para usuários autenticados
<a name="browser-switching-unauthenticated-users"></a>

O Amazon Cognito é compatível com usuários autenticados e não autenticados. Os usuários não autenticados receberão acesso aos recursos se eles não estiverem conectados a nenhum dos provedores de identidade. Esse nível de acesso é útil para exibir conteúdo para usuários antes de fazer login. Cada usuário não autenticado tem uma identidade exclusiva no Amazon Cognito, mesmo que não tenha feito login e sido autenticado individualmente.

### Usuário não autenticado inicialmente
<a name="browser-switching-initially-unauthenticated-user"></a>

Os usuários normalmente começam com a função não autenticada para a qual você define a propriedade de credenciais do objeto de configuração sem uma propriedade `Logins`. Neste caso, sua configuração padrão pode parecer com o seguinte:

```
// set the default config object
var creds = new AWS.CognitoIdentityCredentials({
 IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030'
});
AWS.config.credentials = creds;
```

### Mudar para usuário autenticado
<a name="switch-to-authenticated"></a>

Quando um usuário autenticado faz login em um provedor de identidade e você tem um token, é possível alternar o usuário de não autenticado para autenticado chamando uma função personalizada que atualiza o objeto de credenciais e adiciona o token `Logins`:

```
// Called when an identity provider has a token for a logged in user
function userLoggedIn(providerName, token) {
  creds.params.Logins = creds.params.Logins || {};
  creds.params.Logins[providerName] = token;
                    
  // Expire credentials to refresh them on the next request
  creds.expired = true;
}
```

Também é possível criar um objeto `CognitoIdentityCredentials`. Se fizer isso, você deverá redefinir as propriedades de credenciais de objetos de serviço existentes criados. Os objetos de serviço só são lidos da configuração global na inicialização do objeto. 

Para obter mais informações sobre o objeto `CognitoIdentityCredentials`, consulte [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html) na Referência de API. 

# Usar identidade federada da web para autenticar usuários
<a name="loading-browser-credentials-federated-id"></a>

Você pode configurar diretamente os provedores de identidade individuais para acessar recursos da AWS usando a federação de identidades da web. Atualmente, a AWS é compatível com a autenticação de usuários usando a federação de identidades da web por meio de vários provedores de identidade:
+ [Login da Amazon](https://login.amazon.com)
+ [Login do Facebook](https://www.facebook.com/about/login)
+ [Login do Google](https://developers.google.com/identity/)

Você deve primeiramente registrar o aplicativo com os provedores compatíveis com o aplicativo. Crie um perfil do IAM e configure permissões para ele. A função do IAM criada acaba sendo usada para conceder as permissões configuradas para ela por meio do respectivo provedor de identidade. Por exemplo, é possível configurar uma função que permita a usuários conectados por meio do Facebook ter acesso de leitura a um bucket do Amazon S3 específico controlado por você.

Depois que tiver um perfil do IAM com privilégios configurados e um aplicativo registrado com os provedores de identidade escolhido, você poderá configurar o SDK para receber credenciais para o perfil do IAM usando código auxiliar da seguinte maneira:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
   RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>/:role/<WEB_IDENTITY_ROLE_NAME>',
   ProviderId: 'graph.facebook.com|www.amazon.com', // this is null for Google
   WebIdentityToken: ACCESS_TOKEN
});
```

O valor no parâmetro `ProviderId` depende do provedor de identidade especificado. O valor do parâmetro `WebIdentityToken` é o token de acesso recuperado de um login bem-sucedido com o provedor de identidade. Para obter mais informações sobre como configurar e recuperar tokens de acesso de cada provedor de identidade, consulte a documentação do provedor de identidade.

## Etapa 1: Registrar com provedores de identidade
<a name="config-web-identity-register"></a>

Para começar, registre um aplicativo com os provedores de identidade escolhidos para dar suporte. Você será solicitado a fornecer informações que identifiquem o aplicativo e possivelmente o autor. Isso garante que os provedores de identidade saibam quem está recebendo as informações do usuário. Em cada caso, o provedor de identidade emitirá um ID do aplicativo usado para configurar funções do usuário.

## Etapa 2: Criar um perfil do IAM para um provedor de identidade
<a name="config-web-identity-role"></a>

Depois de obter o ID do aplicativo do provedor de identidade, acesse o console do IAM no [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) para criar um novo perfil do IAM.

**Para criar uma função do perfil do IAM para um provedor de identidade**

1. Acesse a seção **Roles (Funções)** do console e escolha **Create New Role (Criar nova função)**.

1. Digite um nome para a nova função que ajude a controlar o uso, como **facebookIdentity**, e escolha **Next Step (Próxima etapa)**.

1. Em **Select Role Type (Selecionar tipo de função)**, escolha **Role for Identity Provider Access (Função de acesso do provedor de identidade)**.

1. Em **Grant access to web identity providers (Conceder acesso a provedores de identidade da web)**, escolha **Select (Selecionar)**.

1. Na lista **Identity Provider** (Provedor de identidade), escolha o provedor de identidade que você deseja usar nesse perfil do IAM.  
![\[Selecionar função para acesso do provedor de identidade\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v2/developer-guide/images/iam-provider-select.png)

1. Digite o ID do aplicativo fornecido pelo provedor de identidade em **Application ID (ID do aplicativo)** e escolha **Next Step (Próxima etapa)**.

1. Configurar permissões para os recursos que você deseja expor, permitindo acesso a operações específicas em recursos específicos. Para obter mais informações sobre as permissões do IAM, consulte [Visão geral das permissões do IAM do AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions.html) no *Manual do usuário do IAM*. Analise e, se necessário, personalize a função a relação de confiança da função e escolha **Next Step (Próxima etapa)**.

1. Anexe políticas adicionais de que você precisa e escolha **Next Step (Próxima etapa)**. Para obter mais informações sobre políticas do IAM, consulte [Visão geral das políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) no *Guia do usuário do IAM*.

1. Analise a nova função e escolha **Create Role (Criar função)**.

Forneça outras restrições à função, como o escopo para IDs de usuário específicos. Se a função conceder permissões de gravação aos recursos, verifique o escopo correto da função para usuários com os privilégios corretos. Do contrário, qualquer usuário com uma identidade Amazon, Facebook ou Google será capaz de modificar recursos no aplicativo.

Para obter mais informações sobre como usar a federação de identidades da web no IAM, consulte [ Sobre federação de identidades da web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html) no *Guia de usuário do IAM*.

## Etapa 3: Obter um token de acesso do provedor após o login
<a name="config-web-identity-obtain-token"></a>

Configure a ação de login para o aplicativo usando o SDK do provedor de identidade. Faça download e instale um SDK JavaScript do provedor de identidade que permita o login do usuário usando OAuth ou OpenID. Para obter informações sobre como fazer download e configurar o código do SDK no aplicativo, consulte a documentação do SDK do provedor de identidade:
+ [Login da Amazon](https://login.amazon.com/website)
+ [Login do Facebook](https://developers.facebook.com/docs/javascript)
+ [Login do Google](https://developers.google.com/identity/)

## Etapa 4: obter credenciais temporárias
<a name="config-web-identity-get-credentials"></a>

Depois que o aplicativo, as funções e as permissões de recursos forem configurados, adicione o código ao aplicativo para obter credenciais temporárias. Essas credenciais são fornecidas por meio do AWS Security Token Service usando a federação de identidades da web. Os usuários fazem login no provedor de identidade, que retorna um token de acesso. Configure o objeto `AWS.WebIdentityCredentials` usando o ARN do perfil do IAM criado para este provedor de identidade:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
    RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>',
    ProviderId: 'graph.facebook.com|www.amazon.com', // Omit this for Google
    WebIdentityToken: ACCESS_TOKEN // Access token from identity provider
});
```

Os objetos de serviço criados posteriormente terão as credenciais apropriadas. Os objetos criados antes de definir a propriedade `AWS.config.credentials` não terão as credenciais atuais.

Também é possível criar `AWS.WebIdentityCredentials` antes de recuperar o token de acesso. Isso permite criar objetos de serviço que dependam de credenciais antes de carregar o token de acesso. Para isso, crie o objeto de credenciais sem o parâmetro `WebIdentityToken`:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
  RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>',
  ProviderId: 'graph.facebook.com|www.amazon.com' // Omit this for Google
});

// Create a service object
var s3 = new AWS.S3;
```

Defina `WebIdentityToken` no retorno de chamada do SDK do provedor de identidade que contenha o token de acesso:

```
AWS.config.credentials.params.WebIdentityToken = accessToken;
```

# Exemplos de identidades federadas da Web
<a name="config-web-identity-examples"></a>

Aqui estão alguns exemplos de como usar a identidade federada da web para obter credenciais no JavaScript do navegador. Esses exemplos devem ser executados em um esquema http:// ou https:// para garantir que o provedor de identidade possa redirecionar para o aplicativo. 

## Exemplo de Login with Amazon
<a name="config-web-identity-amazon-login-example"></a>

O código a seguir mostra como usar Login with Amazon como um provedor de identidade. 

```
<a href="#" id="login">
  <img border="0" alt="Login with Amazon"
    src="https://images-na.ssl-images-amazon.com/images/G/01/lwa/btnLWA_gold_156x32.png"
    width="156" height="32" />
</a>
<div id="amazon-root"></div>
<script type="text/javascript">
  var s3 = null;
  var clientId = 'amzn1.application-oa2-client.1234567890abcdef'; // client ID
  var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

  window.onAmazonLoginReady = function() {
    amazon.Login.setClientId(clientId); // set client ID

    document.getElementById('login').onclick = function() {
      amazon.Login.authorize({scope: 'profile'}, function(response) {
        if (!response.error) { // logged in
          AWS.config.credentials = new AWS.WebIdentityCredentials({
            RoleArn: roleArn,
            ProviderId: 'www.amazon.com',
            WebIdentityToken: response.access_token
          });

          s3 = new AWS.S3();

          console.log('You are now logged in.');
        } else {
          console.log('There was a problem logging you in.');
        }
      });
    };
  };

  (function(d) {
    var a = d.createElement('script'); a.type = 'text/javascript';
    a.async = true; a.id = 'amazon-login-sdk';
    a.src = 'https://api-cdn.amazon.com/sdk/login1.js';
    d.getElementById('amazon-root').appendChild(a);
  })(document);
</script>
```

## Exemplo de login do Facebook
<a name="config-web-identity-facebook-login-example"></a>

O código a seguir mostra como usar o login do Facebook como um provedor de identidade:

```
<button id="login">Login</button>
<div id="fb-root"></div>
<script type="text/javascript">
var s3 = null;
var appId = '1234567890'; // Facebook app ID
var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

window.fbAsyncInit = function() {
  // init the FB JS SDK
  FB.init({appId: appId});

  document.getElementById('login').onclick = function() {
    FB.login(function (response) {
      if (response.authResponse) { // logged in
        AWS.config.credentials = new AWS.WebIdentityCredentials({
          RoleArn: roleArn,
          ProviderId: 'graph.facebook.com',
          WebIdentityToken: response.authResponse.accessToken
        });

        s3 = new AWS.S3;

        console.log('You are now logged in.');
      } else {
        console.log('There was a problem logging you in.');
      }
    });
  };
};

// Load the FB JS SDK asynchronously
(function(d, s, id){
   var js, fjs = d.getElementsByTagName(s)[0];
   if (d.getElementById(id)) {return;}
   js = d.createElement(s); js.id = id;
   js.src = "//connect.facebook.net/en_US/all.js";
   fjs.parentNode.insertBefore(js, fjs);
 }(document, 'script', 'facebook-jssdk'));
</script>
```

## Exemplo de login do Google\$1
<a name="config-web-identity-google-login-example"></a>

O código a seguir mostra como usar o login do Google\$1 como um provedor de identidade. O token de acesso usado para federação de identidades da web do Google é armazenado em `response.id_token`, em vez de `access_token` como outros provedores de identidade. 

```
<span
  id="login"
  class="g-signin"
  data-height="short"
  data-callback="loginToGoogle"
  data-cookiepolicy="single_host_origin"
  data-requestvisibleactions="http://schemas.google.com/AddActivity"
  data-scope="https://www.googleapis.com/auth/plus.login">
</span>
<script type="text/javascript">
  var s3 = null;
  var clientID = '1234567890.apps.googleusercontent.com'; // Google client ID
  var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

  document.getElementById('login').setAttribute('data-clientid', clientID);
  function loginToGoogle(response) {
    if (!response.error) {
      AWS.config.credentials = new AWS.WebIdentityCredentials({
        RoleArn: roleArn, WebIdentityToken: response.id_token
      });

      s3 = new AWS.S3();

      console.log('You are now logged in.');
    } else {
      console.log('There was a problem logging you in.');
    }
  }

  (function() {
    var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
    po.src = 'https://apis.google.com/js/client:plusone.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
  })();
 </script>
```