Version 4 (V4) von AWS SDK für .NET wurde veröffentlicht\$1

Informationen zu wichtigen Änderungen und zur Migration Ihrer Anwendungen finden Sie im [Migrationsthema](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)

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Beispiele Amazon CognitoAuthentication Amazon-Erweiterungsbibliotheken
<a name="cognito-authentication-extension"></a>

**Anmerkung**  
Die Informationen in diesem Thema beziehen sich speziell auf Projekte, die auf .NET Framework und AWS SDK für .NET Version 3.3 und früher basieren.

Die CognitoAuthentication Erweiterungsbibliothek befindet sich in [Amazon.Extensions. CognitoAuthentication](https://www.nuget.org/packages/Amazon.Extensions.CognitoAuthentication/) NuGet Paket, vereinfacht den Authentifizierungsprozess von Amazon Cognito Cognito-Benutzerpools für .NET Core- und Xamarin-Entwickler. Die Bibliothek baut auf der Amazon Cognito Identity Provider-API auf, um API-Aufrufe zur Benutzerauthentifizierung zu erstellen und zu senden.

## Verwenden der CognitoAuthentication Erweiterungsbibliothek
<a name="using-the-cognitoauthentication-extension-library"></a>

Amazon Cognito verfügt über einige integrierte `AuthFlow` `ChallengeName` Werte für einen Standardauthentifizierungsablauf zur Validierung von Benutzername und Passwort über das Secure Remote Password (SRP). Weitere Informationen zum Authentifizierungsablauf finden Sie unter [Amazon Cognito Ablauf der Authentifizierung in Benutzerpools](https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html).

Die folgenden Beispiele erfordern diese `using`-Anweisungen:

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

### Verwenden Sie die Standardauthentifizierung
<a name="use-basic-authentication"></a>

Erstellen Sie eine [AmazonCognitoIdentityProviderClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CognitoIdentityProvider/TCognitoIdentityProviderClient.html)mit [Anonym AWSCredentials](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/Runtime/TAnonymousAWSCredentials.html), für die keine signierten Anfragen erforderlich sind. Sie müssen keine Region angeben. Der zugrunde liegende Code ruft `FallbackRegionFactory.GetRegionEndpoint()` auf, wenn keine Region angegeben ist. Erstellen Sie die Objekte `CognitoUserPool` und `CognitoUser`. Rufen Sie die Methode `StartWithSrpAuthAsync` mit einer `InitiateSrpAuthRequest` auf, in der das Benutzerpasswort enthalten ist.

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

}
```

### Authentifizieren Sie sich bei Herausforderungen
<a name="authenticate-with-challenges"></a>

Es ist auch einfacher, den Authentifizierungsfluss bei NewPasswordRequired Herausforderungen wie Multi-Factor Authentication (MFA) fortzusetzen. Die einzigen Anforderungen sind die CognitoAuthentication Objekte, das Benutzerkennwort für SRP und die erforderlichen Informationen für die nächste Herausforderung. Diese Informationen werden abgerufen, nachdem der Benutzer zur Eingabe aufgefordert wurde. Der folgende Code zeigt eine Möglichkeit, den Challenge-Typ zu überprüfen und die entsprechenden Antworten für MFA und NewPasswordRequired Challenges während des Authentifizierungsprozesses zu erhalten.

Führen Sie wie zuvor eine grundlegende Authentifizierung durch und geben Sie dann `await` für eine `AuthFlowResponse` aus. Wenn die Antwort empfangen wird, durchlaufen Sie das zurückgegebene `AuthenticationResult`-Objekt. Wenn der `ChallengeName`-Typ `NEW_PASSWORD_REQUIRED` ist, rufen Sie die Methode `RespondToNewPasswordRequiredAsync` auf.

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

### Verwenden Sie AWS Ressourcen nach der Authentifizierung
<a name="use-aws-resources-after-authentication"></a>

Sobald ein Benutzer mithilfe der CognitoAuthentication Bibliothek authentifiziert wurde, besteht der nächste Schritt darin, dem Benutzer den Zugriff auf die entsprechenden AWS Ressourcen zu ermöglichen. Dazu müssen Sie über die Amazon Cognito Federated Identities-Konsole einen Identitätspool erstellen. Indem Sie den Amazon Cognito Cognito-Benutzerpool, den Sie als Anbieter erstellt haben, mithilfe seiner PoolID und ClientID angeben, können Sie den Benutzern Ihres Amazon Cognito Cognito-Benutzerpools den Zugriff auf AWS Ressourcen ermöglichen, die mit Ihrem Konto verbunden sind. Sie können auch unterschiedliche Rollen für authentifizierte und nicht authentifizierte Benutzer angeben, um so Zugriff auf unterschiedliche Ressourcen zu ermöglichen. Sie können diese Regeln in der IAM-Konsole ändern. Hier können Sie im Feld **Aktion** der an die Richtlinie angefügten Rolle Berechtigungen hinzufügen oder entfernen. Anschließend können Sie mithilfe des entsprechenden Identitätspools, Benutzerpools und Amazon Cognito Cognito-Benutzerinformationen Aufrufe an verschiedene AWS Ressourcen tätigen. Das folgende Beispiel zeigt einen mit SRP authentifizierten Benutzer, der auf die verschiedenen Amazon S3 S3-Buckets zugreift, die durch die Rolle des zugehörigen Identitätspools zugelassen sind.

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

## Weitere Authentifizierungsoptionen
<a name="more-authentication-options"></a>

Zusätzlich zu SRP NewPasswordRequired, und MFA bietet die CognitoAuthentication Erweiterungsbibliothek einen einfacheren Authentifizierungsablauf für:
+ Custom – Initiiert durch einen Aufruf an `StartWithCustomAuthAsync(InitiateCustomAuthRequest customRequest)` 
+ RefreshToken - Initiieren Sie mit einem Anruf an `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)` 
+ RefreshTokenSRP — Initiieren Sie mit einem Anruf an `StartWithRefreshTokenAuthAsync(InitiateRefreshTokenAuthRequest refreshTokenRequest)` 
+ AdminNoSRP — Initiieren Sie mit einem Anruf an `StartWithAdminNoSrpAuthAsync(InitiateAdminNoSrpAuthRequest adminAuthRequest)` 

Rufen Sie abhängig vom gewünschten Ablauf die entsprechende Methode auf. Fahren Sie dann mit Eingabeaufforderungen an den Benutzer fort, die ihm in den `AuthFlowResponse`-Objekten eines jeden Methodenaufrufs angezeigt werden. Rufen Sie außerdem die entsprechende Antwortmethode, wie z. B. `RespondToSmsMfaAuthAsync` für MFA-Aufforderungen und `RespondToCustomAuthAsync` für benutzerdefinierte Aufforderungen, auf.