Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Usa un fornitore di credenziali

Un provider di credenziali è una funzione che restituisce un valore GuzzleHttp\Promise\PromiseInterface che viene soddisfatto con un'istanza Aws\Credentials\CredentialsInterface o rifiutato con un valore Aws\Exception\CredentialsException. Puoi utilizzare i provider di credenziali per implementare una tua logica personalizzata volta a creare credenziali o a ottimizzarne il caricamento.

I provider di credenziali vengono indicati nell'opzione di costruzione del client credentials. I provider di credenziali sono asincroni, il che li costringe a essere valutati in modo pigro a ogni chiamata di un'operazione API. Per questo motivo, trasferire una funzione di un provider di credenziali a un costruttore di client SDK non comporta l'immediata convalida delle credenziali. Se il provider di credenziali non restituisce un oggetto credenziali, l'operazione API sarà respinta con un valore Aws\Exception\CredentialsException.

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

Provider integrati nell'SDK

L'SDK fornisce diversi provider predefiniti che possono essere combinati con qualsiasi provider personalizzato. Per ulteriori informazioni sulla configurazione dei provider standardizzati e della catena di fornitori di credenziali negli AWS SDK, consulta Fornitori di credenziali standardizzati nella Guida di riferimento agli SDK e agli AWS strumenti.

Provider assumeRole

Se utilizzi Aws\Credentials\AssumeRoleCredentialProvider per creare le credenziali tramite l'assunzione di un ruolo, devi trasmettere l'informazione 'client' con un oggetto StsClient e dettagli 'assume_role_params', come illustrato.

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

Per ulteriori informazioni in merito, vedere. 'assume_role_params' AssumeRole

Provider SSO

Aws\Credentials\CredentialProvider::ssoè il fornitore di credenziali Single Sign-On. Questo provider è noto anche come fornitore di credenziali. AWS IAM Identity Center

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

Se utilizzi un profilo denominato, sostituisci il nome del tuo profilo con 'default' nell'esempio precedente. Per ulteriori informazioni sulla configurazione di profili denominati, consulta Condivisi config e credentials file nella Guida di riferimento agli AWS SDK e agli strumenti. In alternativa, puoi utilizzare la variabile di AWS_PROFILEambiente per specificare le impostazioni del profilo da utilizzare.

Per saperne di più su come funziona il provider IAM Identity Center, consulta Understand IAM Identity Center Authentication nella Guida di riferimento agli AWS SDK and Tools.

Fornitori di concatenamento

I provider di credenziali possono essere concatenati utilizzando la funzione Aws\Credentials\CredentialProvider::chain(), che accetta un numero di argomenti variadic, ciascuno dei quali è una funzione del provider di credenziali. La funzione restituisce quindi una nuova funzione che è la composizione delle funzioni fornite, in modo tale che vengano richiamate una dopo l'altra finché uno dei provider non restituisce una promessa che viene soddisfatta correttamente.

Il defaultProvider utilizza questa composizione per verificare la presenza di più provider prima di generare errori. Nell'origine del defaultProvider è illustrato l'uso della funzione chain.

// 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)
        )
    );
}

Creazione di un provider personalizzato

I provider di credenziali sono semplicemente funzioni che, se richiamate, restituiscono una promessa (GuzzleHttp\Promise\PromiseInterface) che viene soddisfatta con un oggetto Aws\Credentials\CredentialsInterface o rifiutata con un'eccezione Aws\Exception\CredentialsException.

Una delle best practice per la creazione di provider prevede la creazione di una funzione che viene richiamata per creare il provider di credenziali vero e proprio. Ad esempio ecco l'origine del provider env (leggermente modificata a scopo esemplificativo). Ricorda che si tratta di una funzione che restituisce la funzione di provider vera e propria. In questo modo puoi comporre facilmente i provider di credenziali e passarli come valori.

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

Provider defaultProvider

Aws\Credentials\CredentialProvider::defaultProvider è il provider di credenziali di default, che viene utilizzato in caso di omissione dell'opzione credentials durante la creazione di un client. Il provider tenta prima di caricare le credenziali dalle variabili di ambiente, quindi da un file .ini (prima da un file .aws/credentials e poi da un file .aws/config) e infine da un profilo dell'istanza (prima da EcsCredentials e poi dai metadati Ec2).

Provider ecsCredentials

