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à.
# Utilizzo dei provider di credenziali della AWS SDK per PHP versione 3
Per informazioni di riferimento sui meccanismi di credenziali disponibili per AWS SDKs, vedere [Credenziali e accesso](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) nella Guida di riferimento agli *strumenti AWS SDKs e agli strumenti*.
**Importante**
Per motivi di sicurezza, si *consiglia vivamente* di **non** utilizzare l'account root per AWS l'accesso. Fai sempre riferimento alle [best practice di sicurezza di IAM nella IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) *User Guide* per le raccomandazioni di sicurezza più recenti.
Il ruolo di un fornitore di credenziali nella AWS SDK per PHP versione 3 è quello di reperire e fornire credenziali ai client dell'SDK. Servizio AWS L'SDK utilizza le credenziali che fornisce per autenticarsi con il servizio firmando crittograficamente ogni richiesta. Le credenziali di solito sono costituite da chiavi di accesso: un ID della chiave di accesso e una chiave di accesso segreta insieme.
Quando utilizzi credenziali temporanee, ad esempio quando [configuri l'autenticazione IAM Identity Center](credentials.md#use-idc-for-auth) o configuri il runtime per [assumere un ruolo IAM, viene aggiunto un](assumerole-provider.md) token di sessione alle chiavi di accesso, che fornisce un accesso limitato nel tempo alle risorse. AWS
## Cos'è un provider di credenziali nella versione 3? AWS SDK per PHP
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`. L'[SDK fornisce diverse implementazioni](built-in-providers-in-the-sdk.md) delle funzioni del fornitore di credenziali oppure è possibile [implementare una logica personalizzata per la](creating-a-custom-provider.md) creazione di credenziali o per ottimizzare il caricamento delle credenziali.
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 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
]);
```
# Comprensione della catena di provider di credenziali predefinita nella AWS SDK per PHP versione 3
La catena di provider di credenziali predefinita è composta da una serie di provider di credenziali integrati richiamati dall'SDK. È implementato dalla funzione del [fornitore di credenziali DefaultProvider](defaultprovider-provider.md) senza parametri. Dopo aver trovato credenziali valide, la ricerca viene interrotta.
AWS SDK per PHP Esegue i fornitori di credenziali nel seguente ordine:
+ [**`env`provider**](env-provider.md): l'SDK cerca le [chiavi di AWS accesso che sono state impostate](https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html) come variabili di ambiente.
+ [**`assumeRoleWithWebIdentityCredentialProvider`provider**](assume-role-with-web-identity-provider.md): l'SDK cerca le impostazioni dei file del ruolo IAM e del token di identità web.
+ A questo punto della catena, l'SDK cerca la configurazione nei file condivisi AWS `config` e nei file. `credentials` L'SDK cerca la configurazione nel profilo «predefinito», ma se la variabile di `AWS_PROFILE` ambiente è impostata, l'SDK utilizza il valore del profilo denominato.
+ [**`sso`provider**](sso-provider.md): l'SDK cerca le [impostazioni di configurazione di IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) nel file condiviso. `config`
+ [**`login provider`**](login-provider.md)- L'SDK cerca le impostazioni di configurazione della sessione di accesso alla AWS console nel file condiviso`config`.
+ [**`process`provider**](process-provider.md): l'SDK cerca l'`credential_process`impostazione nel file condiviso`credentials`.
+ [**`ini`provider**](ini-provider.md): l'SDK cerca AWS le credenziali o le informazioni sul ruolo IAM nel file condiviso. `credentials`
+ [**`process`provider**](process-provider.md): l'SDK cerca l'`credential_process`impostazione nel file condiviso. `config`
+ [**`ini`provider**](ini-provider.md): l'SDK cerca AWS le credenziali o le informazioni sul ruolo IAM nel file condiviso. `config`
+ [**`ecsCredentials`provider**](ecscredentials-provider.md) - L'SDK cerca le variabili di ambiente `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI ` o `AWS_CONTAINER_CREDENTIALS_FULL_URI` che forniscono informazioni per acquisire credenziali temporanee.
+ [**`instanceProfile`provider**](instanceprofile-provider.md) - L'SDK utilizza il servizio EC2 Instance Metadata per ottenere il ruolo IAM specificato nel profilo dell'istanza. Utilizzando le informazioni sul ruolo, l'SDK acquisisce credenziali temporanee.
**Nota**
Il risultato del provider di default viene sottoposto automaticamente a memorizzazione.
[È possibile esaminare il codice della catena nel codice sorgente. GitHub ](https://github.com/aws/aws-sdk-php/blob/0a99dab427f0a1c082775301141aeac3558691ad/src/Credentials/CredentialProvider.php#L77)
# Provider di credenziali integrati nella AWS SDK per PHP versione 3
L'SDK fornisce diversi provider di credenziali integrati che è possibile utilizzare singolarmente o combinare in una catena di provider di [credenziali personalizzata](chaining-providers.md).
Quando specificate un provider di credenziali durante la creazione del client di servizio, l'SDK tenta di caricare le credenziali utilizzando solo il provider di credenziali specificato. Non utilizza la catena di provider di credenziali [predefinita](guide_credentials_default_chain.md). Se sai che desideri che un client di servizio utilizzi il `instanceProfile` provider, puoi cortocircuitare la catena predefinita specificando il `instanceProfile` provider nel costruttore del client di servizio:
```
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.
]);
```
**Importante**
I provider di credenziali vengono chiamati ogni volta che viene eseguita un'operazione API. Se il caricamento delle credenziali è un'operazione impegnativa (ad esempio perché avviene da disco o da una risorsa di rete) o se le credenziali non sono memorizzate nella cache dal provider, valutare se eseguire il wrapping del provider di credenziali in una funzione `Aws\Credentials\CredentialProvider::memoize`. Il provider di credenziali di default utilizzato dall'SDK viene sottoposto automaticamente a memorizzazione.
**Topics**
+ [`login`provider nell'SDK for PHP](login-provider.md)
+ [`assumeRole`provider nell'SDK for PHP](assumerole-provider.md)
+ [`sso`provider nell'SDK for PHP](sso-provider.md)
+ [`defaultProvider`provider nell'SDK for PHP](defaultprovider-provider.md)
+ [`ecsCredentials`provider nell'SDK for PHP](ecscredentials-provider.md)
+ [`env`provider nell'SDK for PHP](env-provider.md)
+ [`assumeRoleWithWebIdentityCredentialProvider`provider nell'SDK for PHP](assume-role-with-web-identity-provider.md)
+ [`ini`provider nell'SDK for PHP](ini-provider.md)
+ [`process`provider nell'SDK for PHP](process-provider.md)
+ [`instanceProfile`provider nell'SDK for PHP](instanceprofile-provider.md)
# `login`provider nell'SDK for PHP
`Aws\Credentials\CredentialProvider::login`tenta di caricare le credenziali configurate da una sessione di accesso basata su browser facilitata da strumenti come la CLI. AWS Dopo l'autenticazione, AWS genera credenziali temporanee che funzionano su tutti gli strumenti e a livello locale. AWS SDKs
Con questo processo, puoi autenticarti utilizzando le credenziali root create durante la configurazione iniziale dell'account, un utente IAM o un'identità federata del tuo provider di identità e l'SDK for AWS PHP gestisce automaticamente le credenziali temporanee per te. Questo approccio migliora la sicurezza eliminando la necessità di archiviare le credenziali a lungo termine a livello locale.
Quando si esegue il `aws login` comando, è possibile selezionare una delle sessioni attive della console oppure accedere tramite il flusso di autenticazione basato sul browser e questo genererà automaticamente credenziali temporanee. L' AWS SDK for PHP aggiornerà automaticamente queste credenziali, utilizzando il servizio di accesso, per un massimo di 12 ore.
Il provider di accesso tenta di caricare il token di accesso generato dal flusso di lavoro della sessione di accesso menzionato in precedenza, in base al profilo fornito. Se non viene fornito alcun profilo quando si chiama il provider, tenterà di risolvere un profilo controllando prima la variabile di `AWS_PROFILE` ambiente, prima di tornare al profilo`default`. La configurazione incorporata nel codice può essere passata al provider, dove cercherà un `region` valore per il client del servizio di accesso utilizzato per l'aggiornamento delle credenziali. Se non viene fornita alcuna regione nell'array di configurazione, il provider tenterà di risolvere una regione controllando la variabile di `AWS_REGION` ambiente, quindi un valore di regione impostato nel profilo risolto. Se non è possibile trovare alcuna regione, il provider restituirà una promessa rifiutata con istruzioni su come configurare una regione.
Il provider viene chiamato come parte della catena predefinita e può essere chiamato direttamente.
```
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
]);
```
Per impostazione predefinita, se non viene fornita alcuna configurazione delle credenziali sul client di servizio che si desidera utilizzare, questo provider verrà chiamato come parte della catena di `defaultProvider()` credenziali. In questo scenario, la regione del client di servizio viene passata automaticamente al `login()` provider. Anche in questo scenario, il valore del profilo passato al provider di accesso verrà risolto controllando la variabile di `AWS_PROFILE` ambiente, prima di tornare al profilo`default`.
# `assumeRole`provider nell'SDK for PHP
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.
**Nota**
Per evitare di recuperare inutilmente AWS STS le credenziali su ogni operazione API, puoi utilizzare la `memoize` funzione per gestire l'aggiornamento automatico delle credenziali quando scadono. Di seguito è riportato un esempio di codice.
```
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](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)
# `sso`provider nell'SDK for PHP
`Aws\Credentials\CredentialProvider::sso`è il provider 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 = 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 [`config`Shared and `credentials` files](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) nella *AWS SDKs and Tools Reference Guide*. In alternativa, è possibile utilizzare la variabile di [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)ambiente 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](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) nella *AWS SDKs and Tools Reference Guide*.
# `defaultProvider`provider nell'SDK for PHP
`Aws\Credentials\CredentialProvider::defaultProvider`è il provider di credenziali predefinito ed è anche chiamato catena di provider di [credenziali predefinita](guide_credentials_default_chain.md). che viene utilizzato in caso di omissione dell'opzione `credentials` durante la creazione di un client. Ad esempio, se crei un S3Client come mostrato nel seguente frammento di codice, l'SDK utilizza il provider predefinito:
```
$client = new S3Client([
'region' => 'us-west-2'
]);
```
È inoltre possibile utilizzare DefaultProvider nel codice se si desidera fornire parametri a fornitori di credenziali specifici nella catena. Ad esempio, l'esempio seguente fornisce impostazioni personalizzate per il timeout della connessione e il ritentativo se viene utilizzata la funzione provider. `ecsCredentials`
```
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`provider nell'SDK for PHP
`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
]);
```
# `env`provider nell'SDK for PHP
L'utilizzo di variabili di ambiente per contenere le credenziali impedisce di condividere accidentalmente la chiave di accesso AWS segreta. Ti consigliamo di non aggiungere mai le chiavi di AWS accesso direttamente al client in nessun file di produzione.
Per autenticarsi su Amazon Web Services, l'SDK verifica innanzitutto le credenziali nelle variabili di ambiente. L'SDK utilizza la funzione `getenv()` per individuare le variabili di ambiente `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`e `AWS_SESSION_TOKEN`. Queste credenziali vengono definite credenziali di ambiente. *Per istruzioni su come ottenere questi valori, consulta [Autenticazione con credenziali a breve termine](https://docs.aws.amazon.com/sdkref/latest/guide/access-temp-idc.html) nella and Tools Reference Guide.AWS SDKs *
Se stai ospitando l'applicazione su [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_PHP_eb.html), puoi impostare le variabili `AWS_ACCESS_KEY_ID``AWS_SECRET_KEY`, e di `AWS_SESSION_TOKEN` ambiente [tramite la AWS Elastic Beanstalk console in modo che l'](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-softwaresettings.html#environments-cfg-softwaresettings-console)SDK possa utilizzare tali credenziali automaticamente.
Per ulteriori informazioni su come impostare le variabili di ambiente, consulta [Supporto per le variabili di ambiente nella Guida](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) di *riferimento agli strumenti AWS SDKs e agli strumenti*. Inoltre, per un elenco di tutte le variabili di ambiente supportate dalla maggior parte AWS SDKs, consultate [Elenco delle variabili di ambiente](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings).
È inoltre possibile impostare le variabili di ambiente nella riga di comando, come illustrato di seguito.
**Linux**
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your Account AWS.
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Account AWS.
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Account AWS.
# 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 Account AWS.
C:\> SET AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Account AWS.
C:\> SET AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Account AWS.
# 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` 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`provider nell'SDK for PHP
`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
]);
```
# `ini`provider nell'SDK for PHP
`Aws\Credentials\CredentialProvider::ini`tenta di caricare le credenziali dai file condivisi e. `config` `credentials` Per impostazione predefinita, l'SDK tenta di caricare il profilo «predefinito» dal AWS `credentials` file condiviso che si trova in. `~/.aws/credentials` Se l'SDK trova la variabile di `AWS_SDK_LOAD_NONDEFAULT_CONFIG` ambiente, verifica anche la presenza di un profilo «predefinito» nel AWS `config` file condiviso che si trova in. `~/.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
]);
```
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
]);
```
# `process`provider nell'SDK for PHP
`Aws\Credentials\CredentialProvider::process`tenta di caricare le credenziali eseguendo il `credential_process` valore specificato in un profilo in un file di configurazione [condiviso AWS](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
Per impostazione predefinita, l'SDK tenta di caricare prima il profilo «predefinito» dal AWS `credentials` file condiviso che si trova in. `~/.aws/credentials` Se il profilo «predefinito» non viene trovato nel `credentials` file condiviso, l'SDK cerca il profilo predefinito nel `config` file condiviso. Di seguito è riportato un esempio di configurazione per il `credentials` file condiviso.
```
[default]
credential_process = /path/to/file/credential_returning_executable.sh --custom-command custom_parameter
```
L'SDK chiamerà il `credential_process` comando esattamente come indicato utilizzando la `shell_exec` funzione di PHP e quindi leggerà i dati JSON da stdout. `credential_process`Devono scrivere le credenziali su stdout nel seguente formato:
```
{
"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
]);
```
# `instanceProfile`provider nell'SDK for PHP
`Aws\Credentials\CredentialProvider::instanceProfile`tenta di caricare le credenziali per un ruolo IAM specificato in un profilo di istanza 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'`retries`opzione e disabilitato completamente impostando l'opzione su `0` come mostrato nel codice seguente.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile([
'retries' => 0
]);
$memoizedProvider = CredentialProvider::memoize($provider);
```
Se la variabile di ambiente `AWS_METADATA_SERVICE_NUM_ATTEMPTS` è disponibile, il suo valore ha la precedenza sull'opzione 'retries' mostrata in precedenza.
**Nota**
Puoi disabilitare questo tentativo di caricamento dai profili di istanza di Amazon EC2 impostando la variabile di `AWS_EC2_METADATA_DISABLED` ambiente su. `true`
# Concatenamento dei provider di credenziali nell'SDK for PHP
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 di credenziali personalizzato da utilizzare con l'SDK for PHP
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 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));
};
}
```
# Memorizzazione delle credenziali nell'SDK for PHP
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.
# Assumi un ruolo IAM utilizzando la AWS SDK per PHP versione 3
## Utilizzo dei ruoli IAM per le credenziali delle variabili di istanza Amazon EC2
Se esegui l'applicazione su un'istanza Amazon EC2, il modo migliore per fornire le credenziali a cui effettuare chiamate AWS consiste nell'utilizzare un [ruolo IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) per ottenere credenziali di sicurezza temporanee.
Quando utilizzi i ruoli IAM, non devi preoccuparti della gestione delle credenziali della tua applicazione. Consentono a un'istanza di «assumere» un ruolo recuperando credenziali temporanee dal server di metadati dell'istanza Amazon EC2.
Le credenziali temporanee, spesso chiamate **credenziali del profilo di istanza**, consentono l'accesso alle azioni e alle risorse consentite dalla politica del ruolo. Amazon EC2 gestisce tutte le fasi di autenticazione sicura delle istanze sul servizio IAM per assumere il ruolo e di aggiornare periodicamente le credenziali del ruolo recuperate. In questo modo, l'applicazione resta protetta quasi senza necessità del tuo intervento. Per un elenco di servizi che supportano le credenziali di sicurezza temporanee, consulta [AWS services that work with IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) nella *Guida per l’utente IAM*.
**Nota**
Per evitare di coinvolgere ogni volta il servizio dei metadati, è possibile trasmettere al costruttore di client un'istanza di `Aws\CacheInterface` come opzione `'credentials'`. In questo modo l'SDK utilizza le credenziali del profilo di istanza memorizzate nella cache. [Per i dettagli, consulta Configurazione per la versione 3. AWS SDK per PHP](guide_configuration.md)
*Per ulteriori informazioni sullo sviluppo di applicazioni Amazon EC2 utilizzando la SDKs, consulta Using [IAM roles for Amazon EC2](https://docs.aws.amazon.com/sdkref/latest/guide/access-iam-roles-for-ec2.html) Instances nella AWS SDKs and Tools Reference Guide.*
### Crea e assegna un ruolo IAM a un'istanza Amazon EC2
1. Crea un client IAM.
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Iam\IamClient;
```
**Codice di esempio**
```
$client = new IamClient([
'region' => 'us-west-2',
'version' => '2010-05-08'
]);
```
1. Crea un ruolo IAM con le autorizzazioni per le azioni e le risorse che utilizzerai.
**Codice di esempio**
```
$result = $client->createRole([
'AssumeRolePolicyDocument' => 'IAM JSON Policy', // REQUIRED
'Description' => 'Description of Role',
'RoleName' => 'RoleName', // REQUIRED
]);
```
1. Crea un profilo di istanza IAM e archivia l'Amazon Resource Name (ARN) dal risultato.
**Nota**
Se utilizzi la console IAM anziché AWS SDK per PHP, la console crea automaticamente un profilo di istanza e gli assegna lo stesso nome del ruolo a cui corrisponde.
**Codice di esempio**
```
$IPN = 'InstanceProfileName';
$result = $client->createInstanceProfile([
'InstanceProfileName' => $IPN ,
]);
$ARN = $result['Arn'];
$InstanceID = $result['InstanceProfileId'];
```
1. Crea un client Amazon EC2.
**Importazioni**
```
require 'vendor/autoload.php';
use Aws\Ec2\Ec2Client;
```
**Codice di esempio**
```
$ec2Client = new Ec2Client([
'region' => 'us-west-2',
'version' => '2016-11-15',
]);
```
1. Aggiungi il profilo dell'istanza a un'istanza Amazon EC2 in esecuzione o interrotta. Usa il nome del profilo dell'istanza del tuo ruolo IAM.
**Codice di esempio**
```
$result = $ec2Client->associateIamInstanceProfile([
'IamInstanceProfile' => [
'Arn' => $ARN,
'Name' => $IPN,
],
'InstanceId' => $InstanceID
]);
```
Per ulteriori informazioni sui ruoli IAM, consulta [Ruoli IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) nella *Guida per l'utente di Amazon EC2*.
## Utilizzo dei ruoli IAM per le attività di Amazon ECS
Un'attività in Amazon Elastic Container Service (Amazon ECS) può assumere un ruolo IAM per AWS effettuare chiamate API. Si tratta di una strategia per la gestione delle credenziali da utilizzare per le applicazioni, simile a come i profili di istanza Amazon EC2 forniscono le credenziali alle istanze Amazon EC2.
[Invece di creare e distribuire AWS credenziali a lungo termine ai contenitori o utilizzare il ruolo dell'istanza Amazon EC2, puoi associare un ruolo IAM che utilizza credenziali temporanee a una definizione di attività ECS o a un'operazione API. `RunTask`](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-ecs-2014-11-13.html#runtask)
Per ulteriori informazioni sull'utilizzo dei ruoli IAM che le attività del contenitore possono assumere, consulta l'argomento relativo al [ruolo Task IAM](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) nella *Amazon ECS Developer Guide*. Per esempi di utilizzo del ruolo IAM dell'attività sotto forma di una `taskRoleArn` nelle definizioni delle attività, consulta Definizioni di [attività di esempio](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-example-taskdefs.html) anche nella *Amazon ECS Developer Guide*.
## Assumere un ruolo IAM in un altro Account AWS
Quando lavori in un Account AWS (Account A) e desideri assumere un ruolo in un altro account (Account B), devi prima creare un ruolo IAM nell'Account B. Questo ruolo consente alle entità del tuo account (Account A) di eseguire azioni specifiche nell'Account B. Per ulteriori informazioni sull'accesso tra account, consulta [Tutorial: Delegate l'accesso tra AWS account tramite](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) ruoli IAM.
Dopo aver creato un ruolo nell'Account B, annota il relativo ARN. Utilizzerai questo ARN quando assumerai il ruolo dall'Account A. Assumi il ruolo utilizzando AWS le credenziali associate alla tua entità nell'Account A.
Crea un AWS STS cliente con le credenziali per il tuo. Account AWS Nel seguente esempio, abbiamo utilizzato un profilo con credenziali, ma puoi utilizzare qualsiasi metodo. Con il client AWS STS appena creato, invoca assume-role e fornisci un valore di sessionName personalizzato. Recupera le nuove credenziali provvisorie dal risultato. Per impostazione predefinita, le credenziali durano un'ora.
**Codice di esempio**
```
$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']
]
]);
```
Per ulteriori informazioni, consulta [Using IAM Roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) o [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)nell' AWS SDK per PHP API Reference.
## Utilizzo di un ruolo IAM con identità web
Web Identity Federation consente ai clienti di utilizzare provider di identità di terze parti per l'autenticazione durante l'accesso alle AWS risorse. Prima di assumere un ruolo con un'identità web, devi creare un ruolo IAM e configurare un provider di identità web (IdP). Per ulteriori informazioni, consultare [Creazione di un ruolo per la federazione di identità web o di OpenID Connect (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html).
Dopo aver [creato un provider di identità](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) e [creato un ruolo per la tua identità web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html), utilizza un AWS STS client per autenticare un utente. Fornisci l' webIdentityToken e ProviderId per la tua identità e il Role ARN per il ruolo IAM con le autorizzazioni per l'utente.
**Codice di esempio**
```
$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']
]
]);
```
Per ulteriori informazioni, consulta [AssumeRoleWithWebIdentity—Federation Through a Web-based Identity Provider](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity.html) o [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerolewithwebidentity)nell'API Reference. AWS SDK per PHP
## Assumi un ruolo con profilo
### Definisci i profili in `~/.aws/credentials`
È possibile configurare l'utilizzo AWS SDK per PHP di un ruolo IAM definendo un profilo in`~/.aws/credentials`.
Crea un nuovo profilo con l'`role_arn`impostazione per il ruolo che vuoi assumere. Includi anche l'`source_profile`impostazione per un altro profilo con credenziali autorizzate ad assumere il ruolo IAM. Per maggiori dettagli su queste impostazioni di configurazione, consulta [Assume le credenziali del ruolo](https://docs.aws.amazon.com/sdkref/latest/guide/feature-assume-role-credentials.html) nella *AWS SDKs and Tools* Reference Guide.
Ad esempio, di seguito`~/.aws/credentials`, il `project1` profilo imposta `role_arn` e specifica il `default` profilo come fonte per le credenziali per verificare che l'entità ad esse associata possa assumere il ruolo.
```
[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
```
Se si imposta la variabile di `AWS_PROFILE` ambiente o si utilizza il `profile` parametro quando si crea un'istanza di un client di servizio, `project1` viene assunto il ruolo specificato in, utilizzando il `default` profilo come credenziali di origine.
Il frammento seguente mostra l'uso del parametro in un costruttore. `profile` `S3Client` `S3Client`Avranno le autorizzazioni associate al ruolo associato al profilo. `project1`
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
### Definire i profili in `~/.aws/config`
Il `~/.aws/config` file può contenere anche i profili che si desidera vengano assunti. Se imposti la variabile di ambiente`AWS_SDK_LOAD_NONDEFAULT_CONFIG`, l'SDK for PHP carica i profili `config` dal file. Quando `AWS_SDK_LOAD_NONDEFAULT_CONFIG` è impostato, l'SDK carica i profili da entrambi e. `~/.aws/config` `~/.aws/credentials` I profili di `~/.aws/credentials` vengono caricati per ultimi e hanno la precedenza su un profilo `~/.aws/config` con lo stesso nome. I profili della posizione possono servire come `source_profile` o il profilo da assumere.
L'esempio seguente utilizza il `project1` profilo definito nel `config` file e il `default` profilo nel `credentials` file. `AWS_SDK_LOAD_NONDEFAULT_CONFIG`È inoltre impostato.
```
# 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
```
Quando viene eseguito il `S3Client` costruttore, come mostrato nel frammento seguente, il ruolo definito nel `project1` profilo verrà assunto utilizzando le credenziali associate al profilo. `default`
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
# Usa credenziali temporanee dall' AWS STS SDK for PHP
AWS Security Token Service (AWS STS) consente di richiedere privilegi limitati, **credenziali temporanee** per gli utenti IAM o per gli utenti autenticati tramite la federazione delle identità. *Per una comprensione più approfondita, consulta [Temporary Security Credentials nella IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) User Guide.* Puoi utilizzare credenziali di sicurezza temporanee per accedere alla maggior parte dei AWS servizi. Per un elenco di servizi che supportano le credenziali di sicurezza temporanee, consulta [AWS services that work with IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) nella *Guida per l’utente IAM*.
[Un caso d'uso comune delle credenziali temporanee consiste nel concedere alle applicazioni mobili o lato client l'accesso alle AWS risorse autenticando gli utenti tramite provider di identità di terze parti (vedi Web Identity Federation).](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html)
## Ottenere credenziali temporanee
AWS STS dispone di diverse operazioni che restituiscono credenziali temporanee, ma l'`GetSessionToken`operazione è la più semplice da dimostrare. Il seguente frammento recupera le credenziali temporanee chiamando il `getSessionToken` metodo del client STS di PHP SDK.
```
$sdk = new Aws\Sdk([
'region' => 'us-east-1',
]);
$stsClient = $sdk->createSts();
$result = $stsClient->getSessionToken();
```
Il risultato `GetSessionToken` e le altre AWS STS operazioni contengono sempre un valore. `'Credentials'` Se si stampa `$result` (ad esempio utilizzando`print_r($result)`), il risultato è simile al seguente.
```
Array
(
...
[Credentials] => Array
(
[SessionToken] => ''
[SecretAccessKey] => ''
[Expiration] => 2013-11-01T01:57:52Z
[AccessKeyId] => ''
)
...
)
```
## Fornire credenziali temporanee a AWS SDK per PHP
È possibile utilizzare credenziali temporanee con un altro AWS client creando un'istanza del client e trasmettendo i valori ricevuti direttamente da. AWS STS
```
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']
]
]);
```
Puoi anche costruire un oggetto `Aws\Credentials\Credentials` e utilizzarlo al momento di creare un'istanza del client.
```
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
]);
```
Tuttavia, il modo *migliore* per fornire le credenziali temporanee è utilizzare il metodo helper `createCredentials()` incluso in `StsClient`, Questo metodo estrae i dati da un AWS STS risultato e crea l'`Credentials`oggetto automaticamente.
```
$result = $stsClient->getSessionToken();
$credentials = $stsClient->createCredentials($result);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Per ulteriori informazioni sul motivo per cui potrebbe essere necessario utilizzare credenziali temporanee nell'applicazione o nel progetto, consulta [Scenari per la concessione dell'accesso temporaneo nella documentazione](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html). AWS STS
# Crea client anonimi nell'SDK for PHP
In alcuni casi, è consigliabile creare un client che non sia associato a nessuna credenziale, perché consente di effettuare richieste anonime a un servizio.
Ad esempio, puoi configurare sia gli oggetti Amazon S3 che i CloudSearch domini Amazon per consentire l'accesso anonimo.
Per creare un client anonimo, imposta l'opzione `'credentials'` su `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',
]);
```