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. # Der Umleitungs- und Autorisierungsendpunkt Der `/oauth2/authorize`-Endpunkt ist ein Umleitungsendpunkt, der zwei Umleitungsziele unterstützt. Wenn Sie einen `identity_provider`- oder `idp_identifier`-Parameter in der URL angeben, werden Ihre Benutzer im Hintergrund auf die Anmeldeseite für diesen Identitätsanbieter (IDP) umgeleitet. Andernfalls erfolgt die Umleitung an [Login-Endpunkt](login-endpoint.md) mit denselben URL-Parametern, die Sie in Ihre Anfrage aufgenommen haben. Der Autorisierungsendpunkt leitet entweder zur verwalteten Anmeldung oder zu einer IdP-Anmeldeseite weiter. Das Ziel einer Benutzersitzung an diesem Endpunkt ist eine Webseite, mit der Ihr Benutzer direkt in seinem Browser interagieren muss. Wenn Sie den Autorisierungsendpunkt verwenden möchten, rufen Sie den Browser Ihres Benutzers unter `/oauth2/authorize` mit Parametern auf, die Ihrem Benutzerpool Informationen zu den folgenden Benutzerpool-Details liefern. + Der App-Client, bei dem Sie sich anmelden möchten. + Die Rückruf-URL, zu der Sie gelangen möchten. + Die OAuth 2.0-Bereiche, die Sie im Zugriffstoken Ihres Benutzers anfordern möchten. + Optionaler Drittanbieter-IDP, den Sie für die Anmeldung verwenden möchten. Sie können auch `state`- und `nonce`-Parameter angeben, die Amazon Cognito verwendet, um eingehende Ansprüche zu validieren. ## GET `/oauth2/authorize` Der `/oauth2/authorize` Endpunkt unterstützt ausschließlich `HTTPS GET`. Ihre App initiiert diese Anfrage normalerweise im Browser Ihres Benutzers. Sie können nur über HTTPS Anfragen an den `/oauth2/authorize`-Endpunkt stellen. Weitere Informationen über die Definition des Autorisierungsendpunkts im OpenID Connect (OIDC)-Standard finden Sie unter [Authorisierungsendpunkt](http://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthorizationEndpoint). ### Anforderungsparameter **`response_type`** Erforderlich Die Art der Antwort. Es muss sich entweder um `code` oder `token` handeln. Eine erfolgreiche Anfrage mit einem `response_type` von `code` gibt eine Autorisierungscode-Erteilung zurück. Eine Autorisierungscode-Erteilung ist ein `code`-Parameter, den Amazon Cognito an Ihre Umleitungs-URL anhängt. Ihre App kann den Code durch Zugriffs-, ID- und Aktualisierungstoken austauschen. Verwenden Sie als bewährte Sicherheitsmethode und zum Abrufen von Aktualisierungstoken für Ihre Benutzer eine Autorisierungscode-Erteilung in Ihrer App. Eine erfolgreiche Anfrage mit dem `response_type` `token` gibt eine implizite Erteilung zurück. Eine implizite Erteilung besteht aus einer ID und einem Zugriffstoken, die Amazon Cognito an Ihre Umleitungs-URL anhängt. Eine implizite Erteilung ist weniger sicher, da sie Token und potenzielle identifizierende Informationen für Benutzer verfügbar macht. Sie können die Unterstützung für implizite Erteilungen in der Konfiguration Ihres App-Clients deaktivieren. **`client_id`** Erforderlich Die App-Client-ID). Der Wert `client_id` muss die ID eines App-Clients in dem Benutzerpool sein, in dem Sie die Anfrage stellen. Ihr App-Client muss die Anmeldung durch lokale Benutzer von Amazon Cognito oder mindestens eines externen IdPs unterstützen. **`redirect_uri`** Erforderlich Die URL, an die der Authentifizierungsserver den Browser nach der Autorisierung des Benutzers durch Amazon Cognito weiterleitet. Ein Umleitungs-URI (Uniform Resource Identifier) muss die folgenden Attribute aufweisen: + Es muss ein absoluter URI sein. + Sie müssen die URI im Vorfeld mit einem Client registriert haben. + Sie darf keine Fragmentkomponente enthalten. Siehe [OAuth 2.0 — Endpunkt der Umleitung](https://tools.ietf.org/html/rfc6749#section-3.1.2). Amazon Cognito erfordert, dass Ihr Umleitungs-URI HTTPS verwendet, mit Ausnahme von `http://localhost`, was Sie als Rückruf-URL für Testzwecke festlegen können. Amazon Cognito unterstützt auch App-Callback URLs wie. `myapp://example` **`state`** Optional, empfohlen. Wenn Ihre App einer Anfrage einen Parameter *state* hinzufügt, gibt Amazon Cognito seinen Wert an Ihre App zurück, wenn der Endpunkt `/oauth2/authorize` Ihren Benutzer umleitet. Fügen Sie diesen Wert Ihren Anfragen hinzu, um sich vor [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery)-Angriffen zu schützen. Sie können den Wert eines Parameters `state` nicht auf eine URL-codierte JSON-Zeichenfolge festlegen. Um eine Zeichenfolge, die diesem Format entspricht, in einem `state` Parameter zu übergeben, kodieren Sie die Zeichenfolge in Base64 und dekodieren Sie sie dann in Ihrer App. **`identity_provider`** Optional. Fügen Sie diesen Parameter hinzu, um die verwaltete Anmeldung zu umgehen und Ihren Benutzer auf die Anmeldeseite eines Anbieters umzuleiten. Der Wert des *identity\$1provider*-Parameters ist der Name des Identitätsanbieters (IDP), wie er in Ihrem Benutzerpool angezeigt wird. + Für soziale Anbieter können Sie die *identity\$1provider-Werte*`Facebook`,, und `Google` verwenden. `LoginWithAmazon` `SignInWithApple` + Verwenden Sie für Amazon Cognito Cognito-Benutzerpools den Wert`COGNITO`. + Verwenden Sie für SAML 2.0- und OpenID Connect (OIDC-) Identitätsanbieter (IdPs) den Namen, den Sie dem IdP in Ihrem Benutzerpool zugewiesen haben. **`idp_identifier`** Optional. Fügen Sie diesen Parameter für die Umleitung an einen Anbieter mit einem alternativen Namen für *identity\$1provider* hinzu. Sie können Identifikatoren für Ihre SAML 2.0 und OIDC IdPs im Menü **Soziale Netzwerke und externe Anbieter der Amazon Cognito** Cognito-Konsole eingeben. **`scope`** Optional. Dabei kann es sich um eine Kombination aus für das System reservierten Bereichen oder benutzerdefinierten Bereichen, die einem Client zugeordnet sind, handeln. Bereiche müssen durch Leerzeichen getrennt werden. Für das System reservierte Bereiche sind `openid``email`, `phone`, `profile` und `aws.cognito.signin.user.admin`. Jeder Bereich muss dem Client zugeordnet werden, sonst wird der Client zur Laufzeit ignoriert. Falls der Client keine Bereiche anfordert, verwendet der Authentifizierungsserver alle Bereiche im Zusammenhang mit dem Client. Ein ID-Token wird nur zurückgegeben, wenn der `openid`-Bereich angefordert wird. Das Zugriffs-Token kann nur gegen Amazon-Cognito-Benutzerpools verwendet werden, wenn der Bereich `aws.cognito.signin.user.admin` angefordert wird. Die Bereiche `phone`, `email` und `profile` können nur angefordert werden, wenn der Bereich `openid` ebenfalls angefordert wird. Diese Bereiche bestimmen die Anträge, die im ID-Token eingesetzt werden. **`code_challenge_method`** Optional. Das Hashing-Protokoll, das Sie zur Generierung der Herausforderung verwendet haben. Die [PKCE RFC](https://tools.ietf.org/html/rfc7636) definiert zwei Methoden, die S256-Methode und eine einfache. Der Amazon-Cognito-Authentifikationsserver unterstützt jedoch nur die S256-Methode. **`code_challenge`** Optional. Die PKCE-Abfrage (Proof of Key Code Exchange), die Sie anhand der generiert haben. `code_verifier` Weitere Informationen finden Sie unter [Verwendung von PKCE in Autorisierungscode-Zuschüssen](using-pkce-in-authorization-code.md). Nur erforderlich, wenn Sie einen `code_challenge_method`-Parameter angeben. **`nonce`** Optional. Ein Zufallswert, den Sie der Anforderung hinzufügen können. Der von Ihnen bereitgestellte Nonce-Wert ist im ID-Token enthalten, das Amazon Cognito ausgibt. Zum Schutz vor Replay-Angriffen kann Ihre App den `nonce`-Anspruch im ID-Token untersuchen und mit dem vergleichen, den Sie generiert haben. Weitere Informationen zum `nonce`-Anspruch finden Sie unter [ID-Token-Validierung](https://openid.net/specs/openid-connect-core-1_0.html#IDTokenValidation) im *OpenID Connect-Standard*. **`lang`** Optional. Die Sprache, in der Sie benutzerinteraktive Seiten anzeigen möchten. Verwaltete Anmeldeseiten können lokalisiert werden, gehostete UI-Seiten (klassische Seiten) jedoch nicht. Weitere Informationen finden Sie unter [Lokalisierung bei verwalteter Anmeldung](cognito-user-pools-managed-login.md#managed-login-localization). **`login_hint`** Optional. Eine Aufforderung zur Eingabe eines Benutzernamens, die Sie an den Autorisierungsserver weiterleiten möchten. Sie können einen Benutzernamen, eine E-Mail-Adresse oder eine Telefonnummer von Ihrem Benutzer erfassen und dem Zielanbieter erlauben, den Anmeldenamen des Benutzers vorab auszufüllen. Wenn Sie einen `login_hint` Parameter und keine `idp_identifier` oder `identity_provider` Parameter an den `oauth2/authorize` Endpunkt senden, füllt Managed Login das Feld für den Benutzernamen mit Ihrem Hinweiswert aus. Sie können diesen Parameter auch an den übergeben [Login-Endpunkt](login-endpoint.md) und den Wert für den Benutzernamen automatisch ausfüllen. Wenn Ihre Autorisierungsanfrage eine Weiterleitung zu OIDC aufruft IdPs, fügt Amazon Cognito der Anfrage an diesen Drittanbieter-Autorisierer einen `login_hint` Parameter hinzu. Sie können Anmeldehinweise nicht an SAML, Apple, Login With Amazon, Google oder Facebook (Meta) IdPs weiterleiten. **`prompt`** Optional. Ein OIDC-Parameter, der das Authentifizierungsverhalten für bestehende Sitzungen steuert. Nur in der Branding-Version für verwaltete Anmeldung verfügbar, nicht in der klassischen gehosteten Benutzeroberfläche. Weitere Informationen aus der OIDC-Spezifikation finden Sie unter [Authentifizierungsanfrage](https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest). Die Werte `none` und `login` wirken sich auf das Authentifizierungsverhalten des Benutzerpools aus. Amazon Cognito leitet alle Werte von weiter`none`, `prompt` außer an Ihre, IdPs wenn Benutzer die Authentifizierung bei Drittanbietern auswählen. Dies ist der Fall, wenn die URL, auf die Benutzer zugreifen, einen `identity_provider` `idp_identifier` OR-Parameter enthält oder wenn der Autorisierungsserver sie an den weiterleitet [Login-Endpunkt](login-endpoint.md) und sie einen IdP aus den verfügbaren Schaltflächen auswählen. **Parameterwerte abfragen** `prompt=none` Amazon Cognito setzt die Authentifizierung für Benutzer, die über eine gültige authentifizierte Sitzung verfügen, im Hintergrund fort. Mit dieser Aufforderung können sich Benutzer unbeaufsichtigt zwischen verschiedenen App-Clients in Ihrem Benutzerpool authentifizieren. Wenn der Benutzer noch nicht authentifiziert ist, gibt der Autorisierungsserver einen Fehler zurück. `login_required` `prompt=login` Amazon Cognito verlangt von Benutzern, sich erneut zu authentifizieren, auch wenn sie eine bestehende Sitzung haben. Senden Sie diesen Wert, wenn Sie die Identität des Benutzers erneut überprüfen möchten. Authentifizierte Benutzer, die über eine bestehende Sitzung verfügen, können zur Anmeldung zurückkehren, ohne dass diese Sitzung ungültig wird. Wenn sich ein Benutzer, der eine bestehende Sitzung hat, erneut anmeldet, weist Amazon Cognito ihm ein neues Sitzungscookie zu. Dieser Parameter kann auch an Ihren weitergeleitet werden. IdPs IdPsdie diesen Parameter akzeptieren, fordern auch einen neuen Authentifizierungsversuch vom Benutzer an. `prompt=select_account` Dieser Wert hat keine Auswirkung auf die lokale Anmeldung und muss in Anfragen eingereicht werden, die zu IdPs umleiten. Wenn dieser Parameter in Ihrer Autorisierungsanfrage enthalten ist, wird er `prompt=select_account` zum URL-Pfad für das IdP-Umleitungsziel hinzugefügt. Wenn dieser Parameter IdPs unterstützt wird, fordern sie die Benutzer auf, das Konto auszuwählen, mit dem sie sich anmelden möchten. `prompt=consent` Dieser Wert hat keine Auswirkung auf die lokale Anmeldung und muss in Anfragen eingereicht werden, die zu IdPs umleiten. Wenn dieser Parameter in Ihrer Autorisierungsanfrage enthalten ist, wird er `prompt=consent` zum URL-Pfad für das IdP-Umleitungsziel hinzugefügt. Wenn dieser Parameter IdPs unterstützt wird, fordern sie die Zustimmung des Benutzers an, bevor sie zurück zu Ihrem Benutzerpool weiterleiten. Wenn Sie den `prompt` Parameter in Ihrer Anfrage weglassen, folgt die verwaltete Anmeldung dem Standardverhalten: Benutzer müssen sich anmelden, es sei denn, ihr Browser hat ein gültiges Sitzungscookie für die verwaltete Anmeldung. Sie können beispielsweise mehrere Werte für `prompt` mit einem Leerzeichen als Trennzeichen kombinieren. `prompt=login consent` **`resource`** Optional. Der Bezeichner einer Ressource, die Sie an das Zugriffstoken im Anspruch binden möchten. `aud` Wenn Sie diesen Parameter angeben, überprüft Amazon Cognito, ob es sich bei dem Wert um eine URL handelt, und legt die Zielgruppe des resultierenden Zugriffstokens auf die angeforderte Ressource fest. Sie können einen [Benutzerpool-Ressourcenserver](cognito-user-pools-define-resource-servers.md) mit einer Kennung in einem URL-Format oder einer URL Ihrer Wahl anfordern. Die Werte für diesen Parameter müssen mit `https://``http://localhost`, oder einem benutzerdefinierten URL-Schema wie beginnen`myapp://`. Die Ressourcenbindung ist in [RFC 8707](https://www.rfc-editor.org/rfc/rfc8707.html) definiert. [Weitere Informationen zu Ressourcenservern und Ressourcenbindung finden Sie unter Ressourcenbindung.](cognito-user-pools-define-resource-servers.md#cognito-user-pools-resource-binding) ## Beispiel: Erteilung eines Autorisierungscodes Dies ist ein Beispiel für eine Anfrage zur Erteilung eines Autorisierungscodes. Die folgende Anfrage initiiert eine Sitzung zum Abrufen eines Autorisierungscodes, den Ihr Benutzer an Ihre App am `redirect_uri` Ziel weitergibt. In dieser Sitzung werden Bereiche für Benutzerattribute und für den Zugriff auf Amazon Cognito-Self-Service-API-Operationen angefordert. ``` GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize? response_type=code& client_id=1example23456789& redirect_uri=https://www.example.com& state=abcdefg& scope=openid+profile+aws.cognito.signin.user.admin ``` Der Amazon-Cognito-Authentifikationsserver leitet Autorisierungs-Code und -Status zurück an Ihre App. Der Autorisierungscode ist fünf Minuten gültig. ``` HTTP/1.1 302 Found Location: https://www.example.com?code=a1b2c3d4-5678-90ab-cdef-EXAMPLE11111&state=abcdefg ``` ## Beispiel: Erteilung eines Autorisierungscodes mit PKCE In diesem Beispielablauf wird eine Autorisierungscode-Erteilung mit [PKCE](using-pkce-in-authorization-code.md#using-pkce-in-authorization-code.title) durchgeführt. Diese Anfrage fügt einen `code_challenge` Parameter hinzu. Um den Austausch eines Codes gegen ein Token abzuschließen, müssen Sie den `code_verifier` Parameter in Ihre Anfrage an den `/oauth2/token` Endpunkt aufnehmen. ``` GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize? response_type=code& client_id=1example23456789& redirect_uri=https://www.example.com& state=abcdefg& scope=aws.cognito.signin.user.admin& code_challenge_method=S256& code_challenge=a1b2c3d4... ``` Der Autorisierungsserver leitet mit dem Autorisierungscode und dem Status zurück zu Ihrer Anwendung. Ihre Anwendung verarbeitet den Autorisierungscode und tauscht ihn gegen Token ein. ``` HTTP/1.1 302 Found Location: https://www.example.com?code=a1b2c3d4-5678-90ab-cdef-EXAMPLE11111&state=abcdefg ``` ## Beispiel: erfordert eine erneute Authentifizierung mit `prompt=login` Die folgende Anfrage fügt einen `prompt=login` Parameter hinzu, nach dem sich der Benutzer erneut authentifizieren muss, auch wenn er bereits eine Sitzung hat. ``` GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize? response_type=code& client_id=1example23456789& redirect_uri=https://www.example.com& state=abcdefg& scope=openid+profile+aws.cognito.signin.user.admin& prompt=login ``` Der Autorisierungsserver leitet zum [Anmeldeendpunkt](login-endpoint.md) weiter und erfordert eine erneute Authentifizierung. ``` HTTP/1.1 302 Found Location: https://mydomain.auth.us-east-1.amazoncognito.com/login?response_type=code&client_id=1example23456789&redirect_uri=https://www.example.com&state=abcdefg&scope=openid+profile+aws.cognito.signin.user.admin&prompt=login ``` ## Beispiel: unbeaufsichtigte Authentifizierung mit `prompt=none` Die folgende Anfrage fügt einen `prompt=none` Parameter hinzu, der im Hintergrund überprüft, ob der Benutzer eine gültige Sitzung hat. ``` GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize? response_type=code& client_id=1example23456789& redirect_uri=https://www.example.com& state=abcdefg& scope=openid+profile+aws.cognito.signin.user.admin& prompt=none ``` Wenn keine gültige Sitzung vorhanden ist, gibt der Autorisierungsserver einen Fehler an die Umleitungs-URI zurück ``` HTTP/1.1 302 Found Location: https://www.example.com?error=login_required&state=abcdefg ``` Wenn eine gültige Sitzung besteht, gibt der Autorisierungsserver einen Autorisierungscode zurück. ``` HTTP/1.1 302 Found Location: https://www.example.com?code=AUTHORIZATION_CODE&state=abcdefg ``` ## Beispiel: Erteilung eines Autorisierungscodes mit Ressourcenbindung Die folgende Anfrage fügt einen `resource` Parameter hinzu, um das Zugriffstoken an einen bestimmten Ressourcenserver zu binden. Das resultierende Zugriffstoken schafft die Voraussetzungen dafür, dass die Ziel-API überprüft, ob es sich um die Zielgruppe der Anfrage des authentifizierten Benutzers handelt. ``` GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize? response_type=code& client_id=1example23456789& redirect_uri=https://www.example.com& state=abcdefg& scope=solar-system-data-api.example.com/asteroids.add& resource=https://solar-system-data-api.example.com ``` Der Autorisierungsserver gibt einen Autorisierungscode zurück, der zu einem Zugriffstoken mit dem `aud` Anspruch von `https://solar-system-data-api.example.com` führt. ``` HTTP/1.1 302 Found Location: https://www.example.com?code=AUTHORIZATION_CODE&state=abcdefg ``` ## Beispiel: Token-Erteilung (implizit) ohne Geltungsbereich `openid` Dieser Beispielablauf generiert eine implizite Gewährung und kehrt JWTs direkt zur Sitzung des Benutzers zurück. Die Anfrage bezieht sich auf eine implizite Erteilung von Ihrem Autorisierungsserver. Sie fordert Bereiche im Zugriffstoken an, die Self-Service-Vorgänge für Benutzerprofile autorisieren. ``` GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize? response_type=token& client_id=1example23456789& redirect_uri=https://www.example.com& state=abcdefg& scope=aws.cognito.signin.user.admin ``` Der Autorisierungsserver leitet nur mit einem Zugriffstoken zurück zu Ihrer Anwendung. Da der `openid`-Bereich nicht angefordert wurde, gibt Amazon Cognito kein ID-Token aus. Außerdem gibt Amazon Cognito in diesem Flow kein Aktualisierungs-Token aus. ``` HTTP/1.1 302 Found Location: https://example.com/callback#access_token=eyJra456defEXAMPLE&token_type=bearer&expires_in=3600&state=STATE ``` ## Beispiel: Token-Erteilung (implizit) mit Gültigkeitsbereich `openid` Dieser Beispielablauf generiert eine implizite Gewährung und gibt Token an den Browser des Benutzers zurück. Die Anfrage bezieht sich auf eine implizite Erteilung durch Ihren Autorisierungsserver. Sie fordert Bereiche im Zugriffstoken an, die den Zugriff auf Benutzerattribute und Self-Service-Operationen autorisieren. ``` GET https://mydomain.auth.us-east-1.amazoncognito.com/oauth2/authorize? response_type=token& client_id=1example23456789& redirect_uri=https://www.example.com& state=abcdefg& scope=aws.cognito.signin.user.admin+openid+profile ``` Der Autorisierungsserver leitet mit dem Zugriffstoken und dem ID-Token zurück zu Ihrer Anwendung (da der `openid` Bereich enthalten war): ``` HTTP/1.1 302 Found Location: https://www.example.com#id_token=eyJra67890EXAMPLE&access_token=eyJra12345EXAMPLE&token_type=bearer&expires_in=3600&state=abcdefg ``` ## Beispiele für negative Antworten Amazon Cognito lehnt Ihre Anfrage möglicherweise ab. Negative Anfragen enthalten einen HTTP-Fehlercode und eine Beschreibung, anhand derer Sie Ihre Anforderungsparameter korrigieren können. Im Folgenden finden Sie Beispiele für negative Antworten. + Wenn `client_id` und gültig `redirect_uri` sind, die Anforderungsparameter jedoch nicht korrekt formatiert sind, leitet der Authentifizierungsserver den Fehler an den des Clients weiter `redirect_uri` und fügt eine Fehlermeldung an einen URL-Parameter an. Im Folgenden finden Sie Beispiele für eine falsche Formatierung. + Die Anfrage enthält keinen `response_type` Parameter. + Die Autorisierungsanfrage lieferte einen `code_challenge` Parameter, aber keinen `code_challenge_method` Parameter. + Der Wert des `code_challenge_method` Parameters ist nicht`S256`. Im Folgenden finden Sie die Antwort auf eine Beispielanfrage mit falscher Formatierung. ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request ``` + Wenn der Client eine Anfrage `code` oder `token` eingibt`response_type`, aber keine Genehmigung für diese Anfragen hat, kehrt der Amazon Cognito Cognito-Autorisierungsserver wie folgt `unauthorized_client` zum Client-Autorisierungsserver zurück: `redirect_uri` ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=unauthorized_client ``` + Falls die Anforderung des Clients unbekannt, falsch formatiert oder ungültig ist, sollte der Amazon-Cognito-Autorisierungsserver `invalid_scope` folgendermaßen zur `redirect_uri` des Clients zurückgeben: ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_scope ``` + Wenn auf dem Server ein unerwarteter Fehler auftritt, kehrt der Authentifizierungsserver `server_error` zum Server des `redirect_uri` Clients zurück. Da der HTTP 500-Fehler nicht an den Client gesendet wird, wird der Fehler nicht im Browser des Benutzers angezeigt. Der Autorisierungsserver gibt den folgenden Fehler zurück. ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=server_error ``` + Wenn Amazon Cognito sich über einen Verbund mit einem Drittanbieter authentifiziert IdPs, kann es bei Amazon Cognito zu Verbindungsproblemen kommen, wie z. B. die folgenden: + Wenn es bei der Token-Anforderung vom IdP zu einem Verbindungs-Timeout kommt, leitet der Authentifizierungsserver den Fehler wie folgt an den `redirect_uri` des Clients weiter: ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Timeout+occurred+in+calling+IdP+token+endpoint ``` + Wenn beim Aufrufen des `jwks_uri` Endpunkts zur Überprüfung des ID-Tokens ein Verbindungs-Timeout auftritt, leitet der Authentifizierungsserver mit einem Fehler wie folgt an den des Clients weiter: `redirect_uri` ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=error_description=Timeout+in+calling+jwks+uri ``` + Bei der Authentifizierung über einen Verbund mit einem Drittanbieter IdPs geben die Anbieter möglicherweise Fehlerantworten zurück. Dies kann auf Konfigurationsfehler oder andere Gründe zurückzuführen sein, z. B. auf die folgenden: + Wenn eine Fehlermeldung von anderen Anbietern empfangen wird, leitet der Authentifizierungsserver den Fehler wie folgt an den `redirect_uri` des Clients weiter: ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=[IdP name]+Error+-+[status code]+error getting token ``` + Wenn eine Fehlerantwort von Google empfangen wird, leitet der Authentifizierungsserver den Fehler wie folgt an den `redirect_uri` des Clients weiter: ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Google+Error+-+[status code]+[Google-provided error code] ``` + Wenn Amazon Cognito bei der Verbindung zu einem externen IdP auf eine Kommunikationsausnahme stößt, leitet der Authentifizierungsserver mit einer der folgenden Meldungen `redirect_uri` mit einem Fehler an den des Kunden weiter: + ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Connection+reset ``` + ``` HTTP 1.1 302 Found Location: https://client_redirect_uri?error=invalid_request&error_description=Read+timed+out ```