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 in AWS SDK for Java 2.x
Il ruolo di un fornitore di credenziali in the AWS SDK for Java 2.x è quello di reperire e fornire credenziali ai client dell'SDK. Servizio AWS L'SDK utilizza le credenziali che ottiene 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 si utilizzano credenziali temporanee, che vengono utilizzate quando si configura la [configurazione del provider di token SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) o si configura il runtime per [assumere un ruolo IAM (AWS Identity and Access Management)](https://docs.aws.amazon.com/sdkref/latest/guide/access-assume-role.html#credOrSourceAssumeRole) come esempio, viene aggiunto un token di sessione alle chiavi di accesso, che fornisce un accesso limitato nel tempo alle risorse. AWS
In questo argomento vengono descritti diversi modi per abilitare l'SDK per accedere alle credenziali.
**Topics**
+ [Lavori di sviluppo interattivi](credentials-temporary.md)
+ [Catena di fornitori di credenziali predefinita](credentials-chain.md)
+ [Memorizzazione nella cache delle credenziali](credential-caching.md)
+ [Specificare un provider di credenziali specifico](credentials-providers.md)
+ [Usa profili di configurazione condivisi](credentials-profiles.md)
+ [Utilizzare un processo esterno](credentials-process.md)
+ [Fornire le credenziali nel codice](credentials-explicit.md)
+ [Leggi le credenziali del ruolo IAM su Amazon EC2](ec2-iam-roles.md)
# Credenziali di accesso per il lavoro di sviluppo interattivo utilizzando AWS SDK for Java 2.x
Per una maggiore sicurezza, si AWS consiglia di configurare l'SDK for Java in modo [da utilizzare credenziali temporanee](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) anziché credenziali di lunga durata. Le credenziali temporanee sono costituite da chiavi di accesso (ID chiave di accesso e chiave di accesso segreta) e un token di sessione.
Sono disponibili diversi approcci per lavorare con credenziali temporanee. L'approccio utilizzato, e quindi la configurazione fornita all'SDK, dipende dal caso d'uso.
Quando svolgi attività di sviluppo interattive con Java SDK, ti consigliamo di utilizzare le credenziali di accesso alla AWS Console.
## Utilizzo delle credenziali di accesso alla console
È possibile utilizzare le credenziali di accesso esistenti AWS della Console di gestione per l'accesso programmatico ai servizi. AWS Dopo un flusso di autenticazione basato su browser, AWS genera credenziali temporanee che funzionano con strumenti di sviluppo locali come SDK for AWS CLI Java 2.x.
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 gestire automaticamente le AWS CLI 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'SDK for Java 2.x aggiornerà automaticamente queste credenziali per un massimo di 12 ore.
**Importante**
Oltre alla configurazione impostata nel file di configurazione condiviso che funziona per tutti i progetti, ogni singolo progetto Java richiede la seguente dipendenza nel file Maven: `pom.xml`
```
software.amazon.awssdk
signin
```
La `signin` dipendenza fornisce il codice che consente all'SDK for Java 2.x di accedere e utilizzare le credenziali di accesso alla console.
*Per ulteriori informazioni sui prerequisiti, sull'accesso e sulla disconnessione, consulta [Accesso per lo sviluppo AWS locale utilizzando le credenziali della console](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) nella Guida di riferimento all'SDK and Tools.AWS *
## Single-sign-on approccio
Quando svolgi attività di sviluppo interattive con Java SDK, in alternativa puoi utilizzare l'approccio Single Sign-On. Questo approccio richiede la seguente configurazione:
+ [Configurazione tramite IAM Identity Center](get-started-auth.md#setup-auth)
+ [Configura un profilo nel file di configurazione AWS condiviso](get-started-auth.md#setup-credentials)
+ utilizzando AWS CLI ed [eseguendo un comando](get-started-auth.md#setup-login-sso) per accedere e creare una sessione attiva
### configurazione IAM Identity Center
Quando configuri l'SDK per utilizzare l'accesso Single Sign-On di IAM Identity Center come descritto [Panoramica della configurazione](setup.md#setup-overview) in questa guida, l'SDK utilizza credenziali temporanee.
L'SDK utilizza il token di accesso IAM Identity Center per accedere al ruolo IAM configurato con l'impostazione nel file. `sso_role_name` `config` L'SDK assume questo ruolo IAM e recupera le credenziali temporanee per firmare le richieste. Servizio AWS
Per maggiori dettagli su come l'SDK ottiene le credenziali temporanee dalla configurazione, consulta la sezione [Understanding IAM Identity Center sull'autenticazione](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) della and Tools Reference Guide. AWS SDKs
**Importante**
Oltre alla configurazione impostata nel `config` file condiviso che funziona per tutti i progetti, ogni singolo progetto Java richiede le seguenti dipendenze nel file Maven: `pom.xml`
```
software.amazon.awssdk
sso
software.amazon.awssdk
ssooidc
```
Le `ssooidc` dipendenze `sso` e forniscono il codice che consente all'SDK for Java 2.x di accedere alle credenziali temporanee.
### Recupera le credenziali temporanee dal portale di accesso AWS
In alternativa alla configurazione Single Sign-On di IAM Identity Center, puoi copiare e utilizzare le credenziali temporanee disponibili nel portale di accesso. AWS È possibile utilizzare le credenziali temporanee in un profilo o utilizzarle come valori per le proprietà di sistema e le variabili di ambiente.
**Configura un file di credenziali locale per credenziali temporanee**
1. [Crea un file di credenziali condiviso](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html)
1. Nel file delle credenziali, incolla il seguente testo segnaposto fino a incollare le credenziali temporanee funzionanti.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
1. Salvare il file. Il file `~/.aws/credentials` dovrebbe ora esistere sul tuo sistema di sviluppo locale. Questo file contiene il [profilo [predefinito]](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) utilizzato dall'SDK for Java se non viene specificato un profilo denominato specifico.
1. [Accedi al portale di AWS accesso](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html)
1. Segui queste istruzioni sotto l'intestazione [Aggiornamento manuale delle credenziali](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) per copiare le credenziali del ruolo IAM dal AWS portale di accesso.
1. Per la fase 2 delle istruzioni collegate, scegli `Access keys` il nome del ruolo IAM che concede l'accesso per le tue esigenze di sviluppo. Questo ruolo in genere ha un nome simile **PowerUserAccess**a **Developer**.
1. Nella finestra di dialogo modale, selezionate il sistema operativo in uso e copiate il contenuto da **Aggiungi un profilo al file delle AWS credenziali**.
1. Incolla le credenziali copiate nel `credentials` file locale e rimuovi il nome del profilo generato. Il file dovrebbe essere simile al seguente.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
1. Salvare il file `credentials`.
Quando l'SDK for Java crea un client di servizio, accederà a queste credenziali temporanee e le utilizzerà per ogni richiesta. Le impostazioni per il ruolo IAM scelto nella fase 5a [determinano la durata di validità delle credenziali temporanee](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html). La durata massima è di dodici ore.
Dopo la scadenza delle credenziali temporanee, ripeti i passaggi da 4 a 7.
# Catena di fornitori di credenziali predefinita in AWS SDK for Java 2.x
La catena di provider di credenziali predefinita cerca AWS SDK for Java 2.x automaticamente le AWS credenziali in una sequenza di posizioni predefinita, consentendo alle applicazioni di autenticarsi senza specificare esplicitamente Servizi AWS le fonti delle credenziali.
La catena di provider di credenziali predefinita è implementata dalla classe. [DefaultCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html) Delega in sequenza ad altri provider di credenziali le implementazioni che controllano la configurazione in varie posizioni. Il primo provider di credenziali in grado di trovare tutti gli elementi di configurazione necessari causa la fine della catena.
Per utilizzare la catena di fornitori di credenziali predefinita per fornire credenziali temporanee, create un service client builder ma non specificate un provider di credenziali. Il seguente frammento di codice crea una catena `DynamoDbClient` che utilizza la catena di provider di credenziali predefinita per individuare e recuperare le impostazioni di configurazione.
```
// Any external Region configuration is overridden.
// The SDK uses the default credentials provider chain because no specific credentials provider is specified.
Region region = Region.US_WEST_2;
DynamoDbClient ddb =
DynamoDbClient.builder()
.region(region)
.build();
```
## Ordine di recupero delle impostazioni delle credenziali
La catena di provider di credenziali predefinita di SDK for Java 2.x cerca la configurazione nell'ambiente utilizzando una sequenza predefinita.
1. Proprietà del sistema Java
+ L'SDK utilizza la [SystemPropertyCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/SystemPropertyCredentialsProvider.html)classe per caricare credenziali temporanee dalle proprietà di sistema `aws.accessKeyId``aws.secretAccessKey`, e `aws.sessionToken` Java.
**Nota**
Per informazioni su come impostare le proprietà del sistema Java, consultate il tutorial [System Properties](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) sul sito Web ufficiale di *Java Tutorials*.
1. Variabili di ambiente
+ L'SDK utilizza la [EnvironmentVariableCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/EnvironmentVariableCredentialsProvider.html)classe per caricare credenziali temporanee dalle variabili di ambiente `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, e. `AWS_SESSION_TOKEN`
1. Token di identità Web e ARN del ruolo IAM
+ L'SDK utilizza la [WebIdentityTokenFileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/WebIdentityTokenFileCredentialsProvider.html)classe per caricare le credenziali assumendo un ruolo utilizzando un token di identità web.
+ Il provider di credenziali cerca le seguenti variabili di ambiente o proprietà del sistema JVM:
+ `AWS_WEB_IDENTITY_TOKEN_FILE or aws.webIdentityTokenFile`
+ `AWS_ROLE_ARN` o `aws.roleArn`
+ `AWS_ROLE_SESSION_NAME`o `aws.roleSessionName` (opzionale)
+ Dopo aver acquisito i valori, l'SDK chiama AWS Security Token Service (STS) e utilizza le credenziali temporanee restituite per firmare le richieste.
+ Gli ambienti di runtime come Amazon Elastic Kubernetes Service (EKS) rendono automaticamente disponibili i token di identità Web, consentendo AWS SDKs alle applicazioni di ottenere credenziali temporanee. AWS
1. `config`I file condivisi e `credentials`
+ L'SDK li utilizza [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)per caricare le impostazioni Single Sign-on o le credenziali temporanee di IAM Identity Center dal `[default]` profilo nei file condivisi e nei file. `credentials` `config`
La AWS SDKs and Tools Reference Guide contiene [informazioni dettagliate](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html#idccredres) su come l'SDK for Java funziona con il token single sign-on IAM Identity Center per ottenere le credenziali temporanee che l'SDK utilizza per chiamare. Servizi AWS
**Nota**
I `config` file `credentials` e sono condivisi da vari strumenti. AWS SDKs Per ulteriori informazioni, vedere [The. aws/credentials and .aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)file nella AWS SDKs and Tools Reference Guide.
+ Poiché un profilo condiviso `credentials` e `config` i file possono contenere molti set diversi di impostazioni, i membri `ProfileCredentialsProvider` delegano a una serie di altri provider il compito di cercare le impostazioni all'interno del `[default]` profilo:
+ **Credenziali del token di identità Web** (classe`WebIdentityTokenCredentialsProvider`): quando il profilo contiene `role_arn` e. `web_identity_token_file`
+ **Credenziali SSO** (classe`SsoCredentialsProvider`): quando il profilo contiene proprietà relative a SSO come,. `sso_role_name` `sso_account_id`
+ **Credenziali basate sui ruoli con profilo di origine (classe`StsAssumeRoleCredentialsProvider`): quando il profilo** contiene e. `role_arn` `source_profile`
+ **Credenziali basate sui ruoli con origine delle credenziali** (classe`StsAssumeRoleWithSourceCredentialsProvider`): quando il profilo contiene e. `role_arn` `credential_source`
+ Quando`credential_source = Environment`: utilizza una catena di e `SystemPropertyCredentialsProvider` `EnvironmentVariableCredentialsProvider`
+ Quando`credential_source = Ec2InstanceMetadata`: utilizza `InstanceProfileCredentialsProvider`
+ Quando`credential_source = EcsContainer`: utilizza `ContainerCredentialsProvider`
+ **Credenziali di accesso alla console** (classe`LoginCredentialsProvider`): quando il profilo contiene `login_session`
+ **Credenziali di processo** (classe`ProcessCredentialsProvider`): quando il profilo contiene. `credential_process`
+ **Credenziali di sessione** (classe`StaticSessionCredentialsProvider`): quando il profilo contiene `aws_access_key_id``aws_secret_access_key`, e. `aws_session_token`
+ **Credenziali di base** (classe`StaticCredentialsProvider`): quando il profilo contiene `aws_access_key_id` e. `aws_secret_access_key`
1. Amazon ECS credenziali del contenitore
+ L'SDK utilizza la [ContainerCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ContainerCredentialsProvider.html)classe per caricare le credenziali temporanee utilizzando le seguenti variabili di ambiente:
1. `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` o `AWS_CONTAINER_CREDENTIALS_FULL_URI`
1. `AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE` o `AWS_CONTAINER_AUTHORIZATION_TOKEN`
L'agente contenitore ECS imposta automaticamente la variabile di `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` ambiente, che punta all'endpoint delle credenziali ECS. Le altre variabili di ambiente sono in genere impostate in scenari specifici in cui non viene utilizzato l'endpoint di credenziali ECS standard.
1. Amazon EC2 istanza: credenziali fornite dal ruolo IAM
+ L'SDK utilizza la [InstanceProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/InstanceProfileCredentialsProvider.html)classe per caricare credenziali temporanee dal servizio di metadati. Amazon EC2
1. Se l'SDK non riesce a trovare le impostazioni di configurazione necessarie attraverso tutti i passaggi sopra elencati, genera un'eccezione con un output simile al seguente:
```
software.amazon.awssdk.core.exception.SdkClientException: Unable to load credentials from any of the providers
in the chain AwsCredentialsProviderChain(credentialsProviders=[SystemPropertyCredentialsProvider(),
EnvironmentVariableCredentialsProvider(), WebIdentityTokenCredentialsProvider(), ProfileCredentialsProvider(),
ContainerCredentialsProvider(), InstanceProfileCredentialsProvider()])
```
## Usa il codice in `DefaultCredentialsProvider`
Puoi utilizzare in modo esplicito la catena di fornitori di credenziali predefinita nel tuo codice. Dal punto di vista funzionale, ciò equivale a non specificare affatto un provider di credenziali, poiché l'SDK lo utilizza per impostazione predefinita. `DefaultCredentialsProvider` Tuttavia, utilizzarlo in modo esplicito può rendere il codice più leggibile e autodocumentante. Mostra chiaramente l'intenzione di utilizzare la catena di credenziali predefinita.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
public class ExplicitDefaultCredentialsExample {
public static void main(String[] args) {
// Explicitly create the DefaultCredentialsProvider.
DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider
.builder().build();
// Use it with any service client.
S3Client s3Client = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(defaultCredentialsProvider)
.build();
// Now you can use the client with the default credentials chain.
s3Client.listBuckets();
}
}
```
Quando crei il provider di credenziali predefinito, puoi fornire ulteriori configurazioni:
```
DefaultCredentialsProvider customizedProvider = DefaultCredentialsProvider.builder()
.profileName("custom-profile") // Use a specific profile if the chain gets to the `ProfileCredentialsProvider` stage.
.asyncCredentialUpdateEnabled(true) // Enable async credential updates.
.build();
```
Questo approccio offre un maggiore controllo pur garantendo la comodità della catena di credenziali predefinita.
# Memorizzazione nella cache delle credenziali in AWS SDK for Java 2.x
AWS SDK for Java 2.x Implementa la memorizzazione nella cache delle credenziali per migliorare le prestazioni e ridurre le chiamate alle fonti delle credenziali. Questa sezione spiega come funziona la memorizzazione nella cache delle credenziali e come configurarla per le applicazioni.
## Comprendere la memorizzazione nella cache dei provider di credenziali
I provider di credenziali nell'SDK for Java 2.x utilizzano diverse strategie di caching:
+ Memorizzazione nella cache **interna delle credenziali: molti provider memorizzano nella cache** le credenziali recuperate.
+ **Aggiornamento automatico: i provider con credenziali memorizzate nella cache implementano meccanismi di aggiornamento**.
### Provider con memorizzazione nella cache delle credenziali interne
I seguenti provider di credenziali memorizzano le credenziali internamente, anche quando si creano nuove istanze:
+ **Provider di credenziali del profilo di istanza**: memorizza nella cache le credenziali dal servizio di metadati Amazon EC2.
+ **Provider di credenziali del contenitore**: memorizza nella cache le credenziali dall'endpoint dei metadati del contenitore.
+ **Provider basati su STS**: memorizza nella cache le credenziali temporanee di (STS). AWS Security Token Service
+ **Fornitori di token di identità Web**: memorizza nella cache le credenziali ottenute dai token di identità Web.
+ **Provider di credenziali di processo**: memorizza nella cache le credenziali provenienti da processi esterni.
### Provider senza memorizzazione nella cache interna
I seguenti provider non implementano la memorizzazione nella cache interna:
+ **Provider di credenziali variabili d'ambiente**
+ **Provider di credenziali di proprietà del sistema**
+ **Provider di credenziali statiche**
## Configurazione della memorizzazione nella cache delle credenziali
Puoi personalizzare il comportamento di memorizzazione nella cache durante la creazione di provider di credenziali:
### Tempo stantio
Controlla quando le credenziali sono considerate obsolete e devono essere aggiornate:
```
.staleTime(Duration.ofMinutes(2)) // Consider stale 2 minutes before expiration.
```
### Ora di prefetch
Determina quando iniziare ad aggiornare le credenziali prima della scadenza:
```
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration.
```
### Aggiornamenti asincroni
Abilita l'aggiornamento delle credenziali in background:
```
.asyncCredentialUpdateEnabled(true) // Refresh credentials in background thread.
```
### Durata della sessione
Per i provider basati su STS, controlla per quanto tempo le credenziali temporanee rimangono valide:
```
.refreshRequest(r -> r.durationSeconds(3600)) // 1 hour session.
```
## Esempio di configurazione delle credenziali di memorizzazione nella cache
Come esempio di configurazione della memorizzazione nella cache per un'implementazione di un provider di credenziali, potresti voler fare in modo che l'SDK utilizzi un thread in background per prerecuperare (recuperare in anticipo) le credenziali prima che scadano. In questo modo puoi evitare la chiamata di blocco che recupera nuove credenziali.
Di seguito viene mostrato un esempio che crea un file `[StsAssumeRoleCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsAssumeRoleCredentialsProvider.html)` che utilizza un thread in background per prerecuperare le credenziali impostando la `[asyncCredentialUpdateEnabled](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#asyncCredentialUpdateEnabled(java.lang.Boolean))` proprietà su on the builder: `true`
```
StsAssumeRoleCredentialsProvider provider = StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(r -> r
.roleArn("arn:aws:iam::111122223333:role/example-role")
.roleSessionName("example-session")
.durationSeconds(3600)) // 1 hour session
.staleTime(Duration.ofMinutes(5)) // Consider stale 5 minutes before expiration
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration
.asyncCredentialUpdateEnabled(true) // Refresh in background
.build();
S3Client s3 = S3Client.builder()
.credentialsProvider(provider)
.build();
```
Quando si richiama un'operazione on `s3Client` per la prima volta, un `[AssumeRoleRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/model/AssumeRoleRequest.html)` viene inviato a (STS). AWS Security Token Service STS restituisce credenziali temporanee valide per 15 minuti (900 secondi). L'`s3Client`istanza utilizza le credenziali memorizzate nella cache fino al momento di aggiornarle prima che trascorrano i 15 minuti. Per impostazione predefinita, l'SDK tenta di recuperare nuove credenziali per una nuova sessione tra 5 minuti e 1 minuto prima della scadenza della sessione corrente. La finestra di pre-fetch è configurabile utilizzando le proprietà and. `[prefetchTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#prefetchTime(java.time.Duration))` `[staleTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#staleTime(java.time.Duration))`
È possibile configurare in modo analogo i seguenti provider di credenziali basati sulla sessione:
+ `StsWebIdentityTokenFileCredentialsProvider`
+ `StsGetSessionTokenCredentialsProvider`
+ `StsGetFederationTokenCredentialsProvider`
+ `StsAssumeRoleWithWebIdentityCredentialsProvider`
+ `StsAssumeRoleWithSamlCredentialsProvider`
+ `StsAssumeRoleCredentialsProvider`
+ `DefaultCredentialsProvider`(quando delega al provider di credenziali che utilizza le sessioni)
+ `ProcessCredentialsProvider`
+ `WebIdentityTokenFileCredentialsProvider`
+ `ContainerCredentialsProvider`
+ `InstanceProfileCredentialsProvider`
Comprendere la memorizzazione nella cache delle credenziali consente di ottimizzare le prestazioni e l'affidabilità dell'applicazione quando si lavora con. Servizi AWS
# Specificate un fornitore di credenziali specifico nel AWS SDK for Java 2.x
Sebbene la catena di provider di credenziali predefinita sia utile per molti scenari, la specifica esplicita dei provider di credenziali offre un maggiore controllo sul comportamento di autenticazione, sulle prestazioni e sulla sicurezza.
I motivi per cui potresti voler specificare un provider di credenziali potrebbero includere:
+ La catena di provider predefinita controlla più fonti in sequenza, il che può aggiungere latenza:
```
// The default provider chain checks might check multiple sources until it finds
// sufficient configuration.
S3Client s3Client = S3Client.builder().build();
// You can specify exactly where to look.
S3Client optimizedClient = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
+ È necessario utilizzare posizioni non standard per accedere alla configurazione delle credenziali:
```
// Use configuration from a custom file location.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileFile(ProfileFile.builder()
.content(Paths.get("/custom/path/to/configuration/file"))
.type(ProfileFile.Type.CONFIGURATION) // Expects all non-default profiles to be prefixed with "profile".
.build())
.profileName("custom")
.build())
.build();
```
+ Utilizza credenziali diverse per diversi client di servizio. Ad esempio, se l'applicazione deve accedere a più AWS account o utilizzare autorizzazioni diverse per servizi diversi:
```
// S3 client using one set of credentials.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.create("s3-readonly"))
.build();
// DynamoDB client using different credentials.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("dynamodb-admin"))
.build();
```
+ Controlla il comportamento di aggiornamento delle credenziali:
```
// Create a provider with custom refresh behavior.
StsAssumeRoleCredentialsProvider customRefreshProvider =
StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(AssumeRoleRequest.builder()
.roleArn("arn:aws:iam::123456789012:role/my-role")
.roleSessionName("custom-session")
.build())
.stsClient(StsClient.create())
.asyncCredentialUpdateEnabled(true) // Use a background thread to prefetch credentials.
.build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(customRefreshProvider)
.build();
```
# Utilizza profili di configurazione AWS condivisi in AWS SDK for Java 2.x
Utilizzando il `credentials` file condiviso`config`, puoi configurare diversi profili. Ciò consente all'applicazione di utilizzare più set di configurazione delle credenziali. Il `[default]` profilo è stato menzionato in precedenza. L'SDK utilizza la [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)classe per caricare le impostazioni dai profili definiti nel `credentials` file condiviso.
Il seguente frammento di codice mostra come creare un client di servizio che utilizzi le impostazioni definite come parte del profilo denominato. `my_profile`
```
Region region = Region.US_WEST_2;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("my_profile"))
.build();
```
## Imposta un profilo diverso come predefinito
Per impostare un profilo diverso dal `[default]` profilo come predefinito per l'applicazione, imposta la variabile di `AWS_PROFILE` ambiente sul nome del profilo personalizzato.
Per impostare questa variabile su Linux, macOS o Unix, usa: `export`
```
export AWS_PROFILE="other_profile"
```
Per impostare queste variabili su Windows, utilizza `set`:
```
set AWS_PROFILE="other_profile"
```
In alternativa, impostate la proprietà del sistema `aws.profile` Java sul nome del profilo.
## Ricarica le credenziali del profilo
È possibile configurare qualsiasi provider di credenziali che disponga di un `profileFile()` metodo nel relativo generatore per ricaricare le credenziali del profilo. Queste classi di profilo di credenziali sono:,, e `ProfileCredentialsProvider` `DefaultCredentialsProvider` `InstanceProfileCredentialsProvider` `ProfileTokenProvider.`
**Nota**
Il ricaricamento delle credenziali del profilo funziona solo con le seguenti impostazioni nel file di profilo:`aws_access_key_id`,, `aws_secret_access_key` e. `aws_session_token`
Impostazioni come`region`, `sso_session``sso_account_id`, e `source_profile` vengono ignorate.
Per configurare un provider di credenziali supportato per ricaricare le impostazioni del profilo, fornisci un'istanza del metodo [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html)builder. `profileFile()` Il seguente esempio di codice mostra un `ProfileCredentialsProvider` che ricarica le impostazioni delle credenziali dal profilo. `[default]`
```
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.defaultSupplier())
.build();
// Set up a service client with the provider instance.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(provider)
.build();
/*
Before dynamoDbClient makes a request, it reloads the credentials settings
by calling provider.resolveCredentials().
*/
```
Quando `ProfileCredentialsProvider.resolveCredentials()` viene chiamato, l'SDK for Java ricarica le impostazioni. `ProfileFileSupplier.defaultSupplier()`è una delle [numerose implementazioni pratiche](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html) `ProfileFileSupplier` fornite dall'SDK. Se il tuo caso d'uso lo richiede, puoi fornire la tua implementazione.
L'esempio seguente mostra l'uso del metodo di `ProfileFileSupplier.reloadWhenModified()` convenienza. `reloadWhenModified()`utilizza un `Path` parametro, che offre flessibilità nella designazione del file sorgente per la configurazione anziché la posizione standard `~/.aws/credentials` (o`config`).
Le impostazioni verranno ricaricate quando `resolveCredentials()` viene chiamata solo se SDK determina che il contenuto del file è stato modificato.
```
Path credentialsFilePath = ...
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
Il `ProfileFileSupplier.aggregate()` metodo unisce il contenuto di più file di configurazione. Siete voi a decidere se ricaricare un file per chiamata `resolveCredentials()` o se le impostazioni di un file vengono corrette al momento della prima lettura.
L'esempio seguente mostra un file `DefaultCredentialsProvider` che unisce le impostazioni di due file che contengono le impostazioni del profilo. L'SDK ricarica le impostazioni nel file a cui fa riferimento la `credentialsFilePath` variabile ogni volta che `resolveCredentials()` viene chiamata e le impostazioni vengono modificate. Le impostazioni dell'`profileFile`oggetto rimangono le stesse.
```
Path credentialsFilePath = ...;
ProfileFile profileFile = ...;
DefaultCredentialsProvider provider = DefaultCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.aggregate(
ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS),
ProfileFileSupplier.fixedProfileFile(profileFile)))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
# Caricate le credenziali da un processo esterno utilizzando il AWS SDK for Java 2.x
**avvertimento**
Di seguito viene descritto un metodo per ottenere credenziali temporanee da un processo esterno. Questo può essere potenzialmente pericoloso, quindi procedi con cautela. Ti consigliamo di utilizzare altri fornitori di credenziali, se possibile. Se utilizzi questa opzione, ti consigliamo di assicurarti che il `config` file sia il più protetto possibile utilizzando le migliori pratiche di sicurezza per il tuo sistema operativo.
Assicurati che lo strumento per le credenziali personalizzate non scriva `StdErr` informazioni segrete su. SDKs e AWS CLI può acquisire e registrare tali informazioni, esponendole potenzialmente a utenti non autorizzati.
Con l'SDK for Java 2.x, puoi acquisire credenziali temporanee da un processo esterno per casi d'uso personalizzati. Esistono due modi per configurare questa funzionalità.
## Usa l'`credential_process`impostazione
Se disponi di un metodo che fornisce credenziali temporanee, puoi integrarlo aggiungendo l'`credential_process`impostazione come parte di una definizione di profilo nel `config` file. Il valore specificato deve utilizzare il percorso completo del file di comando. Se il percorso del file contiene spazi, è necessario racchiuderlo tra virgolette.
L'SDK chiama il comando esattamente come indicato e quindi legge i dati JSON da. `stdout`
Gli esempi seguenti mostrano l'uso di questa impostazione per percorsi di file senza spazi e percorsi di file con spazi.
------
#### [ Linux/macOS ]
**Nessuno spazio nel percorso del file**
```
[profile process-credential-profile]
credential_process = /path/to/credential/file/credential_file.sh --custom-command custom_parameter
```
**Spazi nel percorso del file**
```
[profile process-credential-profile]
credential_process = "/path/with/space to/credential/file/credential_file.sh" --custom-command custom_parameter
```
------
#### [ Windows ]
**Nessuno spazio nel percorso del file**
```
[profile process-credential-profile]
credential_process = C:\Path\To\credentials.cmd --custom_command custom_parameter
```
**Spazi nel percorso del file**
```
[profile process-credential-profile]
credential_process = "C:\Path\With Space To\credentials.cmd" --custom_command custom_parameter
```
------
Il seguente frammento di codice mostra come creare un client di servizio che utilizza le credenziali temporanee definite come parte del profilo denominato. `process-credential-profile`
```
Region region = Region.US_WEST_2;
S3Client s3Client = S3Client.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("process-credential-profile"))
.build();
```
Per informazioni dettagliate sull'utilizzo di un processo esterno come fonte di credenziali temporanee, consultate la [sezione relativa alle credenziali di processo nella and Tools Reference](https://docs.aws.amazon.com/sdkref/latest/guide/feature-process-credentials.html) Guide. AWS SDKs
## Utilizzate un `ProcessCredentialsProvider`
In alternativa all'utilizzo delle impostazioni nel `config` file, puoi utilizzare gli SDK `[ProcessCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProcessCredentialsProvider.html)` per caricare le credenziali temporanee utilizzando Java.
Gli esempi seguenti mostrano varie versioni di come specificare un processo esterno utilizzando `ProcessCredentialsProvider` e configurare un client di servizio che utilizza le credenziali temporanee.
------
#### [ Linux/macOS ]
**Nessuno spazio nel percorso del file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path/to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Spazi nel percorso del file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path\\ with\\ spaces\\ to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
#### [ Windows ]
**Nessuno spazio nel percorso del file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("C:\\Path\\To\\credentials.exe optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Spazi nel percorso del file**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("\"C:\\Path\\With Spaces To\\credentials.exe\" optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
## Usa IAM Roles Anywhere per l'autenticazione
[IAM Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) Servizio AWS ti consente di ottenere AWS credenziali temporanee per carichi di lavoro eseguiti al di fuori di. AWS Consente l'accesso sicuro alle AWS risorse da ambienti locali o altri ambienti cloud.
Prima di poter autenticare le richieste con IAM Roles Anywhere, devi prima raccogliere le informazioni richieste e scaricare lo strumento di supporto alle [credenziali](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html). Seguendo le istruzioni [introduttive](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html) nella Guida per l'utente di IAM Roles Anywhere, puoi creare gli elementi necessari.
L'SDK for Java non dispone di un provider di credenziali dedicato per recuperare credenziali temporanee da IAM Roles Anywhere, ma puoi utilizzare lo strumento di supporto delle credenziali insieme a una delle opzioni per recuperare le credenziali [da](#credentials-process) un processo esterno.
### Usa l'impostazione in un profilo `credential_process`
Il seguente frammento del file di AWS configurazione condiviso mostra un profilo denominato `roles_anywhere` che utilizza l'impostazione: `credential_process`
```
[profile roles_anywhere]
credential_process = ./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
```
È necessario sostituire il testo mostrato in rosso con i valori dopo aver assemblato tutti gli artefatti. Il primo elemento dell'impostazione,`aws_signing_helper`, è l'eseguibile dello strumento di supporto alle credenziali ed `credential-process` è il comando.
Quando configuri un client di servizio per l'utilizzo del `roles_anywhere` profilo, come illustrato nel codice seguente, l'SDK memorizza nella cache le credenziali temporanee e le aggiorna prima della scadenza:
```
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileName("roles_anywhere").build())
.build();
```
### Configura un `ProcessCredentialsProvider`
Come illustrato di seguito, puoi utilizzare un approccio basato solo sul codice con, `ProcessCredentialsProvider` anziché utilizzare le impostazioni del profilo:
```
ProcessCredentialsProvider processCredentialsProvider = ProcessCredentialsProvider.builder()
.command("""
./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
""").build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(processCredentialsProvider)
.build();
```
Sostituisci il testo mostrato in rosso con i tuoi valori dopo aver assemblato tutti gli artefatti.
# Fornite le credenziali in codice utilizzando il AWS SDK for Java 2.x
Se la catena di credenziali predefinita o un provider o una catena di fornitori specifici o personalizzati non funzionano per l'applicazione, puoi fornire credenziali temporanee direttamente nel codice. Queste possono essere [credenziali di ruolo IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html) come [descritto sopra](credentials-temporary.md#credentials-temporary-from-portal) o credenziali temporanee recuperate da (). AWS Security Token Service AWS STS Se hai recuperato credenziali temporanee utilizzando AWS STS, forniscile a un Servizio AWS client come mostrato nel seguente esempio di codice.
1. Assumi un ruolo chiamando. `StsClient.assumeRole()`
1. Crea un [StaticCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/StaticCredentialsProvider.html)oggetto e forniscilo con l'`AwsSessionCredentials`oggetto.
1. Configura il service client builder con `StaticCredentialsProvider` e crea il client.
L'esempio seguente crea un client di servizio Amazon S3 utilizzando credenziali temporanee restituite da AWS STS per un ruolo assunto da IAM.
```
// The AWS IAM Identity Center identity (user) who executes this method does not have permission to list buckets.
// The identity is configured in the [default] profile.
public static void assumeRole(String roleArn, String roleSessionName) {
// The IAM role represented by the 'roleArn' parameter can be assumed by identities in two different accounts
// and the role permits the user to only list buckets.
// The SDK's default credentials provider chain will find the single sign-on settings in the [default] profile.
// The identity configured with the [default] profile needs permission to call AssumeRole on the STS service.
try {
Credentials tempRoleCredentials;
try (StsClient stsClient = StsClient.create()) {
AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
.roleArn(roleArn)
.roleSessionName(roleSessionName)
.build();
AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
tempRoleCredentials = roleResponse.credentials();
}
// Use the following temporary credential items for the S3 client.
String key = tempRoleCredentials.accessKeyId();
String secKey = tempRoleCredentials.secretAccessKey();
String secToken = tempRoleCredentials.sessionToken();
// List all buckets in the account associated with the assumed role
// by using the temporary credentials retrieved by invoking stsClient.assumeRole().
StaticCredentialsProvider staticCredentialsProvider = StaticCredentialsProvider.create(
AwsSessionCredentials.create(key, secKey, secToken));
try (S3Client s3 = S3Client.builder()
.credentialsProvider(staticCredentialsProvider)
.build()) {
List buckets = s3.listBuckets().buckets();
for (Bucket bucket : buckets) {
System.out.println("bucket name: " + bucket.name());
}
}
} catch (StsException | S3Exception e) {
logger.error(e.getMessage());
System.exit(1);
}
}
```
## Set di autorizzazioni
Il seguente set di autorizzazioni definito in AWS IAM Identity Center consente all'identità (utente) di eseguire le due operazioni seguenti
1. Il `GetObject` funzionamento di Amazon Simple Storage Service.
1. Il `AssumeRole` funzionamento di AWS Security Token Service.
Senza assumere il ruolo, il `s3.listBuckets()` metodo illustrato nell'esempio fallirebbe.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"sts:AssumeRole"
],
"Resource": [
"*"
]
}
]
}
```
------
## Ruolo assunto
### Politica sulle autorizzazioni relative ai ruoli assunti
La seguente politica di autorizzazioni è allegata al ruolo assunto nell'esempio precedente. Questa politica di autorizzazioni consente di elencare tutti i bucket nello stesso account del ruolo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets"
],
"Resource": [
"*"
]
}
]
}
```
------
### Politica di fiducia per i ruoli assunti
La seguente politica di fiducia è associata al ruolo assunto nell'esempio precedente. La politica consente alle identità (utenti) di assumere il ruolo in due account.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:root",
"arn:aws:iam::555555555555:root"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
# Leggi le credenziali del ruolo IAM su Amazon EC2 utilizzando l'SDK for Java 2.x
Puoi utilizzare un ruolo IAM per gestire le credenziali temporanee per le applicazioni in esecuzione su un'istanza EC2 e che AWS CLI effettuano richieste API. AWS Ciò è preferibile all’archiviazione delle chiavi di accesso nell’istanza EC2. Per assegnare un AWS ruolo a un'istanza EC2 e renderlo disponibile per tutte le sue applicazioni, crei un profilo di istanza collegato all'istanza. Un profilo dell’istanza contiene il ruolo e consente ai programmi in esecuzione sull’istanza EC2 di ottenere le credenziali temporanee. Per ulteriori informazioni, consulta [Utilizzare un ruolo IAM per concedere autorizzazioni alle applicazioni che eseguono istanze Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) nella *Guida per l'utente IAM*.
Questo argomento fornisce informazioni su come configurare l'applicazione Java per l'esecuzione su un'istanza EC2 e abilitare l'acquisizione IAM delle credenziali AWS SDK for Java 2.x di ruolo.
## Acquisisci le credenziali del ruolo IAM dall'ambiente
Se l'applicazione crea un client di AWS servizio utilizzando il `create` metodo (o i `builder().build()` metodi), l'SDK for Java utilizza *la catena di provider di credenziali predefinita*. La catena di fornitori di credenziali predefinita cerca nell'ambiente di esecuzione gli elementi di configurazione che l'SDK può scambiare con credenziali temporanee. La [Catena di fornitori di credenziali predefinita in AWS SDK for Java 2.x](credentials-chain.md) sezione descrive il processo di ricerca completo.
L'ultimo passaggio della catena di provider predefinita è disponibile solo quando l'applicazione viene eseguita su un' Amazon EC2 istanza. In questa fase, l'SDK utilizza un `InstanceProfileCredentialsProvider` per leggere il ruolo IAM definito nel profilo dell'istanza EC2. L'SDK acquisisce quindi le credenziali temporanee per quel ruolo IAM.
Sebbene queste credenziali siano temporanee e alla fine scadano, An le aggiorna `InstanceProfileCredentialsProvider` periodicamente in modo che continuino a consentirne l'accesso. AWS
## Acquisisci le credenziali del ruolo IAM a livello di codice
In alternativa alla catena di provider di credenziali predefinita che alla fine utilizza un client di servizio `InstanceProfileCredentialsProvider` su EC2, puoi configurare un client di servizio in modo esplicito con un. `InstanceProfileCredentialsProvider` Questo approccio è illustrato nel frammento seguente.
```
S3Client s3 = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
## Acquisisci in modo sicuro le credenziali dei ruoli IAM
Per impostazione predefinita, le istanze EC2 eseguono [IMDS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) (Instance Metadata Service) che consente agli SDK di accedere `InstanceProfileCredentialsProvider` a informazioni come il ruolo IAM che è stato configurato. Per impostazione predefinita, le istanze EC2 eseguono due versioni di IMDS:
+ Instance Metadata Service Version 1 ()IMDSv1: un metodo request/response
+ Instance Metadata Service Version 2 (IMDSv2): un metodo orientato alla sessione
[IMDSv2 è un approccio più sicuro di.](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/) IMDSv1
Per impostazione predefinita, Java SDK tenta innanzitutto di IMDSv2 ottenere il ruolo IAM, ma se fallisce, ci prova IMDSv1. Tuttavia, poiché IMDSv1 è meno sicuro, AWS consiglia di utilizzare IMDSv2 solo l'SDK e di disabilitarne i tentativi. IMDSv1
Per utilizzare un approccio più sicuro, disabilita l'utilizzo dell'SDK IMDSv1 fornendo una delle seguenti impostazioni con un valore di. `true`
+ Variabile d'ambiente: `AWS_EC2_METADATA_V1_DISABLED`
+ Proprietà del sistema JVM: aws. `disableEc2MetadataV1`
+ Impostazione del file di configurazione condiviso: `ec2_metadata_v1_disabled`
Con una di queste impostazioni impostata su`true`, l'SDK non carica le credenziali del ruolo IMDS utilizzando IMDSv1 se la chiamata iniziale fallisce. IMDSv2