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 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>
```