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.
# Beispielanwendung für Identitätspools
Der häufigste Anwendungsfall für Amazon Cognito Cognito-Identitätspools besteht darin, Benutzer aus mehreren Anmeldesystemen zusammenzuführen und temporäre AWS Anmeldeinformationen mit eingeschränktem Zugriff direkt an den Client zu senden. Dadurch entfällt die Notwendigkeit, einen Credential-Broker für Zugriffsberechtigungen auf Ihre Ressourcen einzurichten. AWS Möglicherweise müssen Sie Benutzern die Möglichkeit geben, sich mit ihren Social-Media-Konten anzumelden und auf App-Assets von Amazon S3 für Ihre mobile Anwendung zuzugreifen. Identitätspools stellen Benutzern, die sich bei Benutzerpools anmelden, auch Anmeldeinformationen zur Verfügung.
In diesem Tutorial erstellen Sie eine Webanwendung, mit der Sie temporäre Authentifizierungs- und Gastanmeldedaten in den erweiterten und grundlegenden [Authentifizierungsabläufen](authentication-flow.md) mit unterstützten Identitätsanbietern (IdPs) in Identitätspools abrufen können. Wenn Sie bereits Erfahrung in der Webentwicklung haben, laden Sie die Beispiel-App von GitHub herunter.
[Laden Sie die Beispielanwendung von herunter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/cognito/scenarios/identity_pools_example_demo/web)
Diese Beispielanwendung demonstriert die folgenden Funktionen von Amazon Cognito Cognito-Identitätspools:
**Die Authentifizierung erfolgt in Identitätspools**
+ Verbesserter Authentifizierungsablauf mit detaillierten API-Anforderungsaufschlüsselungen
+ Grundlegender Authentifizierungsablauf mit detaillierten Aufschlüsselungen der API-Anfragen
**Implementierung des (nicht authentifizierten) Gastzugriffs**
+ Bieten Sie eingeschränkten AWS-Service Zugriff, ohne dass eine Anmeldung erforderlich ist
**Integration mit unterstützten Identitätsanbietern**
+ Soziale Netzwerke IdPs (Facebook, Amazon, Twitter, Apple und Google) für den Zugang von Verbrauchern
+ Enterprise IdPs (über OpenID Connect oder SAML) für Unternehmensanwender
+ Amazon-Cognito-Benutzerpools
**AWS Verwaltung von Anmeldeinformationen**
+ Austausch von Identitätsanbieter-Token gegen temporäre AWS Anmeldeinformationen
+ Verwenden temporärer Anmeldeinformationen für den sicheren Zugriff auf AWS Dienste
Nachdem Sie die Anwendung auf Ihrem Entwicklungs-Webserver eingerichtet und in einem Browser darauf zugegriffen haben, werden Ihnen die folgenden Optionen angezeigt.
![\[Screenshot der Weboberfläche der Amazon Cognito Cognito-Identitätspool-Demo-Anwendung mit der Hauptseite mit Optionen für Authentifizierungsmethoden und interaktiven Demo-Abschnitten.\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/images/amazon-cognito-identity-pool-demo-app.png)
**Topics**
+ [Voraussetzungen](#demo-prerequisites)
+ [Einrichtung des Authentifizierungsanbieters](#demo-authentication-provider-setup)
+ [Stellen Sie die Demo-Anwendung bereit](#demo-deploy-application)
+ [Erkunden Sie die Authentifizierungsmethoden in Ihrem Identitätspool](#explore-authentication-methods-in-identity-pools-application)
+ [Nächste Schritte](#next-steps)
## Voraussetzungen
Bevor Sie beginnen, müssen Sie die folgenden Ressourcen konfigurieren.
+ Ein AWS Konto mit Zugriff auf Amazon Cognito. Wenn Sie kein AWS Konto haben, folgen Sie den Anweisungen unter[Erste Schritte mit AWS](cognito-getting-started-account-iam.md).
+ Python 3.8 oder höher ist auf Ihrem Entwicklungscomputer installiert.
+ GitHub Zugriff.
+ AWS Anmeldeinformationen, die mit Berechtigungen zum Stellen authentifizierter Anfragen an Amazon Cognito APIs konfiguriert sind. Diese Anmeldeinformationen sind für die [Entwicklerauthentifizierung](authentication-flow.md#authentication-flow-developer) erforderlich.
Weitere Informationen zur Implementierung von AWS Anmeldeinformationen und zum Identitätspoolverbund in Ihrem speziellen SDK finden Sie unter[Abrufen von Anmeldeinformationen](getting-credentials.md).
## Einrichtung des Authentifizierungsanbieters
Um optimale Ergebnisse mit dieser Anwendung zu erzielen, richten Sie einen oder mehrere externe Identitätsanbieter (IdPs) oder Amazon Cognito Cognito-Benutzerpools ein und integrieren Sie sie in Ihren Amazon Cognito Cognito-Identitätspool. Nachdem Sie die Voraussetzungen erfüllt haben und bevor Sie diese Demo-Anwendung ausführen, wählen Sie aus, welche Identitätsanbieter konfiguriert werden sollen. Die [Amazon Cognito Cognito-Konsole](https://console.aws.amazon.com/cognito/v2/identity/identity-pools) führt Sie durch den Prozess der Konfiguration von Identitätspools und Anbietern.
**Amazon-Cognito-Benutzerpools**
+ [Authentifizierung mit Amazon Cognito Cognito-Benutzerpools](authentication.md)
+ [Anwendungsspezifische Einstellungen mit App-Clients](user-pool-settings-client-apps.md)
**Anbieter sozialer Identitäten**
+ Google: [Google als Identitätspool-IdP einrichten](google.md)
+ Facebook: [Facebook als Identitätspools einrichten (IdP)](facebook.md)
+ Amazon: [Login with Amazon als Identitätspools (IdP) einrichten](amazon.md)
**Open ID Connect (OIDC)-Anbieter**
+ [Einrichtung eines OIDC-Anbieters als Identitätspool-IdP](open-id.md)
**SAML-Anbieter**
+ [Einrichtung eines SAML-Anbieters als Identitätspool-IdP](saml-identity-provider.md)
**Anmerkung**
Für diese Demo-Anwendung müssen Sie nicht alle unterstützten Identitätsanbieter einrichten. Sie können mit einem beginnen, der Ihrem Anwendungsfall entspricht. Jeder Link enthält detaillierte Konfigurationsanweisungen.
## Stellen Sie die Demo-Anwendung bereit
### Klonen Sie das Repository
1. Öffnen Sie ein Terminal-Fenster.
1. Klonen Sie das `aws-doc-sdk-examples` Repository oder rufen Sie [diesen Ordner auf andere Weise im Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/cognito/scenarios/identity_pools_example_demo/web) ab.
```
git clone https://github.com/awsdocs/aws-doc-sdk-examples.git
```
1. Navigieren Sie zum -Projektverzeichnis.
```
cd python/example_code/cognito/scenarios/identity_pools_example_demo/web
```
### Erstellen eines Identitäten-Pools
Um einen Amazon Cognito Cognito-Identitätspool für Ihre Anwendung zu erstellen, folgen Sie den Anweisungen unter[Übersicht über die Identity-Pools-Konsole](identity-pools.md).
**Um einen Identitätspool für die Demo-Anwendung zu konfigurieren**
1. Öffnen Sie die [Amazon-Cognito-Konsole](https://console.aws.amazon.com/cognito/home).
1. Wählen Sie im linken Navigationsmenü **Identitätspools** aus. Wählen Sie einen vorhandenen Identitätspool oder erstellen Sie einen neuen.
1. Aktivieren Sie unter **Benutzerzugriff** die **Optionen Authentifizierter Zugriff** und **Gastzugriff**. Konfigurieren Sie eine neue oder bestehende [IAM-Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) und [weisen Sie ihr die Berechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) zu, die Sie den einzelnen Benutzertypen gewähren möchten.
1. Richten Sie unter **Benutzerzugriff** alle Identitätsanbieter ein, die Sie konfigurieren möchten.
1. Aktivieren Sie unter **Eigenschaften des Identitätspools** die **Standardauthentifizierung (klassisch)**.
1. Öffnen Sie in Ihrem Browser die Konsole für Ihren Identitätspool. Sie werden die Identitätspool-ID und andere Konfigurationsinformationen in Ihrem Anwendungs-Setup verwenden.
### Konfigurieren Sie die Anwendung und führen Sie sie aus
Die folgenden Schritte führen Sie durch die Ersteinrichtung Ihrer Demo-Anwendung.
**Um die Demo-Anwendung zu konfigurieren**
1. Öffnen Sie eine Befehlszeile `python/example_code/cognito/scenarios/identity_pools_example_demo/web` in Ihrem `aws-doc-sdk-examples` Clone.
1. Erstellen Sie eine `.env` Datei, indem Sie die [Beispiel-Umgebungsdatei](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/python/example_code/cognito/scenarios/identity_pools_example_demo/web/.env.example) kopieren.
```
cp .env.example .env
```
1. Öffnen Sie die Datei `.env` in einem Text-Editor. Ersetzen Sie die Beispielwerte in der Datei durch Ihre eigenen Konfigurationswerte.
1. Installieren Sie Backend-Abhängigkeiten.
```
pip install -r requirements.txt
```
1. Starten Sie den Backend-Server:
```
cd backend
python oauth_server.py
```
1. Öffnen Sie ein neues Terminalfenster, navigieren Sie zum Projektverzeichnis und starten Sie den Frontend-Server:
```
cd frontend
python -m http.server 8001
```
1. Öffnen Sie Ihren Browser für die Anwendung unter [http://localhost:8001](http://localhost:8001). Ihr Browser zeigt die Benutzeroberfläche der Demo-Anwendung an, mit der Sie die Authentifizierung von Identitätspools testen können.
## Erkunden Sie die Authentifizierungsmethoden in Ihrem Identitätspool
Dieser Abschnitt führt Sie durch grundlegende und erweiterte Authentifizierungsabläufe mit der Demo-Anwendung Amazon Cognito Identity Pools. In dieser Demo erfahren Sie, wie Identitätspools mit verschiedenen Identitätsanbietern zusammenarbeiten, um temporäre AWS Anmeldeinformationen für Ihre Anwendungsbenutzer bereitzustellen.
Im Abschnitt **Interaktive Demo** der Beispielanwendung wählen Sie zunächst zwischen zwei Zugriffsarten, die von Identitätspools unterstützt werden.
**[Nicht authentifizierter (Gast-) Zugriff](#unauthenticated-access)**
Geben Sie Benutzern, die sich noch nicht authentifiziert haben, AWS Anmeldeinformationen an.
**Authentifizierter Zugriff**
Tauschen Sie Identitätsanbieter-Token gegen AWS Anmeldeinformationen mit dem vollen Umfang verfügbarer Berechtigungen aus. Wählen Sie aus den in Ihrer `.env` Datei konfigurierten Identitätsanbietern einen Identitätsanbieter aus.
## Nicht authentifizierter (Gast-) Zugriff
In diesem Schritt wird gezeigt, wie Sie mithilfe der Gastzugriffsfunktion Ihres Identitätspools temporäre AWS Anmeldeinformationen für nicht authentifizierte (Gast-) Benutzer abrufen können. In der Demo-Anwendung testen Sie sowohl erweiterte als auch grundlegende Abläufe, um zu sehen, wie Identitätspools Anmeldeinformationen ausgeben, ohne dass eine Benutzeranmeldung erforderlich ist. Der Gastzugriff verwendet dieselbe API-Sequenz wie der authentifizierte Zugriff, jedoch ohne Bereitstellung von Identitätsanbieter-Token (wie OAuth Token von Google, Facebook oder SAML-Assertionen von Unternehmensanbietern).
Lesen Sie weiter, wenn Sie nach Informationen suchen, wie Sie Benutzern eingeschränkten AWS Zugriff gewähren können, ohne dass eine Authentifizierung erforderlich ist. Nachdem Sie den Gastzugriff implementiert haben, erfahren Sie, wie Sie anonymen Benutzern auf sichere Weise AWS Anmeldeinformationen zur Verfügung stellen können, und Sie werden die Unterschiede zwischen den beiden Authentifizierungsabläufen verstehen.
**Wichtig**
Bei einem nicht authentifizierten Zugriff können Anmeldeinformationen für jeden Benutzer mit Internetzugang ausgestellt werden. Daher eignet er sich am besten für AWS Ressourcen, die nur minimale Sicherheit erfordern, wie z. B. öffentliche Ressourcen APIs und Grafikdateien. Bevor Sie mit diesem Schritt fortfahren, überprüfen Sie, ob Sie Ihren Identitätspool mit aktiviertem Gastzugriff konfiguriert haben, und stellen Sie sicher, dass die richtigen IAM-Richtlinien zur Einschränkung von Berechtigungen vorhanden sind.
------
#### [ Guest access with enhanced flow ]
Der erweiterte Ablauf ist ein optimierter Ansatz zum Abrufen von AWS Anmeldeinformationen für nicht authentifizierte Benutzer mit zwei API-Anfragen.
**Um den Gastzugriff mit dem erweiterten Ablauf zu testen**
1. Navigieren Sie in der Demo-Anwendung zum Bereich **Interaktive Demo**
1. Wählen Sie die Registerkarte **Gastzugriff**.
1. Wählen Sie die Registerkarte „**Verbesserter Ablauf**“.
1. Wählen Sie **Gastzugriff testen** aus.
1. Die App ruft temporäre AWS Anmeldeinformationen aus Ihren Identitätspools ab, ohne dass zusätzliche Authentifizierungsaufforderungen erforderlich sind.
1. Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-07T00:58:21-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ `GetId()`API-Anfrage mit Ihrem`identityPoolId`. Für den Gastzugriff sind keine Authentifizierungstoken erforderlich
```
{
"IdentityPoolId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
Falls gültig, findet oder erstellt es die des Benutzers und gibt sie zurück`IdentityID`. Eine Beispielantwort sieht wie folgt aus:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
+ `GetCredentialsForIdentity()`mit der zurückgegebenen`identityPoolId`.
```
POST GetCredentialsForIdentity
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
Cognito validiert den Gastzugriff, übernimmt intern die nicht authentifizierte Rolle und gibt temporäre AWS STS AWS-Anmeldeinformationen zurück. (Keine IAM-Authentifizierung bei diesem Anruf; Rollenvertrauen muss dies zulassen.) `cognito-identity-amazonzaws.com`
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-07T00:58:21-07:00"
}
}
```
------
#### [ Guest access with basic flow ]
Der grundlegende Ablauf bietet eine detaillierte Kontrolle über den Authentifizierungsprozess mit separaten API-Anfragen für den Identitätsabruf und die Generierung von Anmeldeinformationen.
**Um den Gastzugriff mit dem Basisablauf zu testen**
1. Navigieren Sie in der Demo-Anwendung zum Bereich **Interaktive Demo**
1. Wählen Sie die Registerkarte **Gastzugriff**.
1. Wählen Sie den Tab **Basic Flow**.
1. Wählen Sie **Gastzugriff testen** aus.
1. Die App ruft temporäre AWS Anmeldeinformationen aus Ihren Identitätspools ab, ohne dass zusätzliche Authentifizierungsaufforderungen erforderlich sind.
1. Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden.
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ `GetId()`API-Anfrage mit Ihrer Identitätspool-ID. Für den Gastzugriff sind keine Authentifizierungstoken erforderlich.
```
POST GetId
{
"IdentityPoolId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
```
Falls gültig, findet es die des Benutzers oder erstellt sie und gibt sie zurück`IdentityID`. Eine Beispielantwort sieht wie folgt aus:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetOpenIdToken()`mit der zurückgegebenen `IdentityID` und derselben `Logins` Map
```
POST GetOpenIdToken
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Token": "eyJraWQiOiJFWAMPLE......"
}
```
**Was passiert in diesem Schritt:** Amazon Cognito gibt ein kurzlebiges OpenID Connect-Web-Identitätstoken von cognito-identity.amazonaws.com aus, das dies repräsentiert. `IdentityId` Das Token enthält OIDC-Ansprüche, die AWS STS bewertet werden, darunter aud (Ihre Identitätspool-ID) und amr (authentifiziert oder nicht authentifiziert). Die Vertrauensrichtlinie Ihrer IAM-Rolle muss diese Ansprüche vorschreiben.
+ `AssumeRoleWithWebIdentity()`- Ihre App ruft AWS STS direkt auf, um das Amazon Cognito OpenID-Token gegen temporäre Anmeldeinformationen auszutauschen AWS
```
POST sts:AssumeRoleWithWebIdentity
{
"RoleArn": "arn:aws:iam::111122223333:role/Cognito_IdentityPoolUnauth_Role",
"WebIdentityToken": "eyJraWQiOiJFWAMPLE......"
}
```
Antwort:
```
{
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "FwoGZXIvYXdzEEXAMPLE......"
}
}
```
**Was passiert in diesem Schritt: Nach der Validierung:** Gibt temporäre Anmeldeinformationen zurück AWS
------
### Verwenden Sie die temporären Anmeldeinformationen
Diese temporären Anmeldeinformationen funktionieren wie AWS Standardanmeldedaten, verfügen jedoch über eingeschränkte Berechtigungen, die durch die nicht authentifizierte IAM-Rolle Ihres Identitätspools definiert werden. Sie können sie mit jedem AWS SDK oder verwenden. AWS CLI Weitere Informationen zur Konfiguration AWS SDKs mit Anmeldeinformationen finden Sie unter [Standardisierte Anbieter von Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) im Referenzhandbuch AWS SDKs und im Tools-Referenzhandbuch.
Die folgenden Beispiele stellen keine vollständige Liste dar, sie zeigen jedoch, wie die Gastfunktion eines Identitätspools die Benutzererfahrung verbessern kann.
#### Öffentliche, schreibgeschützte Inhalte
In den folgenden Beispielen werden Anbieter von Anmeldeinformationen für den eingeschränkten Amazon S3 S3-Zugriff als Gastbenutzer konfiguriert.
------
#### [ Python ]
```
# Example: Using credentials with boto3
import boto3
# Configure client with temporary credentials
s3_client = boto3.client(
's3',
aws_access_key_id='AKIAIOSFODNN7EXAMPLE',
aws_secret_access_key='wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
aws_session_token='IQoJb3JpZ2luX2VjEEXAMPLE......'
)
# Make API requests within IAM role permissions
response = s3_client.list_objects_v2(Bucket='my-public-bucket')
# Access public content
for obj in response.get('Contents', []):
print(f"File: {obj['Key']}, Size: {obj['Size']} bytes")
```
------
#### [ JavaScript ]
```
// Example: Accessing public content
import { S3Client, GetObjectCommand } from "@aws-sdk/client-s3";
const s3Client = new S3Client({
region: "us-east-1",
credentials: {
accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
sessionToken: 'IQoJb3JpZ2luX2VjEEXAMPLE......'
}
});
// Access public images or documents
const response = await s3Client.send(new GetObjectCommand({
Bucket: 'my-public-content',
Key: 'product-catalog.pdf'
}));
```
------
### „Try-before-login“ -Funktionen
In den folgenden Beispielen wird der schreibgeschützte Zugriff auf Amazon DynamoDB als Gastbenutzer verwendet.
------
#### [ Python ]
```
# Example: Limited app functionality for trial users
import boto3
dynamodb = boto3.client(
'dynamodb',
aws_access_key_id='AKIAIOSFODNN7EXAMPLE',
aws_secret_access_key='wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
aws_session_token='IQoJb3JpZ2luX2VjEEXAMPLE......'
)
# Allow guest users to view sample data (limited to 5 items)
response = dynamodb.scan(TableName='SampleProducts', Limit=5)
```
------
#### [ JavaScript ]
```
// Example: Limited app functionality for trial users
import { DynamoDBClient, ScanCommand } from "@aws-sdk/client-dynamodb";
const dynamodbClient = new DynamoDBClient({
region: "us-east-1",
credentials: {
accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
sessionToken: 'IQoJb3JpZ2luX2VjEEXAMPLE......'
}
});
// Allow guest users to view sample data (limited to 5 items)
const response = await dynamodbClient.send(new ScanCommand({
TableName: 'SampleProducts',
Limit: 5
}));
```
------
## Authentifizierung durch einen Anbieter sozialer Identitäten
In diesem Schritt wird der allgemeine Ablauf der Nutzung von Anbietern sozialer Identitäten mit Amazon Cognito Cognito-Identitätspools untersucht. Die soziale Authentifizierung bietet ein vertrautes Anmeldeerlebnis bei gleichzeitiger Wahrung der Sicherheit durch föderiertes Identitätsmanagement. Sie können sich bei einem Social Identity Provider (IdP) wie Google, Facebook und Amazon anmelden und dieses IdP-Token dann gegen temporäre AWS Anmeldeinformationen eintauschen. Die Integration von Twitter und Apple wird auch von Identitätspools unterstützt, in der Beispielanwendung jedoch nicht.
Der Identitätspool selbst ist kein Benutzerverzeichnis. Es speichert keine Passwörter oder Profilfelder. Stattdessen vertraut es bei der Authentifizierung des Benutzers IdPs auf externe Benutzer und konzentriert sich darauf, den bereits authentifizierten Benutzer zu autorisieren, AWS Dienste direkt aufzurufen, indem Anmeldeinformationen für IAM-Rollen verkauft werden.
------
#### [ Social identity provider with enhanced flow ]
In diesem Abschnitt wird gezeigt, wie Sie einen Social Identity Provider verwenden können, um einen Benutzer anzumelden und mithilfe des erweiterten Ablaufs das Provider-Token in einem Amazon Cognito Cognito-Identitätspool gegen temporäre Anmeldeinformationen zum Anfordern von AWS Ressourcen auszutauschen.
**Verwenden Sie Social Sign-In mit dem erweiterten Ablauf in der Beispielanwendung**
1. Navigieren Sie in der Demo-Anwendung zum Bereich **Interaktive Demo**
1. Wählen Sie die Registerkarte **Authentifizierter Zugriff**.
1. Wählen Sie die Registerkarte **Erweiterter Ablauf**.
1. Wählen Sie einen unterstützten sozialen Anbieter, den Sie konfiguriert haben, z. B. **Mit Google** **anmelden, Mit Facebook** **anmelden oder Mit Amazon** anmelden.
1. Melden Sie sich an und stimmen Sie zu, Benutzerdaten mit der Anwendung zu teilen.
1. Der Anbieter leitet zurück zur Weiterleitungs-URI der App
1. Die App sendet das Provider-Token an Ihren Identitätspool und ruft temporäre AWS Anmeldeinformationen ab
1. Die App zeigt das **Ergebnisfenster** in der Weboberfläche an.
Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ Die App meldet den Benutzer mit einem sozialen IdP an und erhält das Provider-Token. Identitätspools akzeptieren diese Artefakte von sozialen Anbietern:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/getting-started-identity-pools-application.html)
Nach erfolgreicher Authentifizierung beim sozialen Anbieter erhält Ihre App eine OAuth Antwort mit dem Zugriffstoken und anderen Authentifizierungsdetails:
```
{
"access_token": "ya29.A0AS3H6NEXAMPLE......",
"expires_in": 3599,
"scope": "openid https://www.examplesocial....",
"token_type": "Bearer",
"id_token": "eyJhbGciOiJSUzI1NiIsEXAMPLE......"
}
```
+ `GetId()`API-Anfrage mit Ihrer Identitätspool-ID und einer `Logins` Map, die Ihr Social Provider-Token enthält
```
POST GetId
{
"IdentityPoolId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"Logins": {
"accounts.google.com": "eyJhbGciOiJSUzI1NiIsEXAMPLE......"
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetCredentialsForIdentity()`mit der zurückgegebenen `IdentityID` und derselben `Logins` Map
```
POST GetCredentialsForIdentity
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Logins": {
"accounts.google.com": "eyJhbGciOiJSUzI1NiIsEXAMPLE......"
}
}
```
Antwort:
```
{
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-07T00:58:21-07:00"
},
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
**Was ist passiert**: Amazon Cognito hat das Token anhand des konfigurierten Anbieters validiert, basierend auf Ihrer Anbieterkonfiguration eine IAM-Rolle ausgewählt und in AWS STS Ihrem Namen angerufen. Ihr Identitätspool hat dann temporäre Anmeldeinformationen zurückgegeben.
------
#### [ Social identity provider with basic flow ]
In diesem Abschnitt wird gezeigt, wie Sie einen Social Identity Provider verwenden können, um einen Benutzer anzumelden und mithilfe des Basisablaufs das Provider-Token in einem Amazon Cognito Cognito-Identitätspool gegen temporäre Anmeldeinformationen zum Aufrufen von AWS Diensten auszutauschen.
**Verwenden Sie Social Sign-In mit dem Basisablauf in der Beispielanwendung**
1. Navigieren Sie in der Demo-Anwendung zum Bereich **Interaktive Demo**
1. Wählen Sie die Registerkarte **Authentifizierter Zugriff**.
1. Wählen Sie die Registerkarte **Basic Flow**.
1. Wählen Sie einen unterstützten sozialen Anbieter, den Sie konfiguriert haben, z. B. **Mit Google** **anmelden, Mit Facebook** **anmelden oder Mit Amazon** anmelden.
1. Melden Sie sich an und stimmen Sie zu, Benutzerdaten mit der Anwendung zu teilen.
1. Der Anbieter leitet zurück zur Weiterleitungs-URI der App
1. Die App sendet das Provider-Token an Ihren Identitätspool und ruft temporäre AWS Anmeldeinformationen ab
1. Die App zeigt das **Ergebnisfenster** in der Weboberfläche an.
Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ Die App meldet den Benutzer mit einem sozialen IdP an und erhält das Provider-Token. Identitätspools akzeptieren diese Artefakte von sozialen Anbietern:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/getting-started-identity-pools-application.html)
Nach erfolgreicher Authentifizierung beim sozialen Anbieter erhält Ihre App eine OAuth Antwort mit dem Zugriffstoken und anderen Authentifizierungsdetails:
```
{
"access_token": "ya29.A0AS3H6NEXAMPLE......",
"expires_in": 3599,
"scope": "openid https://www.examplesocial....",
"token_type": "Bearer",
"id_token": "eyJhbGciOiJSUzI1NiIsEXAMPLE......"
}
```
+ `GetId()`API-Anfrage mit Ihrer Identitätspool-ID und einer `Logins` Map, die Ihr Social Provider-Token enthält
```
POST GetId
{
"IdentityPoolId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"Logins": {
"accounts.google.com": "token..."
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetOpenIdToken()`mit der zurückgegebenen `IdentityID` und derselben Logins-Map
```
POST GetOpenIdToken
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Logins": {
"accounts.google.com": "token..."
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Token": "eyJraWQiOiJFWAMPLE......"
}
```
+ `AssumeRoleWithWebIdentity()`mit dem OpenID-Token
```
POST AssumeRoleWithWebIdentity
{
"RoleArn": "arn:aws:iam::111122223333:role/Cognito_IdentityPoolAuth_Role",
"WebIdentityToken": "eyJraWQiOiJFWAMPLE......"
}
```
Antwort:
```
{
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T14:36:17-07:00"
}
}
```
**Was ist passiert**: Amazon Cognito validierte das Token anhand des konfigurierten Anbieters und gab ein OpenID-Token aus. Die Anwendung wurde AWS STS direkt aufgerufen, um eine IAM-Rolle zu übernehmen und temporäre Anmeldeinformationen zu erhalten.
------
### Verstehen Sie den sozialen Zugang
+ Soziale Benutzer erhalten temporäre AWS Anmeldeinformationen über Amazon Cognito Cognito-Identitätspools, nachdem sie sich bei ihrem sozialen Anbieter authentifiziert haben.
+ Jeder authentifizierte Benutzer erhält eine eindeutige Identitäts-ID, die für alle Sitzungen gültig ist.
+ Diese Anmeldeinformationen sind mit einer IAM-Rolle verknüpft, die speziell für den authentifizierten Zugriff entwickelt wurde und umfassendere Berechtigungen bietet als der Gastzugriff.
+ Tokens von sozialen Anbietern werden gegen AWS Anmeldeinformationen ausgetauscht, wobei die Benutzeridentität und die Benutzerberechtigungen gewahrt bleiben.
## Authentifizierung Amazon Cognito Cognito-Benutzerpools
In diesem Schritt wird die Amazon Cognito Cognito-Authentifizierung mit der vom Benutzerpool [verwalteten Anmeldeintegration](cognito-user-pools-managed-login.md) untersucht. Wenn Sie einen Benutzerpool als IdP mit einem Identitätspool verknüpfen, autorisieren Benutzerpool-Token Ihren Identitätspool, temporäre Anmeldeinformationen auszustellen.
------
#### [ User pool authentication with enhanced flow ]
Der erweiterte Ablauf bietet einen optimierten Ansatz zum Abrufen von AWS Anmeldeinformationen über Amazon Cognito Cognito-Identitätspools mit einer einzigen API-Anfrage.
**Verwenden Sie die Amazon Cognito Cognito-Benutzerpool-Authentifizierung mit dem Identity Pool Enhanced Flow**
1. Navigieren Sie in der Demo-Anwendung zum Bereich **Interaktive Demo**
1. Wählen Sie die Registerkarte **Authentifizierter Zugriff**.
1. Wählen Sie die Registerkarte **Erweiterter Ablauf**.
1. Wählen Sie **Mit Amazon Cognito Cognito-Benutzerpools anmelden**
1. Schließen Sie die Anmeldung mit Ihrem Benutzernamen und Passwort bei der verwalteten Anmeldung ab.
1. Der Benutzerpool leitet mit einem Autorisierungscode zurück zu Ihrer Anwendungsweiterleitungs-URI.
1. Die Anwendung tauscht den Autorisierungscode mit Ihrem Benutzerpool gegen JSON-Webtoken aus.
1. Die Anwendung tauscht das ID-Token mit Ihrem Identitätspool gegen temporäre AWS Anmeldeinformationen aus
1. Die App zeigt das **Ergebnisfenster** in der Weboberfläche an
Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ Die App meldet den Benutzer mit einem Amazon Cognito an. Nach erfolgreicher Authentifizierung mit dem Benutzerpool erhält Ihre App eine OAuth 2.0-Antwort, die das ID-Token (JWT) enthält. Identitätspools akzeptieren JWT-ID-Token von Benutzerpools, die dieses Anbieterschlüsselformat verwenden:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/getting-started-identity-pools-application.html)
Nach erfolgreicher Authentifizierung mit dem Benutzerpool erhält Ihre App eine OAuth 2.0-Antwort, die das ID-Token (JWT) enthält:
```
{
"id_token": "eyJraWQiOiJFWAMPLE......",
"token_type": "Bearer",
"expires_in": 3600
}
```
+ `GetId()`API-Anfrage mit Ihrer `identityPoolId` und einer `Logins` Map, die Ihren Benutzerpool-Anbieterschlüssel enthält, der dem zugeordnet ist. `id_token` Amazon Cognito hat überprüft, dass die Signatur, der Aussteller, das Ablaufdatum und die Zielgruppe (`aud`) des Benutzerpool-Id-Tokens mit einem der App-Clients übereinstimmen, die IDs Sie für diesen Benutzerpool-IdP im Identitätspool registriert haben.
```
POST GetId
{
"AccountId": "111122223333",
"IdentityPoolId": "us-east-1:1ac4a76d-1fef-48aa-83af-4224799c0b5c",
"Logins": {
"cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE123": "eyJraWQiOiJFWAMPLE......"
}
}
```
Falls gültig, findet es die des Benutzers oder erstellt sie und gibt sie zurück. `IdentityID` Eine Beispielantwort sieht wie folgt aus:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetCredentialsForIdentity()`mit dem zurückgegebenen `identityPoolId` und a=derselben `Logins` Map mit dem. `id_token` Amazon Cognito überprüft erneut, ob die Signatur, der Aussteller, das Ablaufdatum und die Zielgruppe (`aud`) des Benutzerpool-Id-Tokens mit einem der App-Clients übereinstimmen, die IDs Sie für diesen Benutzerpool-IdP im Identitätspool registriert haben.
```
POST GetCredentialsForIdentity
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Logins": {
"cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE123": "eyJraWQiOiJFWAMPLE......"
}
}
```
Falls gültig, wählt es eine IAM-Rolle (roles-in-token, Regeln oder Standard), ruft in Ihrem Namen AWS STS an und gibt temporäre Anmeldeinformationen zurück. AWS Eine Beispielantwort sieht wie folgt aus:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "ASIAW7TIP7EJEXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T14:36:17-07:00"
}
}
```
------
#### [ User pool authentication with basic flow ]
Der grundlegende Ablauf bietet eine detaillierte Kontrolle über den Authentifizierungsprozess mit separaten API-Anfragen für den Identitätsabruf und die Generierung von Anmeldeinformationen.
**Verwenden Sie die Amazon Cognito Cognito-Benutzerpool-Authentifizierung mit dem Identitätspool-Basisablauf**
1. Navigieren Sie in der Demo-Anwendung zum Bereich **Interaktive Demo**
1. Wählen Sie die Registerkarte **Authentifizierter Zugriff**.
1. Wählen Sie die Registerkarte **Basic Flow**.
1. Wählen Sie **Mit Amazon Cognito Cognito-Benutzerpools anmelden**
1. Schließen Sie die Anmeldung mit Ihrem Benutzernamen und Passwort bei der verwalteten Anmeldung ab.
1. Der Benutzerpool leitet mit einem Autorisierungscode zurück zu Ihrer Anwendungsweiterleitungs-URI.
1. Die Anwendung tauscht den Autorisierungscode mit Ihrem Benutzerpool gegen JSON-Webtoken aus.
1. Die Anwendung tauscht das ID-Token mit Ihrem Identitätspool gegen temporäre AWS Anmeldeinformationen aus
1. Die App zeigt das **Ergebnisfenster** in der Weboberfläche an
Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ Die App meldet den Benutzer mit einem Amazon Cognito Cognito-Benutzerpool an und erhält das ID-Token (JWT) als Artefakt. Nach erfolgreicher Authentifizierung mit dem Benutzerpool erhält Ihre App eine OAuth Antwort, die das ID-Token (JWT) enthält. Identitätspools verwenden dieses Token zur Authentifizierung:
```
{
"id_token": "eyJraWQiOiJFWAMPLE......",
"token_type": "Bearer",
"expires_in": 3600
}
```
+ `GetId()`API-Anfrage mit Ihrer Identitätspool-ID und einer `Logins` Map, die Ihren Benutzerpool-Anbieterschlüssel und das ID-Token als Wert enthält. Amazon Cognito hat überprüft, dass Signatur, Ablauf und Zielgruppe (aud) des Benutzerpool-ID-Tokens mit einem der App-Clients übereinstimmen, die IDs Sie für diesen Benutzerpool-IdP im Identitätspool registriert haben.
```
POST GetId
{
"AccountId": "111122223333",
"IdentityPoolId": "us-east-1:1ac4a76d-1fef-48aa-83af-4224799c0b5c",
"Logins": {
"cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE123": "eyJraWQiOiJFWAMPLE......"
}
}
```
Falls gültig, findet es die des Benutzers oder erstellt sie und gibt sie zurück. `IdentityID` Eine Beispielantwort sieht wie folgt aus:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetOpenIdToken()`mit der zurückgegebenen `IdentityID` und derselben `Logins` Map
```
POST GetOpenIdToken
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Logins": {
"cognito-idp.us-east-1.amazonaws.com/us-east-1_EXAMPLE123": "eyJraWQiOiJFWAMPLE......"
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Token": "eyJraWQiOiJFWAMPLE......"
}
```
**Was passiert in diesem Schritt:** Amazon Cognito gibt ein kurzlebiges OpenID Connect-Web-Identitätstoken von cognito-identity.amazonaws.com aus, das dies repräsentiert. `IdentityId` Das Token enthält OIDC-Ansprüche, die AWS STS bewertet werden, darunter aud (Ihre Identitätspool-ID) und amr (authentifiziert oder nicht authentifiziert). Die Vertrauensrichtlinie Ihrer IAM-Rolle muss diese Ansprüche vorschreiben.
+ `AssumeRoleWithWebIdentity()`- Ihre App ruft AWS STS direkt auf, um das Amazon Cognito OpenID-Token gegen temporäre Anmeldeinformationen auszutauschen AWS
```
POST sts:AssumeRoleWithWebIdentity
{
"RoleArn": "arn:aws:iam::111122223333:role/Cognito_IdentityPoolAuth_Role",
"WebIdentityToken": "eyJraWQiOiJFWAMPLE......",
"RoleSessionName": "CognitoIdentityCredentials"
}
```
Antwort:
```
{
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "FwoGZXIvYXdzEEXAMPLE......",
"Expiration": "2025-08-12T14:36:17-07:00"
},
"AssumedRoleUser": {
"AssumedRoleId": "AROAW7TIP7EJYEXAMPLE:CognitoIdentityCredentials",
"Arn": "arn:aws:sts::111122223333:assumed-role/Cognito_IdentityPoolAuth_Role/CognitoIdentityCredentials"
}
}
```
**Was Ihre Demo-Anwendung getan hat:** Ihre App hat das OpenID-Token von `GetOpenIdToken()` an gesendet AWS STS und temporäre Anmeldeinformationen angefordert. AWS STS hat Validierungsprüfungen durchgeführt und Anmeldeinformationen ausgestellt:
------
### Verstehen Sie den Zugriff auf den Benutzerpool
+ Benutzerpool-Benutzer erhalten temporäre AWS Anmeldeinformationen über Amazon Cognito Cognito-Identitätspools.
+ Diese Anmeldeinformationen sind mit einer IAM-Rolle verknüpft, die in Ihrer Identitätspool-Konfiguration angegeben ist.
+ ID-Token für Benutzerpools werden über den Identitätspool gegen AWS Anmeldeinformationen ausgetauscht.
## SAML-Authentifizierung
In diesem Schritt wird die SAML-Authentifizierung untersucht. Benutzer können sich bei Identitätsanbietern für Unternehmen anmelden, die SAML unterstützen, um auf Dienste zuzugreifen AWS . Der grundlegende Ablauf mit SAML wird in der Beispielanwendung nicht unterstützt.
------
#### [ SAML authentication with enhanced flow ]
In diesem Abschnitt wird gezeigt, wie Sie einen SAML-Identitätsanbieter verwenden können, um einen Benutzer anzumelden und mithilfe des erweiterten Ablaufs die SAML-Assertion in einem Amazon Cognito Cognito-Identitätspool gegen temporäre AWS Anmeldeinformationen zum Aufrufen von Diensten auszutauschen. AWS
**Verwenden Sie die SAML-Authentifizierung mit dem erweiterten Ablauf für den Identitätspool**
1. Navigieren Sie in der Demo-Anwendung zum Bereich **Interaktive Demo**
1. Wählen Sie die Registerkarte **Authentifizierter Zugriff**.
1. Wählen Sie die Registerkarte **Erweiterter Ablauf**.
1. Wählen Sie **Mit SAML-Anbieter anmelden**
1. Schließen Sie die Anmeldung mit Ihren Unternehmensanmeldedaten ab.
1. Der Benutzerpool leitet mit einer SAML-Assertion zurück zu Ihrer Anwendungsumleitungs-URI.
1. Die Anwendung tauscht den Autorisierungscode mit Ihrem Benutzerpool gegen JSON-Webtoken aus.
1. Die Anwendung tauscht die SAML-Antwort mit Ihrem Identitätspool gegen temporäre AWS Anmeldeinformationen aus
1. Die App zeigt das **Ergebnisfenster** in der Weboberfläche an
Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ Die App meldet den Benutzer mit einem SAML-IdP an und erhält die SAML-Antwort. Identitätspools akzeptieren SAML-Assertionen von Unternehmensanbietern, die den SAML-Provider-ARN als Schlüssel verwenden:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/getting-started-identity-pools-application.html)
Nach erfolgreicher Authentifizierung beim SAML-Anbieter erhält Ihre App eine SAML-Antwort per HTTP POST an Ihre Callback-URL:
```
{
"saml_response": "PD94bWwgdmVyc2lvbj0iMS4wIiBFWAMPLE...",
"provider_arn": "arn:aws:iam::111122223333:saml-provider/EXAMPLE",
"status": "Authentication successful"
}
```
+ `GetId()`API-Anfrage mit Ihrer Identitätspool-ID und einer `Logins` Map, die Ihren SAML-Provider-ARN und Ihre Assertion enthält
```
POST GetId
{
"AccountId": "111122223333",
"IdentityPoolId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"Logins": {
"arn:aws:iam::111122223333:saml-provider/EXAMPLE": "PD94bWwgdmVyc2lvbj0iMS4wIiBFWAMPLE..."
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetCredentialsForIdentity()`mit der zurückgegebenen `IdentityID` und derselben Map `Logins`
```
POST GetCredentialsForIdentity
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Logins": {
"arn:aws:iam::111122223333:saml-provider/EXAMPLE": "PD94bWwgdmVyc2lvbj0iMS4wIiBFWAMPLE..."
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......"
}
}
```
**Was ist passiert**: Amazon Cognito validierte die SAML-Assertion anhand des konfigurierten Anbieters, entschied sich für eine IAM-Rolle auf der Grundlage von SAML-Attributen oder -Regeln und rief in Ihrem Namen an. AWS STS
------
### Verstehen Sie den SAML-Zugriff
+ Unternehmensbenutzer erhalten temporäre AWS Anmeldeinformationen von Amazon Cognito Cognito-Identitätspools, nachdem sie sich bei ihrem SAML-Anbieter authentifiziert haben.
+ Jeder authentifizierte Benutzer erhält eine eindeutige Identitäts-ID, die für alle Sitzungen gültig ist.
+ Diese Anmeldeinformationen sind mit einer IAM-Rolle verknüpft, die speziell für den authentifizierten Zugriff entwickelt wurde und umfassendere Berechtigungen bietet als der Gastzugriff.
+ SAML-Assertionen werden gegen AWS Anmeldeinformationen ausgetauscht, wobei die Benutzeridentität und die Unternehmensattribute beibehalten werden.
## OpenID Connect (OIDC) -Authentifizierung
In diesem Schritt wird die OIDC-Authentifizierung mit Identitätsanbietern für Unternehmen untersucht. Benutzer können sich über den Enterprise Identity Provider ihrer Organisation (wie Azure AD, Okta oder Google Workspace) anmelden, um auf Dienste zuzugreifen. AWS Lesen Sie weiter, wenn Sie nach Informationen zur Integration der standardbasierten Authentifizierung in Ihre Ressourcen suchen. AWS Nachdem Sie die OIDC-Authentifizierung implementiert haben, erfahren Sie, wie Sie OIDC-Angaben für eine differenzierte Zugriffskontrolle nutzen können.
------
#### [ OIDC authentication with enhanced flow ]
In diesem Abschnitt wird gezeigt, wie Sie einen OIDC-Identitätsanbieter verwenden können, um einen Benutzer anzumelden und mithilfe des erweiterten Ablaufs das OIDC-Token in einem Amazon Cognito Cognito-Identitätspool gegen temporäre AWS Anmeldeinformationen zum Anrufen von Diensten auszutauschen. AWS
**Verwenden Sie die OIDC-Anmeldung mit dem erweiterten Ablauf für den Identitätspool**
1. **Navigieren Sie in der Demo-Anwendung zum Bereich Interaktive Demo**
1. Wählen Sie die Registerkarte **Authentifizierter Zugriff**.
1. Wählen Sie die Registerkarte **Erweiterter Ablauf**.
1. Wählen Sie **Mit OIDC-Anbieter anmelden**
1. Schließen Sie die Anmeldung mit Ihren Unternehmensanmeldedaten ab.
1. Der OIDC-Anbieter leitet mit einem Autorisierungscode zurück zur App
1. Die Anwendung tauscht den Autorisierungscode mit Ihrem Benutzerpool gegen JSON-Webtoken aus.
1. Die Anwendung sendet das OIDC-Token an Ihren Identitätspool und ruft temporäre Anmeldeinformationen ab. AWS
1. Die App zeigt das **Ergebnisfenster in der Weboberfläche** an
Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ Die App meldet den Benutzer mit einem OIDC-IdP an und erhält das ID-Token. Identitätspools akzeptieren OIDC-Token von Unternehmensanbietern:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/getting-started-identity-pools-application.html)
Nach erfolgreicher Authentifizierung beim OIDC-Anbieter erhält Ihre App eine OAuth 2.0-Antwort mit den folgenden Tokens:
```
{
"token_type": "Bearer",
"expires_in": 3600,
"access_token": "eyJraWQiOiJFWAMPLE......",
"scope": "email openid profile",
"id_token": "eyJraWQiOiJFWAMPLE......"
}
```
+ `GetId()`API-Anfrage mit Ihrer Identitätspool-ID und einer `Logins` Map, die Ihr OIDC-Provider-Token enthält
```
POST GetId
{
"AccountId": "111122223333",
"IdentityPoolId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"Logins": {
"example-provider.com/oauth2/default": "eyJraWQiOiJFWAMPLE......"
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetCredentialsForIdentity()`mit der zurückgegebenen `IdentityID` und derselben Logins-Map
```
POST GetCredentialsForIdentity
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Logins": {
"example-provider.com/oauth2/default": "eyJraWQiOiJFWAMPLE......"
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......"
}
}
```
**Was ist passiert**: Amazon Cognito hat das OIDC-Token anhand des konfigurierten Anbieters validiert, eine IAM-Rolle (Standard, anspruchsbasiert oder regelzugeordnet) ausgewählt und in Ihrem Namen angerufen. AWS STS
------
#### [ OIDC authentication with basic flow ]
In diesem Abschnitt wird gezeigt, wie Sie einen OIDC-Identitätsanbieter verwenden können, um einen Benutzer anzumelden und mithilfe des Basisablaufs das OIDC-Token in einem Amazon Cognito Cognito-Identitätspool gegen temporäre AWS Anmeldeinformationen zum Anrufen von Diensten auszutauschen. AWS
**Verwenden Sie die OIDC-Anmeldung mit dem Basisablauf für den Identitätspool**
1. **Navigieren Sie in der Demo-Anwendung zum Bereich Interaktive Demo**
1. Wählen Sie die Registerkarte **Authentifizierter Zugriff**.
1. Wählen Sie die Registerkarte **Basic Flow**.
1. Wählen Sie **Mit OIDC-Anbieter anmelden**
1. Schließen Sie die Anmeldung mit Ihren Unternehmensanmeldedaten ab.
1. Der OIDC-Anbieter leitet mit einem Autorisierungscode zurück zur App
1. Die Anwendung tauscht den Autorisierungscode mit Ihrem Benutzerpool gegen JSON-Webtoken aus.
1. Die Anwendung sendet das OIDC-Token an Ihren Identitätspool und ruft temporäre Anmeldeinformationen ab. AWS
1. Die App zeigt das **Ergebnisfenster in der Weboberfläche** an
Nach erfolgreicher Authentifizierung wird auf der Weboberfläche das **Ergebnisfenster** angezeigt, und Sie haben zwei Möglichkeiten, diese zu erkunden:
1. Schaltfläche „**Nur Anmeldeinformationen anzeigen**“: Wählen Sie diese Schaltfläche, wenn Sie direkt temporäre AWS Anmeldeinformationen sehen möchten, die ohne die Details zum API-Flow generiert wurden.
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "IQoJb3JpZ2luX2VjEEXAMPLE......",
"Expiration": "2025-08-12T13:36:17-07:00"
}
}
```
1. Schaltfläche „**Detaillierten API-Flow** anzeigen“: Wählen Sie diese Schaltfläche, wenn Sie die step-by-step API-Anfragen sehen möchten.
+ Die App meldet den Benutzer mit einem OIDC-IdP an und erhält das ID-Token. Identitätspools akzeptieren OIDC-Token von Unternehmensanbietern:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cognito/latest/developerguide/getting-started-identity-pools-application.html)
Nach erfolgreicher Authentifizierung beim OIDC-Anbieter erhält Ihre App eine OAuth 2.0-Antwort mit den folgenden Tokens:
```
{
"token_type": "Bearer",
"expires_in": 3600,
"access_token": "eyJraWQiOiJFWAMPLE......",
"scope": "openid email profile",
"id_token": "eyJraWQiOiJFWAMPLE......"
}
```
+ `GetId()`API-Anfrage mit Ihrer Identitätspool-ID und einer `Logins` Map, die Ihr OIDC-Provider-Token enthält
```
POST GetId
{
"IdentityPoolId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"Logins": {
"example-provider.com/oauth2/default": "eyJraWQiOiJFWAMPLE......"
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
```
+ `GetOpenIdToken()`mit der zurückgegebenen IdentityID und derselben Map `Logins`
```
POST GetOpenIdToken
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Logins": {
"example-provider.com/oauth2/default": "eyJraWQiOiJFWAMPLE......"
}
}
```
Antwort:
```
{
"IdentityId": "us-east-1:a1b2c3d4-5678-90ab-cdef-EXAMPLE22222",
"Token": "eyJraWQiOiJFWAMPLE......"
}
```
+ `AssumeRoleWithWebIdentity()`mit dem OpenID-Token
```
POST AssumeRoleWithWebIdentity
{
"RoleArn": "arn:aws:iam::111122223333:role/Cognito_IdentityPoolAuth_Role",
"WebIdentityToken": "eyJraWQiOiJFWAMPLE......"
}
```
Antwort:
```
{
"Credentials": {
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"SessionToken": "FwoGZXIvYXdzEEXAMPLE......",
"Expiration": "2025-08-12T14:36:17-07:00"
}
}
```
**Was ist passiert**: Amazon Cognito validierte das OIDC-Token anhand des konfigurierten Anbieters und gab ein OpenID-Token zurück. Die Anwendung rief AWS STS direkt an, um die entsprechende IAM-Rolle zu übernehmen, und erhielt kurzlebige Anmeldeinformationen.
------
### Verstehen Sie die OIDC-Authentifizierung
+ Standardbasiert: OIDC basiert auf OAuth 2.0 und bietet standardisierte Identitätsinformationen.
+ Token-Validierung: ID-Token können auf ihre Echtheit überprüft werden.
+ Forderungsbasierter Zugriff: OIDC-Ansprüche können für die Rollenzuweisung und Zugriffskontrolle verwendet werden.
+ Unternehmensintegration: Funktioniert mit gängigen Identitätsanbietern für Unternehmen.
## Nächste Schritte
Nachdem Sie die Demo-Anwendung eingerichtet und erkundet haben, können Sie:
+ Konfigurieren Sie zusätzliche Identitätsanbieter, die Sie noch nicht getestet haben
+ Experimentieren Sie mit der erweiterten und der Standardauthentifizierung, um ihre Unterschiede zu verstehen
+ Passen Sie die Demo an Ihren eigenen Anwendungsfall an
+ Integrieren Sie Amazon Cognito Identity Pools in Ihre eigenen Anwendungen.