

La AWS SDK per Java 1.x è stata raggiunta end-of-support il 31 dicembre 2025. Ti consigliamo di eseguire la migrazione a per continuare [AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/home.html)a ricevere nuove funzionalità, miglioramenti della disponibilità e aggiornamenti di sicurezza.

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 ruoli IAM per concedere l'accesso alle AWS risorse su Amazon EC2
<a name="java-dg-roles"></a>

Tutte le richieste a Amazon Web Services (AWS) devono essere firmate crittograficamente utilizzando credenziali emesse da. AWS Puoi utilizzare *i ruoli IAM* per garantire comodamente un accesso sicuro alle AWS risorse delle tue istanze. Amazon EC2 

Questo argomento fornisce informazioni su come utilizzare i ruoli IAM con le applicazioni Java SDK in esecuzione. Amazon EC2 Per ulteriori informazioni sulle istanze IAM, consulta [IAM Roles for Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) nella Guida Amazon EC2 utente per le istanze Linux.

## La catena di provider e EC2 i profili di istanza predefiniti
<a name="default-provider-chain"></a>

Se l'applicazione crea un AWS client utilizzando il costruttore predefinito, il client cercherà le credenziali utilizzando la *catena di provider di credenziali di default*, nell'ordine seguente:

1. Nelle proprietà del sistema Java: `aws.accessKeyId` e `aws.secretKey`.

1. Nelle variabili di ambiente del sistema: `AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY`.

1. Nel file delle credenziali predefinito (il percorso di questo file varia in base alla piattaforma).

1. Credenziali fornite tramite il servizio Amazon EC2 contenitore se la variabile di `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` ambiente è impostata e il responsabile della sicurezza è autorizzato ad accedere alla variabile.

1. Nel *profilo di istanza, le credenziali* presenti nei metadati dell'istanza associati al ruolo IAM per l'istanza. EC2 

1. Credenziali Web Identity Token dall'ambiente o dal contenitore.

La fase relativa alle *credenziali del profilo di istanza* nella catena di provider predefinita è disponibile solo quando si esegue l'applicazione su un' Amazon EC2 istanza, ma offre la massima facilità d'uso e la massima sicurezza quando si lavora con Amazon EC2 le istanze. Puoi anche passare un'[InstanceProfileCredentialsProvider](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/auth/InstanceProfileCredentialsProvider.html)istanza direttamente al costruttore del client per ottenere le credenziali del profilo dell'istanza senza procedere attraverso l'intera catena di provider predefinita.

Per esempio:

```
AmazonS3 s3 = AmazonS3ClientBuilder.standard()
              .withCredentials(new InstanceProfileCredentialsProvider(false))
              .build();
```

Quando si utilizza questo approccio, l'SDK recupera AWS credenziali temporanee con le stesse autorizzazioni di quelle associate al ruolo IAM associato all'istanza nel relativo profilo di istanza. Amazon EC2 Sebbene queste credenziali siano temporanee e alla fine scadano, le aggiorna `InstanceProfileCredentialsProvider` periodicamente in modo che le credenziali ottenute continuino a consentire l'accesso a. AWS

**Importante**  
L'aggiornamento automatico delle credenziali avviene *solo* quando si utilizza il costruttore client predefinito, che ne crea uno proprio `InstanceProfileCredentialsProvider` come parte della catena di provider predefinita, o quando si passa un'`InstanceProfileCredentialsProvider`istanza direttamente al costruttore del client. Se utilizzi un altro metodo per ottenere o passare le credenziali del profilo dell'istanza, sei responsabile del controllo e dell'aggiornamento delle credenziali scadute.

