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, Configuration de Google en tant qu'IdP de pool d'identités, Configuration de Login with Amazon en tant qu'IdP de pool d'identités et Configuration de la connexion avec Apple en tant qu'IdP du pool d'identités. 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
Présentation du flux d'authentification
Le fonctionnement de l'GetOpenIdTokenForDeveloperIdentityAPI 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 GetCredentialsForIdentityAPI avec une Logins carte où la clé est l'émetteur du jeton renvoyé parGetOpenIdTokenForDeveloperIdentity, 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 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" }
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
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.
GetCredentialsForIdentityavec 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 AssumeRoleWithWebIdentityAPI et demandez le nom RoleArn de n'importe quel rôle IAM pour lequel une relation de confiance appropriée est définie. Définissez la valeur de sur WebIdentityToken le jeton obtenu auprès deGetOpenIdTokenForDeveloperIdentity.
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
Définir un nom de fournisseur de développement et l'associer à un groupe d'identités
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é
-
Choisissez Groupes d'identités dans la console Amazon Cognito
. Sélectionnez une réserve d'identités. -
Choisissez l'onglet Accès utilisateur.
-
Sélectionnez Ajouter un fournisseur d'identité.
-
Choisissez Fournisseur du développeur personnalisé.
-
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é.
-
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é
Android
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é.
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 :
DeveloperAuthenticationProvider developerProvider = new DeveloperAuthenticationProvider( null, "IDENTITYPOOLID", Regions.USEAST1); CognitoCachingCredentialsProvider credentialsProvider = new CognitoCachingCredentialsProvider( context, developerProvider, Regions.USEAST1);
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.
iOS – objective-C
Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend AWSCognitoCredentialsProviderHelper
@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 :
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.
- (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.
- (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]; } }
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.
iOS – swift
Pour utiliser des identités authentifiées par le développeur, implémentez votre propre classe de fournisseur d'identité qui étend AWSCognitoCredentialsProviderHelper
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 :
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.
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.
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
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, utilisezcognito-identity.amazonaws.com. Pour les pools d'identités dans d'autres régions, utilisezcognito-identity.. Pour plus d’informations, consultez Format régional de l'émetteur de jetons.region.amazonaws.com
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)
Android
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é :
HashMap<String, String> loginsMap = new HashMap<String, String>(); loginsMap.put(developerAuthenticationProvider.getProviderName(), developerUserIdentifier); credentialsProvider.setLogins(loginsMap); credentialsProvider.refresh();
iOS – objective-C
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.
[credentialsProvider clearCredentials];
iOS – swift
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.
credentialsProvider.clearCredentials()
Obtention d'un jeton (côté serveur)
Vous obtenez un jeton en appelant GetOpenIdTokenForDeveloperIdentity. 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.
// 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
Format régional de l'émetteur de jetons
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
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
Plutôt que de coder en dur la clé de connexion, vous pouvez l'extraire du jeton :
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
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
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
Si vous migrez un pool d'identités vers une région qui utilise un émetteur régionalisé, tenez compte des points suivants :
-
Les clients qui utilisent le code
cognito-identity.amazonaws.comen dur comme clé de connexion échoueront dans le pool d'identités de la nouvelle région. -
Le code client doit être mis à jour pour utiliser l'émetteur régionalisé (
cognito-identity.) ou pour lire dynamiquement lanew-region.amazonaws.comissréclamation à partir du jeton (recommandé). -
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
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. 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
Android
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.
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 :
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
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 AWSCognitoCredentialsProviderHelperloginsmé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.
- (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
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 AWSCognitoCredentialsProviderHelperloginsmé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.
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
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.