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 eines Anmeldeinformationsanbieters

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. Sie können Anmeldeinformationsanbieter verwenden, um Ihre eigene benutzerdefinierte Logik für das Erstellen von Anmeldeinformationen zu implementieren, oder zum Optimieren der Ladezeit von Anmeldeinformationen.

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 default credential provider
$provider = CredentialProvider::defaultProvider();

// Pass the provider to the client
$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => $provider
]);

Integrierte Anbieter im SDK

Das SDK bietet mehrere integrierte Anbieter, die mit beliebigen benutzerdefinierten Anbietern kombiniert werden können. Weitere Informationen zur Konfiguration der standardisierten Anbieter und der Anbieterkette für Anmeldeinformationen in - AWS SDKs finden Sie unter Standardisierte Anbieter von Anmeldeinformationen im AWS Referenzhandbuch für -SDKs und Tools.

assumeRole provider

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.

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 zu finden Sie 'assume_role_params'unter AssumeRole.

SSO-Anbieter

Aws\Credentials\CredentialProvider::sso ist der Anbieter von Single-Sign-On-Anmeldeinformationen. Dieser Anbieter wird auch als Anbieter von AWS IAM Identity Center Anmeldeinformationen bezeichnet.

use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;

$credentials = new Aws\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 den Namen Ihres Profils durch „default“ im vorherigen Beispiel. Weitere Informationen zum Einrichten benannter Profile finden Sie unter Freigegebene - config und -credentialsDateien im Referenzhandbuch für -SDKs und Tools. AWS SDKs Alternativ können Sie die AWS_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 im AWS Referenzhandbuch zu -SDKs und Tools.

Verkettungsanbieter

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 Anbieters

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 Promise\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));
    };
}

defaultProvider provider

Aws\Credentials\CredentialProvider::defaultProvider ist der standardmäßige Anmeldeinformationsanbieter. Dieser Anbieter wird verwendet, wenn Sie bei der Erstellung eines Clients die credentials-Option nicht angeben. Er versucht zuerst, Anmeldeinformationen aus Umgebungsvariablen zu laden, dann aus einer .ini-Datei (zuerst aus der Datei .aws/credentials, dann aus der Datei .aws/config) und dann von einem Instance-Profil (zuerst aus EcsCredentials-, dann aus Ec2-Metadaten).

ecsCredentials provider

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 provider

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

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 Anbieter von Anmeldeinformationen die konfigurierte Region, die vom verwendet wird, StsClient um die Rolle zu übernehmen. Optional StsClient kann ein vollständiger bereitgestellt werden. Anmeldeinformationen sollten false für alle bereitgestellten als festgelegt 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 provider

Aws\Credentials\CredentialProvider::ini versucht, Anmeldeinformationen aus einer ini-Anmeldeinformationsdatei zu laden. Standardmäßig versucht das SDK, das „Standard“-Profil aus der AWS credentials freigegebenen Datei unter zu laden~/.aws/credentials.

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
]);

Prozessanbieter

Aws\Credentials\CredentialProvider::process versucht, Anmeldeinformationen aus einem credential_process zu laden, der in einer ini-Anmeldeinformationsdatei angegeben ist. Standardmäßig versucht das SDK, das „Standard“-Profil aus der AWS credentials freigegebenen Datei unter zu laden~/.aws/credentials. Das SDK ruft den Befehl „credential_process“ genau wie vorgegeben auf und liest dann JSON-Daten aus stdout. Der credential_process muss Anmeldeinformationen im folgenden Format in 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 provider

Aws\Credentials\CredentialProvider::instanceProfile versucht, Anmeldeinformationen aus Amazon EC2-Instance-Profilen zu laden.

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 Wiederholungsversuche kann mit der Option retries festgelegt werden. Wird der Option 0 zugewiesen, erfolgen keine Abrufversuche.

use Aws\Credentials\CredentialProvider;

$provider = CredentialProvider::instanceProfile([
    'retries' => 0
]);
$memoizedProvider = CredentialProvider::memoize($provider);

Identifizierung von Anmeldeinformationen

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 KlasseAws\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.