Die AWS SDK für JavaScript Version 2 ist erreicht end-of-support. Wir empfehlen Ihnen, auf [AWS SDK für JavaScript Version 3](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/) zu migrieren. Weitere Einzelheiten und Informationen zur Migration finden Sie in dieser [Ankündigung](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/).

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.

# Festlegen von Anmeldeinformationen in einem Web-Browser
<a name="setting-credentials-browser"></a>

Es gibt mehrere Möglichkeiten, um dem SDK die Anmeldeinformationen aus Browser-Skripts bereitzustellen. Einige davon sind sicherer und andere bieten eine höhere Benutzerfreundlichkeit bei der Entwicklung eines Skripts. So können Sie Ihre Anmeldeinformationen angeben (in der Reihenfolge der Stärke der Empfehlung):

1. Verwenden von Amazon Cognito Identity zur Benutzerauthentifizierung und Bereitstellung von Anmeldeinformationen

1. Verwenden von Web-Verbundidentitäten

1. Hartcodierung im Skript

**Warnung**  
Wir empfehlen nicht, Ihre AWS Anmeldeinformationen in Ihren Skripten fest zu codieren. Die Hartcodierung der Anmeldeinformationen setzt die Zugriffsschlüssel-ID und den geheimen Zugriffsschlüssel dem Risiko einer Offenlegung aus.

**Topics**
+ [Verwenden von Amazon Cognito Identity zur Benutzerauthentifizierung](loading-browser-credentials-cognito.md)
+ [Verwenden von Web-Verbundidentitäten zum Authentifizieren von Benutzern](loading-browser-credentials-federated-id.md)
+ [Beispiele von Web-Verbundidentitäten](config-web-identity-examples.md)

# Verwenden von Amazon Cognito Identity zur Benutzerauthentifizierung
<a name="loading-browser-credentials-cognito"></a>

Die empfohlene Methode, AWS Anmeldeinformationen für Ihre Browserskripte zu erhalten, ist die Verwendung des Amazon Cognito Identity-Anmeldeinformationsobjekts,`AWS.CognitoIdentityCredentials`. Amazon Cognito ermöglicht die Authentifizierung von Benutzern über externe Identitätsanbieter.

Um Amazon Cognito Identity verwenden zu können, müssen Sie zunächst einen Identitätspool in der Amazon Cognito Cognito-Konsole erstellen. Ein Identitäten-Pool stellt die Gruppe von Identitäten dar, die Ihre Anwendung für Ihre Benutzer bereitstellt. Die den Benutzern zugewiesenen Identitäten identifizieren jedes Benutzerkonto eindeutig. Amazon-Cognito-Identitäten sind keine Anmeldeinformationen. Sie werden mithilfe der Unterstützung von Web Identity Federation in AWS -Security-Token-Service (AWS STS) gegen Anmeldeinformationen ausgetauscht.

Amazon Cognito hilft Ihnen, die Abstraktion von Identitäten über mehrere Identitätsanbieter hinweg mit dem Objekt zu verwalten. `AWS.CognitoIdentityCredentials` Die geladene Identität wird dann gegen Anmeldeinformationen in AWS STS ausgetauscht.

## Konfiguration des Amazon Cognito Identity Credentials-Objekts
<a name="browser-cognito-configuration"></a>

