La AWS SDK pour JavaScript v2 est arrivée end-of-support. Nous vous recommandons de migrer vers la [AWS SDK pour JavaScript version 3](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/). Pour plus de détails et d'informations sur la façon de migrer, veuillez consulter cette [annonce](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/).

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Définition des informations d'identification dans un navigateur web
<a name="setting-credentials-browser"></a>

Il existe plusieurs façons de fournir vos informations d'identification au kit SDK à partir des scripts de navigateur. Certaines sont plus sécurisées, tandis que d'autres s'avèrent plus pratiques lors du développement d'un script. Voici comment fournir vos informations d'identification dans l'ordre recommandé :

1. Utilisation d'Amazon Cognito Identity pour authentifier les utilisateurs et fournir des informations d'identification

1. Utilisation de l'identité web fédérée

1. Codées en dur dans le script

**Avertissement**  
Nous vous déconseillons de coder en dur vos AWS informations d'identification dans vos scripts. En effet, le codage en dur des informations d'identification risque d'exposer votre ID de clé d'accès et votre clé d'accès secrète.

**Topics**
+ [Utiliser Amazon Cognito Identity pour authentifier les utilisateurs](loading-browser-credentials-cognito.md)
+ [Authentification des utilisateurs à l'aide de l'identité web fédérée](loading-browser-credentials-federated-id.md)
+ [Exemples d'identité web fédérée](config-web-identity-examples.md)

# Utiliser Amazon Cognito Identity pour authentifier les utilisateurs
<a name="loading-browser-credentials-cognito"></a>

La méthode recommandée pour obtenir des AWS informations d'identification pour les scripts de votre navigateur consiste à utiliser l'objet d'identification Amazon Cognito Identity,. `AWS.CognitoIdentityCredentials` Amazon Cognito permet l'authentification des utilisateurs par le biais de fournisseurs d'identité tiers.

Pour utiliser Amazon Cognito Identity, vous devez d'abord créer un pool d'identités dans la console Amazon Cognito. Un groupe d'identités représente le groupe des identités fournies par votre application à vos utilisateurs. Les identités attribuées aux utilisateurs identifient de manière unique chaque compte utilisateur. Les identités Amazon Cognito ne sont pas des informations d'identification. Ils sont échangés contre des informations d'identification à l'aide du support de fédération d'identité Web dans AWS Security Token Service (AWS STS).

Amazon Cognito vous aide à gérer l'abstraction des identités entre plusieurs fournisseurs d'identité à l'aide de l'`AWS.CognitoIdentityCredentials`objet. L'identité chargée est ensuite échangée contre les informations d'identification dans AWS STS.

## Configuration de l'objet Amazon Cognito Identity Credentials
<a name="browser-cognito-configuration"></a>

Si vous n'en avez pas encore créé un, créez un pool d'identités à utiliser avec les scripts de votre navigateur dans la [console Amazon Cognito](https://console.aws.amazon.com/cognito) avant de le configurer. `AWS.CognitoIdentityCredentials` Créez et associez des rôles IAM authentifiés et non authentifiés pour votre pool d'identités.

L'identité des utilisateurs non authentifiés n'est pas vérifiée. Ce rôle convient donc pour les utilisateurs invités de votre application ou dans les cas où il n'est pas important que les identités des utilisateurs soient vérifiées. Les utilisateurs authentifiés se connectent à votre application via un fournisseur d'identité tiers qui vérifie leur identité. Assurez-vous de définir de façon appropriée les autorisations des ressources afin de ne pas y accorder l'accès aux utilisateurs non authentifiés.

Une fois un groupe d'identités configuré avec les fournisseurs d'identité attachés, vous pouvez utiliser `AWS.CognitoIdentityCredentials` pour authentifier les utilisateurs. Pour configurer les informations d'identification de votre application afin d'utiliser `AWS.CognitoIdentityCredentials`, définissez la propriété `credentials` d'une configuration `AWS.Config` ou d'une configuration par service. L'exemple suivant utilise `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'
  }
});
```

La propriété facultative `Logins` est un mappage de noms de fournisseur d'identité avec les jetons d'identité de ces fournisseurs. La façon dont vous obtenez le jeton de la part de votre fournisseur d'identité dépend du fournisseur que vous utilisez. Par exemple, si Facebook est l'un de vos fournisseurs d'identité, vous pouvez utiliser la fonction `FB.login` du [kit SDK Facebook](https://developers.facebook.com/docs/facebook-login/web) pour obtenir un jeton de fournisseur d'identité :

```
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.');
  }
});
```

## Permutation entre les utilisateurs non authentifiés et les utilisateurs authentifiés
<a name="browser-switching-unauthenticated-users"></a>

Amazon Cognito prend en charge les utilisateurs authentifiés et non authentifiés. Les utilisateurs non authentifiés bénéficient d'un accès à vos ressources, même s'ils ne sont pas connectés avec l'un de vos fournisseurs d'identité. Ce degré d'accès est utile pour afficher du contenu aux utilisateurs avant qu'ils ne se connectent. Chaque utilisateur non authentifié possède une identité unique dans Amazon Cognito, même s'il n'a pas été connecté et authentifié individuellement.

### Utilisateur initialement non authentifié
<a name="browser-switching-initially-unauthenticated-user"></a>

Les utilisateurs commencent généralement par le rôle non authentifié, pour lequel vous définissez la propriété des informations d'identification de votre objet de configuration sans propriété `Logins`. Dans ce cas, votre configuration par défaut peut se présenter comme suit :

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

### Basculement vers un utilisateur authentifié
<a name="switch-to-authenticated"></a>

Lorsqu'un utilisateur non authentifié se connecte à un fournisseur d'identité et que vous avez un jeton, vous pouvez changer l'utilisateur non authentifié en utilisateur authentifié en appelant une fonction personnalisée qui met à jour l'objet des informations d'identification et ajoute le jeton `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;
}
```

Vous pouvez également créer un objet `CognitoIdentityCredentials`. Dans ce cas, vous devez réinitialiser les propriétés des informations d'identification des objets de service existants que vous avez créés. Les objets de service lisent dans la configuration globale uniquement à l'initialisation de l'objet. 

Pour plus d'informations sur l'`CognitoIdentityCredentials`objet, consultez [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html)la référence de l' AWS SDK pour JavaScript API. 

# Authentification des utilisateurs à l'aide de l'identité web fédérée
<a name="loading-browser-credentials-federated-id"></a>

Vous pouvez configurer directement des fournisseurs d'identité individuels pour accéder aux AWS ressources à l'aide de la fédération d'identité Web. AWS prend actuellement en charge l'authentification des utilisateurs à l'aide de la fédération d'identité Web via plusieurs fournisseurs d'identité :
+ [Login with Amazon](https://login.amazon.com)
+ [Connexion avec Facebook](https://www.facebook.com/about/login)
+ [Connexion avec Google](https://developers.google.com/identity/)

Vous devez tout d'abord enregistrer votre application avec les fournisseurs pris en charge par votre application. Créez ensuite un rôle IAM et configurez des autorisations pour celui-ci. Le rôle IAM que vous créez est ensuite utilisé pour accorder les autorisations que vous avez configurées par le biais du fournisseur d'identité correspondant. Par exemple, vous pouvez configurer un rôle qui permet aux utilisateurs qui se sont connectés via Facebook d'avoir un accès en lecture à un compartiment Amazon S3 spécifique que vous contrôlez.

Une fois que vous avez à la fois un rôle IAM avec des privilèges configurés et une application enregistrée auprès des fournisseurs d'identité que vous avez choisis, vous pouvez configurer le SDK pour obtenir des informations d'identification pour le rôle IAM à l'aide du code d'assistance, comme suit :

```
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
});
```

La valeur du paramètre `ProviderId` dépend du fournisseur d'identité spécifié. La valeur du paramètre `WebIdentityToken` est le jeton d'accès extrait d'une connexion réussie avec le fournisseur d'identité. Pour plus d'informations sur la configuration et l'extraction des jetons d'accès pour chaque fournisseur d'identité, consultez la documentation du fournisseur d'identité.

## Étape 1 : Enregistrement auprès des fournisseurs d'identité
<a name="config-web-identity-register"></a>

Pour commencer, enregistrez une application auprès des fournisseurs d'identité que vous choisissez de prendre en charge. Il vous sera demandé de fournir des informations qui identifient votre application et éventuellement son auteur. Les fournisseurs d'identité sauront ainsi qui reçoit leurs informations utilisateur. Dans chaque cas, le fournisseur d'identité émettra un ID d'application que vous utiliserez pour configurer des rôles utilisateur.

## Étape 2 : Création d'un rôle IAM pour un fournisseur d'identité
<a name="config-web-identity-role"></a>

Après avoir obtenu l'ID d'application auprès d'un fournisseur d'identité, accédez à la console IAM à l'adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)pour créer un nouveau rôle IAM.

**Pour créer un rôle IAM pour un fournisseur d'identité**

1. Dans la section **Rôles** de la console, choisissez **Créer un rôle**.

1. Entrez un nom pour le nouveau rôle qui vous aidera à assurer le suivi de son utilisation, tel que **facebookIdentity**, puis choisissez **Étape suivante**.

1. Sous **Sélectionner un type de rôle**, choisissez **Rôle pour l'accès au fournisseur d'identité**.

1. Sous **Octroyer l'accès aux fournisseurs d'identité Web**, choisissez **Sélectionner**.

1. Dans la liste des **fournisseurs d'identité**, choisissez le fournisseur d'identité que vous souhaitez utiliser pour ce rôle IAM.  
![\[Sélection du rôle pour l'accès au fournisseur d'identité\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v2/developer-guide/images/iam-provider-select.png)

1. Entrez l'ID d'application fourni par le fournisseur d'identité dans le champ **ID d'application**, puis choisissez **Étape suivante**.

1. Configurez les autorisations pour les ressources que vous souhaitez exposer, afin d'autoriser l'accès à des opérations spécifiques sur des ressources spécifiques. Pour plus d'informations sur les autorisations IAM, consultez la section [Présentation des autorisations AWS IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions.html) dans le guide de l'utilisateur *IAM*. Vérifiez et, si nécessaire, personnalisez la relation d'approbation du rôle, puis choisissez **Étape suivante**.

1. Attachez les stratégies supplémentaires dont vous avez besoin, puis choisissez **Étape suivante**. Pour plus d’informations sur les politiques IAM, consultez [Présentation des politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) dans le *Guide de l’utilisateur IAM*.

1. Vérifiez le nouveau rôle, puis choisissez **Créer un rôle**.

Vous pouvez ajouter d'autres contraintes au rôle, par exemple en le délimitant à un utilisateur IDs spécifique. Si le rôle octroie des autorisations en écriture à vos ressources, veillez à définir correctement sa portée pour les utilisateurs dotés des privilèges appropriés. Sinon, n'importe quel utilisateur avec une identité Amazon, Facebook ou Google sera en mesure de modifier les ressources de votre application.

Pour plus d'informations sur l'utilisation de la fédération d'identité Web dans IAM, voir [À propos de la fédération d'identité Web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html) dans le guide de l'*utilisateur d'IAM*.

## Étape 3 : Obtention d'un jeton d'accès du fournisseur après connexion
<a name="config-web-identity-obtain-token"></a>

Configurez l'action de connexion de votre application en utilisant le kit SDK du fournisseur d'identité. Vous pouvez télécharger et installer un JavaScript SDK auprès du fournisseur d'identité qui permet aux utilisateurs de se connecter à l'aide d'OpenID OAuth ou d'OpenID. Pour plus d'informations sur la façon de télécharger et de configurer le code du kit SDK dans votre application, consultez la documentation relative au kit SDK de votre fournisseur d'identité :
+ [Login with Amazon](https://login.amazon.com/website)
+ [Connexion avec Facebook](https://developers.facebook.com/docs/javascript)
+ [Connexion avec Google](https://developers.google.com/identity/)

## Étape 4 : Obtention d'informations d'identification temporaires
<a name="config-web-identity-get-credentials"></a>

Après avoir configuré votre application, les rôles et les autorisations des ressources, ajoutez le code à votre application afin d'obtenir des informations d'identification temporaires. Ces informations d'identification sont fournies par le AWS Security Token Service biais de la fédération d'identité Web. Les utilisateurs se connectent au fournisseur d'identité, qui renvoie un jeton d'accès. Configurez l'`AWS.WebIdentityCredentials`objet à l'aide de l'ARN du rôle IAM que vous avez créé pour ce fournisseur d'identité :

```
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
});
```

Les objets de service créés par la suite disposeront des informations d'identification appropriées. Les objets créés avant la définition de la propriété `AWS.config.credentials` ne disposeront pas des informations d'identification actuelles.

Vous pouvez également créer la propriété `AWS.WebIdentityCredentials` avant d'extraire le jeton d'accès. Vous pourrez ainsi créer des objets de service qui dépendent des informations d'identification avant de charger le jeton d'accès. Pour ce faire, créez l'objet des informations d'identification sans le paramètre `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;
```

Ensuite, définissez `WebIdentityToken` dans le rappel issu du kit SDK du fournisseur d'identité qui contient le jeton d'accès :

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

# Exemples d'identité web fédérée
<a name="config-web-identity-examples"></a>

Voici quelques exemples d'utilisation de l'identité fédérée Web pour obtenir des informations d'identification dans le navigateur. JavaScript Exécutez ces exemples à partir d'une méthode d'hébergement http:// ou https:// afin que le fournisseur d'identité puisse les rediriger vers votre application. 

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

Le code ci-dessous indique comment utiliser Login with Amazon comme fournisseur d'identité. 

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

## Exemple de connexion avec Facebook
<a name="config-web-identity-facebook-login-example"></a>

Le code ci-dessous indique comment utiliser Connexion avec Facebook comme fournisseur d'identité.

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

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

Le code ci-dessous indique comment utiliser Connexion avec Google\$1 comme fournisseur d'identité. Le jeton d'accès utilisé pour la fédération des identités web à partir de Google est stocké dans `response.id_token`, plutôt que dans `access_token` comme pour les autres fournisseurs d'identité. 

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