

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.

# Developer-authenticated identités

Amazon Cognito prend en charge les identités authentifiées par le développeur en plus de la fédération d'identité Web via [Configuration de Facebook en tant qu'IdP de pool d'identités](facebook.md), [Configuration de Google en tant qu'IdP de pool d'identités](google.md), [Configuration de Login with Amazon en tant qu'IdP de pool d'identités](amazon.md) et [Configuration de la connexion avec Apple en tant qu'IdP du pool d'identités](apple.md). Grâce aux identités authentifiées par les développeurs, vous pouvez enregistrer et authentifier les utilisateurs par le biais de votre propre processus d'authentification existant, tout en utilisant Amazon Cognito pour synchroniser les données utilisateur et accéder aux ressources. AWS L'utilisation d'identités authentifiées par le développeur implique une interaction entre l'appareil de l'utilisateur final, votre back-end pour l'authentification et Amazon Cognito. Pour plus de détails, consultez la section [Comprendre l'authentification Amazon Cognito, partie 2 : Identités authentifiées par les développeurs](https://aws.amazon.com/blogs/mobile/understanding-amazon-cognito-authentication-part-2-developer-authenticated-identities/) sur le blog. AWS 

## Présentation du flux d'authentification
<a name="understanding-the-authentication-flow"></a>

Le fonctionnement de l'[GetOpenIdTokenForDeveloperIdentity](https://docs.aws.amazon.com/cognitoidentity/latest/APIReference/API_GetOpenIdTokenForDeveloperIdentity.html)API peut initier l'authentification du développeur pour l'authentification améliorée et l'authentification de base. Cette API authentifie une demande à l'aide d'informations d'identification administratives. La `Logins` carte est un nom de fournisseur de développeur de pool d'identités `login.mydevprovider` associé à un identifiant personnalisé.

Exemple :

```
"Logins": {
        "login.mydevprovider": "my developer identifier"
    }
```

**Authentification améliorée**

Appelez l'opération [GetCredentialsForIdentity](https://docs.aws.amazon.com/cognitoidentity/latest/APIReference/API_GetCredentialsForIdentity.html)API avec une `Logins` carte où la clé est l'émetteur du jeton renvoyé par`GetOpenIdTokenForDeveloperIdentity`, et la valeur est le jeton lui-même.

L'émetteur (et donc la clé de connexion requise) dépend de la région de votre pool d'identités. Consultez [Émetteur de jetons par région](#token-issuer-by-region) la liste complète des régions et de leurs émetteurs de jetons.

Exemple de pool d'identités dans une région qui utilise l'émetteur mondial :

```
"Logins": {
        "cognito-identity.amazonaws.com": "eyJra12345EXAMPLE"
    }
```

Exemple de pool d'identités dans une nouvelle région (comme eu-south-2) :

```
"Logins": {
        "cognito-identity.eu-south-2.amazonaws.com": "eyJra12345EXAMPLE"
    }
```

**Important**  
La clé de la carte de connexion doit correspondre exactement à la réclamation `iss` (de l'émetteur) contenue dans le jeton. S'ils ne correspondent pas, `GetCredentialsForIdentity` renvoie : `NotAuthorizedException: Invalid login token. Issuer doesn't match providerName`

**Astuce**  
Pour déterminer la bonne clé de connexion par programmation, décodez le jeton (un JWT) et lisez la valeur de la réclamation. `iss` Utilisez cette valeur comme clé de mappage des connexions.

`GetCredentialsForIdentity`avec des identités authentifiées par le développeur renvoie des informations d'identification temporaires pour le rôle authentifié par défaut du pool d'identités.

**Authentification de base**

Appelez l'opération [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithWebIdentity.html)API et demandez le nom `RoleArn` de n'importe quel rôle IAM pour lequel une [relation de confiance appropriée est définie](iam-roles.md#role-trust-and-permissions). Définissez la valeur de sur `WebIdentityToken` le jeton obtenu auprès de`GetOpenIdTokenForDeveloperIdentity`.

Pour plus d'informations sur le flux d'authentification des identités authentifiées par le développeur et sur la façon dont il diffère des identités des fournisseurs externes, voir. [Flux d'authentification des groupes d'identités](authentication-flow.md)

## Définir un nom de fournisseur de développement et l'associer à un groupe d'identités
<a name="associate-developer-provider"></a>

Pour utiliser les identités authentifiées par le développeur, vous avez besoin d'une réserve d'identités associée à votre fournisseur de développement. Pour ce faire, procédez comme suit :

**Pour ajouter un fournisseur de développement personnalisé**

1. Choisissez **Groupes d'identités** dans la [console Amazon Cognito](https://console.aws.amazon.com/cognito/home). Sélectionnez une réserve d'identités.

1. Choisissez l'onglet **Accès utilisateur**.

1. Sélectionnez **Ajouter un fournisseur d'identité**.

1. Choisissez **Fournisseur du développeur personnalisé**.

1. Saisissez le **nom du fournisseur de développement**. Vous ne pouvez pas modifier ni supprimer votre fournisseur de développement après l'avoir ajouté.

1. Cliquez sur **Enregistrer les modifications**.

Remarque : une fois que le nom du fournisseur a été défini, il ne peut pas être modifié.

## Implémentation d'un fournisseur d'identité
<a name="implement-an-identity-provider"></a>

### Android
<a name="implement-id-provider-1.android"></a>

Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend `AWSAbstractCognitoIdentityProvider`. Votre classe de fournisseur d'identité doit retourner un objet de réponse contenant le jeton comme attribut.

Vous trouverez ci-après un exemple de base d'un fournisseur d'identité.

```java
public class DeveloperAuthenticationProvider extends AWSAbstractCognitoDeveloperIdentityProvider {

  private static final String developerProvider = "<Developer_provider_name>";

  public DeveloperAuthenticationProvider(String accountId, String identityPoolId, Regions region) {
    super(accountId, identityPoolId, region);
    // Initialize any other objects needed here.
  }

  // Return the developer provider name which you choose while setting up the
  // identity pool in the &COG; Console

  @Override
  public String getProviderName() {
    return developerProvider;
  }

  // Use the refresh method to communicate with your backend to get an
  // identityId and token.

  @Override
  public String refresh() {

    // Override the existing token
    setToken(null);

    // Get the identityId and token by making a call to your backend
    // (Call to your backend)

    // Call the update method with updated identityId and token to make sure
    // these are ready to be used from Credentials Provider.

    update(identityId, token);
    return token;

  }

  // If the app has a valid identityId return it, otherwise get a valid
  // identityId from your backend.

  @Override
  public String getIdentityId() {

    // Load the identityId from the cache
    identityId = cachedIdentityId;

    if (identityId == null) {
       // Call to your backend
    } else {
       return identityId;
    }

  }
}
```

Pour utiliser ce fournisseur d'identité, vous devez le transmettre dans `CognitoCachingCredentialsProvider`. Voici un exemple :

```java
DeveloperAuthenticationProvider developerProvider = new DeveloperAuthenticationProvider( null, "IDENTITYPOOLID", Regions.USEAST1);
CognitoCachingCredentialsProvider credentialsProvider = new CognitoCachingCredentialsProvider( context, developerProvider, Regions.USEAST1);
```

**Note**  
Les anciennes versions du AWS SDK pour Android (2.x et antérieures) sont `cognito-identity.amazonaws.com` utilisées comme nom de fournisseur interne pour les identités authentifiées par le développeur. Si votre pool d'identités se trouve dans une région plus récente qui utilise un émetteur régionalisé, passez à la version actuelle du SDK. Pour plus d’informations, consultez [Format régional de l'émetteur de jetons](#regional-token-issuer-format).

### iOS – objective-C
<a name="implement-id-provider-1.ios-objc"></a>

Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend [AWSCognitoCredentialsProviderHelper](https://github.com/aws-amplify/aws-sdk-ios). Votre classe de fournisseur d'identité doit retourner un objet de réponse contenant le jeton comme attribut.

```objectivec
@implementation DeveloperAuthenticatedIdentityProvider
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */

- (AWSTask <NSString*> *) token {
    //Write code to call your backend:
    //Pass username/password to backend or some sort of token to authenticate user
    //If successful, from backend call getOpenIdTokenForDeveloperIdentity with logins map 
    //containing "your.provider.name":"enduser.username"
    //Return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = response.identityId;
    return [AWSTask taskWithResult:response.token];
}

@end
```

Pour utiliser ce fournisseur d'identité, transmettez-le dans `AWSCognitoCredentialsProvider` comme illustré dans l'exemple suivant :

```objectivec
DeveloperAuthenticatedIdentityProvider * devAuth = [[DeveloperAuthenticatedIdentityProvider alloc] initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION 
                                         identityPoolId:@"YOUR_IDENTITY_POOL_ID"
                                        useEnhancedFlow:YES
                                identityProviderManager:nil];
AWSCognitoCredentialsProvider *credentialsProvider = [[AWSCognitoCredentialsProvider alloc]
                                                          initWithRegionType:AWSRegionYOUR_IDENTITY_POOL_REGION
                                                          identityProvider:devAuth];
```

Si vous souhaitez prendre en charge les identités non authentifiées et les identités authentifiées par le développeur, remplacez la méthode `logins` dans votre implémentation de `AWSCognitoCredentialsProviderHelper`.

```objectivec
- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else{
        return [super logins];
    }
}
```

Si vous souhaitez prendre en charge les identités authentifiées par le développeur et les fournisseurs sociaux, vous devez gérer qui est le fournisseur actuel dans votre implémentation `logins` de `AWSCognitoCredentialsProviderHelper`.

```objectivec
- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}
```

**Note**  
Les anciennes versions du AWS SDK pour iOS (2.x et antérieures) sont `cognito-identity.amazonaws.com` utilisées comme nom de fournisseur interne pour les identités authentifiées par le développeur. Si votre pool d'identités se trouve dans une région plus récente qui utilise un émetteur régionalisé, passez à la version actuelle du SDK. Pour plus d’informations, consultez [Format régional de l'émetteur de jetons](#regional-token-issuer-format).

### iOS – swift
<a name="implement-id-provider-1.ios-swift"></a>

Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend [AWSCognitoCredentialsProviderHelper](https://github.com/aws-amplify/aws-sdk-ios). Votre classe de fournisseur d'identité doit retourner un objet de réponse contenant le jeton comme attribut.

```swift
import AWSCore
/*
 * Use the token method to communicate with your backend to get an
 * identityId and token.
 */
class DeveloperAuthenticatedIdentityProvider : AWSCognitoCredentialsProviderHelper {
    override func token() -> AWSTask<NSString> {
    //Write code to call your backend:
    //pass username/password to backend or some sort of token to authenticate user, if successful, 
    //from backend call getOpenIdTokenForDeveloperIdentity with logins map containing "your.provider.name":"enduser.username"
    //return the identity id and token to client
    //You can use AWSTaskCompletionSource to do this asynchronously

    // Set the identity id and return the token
    self.identityId = resultFromAbove.identityId
    return AWSTask(result: resultFromAbove.token)
}
```

Pour utiliser ce fournisseur d'identité, transmettez-le dans `AWSCognitoCredentialsProvider` comme illustré dans l'exemple suivant :

```swift
let devAuth = DeveloperAuthenticatedIdentityProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityPoolId: "YOUR_IDENTITY_POOL_ID", useEnhancedFlow: true, identityProviderManager:nil)
let credentialsProvider = AWSCognitoCredentialsProvider(regionType: .YOUR_IDENTITY_POOL_REGION, identityProvider:devAuth)
let configuration = AWSServiceConfiguration(region: .YOUR_IDENTITY_POOL_REGION, credentialsProvider:credentialsProvider)
AWSServiceManager.default().defaultServiceConfiguration = configuration
```

Si vous souhaitez prendre en charge les identités non authentifiées et les identités authentifiées par le développeur, remplacez la méthode `logins` dans votre implémentation de `AWSCognitoCredentialsProviderHelper`.

```swift
override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else {
        return super.logins()
    }
}
```

Si vous souhaitez prendre en charge les identités authentifiées par le développeur et les fournisseurs sociaux, vous devez gérer qui est le fournisseur actuel dans votre implémentation `logins` de `AWSCognitoCredentialsProviderHelper`.

```swift
override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}
```

### JavaScript
<a name="implement-id-provider-1.javascript"></a>

Une fois que vous aurez obtenu un identifiant d'identité et un jeton de session auprès de votre backend, vous les transmettrez au `fromCognitoIdentity` fournisseur depuis`@aws-sdk/credential-providers`. La clé de connexion doit correspondre à la `iss` demande du jeton. Pour les pools d'identités dans les régions qui utilisent l'émetteur mondial, utilisez`cognito-identity.amazonaws.com`. Pour les pools d'identités dans d'autres régions, utilisez`cognito-identity.{{region}}.amazonaws.com`. Pour plus d’informations, consultez [Format régional de l'émetteur de jetons](#regional-token-issuer-format).

```javascript
import { fromCognitoIdentity } from "@aws-sdk/credential-providers";

const token = 'TOKEN_RETURNED_FROM_YOUR_PROVIDER';
const region = 'IDENTITY_POOL_REGION';

// Extract the issuer from the token
const payload = token.split('.')[1];
const claims = JSON.parse(Buffer.from(payload, 'base64url').toString());
const providerName = claims.iss;

// Your backend already established the identity, so use fromCognitoIdentity
// (which calls GetCredentialsForIdentity directly for the identity ID you pass)
// rather than fromCognitoIdentityPool (which would call GetId and resolve a new identity).
const credentials = fromCognitoIdentity({
   identityId: 'IDENTITY_ID_RETURNED_FROM_YOUR_PROVIDER',
   logins: {
      [providerName]: token
   },
   clientConfig: { region }
});

// Attach the provider to each service client that needs credentials.
const client = new SomeServiceClient({ region, credentials });
```

## Mise à jour de la carte de connexions (Android et iOS uniquement)
<a name="updating-the-logins-map"></a>

### Android
<a name="updating-logins-map-1.android"></a>

Une fois que l'utilisateur est authentifié avec votre système d'authentification, mettez à jour le mappage des connexions avec le nom du fournisseur de développement et un ID utilisateur de développeur. Il s'agit d'une chaîne alphanumérique qui identifie de manière unique un utilisateur dans votre système d'authentification. Veillez à appeler la méthode `refresh` après la mise à jour de la carte de connexions, car il se peut que l'`identityId` ait changé :

```java
HashMap<String, String> loginsMap = new HashMap<String, String>();
loginsMap.put(developerAuthenticationProvider.getProviderName(), developerUserIdentifier);

credentialsProvider.setLogins(loginsMap);
credentialsProvider.refresh();
```

### iOS  – objective-C
<a name="updating-logins-map-1.ios-objc"></a>

Le kit SDK iOS appelle uniquement votre méthode `logins` pour obtenir la dernière carte de connexions s'il n'existe pas d'informations d'identification ou si celles-ci ont expiré. Si vous voulez forcer le kit SDK à obtenir de nouvelles informations d'identification (par exemple, votre utilisateur final est passé de non authentifié à authentifié et vous souhaitez des informations d'identification pour l'utilisateur authentifié), appelez `clearCredentials` sur votre `credentialsProvider`.

```objectivec
[credentialsProvider clearCredentials];
```

### iOS – swift
<a name="updating-logins-map-1.ios-swift"></a>

Le kit SDK iOS appelle uniquement votre méthode `logins` pour obtenir la dernière carte de connexions s'il n'existe pas d'informations d'identification ou si celles-ci ont expiré. Si vous voulez forcer le kit SDK à obtenir les nouvelles informations d'identification (par exemple, votre utilisateur final est passé de non authentifié à authentifié et vous souhaitez des informations d'identification pour l'utilisateur authentifié), appelez `clearCredentials` sur votre `credentialsProvider`.

```swift
credentialsProvider.clearCredentials()
```

## Obtention d'un jeton (côté serveur)
<a name="getting-a-token-server-side"></a>

Vous obtenez un jeton en appelant [GetOpenIdTokenForDeveloperIdentity](https://docs.aws.amazon.com/cognitoidentity/latest/APIReference/API_GetOpenIdTokenForDeveloperIdentity.html). Cette API doit être invoquée depuis votre backend à l'aide des informations d'identification AWS du développeur. Elle ne doit pas être appelée depuis le kit SDK client. L'API reçoit l'ID de réserve d'identités Cognito, un mappage de connexions contenant votre nom de fournisseur d'identité comme clé et l'identificateur comme valeur, ainsi qu'éventuellement un ID d'identité Cognito (par exemple, vous transformez un utilisateur non authentifié en utilisateur authentifié). L'identificateur peut être le nom de l'utilisateur, une adresse e-mail ou une valeur numérique. L'API répond à votre appel avec un ID Cognito unique et un jeton OpenID Connect pour l'utilisateur.

Voici quelques éléments à garder à l'esprit sur le jeton renvoyé par   :`GetOpenIdTokenForDeveloperIdentity`
+ Vous pouvez spécifier une durée d'expiration personnalisée pour le jeton, afin de pouvoir le mettre en cache. Si vous ne fournissez pas de durée d'expiration personnalisée, le jeton est valide pendant 15 minutes. 
+ La durée maximale que vous pouvez définir pour un jeton est de 24 heures.
+ Gardez à l'esprit les répercussions que l'augmentation de la durée de validité du jeton peut avoir sur la sécurité. Si un attaquant obtient ce jeton, il peut l'échanger contre des AWS informations d'identification pour l'utilisateur final pendant la durée du jeton.

L'extrait de code Java suivant montre comment initialiser un client Amazon Cognito et récupérer un jeton pour une identité authentifiée par le développeur.

```java
// authenticate your end user as appropriate
// ....

// if authenticated, initialize a cognito client with your AWS developer credentials
AmazonCognitoIdentity identityClient = new AmazonCognitoIdentityClient(
  new BasicAWSCredentials("access_key_id", "secret_access_key")
);

// create a new request to retrieve the token for your end user
GetOpenIdTokenForDeveloperIdentityRequest request =
  new GetOpenIdTokenForDeveloperIdentityRequest();
request.setIdentityPoolId("YOUR_COGNITO_IDENTITY_POOL_ID");

request.setIdentityId("YOUR_COGNITO_IDENTITY_ID"); //optional, set this if your client has an
                                                   //identity ID that you want to link to this 
                                                   //developer account

// set up your logins map with the username of your end user
HashMap<String,String> logins = new HashMap<>();
logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER");
request.setLogins(logins);

// optionally set token duration (in seconds)
request.setTokenDuration(60 * 15l);
GetOpenIdTokenForDeveloperIdentityResult response =
  identityClient.getOpenIdTokenForDeveloperIdentity(request);

// obtain identity id and token to return to your client
String identityId = response.getIdentityId();
String token = response.getToken();

//code to return identity id and token to client
//...
```

Une fois que vous aurez suivi les étapes précédentes, vous devriez être en mesure d'intégrer les identités authentifiées par le développeur dans votre application. Si vous avez des problèmes ou des questions, publiez-les [sur nos forums](https://forums.aws.amazon.com/forum.jspa?forumID=173).

## Format régional de l'émetteur de jetons
<a name="regional-token-issuer-format"></a>

Le jeton OpenID Connect renvoyé par `GetOpenIdTokenForDeveloperIdentity` contient une réclamation `iss` (de l'émetteur). Le format de cette réclamation dépend de la AWS région du pool d'identités.

Lorsque vous appelez `GetCredentialsForIdentity` (flux amélioré), la clé de la carte de connexion **doit correspondre exactement** à la `iss` demande du jeton.

### Émetteur de jetons par région
<a name="token-issuer-by-region"></a>

La valeur de l'émetteur du jeton dépend de la région de votre pool d'identités.
+ **Régions utilisant l'émetteur mondial** (us-east-1, us-east-2, us-west-1, us-west-2, us-west-2, ap-northeast-1, ap-northeast-2, ap-northeast-3, ap-south-1 ap-southeast-1, ap-southeast-1, ap-southeast-2, ca-central-1, eu-central-1, eu-nord-1, eu-west-1, eu-west-1, eu-west-2, eu-west-3, sa-east-1) : `cognito-identity.amazonaws.com`
+ **Les régions de la Chine** (cn-north-1) : `cognito-identity.cn-north-1.amazonaws.com.cn`
+ **Toutes les autres AWS régions commerciales** : `cognito-identity.{{region}}.amazonaws.com`

### Déterminer la clé de connexion par programmation
<a name="determining-logins-key-programmatically"></a>

Plutôt que de coder en dur la clé de connexion, vous pouvez l'extraire du jeton :

**Java**

```java
import java.util.Base64;
import org.json.JSONObject;

String[] parts = token.split("\\.");
String payload = new String(Base64.getUrlDecoder().decode(parts[1]));
String issuer = new JSONObject(payload).getString("iss");
// Use 'issuer' as the logins map key in GetCredentialsForIdentity
```

**Python**

```python
import base64, json

payload = token.split('.')[1]
# Add padding if needed
payload += '=' * (4 - len(payload) % 4)
claims = json.loads(base64.urlsafe_b64decode(payload))
issuer = claims['iss']
# Use 'issuer' as the logins map key
```

**JavaScript**

```javascript
const payload = token.split('.')[1];
const claims = JSON.parse(Buffer.from(payload, 'base64url').toString());
const issuer = claims.iss;
// Use 'issuer' as the logins map key
```

### Considérations concernant la migration
<a name="migration-considerations"></a>

Si vous migrez un pool d'identités vers une région qui utilise un émetteur régionalisé, tenez compte des points suivants :

1. Les clients qui utilisent le code `cognito-identity.amazonaws.com` en dur comme clé de connexion échoueront dans le pool d'identités de la nouvelle région.

1. Le code client doit être mis à jour pour utiliser l'émetteur régionalisé (`cognito-identity.{{new-region}}.amazonaws.com`) ou pour lire dynamiquement la `iss` réclamation à partir du jeton (recommandé).

1. Les anciennes versions des SDK AWS mobiles codent en dur l'émetteur mondial. Cela inclut le AWS SDK pour Android 2.x et versions antérieures, ainsi que AWS le SDK pour iOS 2.x et versions antérieures. Si votre pool d'identités utilise un émetteur régionalisé, passez à une version actuelle du SDK.

## Connexion à une identité sociale existante
<a name="connect-to-an-existing-social-identity"></a>

Toute mise en relation des fournisseurs lorsque vous utilisez des identités authentifiées par le développeur doit être effectuée depuis votre back-end. Pour associer une identité personnalisée à l'identité sociale d'un utilisateur (Login with Amazon, Sign in with Apple, Facebook ou Google), ajoutez le jeton du fournisseur d'identité à la carte des connexions lorsque vous appelez [GetOpenIdTokenForDeveloperIdentity](https://docs.aws.amazon.com/cognitoidentity/latest/APIReference/API_GetOpenIdTokenForDeveloperIdentity.html). Pour que cela soit possible, lorsque vous appelez votre back-end depuis le SDK de votre client pour authentifier votre utilisateur final, transmettez également le jeton du fournisseur social de l'utilisateur final.

Par exemple, si vous essayez de lier une identité personnalisée à Facebook, vous ajoutez le jeton Facebook en plus de votre identificateur de fournisseur d'identité à la carte de connexions lorsque vous appelez `GetOpenIdTokenForDeveloperIdentity`.

```
logins.put("YOUR_IDENTITY_PROVIDER_NAME","YOUR_END_USER_IDENTIFIER");
logins.put("graph.facebook.com","END_USERS_FACEBOOK_ACCESSTOKEN");
```

## Transition d'un fournisseur à un autre
<a name="supporting-transition-between-providers"></a>

### Android
<a name="support-transition-between-providers-1.android"></a>

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. La principale différence entre les identités authentifiées par le développeur et les autres (identités non authentifiées ou authentifiées via un fournisseur public) réside dans le mode de récupération de l'ID d'identité et du jeton. Pour les autres identités, l'application mobile interagit directement avec Amazon Cognito au lieu de contacter votre système d'authentification. Par conséquent, l'application mobile doit être capable de prendre en charge deux flux distincts selon le choix de l'utilisateur de l'application. Pour cela, vous devez apporter des modifications au fournisseur d'identités personnalisées.

La méthode `refresh` vérifie le mappage des connexions. Si la carte n'est pas vide et comporte une clé avec le nom du fournisseur du développeur, appelez votre backend. Sinon, appelez la IdentityId méthode get et renvoyez null.

```java
public String refresh() {

   setToken(null);

   // If the logins map is not empty make a call to your backend
   // to get the token and identityId
   if (getProviderName() != null &&
      !this.loginsMap.isEmpty() &&
      this.loginsMap.containsKey(getProviderName())) {

      /**
       * This is where you would call your backend
       **/

      // now set the returned identity id and token in the provider
      update(identityId, token);
      return token;

   } else {
      // Call getIdentityId method and return null
      this.getIdentityId();
      return null;
   }
}
```

De même, la `getIdentityId` méthode comporte deux flux en fonction du contenu de la carte des connexions :

```java
public String getIdentityId() {

   // Load the identityId from the cache
   identityId = cachedIdentityId;

   if (identityId == null) {

      // If the logins map is not empty make a call to your backend
      // to get the token and identityId

      if (getProviderName() != null && !this.loginsMap.isEmpty()
         && this.loginsMap.containsKey(getProviderName())) {

         /**
           * This is where you would call your backend
          **/

         // now set the returned identity id and token in the provider
         update(identityId, token);
         return token;

      } else {
         // Otherwise call &COG; using getIdentityId of super class
         return super.getIdentityId();
      }

   } else {
      return identityId;
   }

}
```

### iOS – objective-C
<a name="support-transition-between-providers-1.ios-objc"></a>

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. Pour ce faire, remplacez la [AWSCognitoCredentialsProviderHelper](https://github.com/aws-amplify/aws-sdk-ios)`logins`méthode afin de pouvoir renvoyer la carte de connexion correcte en fonction du fournisseur d'identité actuel. Cet exemple montre comment vous pouvez alterner entre une identité non authentifiée, Facebook et authentifiée par le développeur.

```objectivec
- (AWSTask<NSDictionary<NSString *, NSString *> *> *)logins {
    if(/*logic to determine if user is unauthenticated*/) {
        return [AWSTask taskWithResult:nil];
    }else if (/*logic to determine if user is Facebook*/){
        return [AWSTask taskWithResult: @{ AWSIdentityProviderFacebook : [FBSDKAccessToken currentAccessToken] }];
    }else {
        return [super logins];
    }
}
```

Lorsque vous passez d'une identité non authentifiée à une identité authentifiée, vous devez appeler `[credentialsProvider clearCredentials];` pour forcer le kit SDK à obtenir les nouvelles informations d'identification authentifiées. Lorsque vous basculez entre deux fournisseurs authentifiés et que vous n'essayez pas de lier les deux fournisseurs (par exemple, si vous ne fournissez pas de jetons pour plusieurs fournisseurs dans votre dictionnaire de connexions), appelez `[credentialsProvider clearKeychain];`. Cela efface à la fois les informations d'identification et l'identité et oblige le SDK à en obtenir de nouvelles.

### iOS – swift
<a name="support-transition-between-providers-1.ios-swift"></a>

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. Pour ce faire, remplacez la [AWSCognitoCredentialsProviderHelper](https://github.com/aws-amplify/aws-sdk-ios)`logins`méthode afin de pouvoir renvoyer la carte de connexion correcte en fonction du fournisseur d'identité actuel. Cet exemple montre comment vous pouvez alterner entre une identité non authentifiée, Facebook et authentifiée par le développeur.

```swift
override func logins () -> AWSTask<NSDictionary> {
    if(/*logic to determine if user is unauthenticated*/) {
        return AWSTask(result:nil)
    }else if (/*logic to determine if user is Facebook*/){
        if let token = AccessToken.current?.authenticationToken {
            return AWSTask(result: [AWSIdentityProviderFacebook:token])
        }
        return AWSTask(error:NSError(domain: "Facebook Login", code: -1 , userInfo: ["Facebook" : "No current Facebook access token"]))
    }else {
        return super.logins()
    }
}
```

Lorsque vous passez d'une identité non authentifiée à une identité authentifiée, vous devez appeler `credentialsProvider.clearCredentials()` pour forcer le kit SDK à obtenir les nouvelles informations d'identification authentifiées. Lorsque vous basculez entre deux fournisseurs authentifiés et que vous n'essayez pas de lier les deux fournisseurs (vous ne fournissez pas de jetons pour plusieurs fournisseurs dans votre dictionnaire de connexions), vous devez appeler `credentialsProvider.clearKeychain()`. Cela efface à la fois les informations d'identification et l'identité et oblige le SDK à en obtenir de nouvelles.

### Unity
<a name="support-transition-between-providers-1.unity"></a>

Votre application peut nécessiter de prendre en charge les identités authentifiées ou non authentifiées via les fournisseurs publics (Login with Amazon, Se connecter avec Apple, Facebook ou Google), ainsi que les identités authentifiées par le développeur. La principale différence entre les identités authentifiées par le développeur et les autres (identités non authentifiées ou authentifiées via un fournisseur public) réside dans le mode de récupération de l'ID d'identité et du jeton. Pour les autres identités, l'application mobile interagit directement avec Amazon Cognito au lieu de contacter votre système d'authentification. L'application mobile doit être capable de prendre en charge deux flux distincts selon le choix de l'utilisateur de l'application. Pour cela, vous devrez apporter des modifications au fournisseur d'identités personnalisées.

La méthode recommandée pour le faire dans Unity est d'étendre votre fournisseur d'identité à la AmazonCognitoEnhancedIdentityProvide place de AbstractCognitoIdentityProvider et d'appeler la RefreshAsync méthode parent au lieu de la vôtre au cas où l'utilisateur ne serait pas authentifié auprès de votre propre backend. Si l'utilisateur est authentifié, vous pouvez utiliser le flux expliqué précédemment.