La version 4 (V4) du AWS SDK pour .NET est sortie \$1
Pour plus d'informations sur les modifications majeures et la migration de vos applications, consultez la [rubrique relative à la migration](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html).
[https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html)
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.
# Authentification des utilisateurs avec Amazon Cognito
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
À l'aide d'Amazon Cognito Identity, vous pouvez créer des identités uniques pour vos utilisateurs et les authentifier pour un accès sécurisé à vos AWS ressources telles qu'Amazon S3 ou Amazon DynamoDB. Amazon Cognito Identity prend en charge les fournisseurs d'identité publics tels qu'Amazon, Facebook, Twitter/Digits, Google ou tout autre fournisseur compatible avec OpenID Connect, ainsi que les identités non authentifiées. Amazon Cognito prend également en charge les [identités authentifiées par les développeurs](https://aws.amazon.com/blogs/mobile/amazon-cognito-announcing-developer-authenticated-identities/), qui vous permettent d'enregistrer et d'authentifier les utilisateurs à l'aide de votre propre processus d'authentification principal, tout en utilisant Amazon Cognito Sync pour synchroniser les données utilisateur et accéder aux ressources. AWS
Pour plus d'informations sur [Amazon Cognito](https://aws.amazon.com/cognito/), consultez le guide du développeur [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/).
Les exemples de code suivants montrent comment utiliser facilement Amazon Cognito Identity. L'[Fournisseur d'informations d'identification](cognito-creds-provider.md)exemple montre comment créer et authentifier les identités des utilisateurs. L'[CognitoAuthentication bibliothèque d'extensions](cognito-authentication-extension.md)exemple montre comment utiliser la bibliothèque d' CognitoAuthentication extensions pour authentifier les groupes d'utilisateurs Amazon Cognito.
**Topics**
+ [Fournisseur d'informations d'identification](cognito-creds-provider.md)
+ [CognitoAuthentication bibliothèque d'extensions](cognito-authentication-extension.md)
# Fournisseur d'identifiants Amazon Cognito
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
`Amazon.CognitoIdentity.CognitoAWSCredentials`, qui se trouve dans le [AWSSDK. CognitoIdentity](https://www.nuget.org/packages/AWSSDK.CognitoIdentity/) NuGetpackage, est un objet d'identification qui utilise Amazon Cognito et the AWS Security Token Service (AWS STS) pour récupérer les informations d'identification pour passer AWS des appels.
La première étape de configuration de `CognitoAWSCredentials` consiste à créer un « groupe d'identités ». Un groupe d'identités est un magasin d'informations relatives à l'identité de l'utilisateur qui est propre au compte. Les informations peuvent être récupérées quels que soient les plateformes client, appareils et systèmes d'exploitation. Autrement dit, si un utilisateur commence à utiliser votre application sur un téléphone, puis passe à une tablette, les informations de l'application restent disponibles pour cet utilisateur. Vous pouvez créer un nouveau pool d'identités depuis la console Amazon Cognito. Si vous utilisez la console, celle-ci vous fournira également les autres éléments d'information dont vous avez besoin :
+ Votre numéro de compte – Un numéro à 12 chiffres, comme 123456789012, qui est unique pour votre compte.
+ L'ARN du rôle non authentifié – Un rôle que les utilisateurs non authentifiés assumeront. Par exemple, ce rôle peut fournir des autorisations d'accès en lecture seule à vos données.
+ L'ARN du rôle authentifié – Un rôle que les utilisateurs authentifiés assumeront. Ce rôle peut fournir des autorisations plus étendues à vos données.
## Configurer Cognito AWSCredentials
L'exemple de code suivant montre comment procéder à la configuration`CognitoAWSCredentials`, que vous pouvez ensuite utiliser pour appeler Amazon S3 en tant qu'utilisateur non authentifié. Cela vous permet d'effectuer des appels avec seulement un volume minimum de données requises pour authentifier l'utilisateur. Les autorisations utilisateur sont contrôlées par le rôle. Vous pouvez donc configurer l'accès selon vos besoins.
```
CognitoAWSCredentials credentials = new CognitoAWSCredentials(
accountId, // Account number
identityPoolId, // Identity pool ID
unAuthRoleArn, // Role for unauthenticated users
null, // Role for authenticated users, not set
region);
using (var s3Client = new AmazonS3Client(credentials))
{
s3Client.ListBuckets();
}
```
## Utiliser AWS en tant qu'utilisateur non authentifié
L'exemple de code suivant montre comment vous pouvez commencer à utiliser en AWS tant qu'utilisateur non authentifié, puis vous authentifier via Facebook et mettre à jour les informations d'identification pour utiliser les informations d'identification Facebook. En utilisant cette approche, vous pouvez accorder différentes capacités aux utilisateurs authentifiés via le rôle authentifié. Par exemple, votre application de téléphone peut autoriser des utilisateurs à afficher un contenu de manière anonyme, mais leur permet de publier s'ils sont connectés avec un ou plusieurs des fournisseurs configurés.
```
CognitoAWSCredentials credentials = new CognitoAWSCredentials(
accountId, identityPoolId,
unAuthRoleArn, // Role for unauthenticated users
authRoleArn, // Role for authenticated users
region);
using (var s3Client = new AmazonS3Client(credentials))
{
// Initial use will be unauthenticated
s3Client.ListBuckets();
// Authenticate user through Facebook
string facebookToken = GetFacebookAuthToken();
// Add Facebook login to credentials. This clears the current AWS credentials
// and retrieves new AWS credentials using the authenticated role.
credentials.AddLogin("graph.facebook.com", facebookAccessToken);
// This call is performed with the authenticated role and credentials
s3Client.ListBuckets();
}
```
L'objet `CognitoAWSCredentials` fournit encore plus de fonctionnalités si vous l'utilisez avec l'objet `AmazonCognitoSyncClient` qui fait partie du kit AWS SDK pour .NET. Si vous utilisez les deux `AmazonCognitoSyncClient` et`CognitoAWSCredentials`, vous n'avez pas à spécifier les `IdentityId` propriétés `IdentityPoolId` et lorsque vous passez des appels avec le`AmazonCognitoSyncClient`. Ces propriétés sont automatiquement renseignées à partir de `CognitoAWSCredentials`. L'exemple de code suivant illustre ceci, ainsi qu'un événement qui vous informe chaque fois que `IdentityId` pour `CognitoAWSCredentials` est modifié. `IdentityId` peut changer dans certains cas, par exemple lors du passage d'un utilisateur non authentifié à un utilisateur authentifié.
```
CognitoAWSCredentials credentials = GetCognitoAWSCredentials();
// Log identity changes
credentials.IdentityChangedEvent += (sender, args) =>
{
Console.WriteLine("Identity changed: [{0}] => [{1}]", args.OldIdentityId, args.NewIdentityId);
};
using (var syncClient = new AmazonCognitoSyncClient(credentials))
{
var result = syncClient.ListRecords(new ListRecordsRequest
{
DatasetName = datasetName
// No need to specify these properties
//IdentityId = "...",
//IdentityPoolId = "..."
});
}
```
# Exemples de bibliothèques d' CognitoAuthentication extensions Amazon
**Note**
Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur .NET Framework et les AWS SDK pour .NET versions 3.3 et antérieures.
La bibliothèque d' CognitoAuthentication extensions, qui se trouve dans le dossier [Amazon.Extensions. CognitoAuthentication](https://www.nuget.org/packages/Amazon.Extensions.CognitoAuthentication/) NuGet package, simplifie le processus d'authentification des groupes d'utilisateurs Amazon Cognito pour les développeurs .NET Core et Xamarin. La bibliothèque repose sur l'API du fournisseur d'identité Amazon Cognito pour créer et envoyer des appels d'API d'authentification utilisateur.
## Utilisation de la bibliothèque d' CognitoAuthentication extensions
Amazon Cognito intègre des `ChallengeName` valeurs `AuthFlow` et des valeurs pour un flux d'authentification standard permettant de valider le nom d'utilisateur et le mot de passe via le Secure Remote Password (SRP). Pour plus d'informations sur le flux d'authentification, consultez [Flux d'authentification du groupe d'utilisateurs Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html).
Les exemples suivant nécessitent ces instructions `using` :
```
// Required for all examples
using System;
using Amazon;
using Amazon.CognitoIdentity;
using Amazon.CognitoIdentityProvider;
using Amazon.Extensions.CognitoAuthentication;
using Amazon.Runtime;
// Required for the GetS3BucketsAsync example
using Amazon.S3;
using Amazon.S3.Model;
```
### Utiliser l'authentification de base
Créez un [AmazonCognitoIdentityProviderClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CognitoIdentityProvider/TCognitoIdentityProviderClient.html)en utilisant [Anonymous AWSCredentials](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/Runtime/TAnonymousAWSCredentials.html), qui ne nécessite pas de demandes signées. Vous n'avez pas besoin de fournir une région ; le code sous-jacent appelle `FallbackRegionFactory.GetRegionEndpoint()` si aucune région n'est indiquée. Créez des objets `CognitoUserPool` et `CognitoUser`. Appelez la méthode `StartWithSrpAuthAsync` avec une demande `InitiateSrpAuthRequest` qui contient le mot de passe utilisateur.
```
public static async void GetCredsAsync()
{
AmazonCognitoIdentityProviderClient provider =
new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials());
CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider);
CognitoUser user = new CognitoUser("username", "clientID", userPool, provider);
InitiateSrpAuthRequest authRequest = new InitiateSrpAuthRequest()
{
Password = "userPassword"
};
AuthFlowResponse authResponse = await user.StartWithSrpAuthAsync(authRequest).ConfigureAwait(false);
accessToken = authResponse.AuthenticationResult.AccessToken;
}
```
### Authentifiez-vous en relevant les défis
Il est également plus simple de poursuivre le flux d'authentification avec NewPasswordRequired des défis tels que l'authentification multifactorielle (MFA). Les seules exigences sont les CognitoAuthentication objets, le mot de passe de l'utilisateur pour le SRP et les informations nécessaires pour le prochain défi, qui sont acquises après avoir invité l'utilisateur à les saisir. Le code suivant montre un moyen de vérifier le type de défi et d'obtenir les réponses appropriées pour le MFA et les NewPasswordRequired défis pendant le flux d'authentification.
Effectuez une authentification de base comme auparavant, et attendez (`await`) une réponse `AuthFlowResponse`. Lorsque la réponse est reçue, parcourez l'objet `AuthenticationResult` renvoyé. Si le type `ChallengeName` est `NEW_PASSWORD_REQUIRED`, appelez la méthode `RespondToNewPasswordRequiredAsync`.
```
public static async void GetCredsChallengesAsync()
{
AmazonCognitoIdentityProviderClient provider =
new AmazonCognitoIdentityProviderClient(new Amazon.Runtime.AnonymousAWSCredentials());
CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider);
CognitoUser user = new CognitoUser("username", "clientID", userPool, provider);
InitiateSrpAuthRequest authRequest = new InitiateSrpAuthRequest(){
Password = "userPassword"
};
AuthFlowResponse authResponse = await user.StartWithSrpAuthAsync(authRequest).ConfigureAwait(false);
while (authResponse.AuthenticationResult == null)
{
if (authResponse.ChallengeName == ChallengeNameType.NEW_PASSWORD_REQUIRED)
{
Console.WriteLine("Enter your desired new password:");
string newPassword = Console.ReadLine();
authResponse = await user.RespondToNewPasswordRequiredAsync(new RespondToNewPasswordRequiredRequest()
{
SessionID = authResponse.SessionID,
NewPassword = newPassword
});
accessToken = authResponse.AuthenticationResult.AccessToken;
}
else if (authResponse.ChallengeName == ChallengeNameType.SMS_MFA)
{
Console.WriteLine("Enter the MFA Code sent to your device:");
string mfaCode = Console.ReadLine();
AuthFlowResponse mfaResponse = await user.RespondToSmsMfaAuthAsync(new RespondToSmsMfaRequest()
{
SessionID = authResponse.SessionID,
MfaCode = mfaCode
}).ConfigureAwait(false);
accessToken = authResponse.AuthenticationResult.AccessToken;
}
else
{
Console.WriteLine("Unrecognized authentication challenge.");
accessToken = "";
break;
}
}
if (authResponse.AuthenticationResult != null)
{
Console.WriteLine("User successfully authenticated.");
}
else
{
Console.WriteLine("Error in authentication process.");
}
}
```
### Utiliser AWS les ressources après l'authentification
Une fois qu'un utilisateur est authentifié à l'aide de la CognitoAuthentication bibliothèque, l'étape suivante consiste à lui permettre d'accéder aux AWS ressources appropriées. Pour ce faire, vous devez créer un pool d'identités via la console Amazon Cognito Federated Identities. En spécifiant le groupe d'utilisateurs Amazon Cognito que vous avez créé en tant que fournisseur, à l'aide de son pool et de son ID client, vous pouvez autoriser les utilisateurs de votre groupe d'utilisateurs Amazon Cognito à accéder aux ressources connectées à votre compte. AWS Vous pouvez également spécifier des rôles différents pour permettre aux utilisateurs non authentifiés et authentifiés d'accéder à des ressources différentes. Vous pouvez modifier ces règles dans la console IAM, où vous pouvez ajouter ou supprimer des autorisations dans le champ **Action** de la stratégie attachée du rôle. Ensuite, en utilisant le groupe d'identités, le groupe d'utilisateurs et les informations utilisateur Amazon Cognito appropriés, vous pouvez passer des appels vers différentes AWS ressources. L'exemple suivant montre un utilisateur authentifié par SRP accédant aux différents compartiments Amazon S3 autorisés par le rôle du pool d'identités associé.
```
public async void GetS3BucketsAsync()
{
var provider = new AmazonCognitoIdentityProviderClient(new AnonymousAWSCredentials());
CognitoUserPool userPool = new CognitoUserPool("poolID", "clientID", provider);
CognitoUser user = new CognitoUser("username", "clientID", userPool, provider);
string password = "userPassword";
AuthFlowResponse context = await user.StartWithSrpAuthAsync(new InitiateSrpAuthRequest()
{
Password = password
}).ConfigureAwait(false);
CognitoAWSCredentials credentials =
user.GetCognitoAWSCredentials("identityPoolID", RegionEndpoint.< YourIdentityPoolRegion >);
using (var client = new AmazonS3Client(credentials))
{
ListBucketsResponse response =
await client.ListBucketsAsync(new ListBucketsRequest()).ConfigureAwait(false);
foreach (S3Bucket bucket in response.Buckets)
{
Console.WriteLine(bucket.BucketName);
}
}
}
```
## Options d'authentification supplémentaires
Outre le SRP et le MFA NewPasswordRequired, CognitoAuthentication la bibliothèque d'extensions facilite le flux d'authentification pour :
+ Personnalisé - Initier avec un appel à `StartWithCustomAuthAsync(InitiateCustomAuthRequest customRequest)`
+ RefreshToken - Commencez par un appel à `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)`
+ RefreshTokenSRP - Initiez par un appel à `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)`
+ AdminNoSRP - Initiez par un appel à `StartWithAdminNoSrpAuthAsync(InitiateAdminNoSrpAuthRequest adminAuthRequest)`
Appelez la méthode appropriée selon le flux souhaité. Continuez ensuite à interroger l'utilisateur avec des stimulations comme elles sont présentées dans les objets `AuthFlowResponse` de chaque appel de méthode. Appelez également la méthode de réponse appropriée, comme `RespondToSmsMfaAuthAsync` pour les stimulations MFA et `RespondToCustomAuthAsync` pour les stimulations personnalisées.