Aws\Credentials\CredentialProvider::ecsCredentials tenta di caricare le credenziali tramite una richiesta GET, il cui URI è specificato dalla variabile di ambiente AWS_CONTAINER_CREDENTIALS_RELATIVE_URI nel container.

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

Provider env

Aws\Credentials\CredentialProvider::env tenta di caricare le credenziali dalle variabili di ambiente.

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

$client = new S3Client([
    'region'      => 'us-west-2',
    'version'     => '2006-03-01',
    'credentials' => CredentialProvider::env()
]);

assumeRoleWithWebIdentityCredentialProvider fornitore

Aws\Credentials\CredentialProvider::assumeRoleWithWebIdentityCredentialProvider tenta di caricare le credenziali tramite l'assunzione di un ruolo. Se le variabili di ambiente AWS_ROLE_ARN e AWS_WEB_IDENTITY_TOKEN_FILE sono presenti, il provider cercherà di assumere il ruolo specificato in AWS_ROLE_ARN utilizzando il token su disco nel percorso completo specificato in AWS_WEB_IDENTITY_TOKEN_FILE. Se vengono utilizzate variabili di ambiente, il provider cercherà di impostare la sessione dalla variabile di ambiente AWS_ROLE_SESSION_NAME.

Se le variabili di ambiente non sono impostate, il provider utilizzerà il profilo predefinito oppure quello impostato come AWS_PROFILE. Il provider legge i profili da ~/.aws/credentials e ~/.aws/config per impostazione predefinita e può leggere i profili specificati nell'opzione di configurazione filename. Il provider assume il ruolo specificato in role_arn del profilo, leggendo un token dal percorso completo impostato in web_identity_token_file. role_session_name verrà utilizzato se impostato nel profilo.

Il provider viene chiamato come parte della catena predefinita e può essere chiamato direttamente.

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

Per impostazione predefinita, questo provider di credenziali erediterà la regione configurata che verrà utilizzata da StsClient per assumere il ruolo. Facoltativamente, StsClient può essere fornito un file completo. Le credenziali devono essere impostate come false su quelle fornite. 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
]);

Provider ini

Aws\Credentials\CredentialProvider::ini tenta di caricare le credenziali da un file di credenziali ini. Per impostazione predefinita, l'SDK tenta di caricare il profilo «predefinito» dal AWS credentials file condiviso che si trova in. ~/.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
]);

Puoi utilizzare un profilo o un percorso del file .ini personalizzato fornendo argomenti alla funzione che crea il provider.

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

provider di processo

Aws\Credentials\CredentialProvider::process tenta di caricare le credenziali da un credential_process specificato in un file delle credenziali ini. Per impostazione predefinita, l'SDK tenta di caricare il profilo «predefinito» dal AWS credentials file condiviso che si trova in. ~/.aws/credentials L'SDK chiama il comando credential_process esattamente come specificato e quindi legge i dati JSON da stdout. Il comando credential_process deve scrivere le credenziali in stdout nel formato seguente:

{
    "Version": 1,
    "AccessKeyId": "",
    "SecretAccessKey": "",
    "SessionToken": "",
    "Expiration": ""
}

SessionToken e Expiration sono facoltativi. Se presenti, le credenziali verranno considerate come temporanee.

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

Puoi utilizzare un profilo o un percorso del file .ini personalizzato fornendo argomenti alla funzione che crea il provider.

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

Provider instanceProfile

Aws\Credentials\CredentialProvider::instanceProfiletenta di caricare le credenziali dai profili delle istanze di Amazon EC2.

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

Per impostazione predefinita, il provider effettua un nuovo tentativo di recupero delle credenziali per un massimo di tre volte. Il numero di tentativi può essere impostato con l'opzione retries e disabilitato completamente impostando l'opzione su 0.

use Aws\Credentials\CredentialProvider;

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

Memorizzazione delle credenziali

Talvolta è necessario creare un provider di credenziali in grado di ricordare il valore restituito in precedenza. Può essere utile per migliorare le prestazioni quando il caricamento di credenziali è un'operazione impegnativa o quando si usa la classe Aws\Sdk per condividere un provider di credenziali su più client. Puoi aggiungere la memorizzazione a un provider di credenziali eseguendo il wrapping della relativa funzione in una funzione memoize.

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

Quando le credenziali sottoposte a memorizzazione scadono, il wrapper della funzione memoize richiama il provider nel wrapping nel tentativo di aggiornare le credenziali.