Se il costruttore del client non riesce a trovare le credenziali utilizzando la catena di fornitori di credenziali, genererà un. [AmazonClientException](https://docs.aws.amazon.com/sdk-for-java/v1/reference/com/amazonaws/AmazonClientException.html)

## Procedura dettagliata: utilizzo dei ruoli IAM per le istanze EC2
<a name="roles-walkthrough"></a>

La seguente procedura dettagliata mostra come recuperare un oggetto Amazon S3 utilizzando un ruolo IAM per gestire l'accesso.

### Creazione di un ruolo IAM
<a name="java-dg-create-the-role"></a>

Crea un ruolo IAM che garantisca l'accesso in sola lettura a. Amazon S3

1. Apri la [console IAM](https://console.aws.amazon.com/iam/home).

1. Nel riquadro di navigazione, seleziona **Ruoli**, quindi **Crea** nuovo ruolo.

1. Inserisci un nome per il ruolo, quindi seleziona **Next Step (Fase successiva)**. Ricorda questo nome, poiché ti servirà all'avvio dell' Amazon EC2 istanza.

1. Nella pagina **Seleziona il tipo di ruolo**, in ** Servizio AWS Ruoli**, seleziona ** Amazon EC2 **.

1. Nella pagina **Imposta autorizzazioni**, in **Seleziona modello di policy**, seleziona **Accesso in sola Amazon S3 lettura**, quindi **Passaggio successivo**.

1. Nella pagina di **revisione**, seleziona **Crea ruolo**.

### Avvia un' EC2 istanza e specifica il tuo ruolo IAM
<a name="java-dg-launch-ec2-instance-with-instance-profile"></a>

Puoi avviare un' Amazon EC2 istanza con un ruolo IAM utilizzando la Amazon EC2 console o il AWS SDK per Java.
+ Per avviare un' Amazon EC2 istanza utilizzando la console, segui le istruzioni riportate in [Getting Started with Amazon EC2 Linux Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) nella Guida per l' Amazon EC2 utente delle istanze Linux.

  Quando raggiungi la pagina **Review Instance Launch (Verifica del lancio dell'istanza)**, seleziona **Edit instance details (Modifica dettagli istanza)**. Nel **ruolo IAM**, scegli il ruolo IAM che hai creato in precedenza. Completa la procedura come descritto.
**Nota**  
Dovrai creare o utilizzare un gruppo di sicurezza e una coppia di chiavi esistenti per connetterti all'istanza.
+ Per avviare un' Amazon EC2 istanza con un ruolo IAM utilizzando il AWS SDK per Java, consulta [Run an Amazon EC2 Instance](run-instance.md).

### Crea la tua applicazione
<a name="java-dg-remove-the-credentials"></a>

Creiamo l'applicazione di esempio da eseguire sull' EC2 istanza. Per prima cosa, crea una directory che puoi usare per contenere i file del tutorial (ad esempio,`GetS3ObjectApp`).

Quindi, copiate le AWS SDK per Java librerie nella cartella appena creata. Se le hai AWS SDK per Java scaricate nella tua `~/Downloads` directory, puoi copiarle usando i seguenti comandi:

```
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/lib .
cp -r ~/Downloads/aws-java-sdk-{1.7.5}/third-party .
```

Aprite un nuovo file, richiamatelo `GetS3Object.java` e aggiungete il seguente codice:

```
import java.io.*;

import com.amazonaws.auth.*;
import com.amazonaws.services.s3.*;
import com.amazonaws.services.s3.model.*;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;

public class GetS3Object {
  private static final String bucketName = "text-content";
  private static final String key = "text-object.txt";

  public static void main(String[] args) throws IOException
  {
    AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();

    try {
      System.out.println("Downloading an object");
      S3Object s3object = s3Client.getObject(
          new GetObjectRequest(bucketName, key));
      displayTextInputStream(s3object.getObjectContent());
    }
    catch(AmazonServiceException ase) {
      System.err.println("Exception was thrown by the service");
    }
    catch(AmazonClientException ace) {
      System.err.println("Exception was thrown by the client");
    }
  }

  private static void displayTextInputStream(InputStream input) throws IOException
  {
    // Read one text line at a time and display.
    BufferedReader reader = new BufferedReader(new InputStreamReader(input));
    while(true)
    {
      String line = reader.readLine();
      if(line == null) break;
      System.out.println( "    " + line );
    }
    System.out.println();
  }
}
```

Apri un nuovo file, chiamalo `build.xml` e aggiungi le seguenti righe:

```
<project name="Get {S3} Object" default="run" basedir=".">
  <path id="aws.java.sdk.classpath">
    <fileset dir="./lib" includes="**/*.jar"/>
    <fileset dir="./third-party" includes="**/*.jar"/>
    <pathelement location="lib"/>
    <pathelement location="."/>
  </path>

  <target name="build">
  <javac debug="true"
    includeantruntime="false"
    srcdir="."
    destdir="."
    classpathref="aws.java.sdk.classpath"/>
  </target>

  <target name="run" depends="build">
    <java classname="GetS3Object" classpathref="aws.java.sdk.classpath" fork="true"/>
  </target>
</project>
```

Compila ed esegui il programma modificato. Nota che non ci sono credenziali memorizzate nel programma. Pertanto, a meno che non siano già state specificate AWS le credenziali, il codice verrà generato. `AmazonServiceException` Per esempio:

```
$ ant
Buildfile: /path/to/my/GetS3ObjectApp/build.xml

build:
  [javac] Compiling 1 source file to /path/to/my/GetS3ObjectApp

run:
   [java] Downloading an object
   [java] AmazonServiceException

BUILD SUCCESSFUL
```

### Trasferisci il programma compilato sulla tua istanza EC2
<a name="java-dg-transfer-compiled-program-to-ec2-instance"></a>

Trasferisci il programma sulla tua Amazon EC2 istanza utilizzando secure copy (**``**), insieme alle AWS SDK per Java librerie. La sequenza di comandi è simile alla seguente.

```
scp -p -i {my-key-pair}.pem GetS3Object.class ec2-user@{public_dns}:GetS3Object.class
scp -p -i {my-key-pair}.pem build.xml ec2-user@{public_dns}:build.xml
scp -r -p -i {my-key-pair}.pem lib ec2-user@{public_dns}:lib
scp -r -p -i {my-key-pair}.pem third-party ec2-user@{public_dns}:third-party
```

**Nota**  
A seconda della distribuzione Linux utilizzata, il *nome utente* potrebbe essere «ec2-user», «root» o «ubuntu». Per ottenere il nome DNS pubblico dell'istanza, apri la [EC2 console](https://console.aws.amazon.com/ec2/home) e cerca il valore **Public DNS** nella scheda **Descrizione** (ad esempio,). `ec2-198-51-100-1.compute-1.amazonaws.com`

Nei comandi precedenti:
+  `GetS3Object.class`è il tuo programma compilato
+  `build.xml`è il file ant utilizzato per creare ed eseguire il programma
+ le `third-party` directory `lib` e sono le cartelle della libreria corrispondenti da. AWS SDK per Java
+ L'`-r`interruttore indica che `scp` dovrebbe fare una copia ricorsiva di tutti i contenuti delle `third-party` directory `library` e della distribuzione. AWS SDK per Java 
+ L'`-p`interruttore indica che `scp` deve conservare le autorizzazioni dei file di origine quando li copia nella destinazione.
**Nota**  
Lo `-p` switch funziona solo su Linux, macOS o Unix. Se stai copiando file da Windows, potresti dover correggere le autorizzazioni relative ai file sull'istanza utilizzando il seguente comando:

```
chmod -R u+rwx GetS3Object.class build.xml lib third-party
```

### Esegui il programma di esempio sull'istanza EC2
<a name="java-dg-run-the-program"></a>

Per eseguire il programma, connettiti alla tua Amazon EC2 istanza. Per ulteriori informazioni, consulta [Connect to Your Linux Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstances.html) nella Amazon EC2 User Guide for Linux Instances.

Se non **` ant `**è disponibile sulla tua istanza, installala utilizzando il seguente comando:

```
sudo yum install ant
```

Quindi, esegui il programma `ant` nel modo seguente:

```
ant run
```

Il programma scriverà il contenuto dell' Amazon S3 oggetto nella finestra di comando.