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.
# Verwenden von Anmeldeinformationsanbietern der AWS SDK für PHP Version 3
Referenzinformationen zu den verfügbaren Anmeldemechanismen für finden Sie unter [Anmeldeinformationen und Zugriff](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) im *AWS SDKs Referenzhandbuch zu Tools*. AWS SDKs
**Wichtig**
Aus Sicherheitsgründen *empfehlen wir dringend*, **nicht** das Root-Konto für den AWS Zugriff zu verwenden. Aktuelle [Sicherheitsempfehlungen finden Sie immer unter Bewährte](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) Sicherheitsmethoden in *IAM im IAM-Benutzerhandbuch*.
Die Rolle eines Anbieters für Anmeldeinformationen in AWS SDK für PHP Version 3 besteht darin, Anmeldeinformationen für die SDK-Clients zu beschaffen und bereitzustellen. AWS-Service Das SDK verwendet die Anmeldeinformationen, die es bezieht, um sich beim Dienst zu authentifizieren, indem es jede Anfrage kryptografisch signiert. Anmeldeinformationen bestehen normalerweise aus Zugriffsschlüsseln — einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel zusammen.
Wenn Sie temporäre Anmeldeinformationen verwenden, z. B. wenn Sie die [IAM Identity Center-Authentifizierung einrichten](credentials.md#use-idc-for-auth) oder Ihre Runtime so konfigurieren, dass sie [eine IAM-Rolle übernimmt](assumerole-provider.md), wird den Zugriffsschlüsseln ein Sitzungstoken hinzugefügt, das einen zeitlich begrenzten Zugriff auf Ressourcen ermöglicht. AWS
## Was ist ein Anmeldeinformationsanbieter in Version 3? AWS SDK für PHP
Ein Anmeldeinformationsanbieter ist eine Funktion, die eine `GuzzleHttp\Promise\PromiseInterface` zurückgibt, die mit einer `Aws\Credentials\CredentialsInterface`-Instance erfüllt oder mit einer `Aws\Exception\CredentialsException` abgelehnt wird. Das [SDK bietet verschiedene Implementierungen](built-in-providers-in-the-sdk.md) von Funktionen des Anmeldeinformationsanbieters. Sie können aber auch [Ihre eigene benutzerdefinierte Logik zum Erstellen von Anmeldeinformationen oder zum Optimieren des Ladens von Anmeldeinformationen implementieren](creating-a-custom-provider.md).
Anmeldeinformationsanbieter werden in der `credentials`-Option des Client-Konstruktors übergeben. Anmeldeinformationsanbieter sind asynchron, sodass sie jedes Mal, wenn eine API-Operation aufgerufen wird, langsam ausgewertet werden. Die Übergabe einer Anmeldeinformationsanbieter-Funktion an einen SDK-Client-Konstruktor führt daher nicht sofort zur Validierung der Anmeldeinformationen. Wenn der Anmeldeinformationsanbieter kein Anmeldeinformationsobjekt zurückgibt, wird eine API-Operation mit einer `Aws\Exception\CredentialsException` abgelehnt.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
// Use the ECS credential provider.
$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials.
$memoizedProvider = CredentialProvider::memoize($provider);
// Pass the provider to the client
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
# Grundlegendes zur standardmäßigen Anbieterkette für Anmeldeinformationen in AWS SDK für PHP Version 3
Die standardmäßige Anbieterkette für Anmeldeinformationen besteht aus einer Reihe integrierter Anmeldeinformationsanbieter, die das SDK aufruft. Es wird von der [DefaultProvider-Funktion](defaultprovider-provider.md) für Anmeldeinformationsanbieter ohne Parameter implementiert. Nachdem gültige Anmeldeinformationen gefunden wurden, wird die Suche beendet.
Der AWS SDK für PHP führt Anmeldeinformationsanbieter in der folgenden Reihenfolge aus:
+ [**`env`provider**](env-provider.md) — Das SDK sucht nach [AWS Zugriffsschlüsseln, die als Umgebungsvariablen festgelegt wurden](https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html).
+ [**`assumeRoleWithWebIdentityCredentialProvider`provider**](assume-role-with-web-identity-provider.md) — Das SDK sucht nach Dateieinstellungen für die IAM-Rolle und das Web-Identitätstoken.
+ An diesem Punkt in der Kette sucht das SDK nach Konfigurationen in den gemeinsam genutzten `credentials` Dateien AWS `config` und Dateien. Das SDK sucht unter dem „Standard“ -Profil nach der Konfiguration, aber wenn die `AWS_PROFILE` Umgebungsvariable gesetzt ist, verwendet das SDK ihren benannten Profilwert.
+ [**`sso`provider**](sso-provider.md) — Das SDK sucht in der gemeinsam genutzten `config` Datei nach den [IAM Identity Center-Konfigurationseinstellungen](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config).
+ [**`login provider`**](login-provider.md)- Das SDK sucht in der gemeinsam genutzten `config` Datei nach Konfigurationseinstellungen für die AWS Konsolen-Anmeldesitzung.
+ [**`process`Anbieter**](process-provider.md) — Das SDK sucht in der gemeinsam genutzten `credentials` Datei nach der `credential_process` Einstellung.
+ [**`ini`provider**](ini-provider.md) — Das SDK sucht in der gemeinsam genutzten `credentials` Datei nach den AWS Anmeldeinformationen oder IAM-Rolleninformationen.
+ [**`process`provider**](process-provider.md) — Das SDK sucht in der gemeinsam genutzten `config` Datei nach der `credential_process` Einstellung.
+ [**`ini`provider**](ini-provider.md) — Das SDK sucht in der gemeinsam genutzten `config` Datei nach den AWS Anmeldeinformationen oder IAM-Rolleninformationen.
+ [**`ecsCredentials`provider**](ecscredentials-provider.md) — Das SDK sucht nach Umgebungsvariablen `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI ` oder Variablen`AWS_CONTAINER_CREDENTIALS_FULL_URI`, die Informationen zum Abrufen temporärer Anmeldeinformationen bereitstellen.
+ [**`instanceProfile`provider**](instanceprofile-provider.md) — Das SDK verwendet den EC2-Instanz-Metadatendienst, um die im Instanzprofil angegebene IAM-Rolle abzurufen. Mithilfe der Rolleninformationen ruft das SDK temporäre Anmeldeinformationen ab.
**Anmerkung**
Das Ergebnis des Standard-Anbieters wird automatisch gespeichert.
Sie können den Code für die Kette im GitHub [Quellcode](https://github.com/aws/aws-sdk-php/blob/0a99dab427f0a1c082775301141aeac3558691ad/src/Credentials/CredentialProvider.php#L77) überprüfen.
# Integrierte Anmeldeinformationsanbieter in der AWS SDK für PHP Version 3
Das SDK bietet mehrere integrierte Anbieter von Anmeldeinformationen, die Sie einzeln verwenden oder in einer [benutzerdefinierten](chaining-providers.md) Anbieterkette kombinieren können.
Wenn Sie bei der Erstellung des Dienstclients einen Anbieter für Anmeldeinformationen angeben, versucht das SDK, Anmeldeinformationen zu laden, indem es nur den angegebenen Anmeldeinformationsanbieter verwendet. Es verwendet nicht die [standardmäßige Anbieterkette für Anmeldeinformationen](guide_credentials_default_chain.md). Wenn Sie wissen, dass ein Dienstclient den `instanceProfile` Anbieter verwenden soll, können Sie die Standardkette kurzschließen, indem Sie den `instanceProfile` Anbieter im Service-Client-Konstruktor angeben:
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::instanceProfile();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $memoizedProvider // The default credential provider chain is not used.
]);
```
**Wichtig**
Anmeldeinformationsanbieter werden jedes Mal aufgerufen, wenn eine API-Operation ausgeführt wird. Wenn das Laden von Anmeldeinformationen eine teure Aufgabe ist (z. B. das Laden von Festplatten oder eine Netzwerkressource), oder wenn Anmeldeinformationen von Ihrem Anbieter nicht im Cache gespeichert werden, sollten Sie in Betracht ziehen, Ihren Anmeldeinformationsanbieter in eine `Aws\Credentials\CredentialProvider::memoize`-Funktion zu verpacken. Das SDK merkt sich den Standard-Anmeldeinformationsanbieter automatisch.
**Topics**
+ [`login`Anbieter im SDK for PHP](login-provider.md)
+ [`assumeRole`Anbieter im SDK for PHP](assumerole-provider.md)
+ [`sso`Anbieter im SDK for PHP](sso-provider.md)
+ [`defaultProvider`Anbieter im SDK for PHP](defaultprovider-provider.md)
+ [`ecsCredentials`Anbieter im SDK for PHP](ecscredentials-provider.md)
+ [`env`Anbieter im SDK for PHP](env-provider.md)
+ [`assumeRoleWithWebIdentityCredentialProvider`Anbieter im SDK for PHP](assume-role-with-web-identity-provider.md)
+ [`ini`Anbieter im SDK for PHP](ini-provider.md)
+ [`process`Anbieter im SDK for PHP](process-provider.md)
+ [`instanceProfile`Anbieter im SDK for PHP](instanceprofile-provider.md)
# `login`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::login`versucht, Anmeldeinformationen zu laden, die durch eine browserbasierte Anmeldesitzung konfiguriert wurden, die durch Tools wie die AWS CLI unterstützt wird. AWS Generiert nach der Authentifizierung temporäre Anmeldeinformationen, die lokal AWS SDKs und in allen Tools funktionieren.
Mit diesem Prozess können Sie sich mit Root-Anmeldeinformationen, die bei der ersten Kontoeinrichtung erstellt wurden, mit einem IAM-Benutzer oder einer föderierten Identität von Ihrem Identitätsanbieter authentifizieren. Das AWS SDK for PHP verwaltet die temporären Anmeldeinformationen automatisch für Sie. Dieser Ansatz erhöht die Sicherheit, da die Notwendigkeit entfällt, langfristige Anmeldeinformationen lokal zu speichern.
Wenn Sie den `aws login` Befehl ausführen, können Sie aus Ihren aktiven Konsolensitzungen wählen oder sich über den browserbasierten Authentifizierungsablauf anmelden. Dabei werden automatisch temporäre Anmeldeinformationen generiert. Das AWS SDK for PHP aktualisiert diese Anmeldeinformationen mithilfe des Anmeldedienstes automatisch für bis zu 12 Stunden.
Der Anmeldeanbieter versucht, das durch den zuvor erwähnten Ablauf der Anmeldesitzung generierte Zugriffstoken auf der Grundlage des bereitgestellten Profils zu laden. Wenn beim Aufrufen des Anbieters kein Profil angegeben wird, versucht dieser, ein Profil aufzulösen, indem zuerst die `AWS_PROFILE` Umgebungsvariable überprüft wird, bevor auf das Profil zurückgegriffen wird`default`. Die Code-Konfiguration kann an den Anbieter übergeben werden, der dann nach einem `region` Wert für den Anmeldedienstclient sucht, der zum Aktualisieren der Anmeldeinformationen verwendet wird. Wenn im Konfigurationsarray keine Region angegeben ist, versucht der Anbieter, eine Region aufzulösen, indem er die `AWS_REGION` Umgebungsvariable und dann einen im aufgelösten Profil festgelegten Regionswert überprüft. Wenn keine Region gefunden werden kann, gibt der Anbieter eine abgelehnte Zusage mit Anweisungen zur Konfiguration einer Region zurück.
Der Anbieter wird als Teil der Standardkette aufgerufen und kann direkt aufgerufen werden.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::login(, ['region' => ]);
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
Wenn auf dem Service-Client, den Sie verwenden möchten, keine Konfiguration für Anmeldeinformationen bereitgestellt wird, wird dieser Anbieter standardmäßig als Teil der `defaultProvider()` Anmeldeinformationskette aufgerufen. In diesem Szenario wird die Region des Service-Clients automatisch an den `login()` Anbieter übergeben. Auch in diesem Szenario wird der an den Anmeldeanbieter übergebene Profilwert durch Überprüfung der `AWS_PROFILE` Umgebungsvariablen aufgelöst, bevor auf das Profil zurückgegriffen wird`default`.
# `assumeRole`Anbieter im SDK for PHP
Wenn Sie `Aws\Credentials\AssumeRoleCredentialProvider` zum Erstellen von Anmeldeinformationen verwenden, indem Sie eine Rolle annehmen, müssen Sie `'client'`-Informationen mit einem `StsClient`-Objekt und `'assume_role_params'`-Details bereitstellen, wie dargestellt.
**Anmerkung**
Um zu vermeiden, dass bei jedem API-Vorgang AWS STS Anmeldeinformationen unnötig abgerufen werden, können Sie die `memoize` Funktion verwenden, um die Anmeldeinformationen automatisch zu aktualisieren, wenn sie ablaufen. Nachfolgend finden Sie ein Codebeispiel.
```
use Aws\Credentials\CredentialProvider;
use Aws\Credentials\InstanceProfileProvider;
use Aws\Credentials\AssumeRoleCredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
// Passing Aws\Credentials\AssumeRoleCredentialProvider options directly
$profile = new InstanceProfileProvider();
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$assumeRoleCredentials = new AssumeRoleCredentialProvider([
'client' => new StsClient([
'region' => 'us-east-2',
'version' => '2011-06-15',
'credentials' => $profile
]),
'assume_role_params' => [
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
],
]);
// To avoid unnecessarily fetching STS credentials on every API operation,
// the memoize function handles automatically refreshing the credentials when they expire
$provider = CredentialProvider::memoize($assumeRoleCredentials);
$client = new S3Client([
'region' => 'us-east-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Weitere Informationen `'assume_role_params'` dazu finden Sie unter. [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)
# `sso`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::sso`ist der Anbieter von Single Sign-On-Anmeldeinformationen. Dieser Anbieter wird auch als AWS IAM Identity Center Anmeldeinformationsanbieter bezeichnet.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$credentials = CredentialProvider::sso('profile default');
$s3 = new Aws\S3\S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Wenn Sie ein benanntes Profil verwenden, ersetzen Sie '`default`' im vorherigen Beispiel durch den Namen Ihres Profils. Weitere Informationen zum Einrichten benannter Profile finden Sie unter [Geteilte Profile `config` und `credentials` Dateien](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*. Alternativ können Sie die [https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile)Umgebungsvariable verwenden, um anzugeben, welche Profileinstellungen verwendet werden sollen.
Weitere Informationen zur Funktionsweise des IAM Identity Center-Anbieters finden Sie unter [Grundlegendes zur IAM Identity Center-Authentifizierung](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) im *AWS SDKs Referenzhandbuch zu Tools.*
# `defaultProvider`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::defaultProvider`ist der Standardanbieter für Anmeldeinformationen und wird auch als [Standardanbieterkette für Anmeldeinformationen](guide_credentials_default_chain.md) bezeichnet. Dieser Anbieter wird verwendet, wenn Sie bei der Erstellung eines Clients die `credentials`-Option nicht angeben. Wenn Sie beispielsweise einen S3Client erstellen, wie im folgenden Codeausschnitt gezeigt, verwendet das SDK den Standardanbieter:
```
$client = new S3Client([
'region' => 'us-west-2'
]);
```
Sie können den defaultProvider auch im Code verwenden, wenn Sie bestimmten Anmeldeinformationsanbietern in der Kette Parameter zur Verfügung stellen möchten. Das folgende Beispiel bietet beispielsweise benutzerdefinierte Einstellungen für Verbindungstimeout und Wiederholungsversuche, wenn die `ecsCredentials` Provider-Funktion verwendet wird.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::defaultProvider([
'timeout' => '1.5',
'retries' => 5
]);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
# `ecsCredentials`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::ecsCredentials` versucht, Anmeldeinformationen über eine `GET`-Anforderung zu laden, deren URI durch die Umgebungsvariable `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` im Container angegeben ist.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
# `env`Anbieter im SDK for PHP
Die Verwendung von Umgebungsvariablen zur Speicherung Ihrer Anmeldeinformationen verhindert, dass Sie versehentlich Ihren AWS geheimen Zugriffsschlüssel weitergeben. Wir empfehlen, dass Sie Ihre AWS Zugangsschlüssel niemals direkt dem Client in Produktionsdateien hinzufügen.
Um sich bei Amazon Web Services zu authentifizieren, sucht das SDK zunächst nach Anmeldeinformationen in Ihren Umgebungsvariablen. Das SDK verwendet die `getenv()`-Funktion, um nach den Umgebungsvariablen `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` und `AWS_SESSION_TOKEN` zu suchen. Diese Anmeldeinformationen werden als Umgebungs-Anmeldeinformationen bezeichnet. Anweisungen zum Abrufen dieser Werte finden Sie unter [Authentifizieren mit kurzfristigen Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/access-temp-idc.html) im *Referenzhandbuch AWS SDKs zu Tools.*
Wenn Sie Ihre Anwendung auf hosten [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_PHP_eb.html), können Sie die `AWS_SESSION_TOKEN` Umgebungsvariablen `AWS_ACCESS_KEY_ID``AWS_SECRET_KEY`, und [über die AWS Elastic Beanstalk Konsole](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-softwaresettings.html#environments-cfg-softwaresettings-console) festlegen, sodass das SDK diese Anmeldeinformationen automatisch verwenden kann.
Weitere Informationen zum Einstellen von Umgebungsvariablen finden Sie unter [Unterstützung von Umgebungsvariablen](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) im Referenzhandbuch *AWS SDKs und im Tools-Referenzhandbuch*. Eine Liste aller Umgebungsvariablen, die von den meisten unterstützt werden AWS SDKs, finden Sie auch unter [Liste der Umgebungsvariablen](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings).
Sie können die Umgebungsvariablen auch in der Befehlszeile festlegen, wie hier gezeigt.
**Linux**
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your AWS-Konto.
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your AWS-Konto.
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your AWS-Konto.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs other than PHP.
```
**Windows**
```
C:\> SET AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your AWS-Konto.
C:\> SET AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your AWS-Konto.
C:\> SET AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your AWS-Konto.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs besides PHP.
```
`Aws\Credentials\CredentialProvider::env` versucht, Anmeldeinformationen aus Umgebungsvariablen zu laden.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => CredentialProvider::env()
]);
```
# `assumeRoleWithWebIdentityCredentialProvider`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::assumeRoleWithWebIdentityCredentialProvider` versucht Anmeldeinformationen durch Übernehmen einer Rolle zu laden. Wenn die Umgebungsvariablen `AWS_ROLE_ARN` und `AWS_WEB_IDENTITY_TOKEN_FILE` vorhanden sind, versucht der Anbieter, die mit `AWS_ROLE_ARN` angegebene Rolle unter Verwendung des Tokens auf dem Datenträger in dem mit `AWS_WEB_IDENTITY_TOKEN_FILE` angegebenen vollständigen Pfad zu übernehmen. Wenn Umgebungsvariablen verwendet werden, versucht der Anbieter, die Sitzung mit der Umgebungsvariablen `AWS_ROLE_SESSION_NAME` einzurichten.
Wenn keine Umgebungsvariablen festgelegt wurden, verwendet der Anbieter das Standardprofil oder das als `AWS_PROFILE` festgelegte Profil. Der Anbieter liest Profile standardmäßig in `~/.aws/credentials` und `~/.aws/config` und kann Profile lesen, die in der Konfigurationsoption `filename` angegeben sind. Der Anbieter übernimmt die in `role_arn` des Profils angegebene Rolle, indem ein Token in dem in `web_identity_token_file` angegebenen vollständigen Pfad gelesen wird. `role_session_name` wird verwendet, wenn dies im Profil festgelegt ist.
Der Anbieter wird als Teil der Standardkette aufgerufen und kann direkt aufgerufen werden.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Standardmäßig erbt dieser Anmeldeinformationsanbieter die konfigurierte Region, die von dem für die Übernahme der StsClient Rolle verwendet wird. Optional kann eine vollständige Datei bereitgestellt StsClient werden. Die Anmeldeinformationen sollten wie `false` bei allen angegebenen angegeben werden StsClient.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
$stsClient = new StsClient([
'region' => 'us-west-2',
'version' => 'latest',
'credentials' => false
])
$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider([
'stsClient' => $stsClient
]);
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# `ini`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::ini`versucht, Anmeldeinformationen aus den geteilten Dateien `config` und `credentials` Dateien zu laden. Standardmäßig versucht das SDK, das „Standard“ -Profil aus der gemeinsam genutzten AWS `credentials` Datei unter zu laden`~/.aws/credentials`. Wenn das SDK die `AWS_SDK_LOAD_NONDEFAULT_CONFIG` Umgebungsvariable findet, sucht es auch nach einem „Standard“ -Profil in der gemeinsam genutzten AWS `config` Datei unter`~/.aws/config`.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::ini();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Sie können ein benutzerdefiniertes Profil oder einen .ini-Dateispeicherort verwenden, indem Sie der Funktion Argumente übergeben, die den Anbieter erstellt.
```
$profile = 'production';
$path = '/full/path/to/credentials.ini';
$provider = CredentialProvider::ini($profile, $path);
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# `process`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::process`versucht, Anmeldeinformationen zu laden, indem ein `credential_process` Wert ausgeführt wird, der in einem Profil in einer [gemeinsam genutzten AWS Konfigurationsdatei](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) angegeben ist.
Standardmäßig versucht das SDK, das „Standard“ -Profil zuerst aus der gemeinsam genutzten AWS `credentials` Datei zu laden, die sich unter befindet`~/.aws/credentials`. Wenn das „Standard“ -Profil in der gemeinsam genutzten `credentials` Datei nicht gefunden wird, sucht das SDK in der gemeinsam genutzten `config` Datei nach dem Standardprofil. Im Folgenden finden Sie ein Beispiel für die Konfiguration der gemeinsam genutzten `credentials` Datei.
```
[default]
credential_process = /path/to/file/credential_returning_executable.sh --custom-command custom_parameter
```
Das SDK ruft den `credential_process` Befehl genau so auf, wie er mithilfe der `shell_exec` PHP-Funktion angegeben wurde, und liest dann JSON-Daten aus stdout. Sie `credential_process` müssen Anmeldeinformationen im folgenden Format auf stdout schreiben:
```
{
"Version": 1,
"AccessKeyId": "",
"SecretAccessKey": "",
"SessionToken": "",
"Expiration": ""
}
```
`SessionToken` und `Expiration` sind optional. Falls vorhanden, werden die Anmeldeinformationen als temporär behandelt.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::process();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Sie können ein benutzerdefiniertes Profil oder einen .ini-Dateispeicherort verwenden, indem Sie der Funktion Argumente übergeben, die den Anbieter erstellt.
```
$profile = 'production';
$path = '/full/path/to/credentials.ini';
$provider = CredentialProvider::process($profile, $path);
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# `instanceProfile`Anbieter im SDK for PHP
`Aws\Credentials\CredentialProvider::instanceProfile`versucht, Anmeldeinformationen für eine IAM-Rolle zu laden, die in einem Amazon EC2 EC2-Instance-Profil angegeben ist.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::instanceProfile();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
Standardmäßig versucht der Anbieter bis zu drei Mal, die Anmeldeinformationen abzurufen. Die Anzahl der Wiederholungen kann mit der `retries` Option festgelegt und vollständig deaktiviert werden, indem die Option auf gesetzt wird, `0` wie im folgenden Code gezeigt.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile([
'retries' => 0
]);
$memoizedProvider = CredentialProvider::memoize($provider);
```
Wenn die Umgebungsvariable verfügbar `AWS_METADATA_SERVICE_NUM_ATTEMPTS` ist, hat ihr Wert Vorrang vor der zuvor gezeigten Option „Wiederholungen“.
**Anmerkung**
Sie können diesen Versuch, aus Amazon EC2 EC2-Instance-Profilen zu laden, deaktivieren, indem Sie die `AWS_EC2_METADATA_DISABLED` Umgebungsvariable auf `true` setzen.
# Verkettung von Anmeldeinformationsanbietern im SDK for PHP
Sie können Anmeldeinformationsanbieter mit der Funktion `Aws\Credentials\CredentialProvider::chain()` verketten. Diese Funktion akzeptiert eine variable Anzahl von Argumenten, wobei es sich jeweils um Anmeldeinformationsanbieter-Funktionen handelt. Diese Funktion gibt dann eine neue Funktion zurück, die eine Zusammensetzung der bereitgestellten Funktionen ist, sodass sie nacheinander aufgerufen werden, bis einer der Anbieter ein Promise zurückgibt, das erfolgreich erfüllt wurde.
Der `defaultProvider` verwendet diese Zusammenstellung, um mehrere Anbieter zu überprüfen, bevor ein Fehler zurückgegeben wird. Die Quelle des `defaultProvider` demonstriert die Nutzung der `chain`-Funktion.
```
// This function returns a provider
public static function defaultProvider(array $config = [])
{
// This function is the provider, which is actually the composition
// of multiple providers. Notice that we are also memoizing the result by
// default.
return self::memoize(
self::chain(
self::env(),
self::ini(),
self::instanceProfile($config)
)
);
}
```
# Erstellen eines benutzerdefinierten Anmeldeinformationsanbieters zur Verwendung mit dem SDK for PHP
Anmeldeinformationsanbieter sind einfach Funktionen, die beim Aufrufen ein Promise (`GuzzleHttp\Promise\PromiseInterface`) zurückgeben, das mit einem `Aws\Credentials\CredentialsInterface`-Objekt erfüllt oder mit einer `Aws\Exception\CredentialsException` abgelehnt wird.
Eine gute Vorgehensweise zum Erstellen von Anbietern ist es, eine Funktion zu erstellen, die aufgerufen wird, um den eigentlichen Anmeldeinformationsanbieter zu erstellen. Als Beispiel finden Sie hier die Quelle des `env`-Anbieters (für Beispielzwecke leicht abgeändert). Beachten Sie, dass es sich um eine Funktion handelt, die die eigentliche Anbieter-Funktion zurückgibt. Auf diese Weise können Sie problemlos die Anmeldeinformationsanbieter erstellen und sie als Werte übergeben.
```
use GuzzleHttp\Promise;
use GuzzleHttp\Promise\RejectedPromise;
// This function CREATES a credential provider
public static function env()
{
// This function IS the credential provider
return function () {
// Use credentials from environment variables, if available
$key = getenv(self::ENV_KEY);
$secret = getenv(self::ENV_SECRET);
if ($key && $secret) {
return Create::promise_for(
new Credentials($key, $secret, getenv(self::ENV_SESSION))
);
}
$msg = 'Could not find environment variable '
. 'credentials in ' . self::ENV_KEY . '/' . self::ENV_SECRET;
return new RejectedPromise(new CredentialsException($msg));
};
}
```
# Speichern von Anmeldeinformationen im SDK for PHP
Manchmal ist es notwendig, einen Anmeldeinformationsanbieter zu erstellen, der sich den vorherigen Rückgabewert merkt. Dies kann für die Performance nützlich sein, wenn das Laden von Anmeldeinformationen eine teure Operation ist oder wenn die Klasse`Aws\Sdk` verwendet wird, um einen Anmeldeinformationsanbieter für mehrere Clients freizugeben. Sie können einem Anmeldeinformationsanbieter das Speichern hinzufügen, indem Sie die Anmeldeinformationsanbieter-Funktion in eine `memoize`-Funktion verpacken.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile();
// Wrap the actual provider in a memoize function
$provider = CredentialProvider::memoize($provider);
// Pass the provider into the Sdk class and share the provider
// across multiple clients. Each time a new client is constructed,
// it will use the previously returned credentials as long as
// they haven't yet expired.
$sdk = new Aws\Sdk(['credentials' => $provider]);
$s3 = $sdk->getS3(['region' => 'us-west-2', 'version' => 'latest']);
$ec2 = $sdk->getEc2(['region' => 'us-west-2', 'version' => 'latest']);
assert($s3->getCredentials() === $ec2->getCredentials());
```
Wenn die gespeicherten Anmeldeinformationen abgelaufen sind, ruft der Memorize-Wrapper den verpackten Anbieter auf, um die Anmeldeinformationen zu aktualisieren.
# Gehen Sie mit AWS SDK für PHP Version 3 von einer IAM-Rolle aus
## Verwenden von IAM-Rollen für Amazon EC2 EC2-Instance-Variablenanmeldedaten
Wenn Sie Ihre Anwendung auf einer Amazon EC2 EC2-Instance ausführen, AWS ist die bevorzugte Methode zur Bereitstellung von Anmeldeinformationen für Aufrufe die Verwendung einer [IAM-Rolle](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html), um temporäre Sicherheitsanmeldeinformationen abzurufen.
Wenn Sie IAM-Rollen verwenden, müssen Sie sich keine Gedanken über die Verwaltung der Anmeldeinformationen in Ihrer Anwendung machen. Sie ermöglichen es einer Instance, eine Rolle zu „übernehmen“, indem sie temporäre Anmeldeinformationen vom Metadatenserver der Amazon EC2 EC2-Instance abruft.
Die temporären Anmeldeinformationen, die oft als **Anmeldeinformationen für das Instance-Profil** bezeichnet werden, ermöglichen den Zugriff auf die Aktionen und Ressourcen, die die Rollenrichtlinie zulässt. Amazon EC2 übernimmt die gesamte Arbeit der sicheren Authentifizierung von Instances gegenüber dem IAM-Service, um die Rolle zu übernehmen, und der regelmäßigen Aktualisierung der abgerufenen Rollenanmeldedaten. Damit bleibt Ihre Anwendung sicher, ohne dass Sie selbst etwas tun müssen. Eine Liste der Dienste, die temporäre Sicherheitsnachweise akzeptieren, finden Sie unter [AWS Dienste, die mit IAM arbeiten](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) im *IAM-Benutzerhandbuch*.
**Anmerkung**
Um zu vermeiden, dass jedes Mal der Metadatenservice benötigt wird, kann eine Instance von `Aws\CacheInterface` als `'credentials'`-Option an einen Client-Konstruktor übergeben werden. Auf diese Weise kann das SDK stattdessen im Cache gespeicherte Instance-Profil-Anmeldeinformationen verwenden. Einzelheiten finden Sie unter [Konfiguration für Version 3. AWS SDK für PHP](guide_configuration.md)
Weitere Informationen zur Entwicklung von Amazon EC2 EC2-Anwendungen mithilfe von finden Sie unter Verwenden von [IAM-Rollen für Amazon EC2 EC2-Instances](https://docs.aws.amazon.com/sdkref/latest/guide/access-iam-roles-for-ec2.html) im Referenzhandbuch *AWS SDKs und im Tools-Referenzhandbuch*. SDKs
### Eine IAM-Rolle erstellen und einer Amazon EC2 EC2-Instance zuweisen
1. Erstellen Sie einen IAM-Client.
**Importe**
```
require 'vendor/autoload.php';
use Aws\Iam\IamClient;
```
**Beispiel-Code**
```
$client = new IamClient([
'region' => 'us-west-2',
'version' => '2010-05-08'
]);
```
1. Erstellen Sie eine IAM-Rolle mit den Berechtigungen für die Aktionen und Ressourcen, die Sie verwenden werden.
**Beispiel-Code**
```
$result = $client->createRole([
'AssumeRolePolicyDocument' => 'IAM JSON Policy', // REQUIRED
'Description' => 'Description of Role',
'RoleName' => 'RoleName', // REQUIRED
]);
```
1. Erstellen Sie ein IAM-Instance-Profil und speichern Sie den Amazon-Ressourcennamen (ARN) aus dem Ergebnis.
**Anmerkung**
Wenn Sie die IAM-Konsole anstelle von verwenden AWS SDK für PHP, erstellt die Konsole automatisch ein Instance-Profil und weist diesem denselben Namen zu wie der Rolle, der es entspricht.
**Beispiel-Code**
```
$IPN = 'InstanceProfileName';
$result = $client->createInstanceProfile([
'InstanceProfileName' => $IPN ,
]);
$ARN = $result['Arn'];
$InstanceID = $result['InstanceProfileId'];
```
1. Erstellen Sie einen Amazon EC2 EC2-Client.
**Importe**
```
require 'vendor/autoload.php';
use Aws\Ec2\Ec2Client;
```
**Beispiel-Code**
```
$ec2Client = new Ec2Client([
'region' => 'us-west-2',
'version' => '2016-11-15',
]);
```
1. Fügen Sie das Instance-Profil zu einer laufenden oder angehaltenen Amazon EC2 EC2-Instance hinzu. Verwenden Sie den Instance-Profilnamen Ihrer IAM-Rolle.
**Beispiel-Code**
```
$result = $ec2Client->associateIamInstanceProfile([
'IamInstanceProfile' => [
'Arn' => $ARN,
'Name' => $IPN,
],
'InstanceId' => $InstanceID
]);
```
Weitere Informationen finden Sie unter [IAM-Rollen für Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) im *Amazon EC2 Benutzerhandbuch*.
## Verwenden von IAM-Rollen für Amazon ECS-Aufgaben
Eine Aufgabe in Amazon Elastic Container Service (Amazon ECS) kann eine IAM-Rolle übernehmen, um AWS API-Aufrufe zu tätigen. Dies ist eine Strategie zur Verwaltung der Anmeldeinformationen, die Ihre Anwendungen verwenden sollen, ähnlich wie Amazon EC2 EC2-Instance-Profile Anmeldeinformationen für Amazon EC2 EC2-Instances bereitstellen.
Anstatt langfristige AWS Anmeldeinformationen zu erstellen und an Container zu verteilen oder die Rolle der Amazon EC2 EC2-Instance zu verwenden, können Sie eine IAM-Rolle, die temporäre Anmeldeinformationen verwendet, mit einer ECS-Aufgabendefinition oder einem `RunTask` [API-Vorgang](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-ecs-2014-11-13.html#runtask) verknüpfen.
Weitere Informationen zur Verwendung von IAM-Rollen, die Container-Tasks annehmen können, finden Sie im Thema [Task-IAM-Rolle](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) im *Amazon ECS Developer Guide*. Beispiele für die Verwendung der Task-IAM-Rolle in Form einer `taskRoleArn` in Aufgabendefinitionen finden Sie unter [Beispielaufgabendefinitionen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-example-taskdefs.html) ebenfalls im *Amazon ECS Developer Guide*.
## Übernahme einer IAM-Rolle in einer anderen AWS-Konto
Wenn Sie in einem AWS-Konto (Konto A) arbeiten und eine Rolle in einem anderen Konto (Konto B) übernehmen möchten, müssen Sie zunächst eine IAM-Rolle in Konto B erstellen. Diese Rolle ermöglicht es Entitäten in Ihrem Konto (Konto A), bestimmte Aktionen in Konto B durchzuführen. Weitere Informationen zum kontoübergreifenden Zugriff finden Sie unter [Tutorial: Kontoübergreifendes Delegieren des Zugriffs mithilfe von IAM-Rollen AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html).
Notieren Sie sich nach dem Erstellen der Rolle in Konto B den ARN. Sie verwenden diesen ARN, wenn Sie die Rolle von Konto A übernehmen. Sie übernehmen die Rolle mit den AWS Anmeldeinformationen, die Ihrer Entität in Konto A zugeordnet sind.
Erstellen Sie einen AWS STS Client mit Anmeldeinformationen für Ihren AWS-Konto. Im Folgenden wird hierzu ein Anmeldeinformationsprofil verwendet, aber Sie können eine beliebige Methode nutzen. Rufen Sie mit dem neu erstellten AWS STS -Client assume-role auf und legen Sie einen benutzerdefinierten sessionName fest. Rufen Sie die neuen temporären Anmeldeinformationen aus dem Ergebnis ab. Die Anmeldeinformationen dauern standardmäßig eine Stunde.
**Beispiel-Code**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$result = $stsClient->AssumeRole([
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Weitere Informationen finden Sie unter [Verwenden von IAM-Rollen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) oder [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)in der AWS SDK für PHP API-Referenz.
## Verwenden einer IAM-Rolle mit Webidentität
Web Identity Federation ermöglicht es Kunden, beim Zugriff auf AWS Ressourcen externe Identitätsanbieter für die Authentifizierung zu verwenden. Bevor Sie eine Rolle mit Web-Identität übenehmen können, müssen Sie zunächst eine IAM-Rolle erstellen und einen Web-Identitätsanbieter (Identity provider, IdP) konfigurieren. Weitere Informationen finden Sie unter [Erstellen von Rollen für Web-Identität oder OpenID Connect-Verbund (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html).
Nachdem Sie [einen Identitätsanbieter](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) und [eine Rolle für Ihre Web-Identität erstellt](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html) haben, verwenden Sie einen AWS STS Client, um einen Benutzer zu authentifizieren. Geben Sie das webIdentityToken und ProviderId für Ihre Identität und den Rollen-ARN für die IAM-Rolle mit Berechtigungen für den Benutzer an.
**Beispiel-Code**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$duration = 3600;
$result = $stsClient->AssumeRoleWithWebIdentity([
'WebIdentityToken' => "FACEBOOK_ACCESS_TOKEN",
'ProviderId' => "graph.facebook.com",
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Weitere Informationen finden Sie unter [AssumeRoleWithWebIdentity—Verbund über einen webbasierten Identitätsanbieter](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity.html) oder [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerolewithwebidentity)in der AWS SDK für PHP API-Referenz.
## Nehmen Sie die Rolle mit dem Profil an
### Definieren Sie Profile in `~/.aws/credentials`
Sie können die so konfigurieren AWS SDK für PHP , dass sie eine IAM-Rolle verwendet, indem Sie ein Profil in `~/.aws/credentials` definieren.
Erstellen Sie ein neues Profil mit der `role_arn` Einstellung für die Rolle, die Sie übernehmen möchten. Fügen Sie auch die `source_profile` Einstellung für ein anderes Profil mit Anmeldeinformationen hinzu, die berechtigt sind, die IAM-Rolle anzunehmen. Weitere Informationen zu diesen Konfigurationseinstellungen finden Sie unter [Rollenanmeldedaten annehmen](https://docs.aws.amazon.com/sdkref/latest/guide/feature-assume-role-credentials.html) im Referenzhandbuch *AWS SDKs und im Tools-Referenzhandbuch.*
Im Folgenden legt das Profil `~/.aws/credentials` beispielsweise das `project1` Profil fest `role_arn` und gibt das `default` Profil als Quelle für Anmeldeinformationen an, um zu überprüfen, ob die mit ihnen verknüpfte Entität die Rolle übernehmen kann.
```
[project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Wenn Sie die `AWS_PROFILE` Umgebungsvariable festlegen oder bei der Instanziierung eines Dienstclients `profile` Parameter verwenden, wird die in angegebene Rolle übernommen, wobei das `default` Profil als Quellanmeldeinformationen verwendet `project1` wird.
Der folgende Ausschnitt zeigt die Verwendung des `profile` Parameters in einem Konstruktor. `S3Client` `S3Client`Sie werden über die Berechtigungen verfügen, die der Rolle zugeordnet sind, die dem Profil zugeordnet ist. `project1`
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
### Definieren Sie Profile in `~/.aws/config`
Die `~/.aws/config` Datei kann auch Profile enthalten, von denen Sie annehmen möchten. Wenn Sie die Umgebungsvariable setzen`AWS_SDK_LOAD_NONDEFAULT_CONFIG`, lädt das SDK for PHP Profile aus der `config` Datei. Wenn `AWS_SDK_LOAD_NONDEFAULT_CONFIG` diese Option gesetzt ist, lädt das SDK Profile `~/.aws/config` sowohl aus als auch`~/.aws/credentials`. Profile von `~/.aws/credentials` werden zuletzt geladen und haben Vorrang vor Profilen von `~/.aws/config` mit demselben Namen. Profile aus beiden Speicherorten können als `source_profile` oder als das zu übernehmende Profil dienen.
Im folgenden Beispiel werden das in der `config` Datei definierte `project1` Profil und das `default` Profil in der `credentials` Datei verwendet. Das `AWS_SDK_LOAD_NONDEFAULT_CONFIG` ist ebenfalls festgelegt.
```
# Profile in ~/.aws/config.
[profile project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
```
```
# Profile in ~/.aws/credentials.
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Wenn der `S3Client` Konstruktor ausgeführt wird, der im folgenden Codeausschnitt gezeigt wird, wird die im Profil definierte Rolle anhand der mit dem `project1` Profil verknüpften Anmeldeinformationen übernommen. `default`
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
# Verwenden Sie temporäre Anmeldeinformationen aus AWS STS dem SDK for PHP
AWS -Security-Token-Service (AWS STS) ermöglicht es Ihnen, eingeschränkte Rechte und **temporäre Anmeldeinformationen** für IAM-Benutzer oder für Benutzer, die Sie über einen Identitätsverbund authentifizieren, anzufordern. Weitere Informationen finden Sie unter [Temporäre Sicherheitsanmeldedaten](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) im *IAM-Benutzerhandbuch*. Für den Zugriff auf die meisten AWS Dienste können Sie temporäre Sicherheitsanmeldedaten verwenden. Eine Liste der Dienste, die temporäre Sicherheitsnachweise akzeptieren, finden Sie unter [AWS Dienste, die mit IAM arbeiten](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) im *IAM-Benutzerhandbuch*.
Ein häufiger Anwendungsfall für temporäre Anmeldeinformationen besteht darin, mobilen oder clientseitigen Anwendungen Zugriff auf AWS Ressourcen zu gewähren, indem Benutzer über externe Identitätsanbieter authentifiziert werden (siehe [Web Identity](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html) Federation).
## Abrufen temporärer Anmeldeinformationen
AWS STS hat mehrere Operationen, die temporäre Anmeldeinformationen zurückgeben, aber der `GetSessionToken` Vorgang ist am einfachsten zu demonstrieren. Das folgende Snippet ruft temporäre Anmeldeinformationen ab, indem es die `getSessionToken` Methode des STS-Clients des PHP-SDK aufruft.
```
$sdk = new Aws\Sdk([
'region' => 'us-east-1',
]);
$stsClient = $sdk->createSts();
$result = $stsClient->getSessionToken();
```
Das Ergebnis für `GetSessionToken` und die anderen AWS STS Operationen enthält immer einen Wert. `'Credentials'` Wenn Sie das drucken `$result` (zum Beispiel mit`print_r($result)`), sieht es wie folgt aus.
```
Array
(
...
[Credentials] => Array
(
[SessionToken] => ''
[SecretAccessKey] => ''
[Expiration] => 2013-11-01T01:57:52Z
[AccessKeyId] => ''
)
...
)
```
## Bereitstellung temporärer Anmeldeinformationen für AWS SDK für PHP
Sie können temporäre Anmeldeinformationen mit einem anderen AWS Client verwenden, indem Sie den Client instanziieren und die von AWS STS diesem empfangenen Werte direkt übergeben.
```
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Sie können auch ein `Aws\Credentials\Credentials`-Objekt konstruieren und es bei der Instanziierung des Clients verwenden.
```
use Aws\Credentials\Credentials;
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$credentials = new Credentials(
$result['Credentials']['AccessKeyId'],
$result['Credentials']['SecretAccessKey'],
$result['Credentials']['SessionToken']
);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Allerdings ist die *beste* Möglichkeit, temporäre Anmeldeinformationen bereitzustellen, die Verwendung der `createCredentials()` Hilfsmethode aus dem `StsClient`. Diese Methode extrahiert die Daten aus einem AWS STS Ergebnis und erstellt das `Credentials` Objekt für Sie.
```
$result = $stsClient->getSessionToken();
$credentials = $stsClient->createCredentials($result);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Weitere Informationen darüber, warum Sie möglicherweise temporäre Anmeldeinformationen in Ihrer Anwendung oder Ihrem Projekt verwenden müssen, finden Sie in der AWS STS Dokumentation unter [Szenarien für die Gewährung temporären Zugriffs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html).
# Anonyme Clients im SDK for PHP erstellen
In einigen Fällen möchten Sie möglicherweise einen Client erstellen, der nicht mit Anmeldeinformationen verknüpft ist. Auf diese Weise können Sie anonymen Anforderungen an einen Service stellen.
Sie können beispielsweise sowohl Amazon S3-Objekte als auch CloudSearch Amazon-Domains so konfigurieren, dass anonymer Zugriff möglich ist.
Um einen anonymen Client zu erstellen, setzen Sie die `'credentials'`-Option auf `false`.
```
$s3Client = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'credentials' => false
]);
// Makes an anonymous request. The object would need to be publicly
// readable for this to succeed.
$result = $s3Client->getObject([
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'my-key',
]);
```