Wenn Sie noch keinen erstellt haben, erstellen Sie vor der Konfiguration `AWS.CognitoIdentityCredentials` einen Identitätspool, den Sie mit Ihren Browserskripten in der [Amazon Cognito Cognito-Konsole](https://console.aws.amazon.com/cognito) verwenden können. Erstellen Sie sowohl authentifizierte als auch nicht authentifizierte IAM-Rollen für Ihren Identitätspool und ordnen Sie sie zu.

Für nicht authentifizierte Benutzer wird die Identität nicht verifiziert, sodass diese Rolle für Gastbenutzer Ihrer Anwendung geeignet ist, oder in Fällen, in denen es keine Rolle spielt, ob Benutzer ihre Identität verifizieren lassen. Authentifizierte Benutzer melden sich bei Ihrer Anwendung über einen Drittanbieter an, der ihre Identität überprüft. Vergewissern Sie sich, dass Sie die Berechtigungen der Ressourcen entsprechend anpassen, damit Sie keinen Zugriff von nicht authentifizierten Benutzern darauf gewähren.

Nachdem Sie einen Identitäten-Pool mit angefügten Identitätsanbietern konfiguriert haben, können Sie mit `AWS.CognitoIdentityCredentials` Benutzer authentifizieren. Um die Anmeldeinformationen für Ihre Anwendung so zu konfigurieren, dass Sie `AWS.CognitoIdentityCredentials` verwenden können, setzen Sie die `credentials`-Eigenschaft für `AWS.Config` oder Sie verwenden eine servicespezifische Konfiguration. Im folgenden Beispiel wird verwende `AWS.Config`:

```
AWS.config.credentials = new AWS.CognitoIdentityCredentials({
  IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030',
  Logins: { // optional tokens, used for authenticated login
    'graph.facebook.com': 'FBTOKEN',
    'www.amazon.com': 'AMAZONTOKEN',
    'accounts.google.com': 'GOOGLETOKEN'
  }
});
```

Die optionale `Logins`-Eigenschaft ist eine Abbildung der Namen des Identitätsanbieters auf die Identitäts-Token für diese Anbieter. Wie Sie den Token von Ihrem Identitätsanbieter erhalten, hängt davon ab, welchen Anbieter Sie verwenden. Ist beispielsweise Facebook einer Ihrer Identitätsanbieter, könnten sie die `FB.login`-Funktion aus dem [Facebook SDK](https://developers.facebook.com/docs/facebook-login/web) verwenden, um ein Identitätsanbieter-Token zu erhalten:

```
FB.login(function (response) {
  if (response.authResponse) { // logged in
    AWS.config.credentials = new AWS.CognitoIdentityCredentials({
      IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030',
      Logins: {
        'graph.facebook.com': response.authResponse.accessToken
      }
    });

    s3 = new AWS.S3; // we can now create our service object

    console.log('You are now logged in.');
  } else {
    console.log('There was a problem logging you in.');
  }
});
```

## Wechseln von nicht authentifizierten Benutzern zu authentifizierten Benutzern
<a name="browser-switching-unauthenticated-users"></a>

Amazon Cognito unterstützt sowohl authentifizierte als auch nicht authentifizierte Benutzer. Nicht authentifizierte Benutzer erhalten Zugriff auf Ihre Ressourcen, auch wenn sie nicht über Ihre Identitätsanbieter angemeldet sind. Dieser Grad des Zugriffs ist nützlich, um Inhalte für Benutzer anzuzeigen, bevor diese sich anmelden. Jeder nicht authentifizierte Benutzer hat eine eindeutige Identität in Amazon Cognito, obwohl er nicht einzeln angemeldet und authentifiziert wurde.

### Anfänglich nicht authentifizierter Benutzer
<a name="browser-switching-initially-unauthenticated-user"></a>

Benutzer beginnen in der Regel mit der nicht authentifizierten Rolle, für die Sie die Eigenschaft für die Anmeldeinformationen Ihres Konfigurationsobjekts ohne eine `Logins`-Eigenschaft festlegen. In diesem Fall könnte Ihre Standardkonfiguration folgendermaßen aussehen:

```
// set the default config object
var creds = new AWS.CognitoIdentityCredentials({
 IdentityPoolId: 'us-east-1:1699ebc0-7900-4099-b910-2df94f52a030'
});
AWS.config.credentials = creds;
```

### Wechseln Sie zum authentifizierten Benutzer
<a name="switch-to-authenticated"></a>

Wenn ein nicht authentifizierter Benutzer sich bei einem Identitätsanbieter anmeldet und Sie ein Token haben, können Sie den Benutzer von einem nicht authentifizierten in einen authentifizierten Benutzer umändern, indem Sie eine benutzerdefinierte Funktion aufrufen, welche das Anmeldeobjekt aktualisiert und das `Logins`-Token hinzufügt:

```
// Called when an identity provider has a token for a logged in user
function userLoggedIn(providerName, token) {
  creds.params.Logins = creds.params.Logins || {};
  creds.params.Logins[providerName] = token;
                    
  // Expire credentials to refresh them on the next request
  creds.expired = true;
}
```

Darüber hinaus können Sie ein `CognitoIdentityCredentials`-Objekt erstellen. Wenn Sie dies tun, müssen Sie die Eigenschaften für die Anmeldeinformationen der vorhandenen, von Ihnen erstellten Serviceobjekte zurücksetzen. Serviceobjekte lesen die globale Konfiguration nur während der Objektinitialisierung. 

Weitere Informationen zu dem `CognitoIdentityCredentials` Objekt finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/CognitoIdentityCredentials.html)in der API-Referenz. AWS SDK für JavaScript 

# Verwenden von Web-Verbundidentitäten zum Authentifizieren von Benutzern
<a name="loading-browser-credentials-federated-id"></a>

Sie können einzelne Identitätsanbieter direkt für den Zugriff auf AWS Ressourcen mithilfe des Web-Identitätsverbunds konfigurieren. AWS unterstützt derzeit die Authentifizierung von Benutzern mithilfe des Web-Identitätsverbunds über mehrere Identitätsanbieter:
+ [Login mit Amazon](https://login.amazon.com)
+ [Facebook-Anmeldung](https://www.facebook.com/about/login)
+ [Google-Anmeldung](https://developers.google.com/identity/)

Sie müssen Ihre Anwendung zunächst mit den Anbietern registrieren, die von Ihrer Anwendung unterstützt werden. Erstellen Sie als Nächstes eine IAM-Rolle und richten Sie die entsprechenden Berechtigungen ein. Die von Ihnen erstellte IAM-Rolle wird dann verwendet, um die Berechtigungen zu erteilen, die Sie dafür über den jeweiligen Identitätsanbieter konfiguriert haben. Sie können beispielsweise eine Rolle einrichten, die Benutzern, die sich über Facebook angemeldet haben, Lesezugriff auf einen bestimmten Amazon S3 S3-Bucket gewährt, den Sie kontrollieren.

Nachdem Sie sowohl eine IAM-Rolle mit konfigurierten Rechten als auch eine Anwendung bei den von Ihnen ausgewählten Identitätsanbietern registriert haben, können Sie das SDK so einrichten, dass Anmeldeinformationen für die IAM-Rolle mithilfe des Hilfscodes wie folgt abgerufen werden:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
   RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>/:role/<WEB_IDENTITY_ROLE_NAME>',
   ProviderId: 'graph.facebook.com|www.amazon.com', // this is null for Google
   WebIdentityToken: ACCESS_TOKEN
});
```

Der Wert des `ProviderId`-Parameters hängt vom angegebenen Identitätsanbieter ab. Der Wert des `WebIdentityToken`-Parameters ist das abgerufene Zugriffstoken aus einer erfolgreichen Anmeldung mit dem Identitätsanbieter. Weitere Informationen zum Konfigurieren und Abrufen von Zugriffstoken für die einzelnen Identitätsanbieter finden Sie in der Dokumentation des Identitätsanbieters.

## Schritt 1: Registrierung bei den Identitätsanbietern
<a name="config-web-identity-register"></a>

Registrieren Sie eine Anwendung zu Beginn bei den Identitätsanbietern, die Sie unterstützen möchten. Sie werden um Informationen gebeten, anhand derer Ihre Anwendung und möglicherweise auch deren Autor identifiziert werden können. Auf diese Weise wird sichergestellt, dass die Identitätsanbieter den Empfänger ihrer Benutzerinformationen kennen. In jedem Fall erstellt der Identitätsanbieter eine Anwendungs-ID, mit der Sie Benutzerrollen konfigurieren können.

## Schritt 2: Erstellen einer IAM-Rolle für einen Identitätsanbieter
<a name="config-web-identity-role"></a>

Nachdem Sie die Anwendungs-ID von einem Identitätsanbieter erhalten haben, rufen Sie die IAM-Konsole unter auf, [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)um eine neue IAM-Rolle zu erstellen.

**Um eine IAM-Rolle für einen Identitätsanbieter zu erstellen**

1. Rufen Sie in der Konsole den Abschnitt **Roles (Rollen)** auf und wählen Sie anschließend **Create new role (Neue Rolle erstellen)** aus.

1. Geben Sie einen Namen für die neue Rolle ein, über den Sie deren Verwendung verfolgen können, z. B. **facebookIdentity**. Wählen Sie anschließend **Next Step (Nächster Schritt)** aus.

1. Wählen Sie unter **Select Role Type (Rollentyp auswählen)** die Option **Role for Identity Provider Access (Rolle für den Zugriff von Identitätsanbietern)** aus.

1. Wählen Sie unter **Grant access to web identity providers (Web-Identitätsanbietern Zugriff gewähren)** die Option **Select (Auswählen)** aus.

1. Wählen Sie aus der Liste der **Identitätsanbieter** den Identitätsanbieter aus, den Sie für diese IAM-Rolle verwenden möchten.  
![\[Auswählen der Rolle für den Zugriff von Identitätsanbietern\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v2/developer-guide/images/iam-provider-select.png)

1. Geben Sie die Anwendungs-ID des Identitätsanbieters im Feld **Application ID (Anwendungs-ID)** ein und wählen Sie dann **Next Step (Nächster Schritt)** aus

1. Konfigurieren Sie Berechtigungen für die Ressourcen, die Sie bereitstellen möchten, damit der Zugriff auf bestimmte Operationen für bestimmte Ressourcen gewährt wird. Weitere Informationen zu IAM-Berechtigungen finden Sie unter [Überblick über AWS IAM-Berechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_permissions.html) im *IAM-Benutzerhandbuch*. Überprüfen Sie die Vertrauensstellung der Rolle und passen Sie sie erforderlichenfalls an. Klicken Sie anschließend auf **Next Step (Nächster Schritt)**.

1. Fügen Sie zusätzliche benötigte Richtlinien an und wählen Sie dann **Next Step (Nächster Schritt)** aus. Weitere Informationen zu IAM-Richtlinien finden Sie unter [Übersicht über IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html) im *IAM-Benutzerhandbuch*.

1. Prüfen Sie die neue Rolle und wählen Sie dann **Create Role (Rolle erstellen)** aus.

Sie können weitere Einschränkungen für die Rolle festlegen, z. B. den Geltungsbereich auf einen bestimmten Benutzer beschränken. IDs Wenn die Rolle Schreibberechtigungen für Ihre Ressourcen erteilt, stellen Sie sicher, dass Sie die Rolle nur Benutzern mit den entsprechenden Berechtigungen zuordnen, ansonsten kann jeder Benutzer mit einer Amazon-, Facebook- oder Google-Identität Änderungen an Ihren Ressourcen vornehmen.

Weitere Informationen zur Verwendung von Web Identity Federation in IAM finden Sie unter [About Web Identity Federation](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html) im *IAM-Benutzerhandbuch*.

## Schritt 3: Abrufen eines Zugriffstokens für Anbieter nach der Anmeldung
<a name="config-web-identity-obtain-token"></a>

Richten Sie die Anmeldung für Ihre Anwendung ein, indem Sie das SDK des Identitätsanbieters verwenden. Sie können ein JavaScript SDK vom Identitätsanbieter herunterladen und installieren, das die Benutzeranmeldung entweder mit OpenID OAuth oder OpenID ermöglicht. Weitere Informationen zum Herunterladen und Einrichten des SDK-Codes in Ihrer Anwendung finden Sie in der SDK-Dokumentation Ihres Identitätsanbieters:
+ [Login mit Amazon](https://login.amazon.com/website)
+ [Facebook-Anmeldung](https://developers.facebook.com/docs/javascript)
+ [Google-Anmeldung](https://developers.google.com/identity/)

## Schritt 4: Abrufen temporärer Anmeldeinformationen
<a name="config-web-identity-get-credentials"></a>

Nachdem Sie die Anwendung, Rollen und Ressourcenberechtigungen konfiguriert haben, fügen Sie Ihrer Anwendung den Code hinzu, um temporäre Anmeldeinformationen zu erhalten. Diese Anmeldeinformationen werden über den AWS -Security-Token-Service Webidentitätsverbund bereitgestellt. Benutzer melden sich beim Identitätsanbieter an, wodurch Ihnen ein Zugriffstoken bereitgestellt wird. Richten Sie das `AWS.WebIdentityCredentials` Objekt mithilfe des ARN für die IAM-Rolle ein, die Sie für diesen Identitätsanbieter erstellt haben:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
    RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>',
    ProviderId: 'graph.facebook.com|www.amazon.com', // Omit this for Google
    WebIdentityToken: ACCESS_TOKEN // Access token from identity provider
});
```

Serviceobjekte, die anschließend erstellt werden, verfügen über die entsprechenden Anmeldeinformationen. Objekte, die vor der Einrichtung der `AWS.config.credentials`-Eigenschaft erstellt wurden, verfügen nicht über die aktuellen Anmeldeinformationen.

Sie können `AWS.WebIdentityCredentials` auch vor dem Abrufen des Zugriffstokens erstellen. Auf diese Weise können Sie Serviceobjekte erstellen, die von den Anmeldeinformationen abhängen, bevor Sie das Zugriffstoken laden. Erstellen Sie hierzu das Anmeldeinformationsobjekt ohne den `WebIdentityToken`-Parameter:

```
AWS.config.credentials = new AWS.WebIdentityCredentials({
  RoleArn: 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>',
  ProviderId: 'graph.facebook.com|www.amazon.com' // Omit this for Google
});

// Create a service object
var s3 = new AWS.S3;
```

Definieren Sie anschließend `WebIdentityToken` im Callback des SDK des Identitätsanbieters, das den Zugriffstoken enthält:

```
AWS.config.credentials.params.WebIdentityToken = accessToken;
```

# Beispiele von Web-Verbundidentitäten
<a name="config-web-identity-examples"></a>

Im Folgenden finden Sie einige Beispiele für die Verwendung von Web Federated Identity zum Abrufen von Anmeldeinformationen im Browser. JavaScript Diese Beispiele müssen über ein Host-Schema „http://“ oder „https://“ ausgeführt werden, um sicherzustellen, dass die Weiterleitung an Ihre Anwendung durch den Identitätsanbieter erfolgen kann. 

## Beispiel für Login with Amazon
<a name="config-web-identity-amazon-login-example"></a>

Der folgende Code zeigt, wie Sie Login with Amazon als Identitätsanbieter verwenden. 

```
<a href="#" id="login">
  <img border="0" alt="Login with Amazon"
    src="https://images-na.ssl-images-amazon.com/images/G/01/lwa/btnLWA_gold_156x32.png"
    width="156" height="32" />
</a>
<div id="amazon-root"></div>
<script type="text/javascript">
  var s3 = null;
  var clientId = 'amzn1.application-oa2-client.1234567890abcdef'; // client ID
  var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

  window.onAmazonLoginReady = function() {
    amazon.Login.setClientId(clientId); // set client ID

    document.getElementById('login').onclick = function() {
      amazon.Login.authorize({scope: 'profile'}, function(response) {
        if (!response.error) { // logged in
          AWS.config.credentials = new AWS.WebIdentityCredentials({
            RoleArn: roleArn,
            ProviderId: 'www.amazon.com',
            WebIdentityToken: response.access_token
          });

          s3 = new AWS.S3();

          console.log('You are now logged in.');
        } else {
          console.log('There was a problem logging you in.');
        }
      });
    };
  };

  (function(d) {
    var a = d.createElement('script'); a.type = 'text/javascript';
    a.async = true; a.id = 'amazon-login-sdk';
    a.src = 'https://api-cdn.amazon.com/sdk/login1.js';
    d.getElementById('amazon-root').appendChild(a);
  })(document);
</script>
```

## Beispiel für eine Facebook-Anmeldung
<a name="config-web-identity-facebook-login-example"></a>

Der folgende Code zeigt, wie Sie die Facebook-Anmeldung als Identitätsanbieter verwenden:

```
<button id="login">Login</button>
<div id="fb-root"></div>
<script type="text/javascript">
var s3 = null;
var appId = '1234567890'; // Facebook app ID
var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

window.fbAsyncInit = function() {
  // init the FB JS SDK
  FB.init({appId: appId});

  document.getElementById('login').onclick = function() {
    FB.login(function (response) {
      if (response.authResponse) { // logged in
        AWS.config.credentials = new AWS.WebIdentityCredentials({
          RoleArn: roleArn,
          ProviderId: 'graph.facebook.com',
          WebIdentityToken: response.authResponse.accessToken
        });

        s3 = new AWS.S3;

        console.log('You are now logged in.');
      } else {
        console.log('There was a problem logging you in.');
      }
    });
  };
};

// Load the FB JS SDK asynchronously
(function(d, s, id){
   var js, fjs = d.getElementsByTagName(s)[0];
   if (d.getElementById(id)) {return;}
   js = d.createElement(s); js.id = id;
   js.src = "//connect.facebook.net/en_US/all.js";
   fjs.parentNode.insertBefore(js, fjs);
 }(document, 'script', 'facebook-jssdk'));
</script>
```

## Beispiel für eine Google\$1-Anmeldung
<a name="config-web-identity-google-login-example"></a>

Der folgende Code zeigt, wie Sie die Google\$1-Anmeldung als Identitätsanbieter verwenden. Das Zugriffstoken für den Web-Identitätsverbund von Google wird im `response.id_token` und nicht im `access_token` gespeichert, wie dies bei anderen Identitätsanbietern der Fall ist. 

```
<span
  id="login"
  class="g-signin"
  data-height="short"
  data-callback="loginToGoogle"
  data-cookiepolicy="single_host_origin"
  data-requestvisibleactions="http://schemas.google.com/AddActivity"
  data-scope="https://www.googleapis.com/auth/plus.login">
</span>
<script type="text/javascript">
  var s3 = null;
  var clientID = '1234567890.apps.googleusercontent.com'; // Google client ID
  var roleArn = 'arn:aws:iam::<AWS_ACCOUNT_ID>:role/<WEB_IDENTITY_ROLE_NAME>';

  document.getElementById('login').setAttribute('data-clientid', clientID);
  function loginToGoogle(response) {
    if (!response.error) {
      AWS.config.credentials = new AWS.WebIdentityCredentials({
        RoleArn: roleArn, WebIdentityToken: response.id_token
      });

      s3 = new AWS.S3();

      console.log('You are now logged in.');
    } else {
      console.log('There was a problem logging you in.');
    }
  }

  (function() {
    var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
    po.src = 'https://apis.google.com/js/client:plusone.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
  })();
 </script>
```