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à.

# Creazione di una semplice applicazione utilizzando AWS SDK for Java 2.x
<a name="get-started-tutorial"></a>

Questo tutorial mostra come utilizzare [Apache Maven](https://maven.apache.org/) per definire le dipendenze per l'SDK for Java 2.x e quindi scrivere codice che si connette a per caricare un file. Amazon S3 

Segui questi passaggi per completare questo tutorial:
+  [Fase 1: Configurazione per questo tutorial](#get-started-setup) 
+  [Fase 2: Creare il progetto](#get-started-projectsetup) 
+  [Fase 3: Scrivere il codice](#get-started-code) 
+  [Fase 4: Compilare ed eseguire l'applicazione](#get-started-run) 

## Fase 1: prepararsi per il tutorial
<a name="get-started-setup"></a>

Prima di iniziare questo tutorial, servirà quanto segue:
+ Autorizzazione all'accesso Amazon S3
+ Un ambiente di sviluppo Java configurato per accedere Servizi AWS tramite Single Sign-On a AWS IAM Identity Center

Usa le istruzioni riportate in questa guida [Panoramica della configurazione](setup.md#setup-overview) per prepararti a questo tutorial. Dopo aver [configurato l'ambiente di sviluppo con l'accesso Single Sign-On per Java SDK e aver avuto una sessione attiva sul](get-started-auth.md#setup-credentials) [portale di AWS accesso](get-started-auth.md#setup-login-sso), continua con la Fase 2 di questo tutorial.

## Fase 2: creare il progetto
<a name="get-started-projectsetup"></a>

Per creare il progetto per questo tutorial, si esegue un comando Maven che richiede input su come configurare il progetto. Dopo aver inserito e confermato tutti gli input, Maven completa la creazione del progetto creando un `pom.xml` file Java stub.

1. Apri un terminale o una finestra del prompt dei comandi e accedi a una directory a tua scelta, ad esempio il `Desktop` o la cartella `Home`.

1. Immettete il seguente comando nel terminale e premete. `Enter`

   ```
   mvn archetype:generate \
     -DarchetypeGroupId=software.amazon.awssdk \
     -DarchetypeArtifactId=archetype-app-quickstart \
     -DarchetypeVersion=2.27.21
   ```

1. Immettete il valore elencato nella seconda colonna per ogni prompt.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sdk-for-java/latest/developer-guide/get-started-tutorial.html)

1. Dopo aver inserito l'ultimo valore, Maven elenca le scelte effettuate. Conferma inserendo *`Y`*o reinserisci i valori inserendo. *`N`*

Maven crea la cartella di progetto denominata `getstarted` in base al `artifactId` valore inserito. All'interno della `getstarted` cartella, trova un `README.md` file che puoi rivedere, un `pom.xml` file e una `src` directory.

Maven crea la seguente struttura di cartelle.

```
getstarted
├── README.md
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── org
    │   │       └── example
    │   │           ├── App.java
    │   │           ├── DependencyFactory.java
    │   │           └── Handler.java
    │   └── resources
    │       └── simplelogger.properties
    └── test
        └── java
            └── org
                └── example
                    └── HandlerTest.java

10 directories, 7 files
```

Di seguito viene mostrato il contenuto del file di progetto `pom.xml`.

### `pom.xml`
<a name="projectsetup-collapse2"></a>

La `dependencyManagement` sezione contiene una dipendenza da AWS SDK for Java 2.x e la `dependencies` sezione ha una dipendenza per Amazon S3. Il progetto utilizza Java 1.8 a causa del valore `1.8` delle proprietà `maven.compiler.source` e `maven.compiler.target`.

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>getstarted</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.shade.plugin.version>3.2.1</maven.shade.plugin.version>
        <maven.compiler.plugin.version>3.6.1</maven.compiler.plugin.version>
        <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
        <aws.java.sdk.version>2.27.21</aws.java.sdk.version> <-------- SDK version picked up from archetype version.
        <slf4j.version>1.7.28</slf4j.version>
        <junit5.version>5.8.1</junit5.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.java.sdk.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>  <-------- S3 dependency
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>sso</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>ssooidc</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId> <-------- HTTP client specified.
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Needed to adapt Apache Commons Logging used by Apache HTTP Client to Slf4j to avoid
        ClassNotFoundException: org.apache.commons.logging.impl.LogFactoryImpl during runtime -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Test Dependencies -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit5.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin.version}</version>
            </plugin>
        </plugins>
    </build>

</project>
```

## Fase 3: scrivere il codice
<a name="get-started-code"></a>

Il codice seguente mostra la `App` classe creata da Maven. Il metodo `main` è il punto di ingresso nell’applicazione, che crea un’istanza della classe `Handler` e quindi ne richiama il metodo `sendRequest`.

### Classe `App`
<a name="projectsetup-collapse2"></a>

```
package org.example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class App {
    private static final Logger logger = LoggerFactory.getLogger(App.class);

    public static void main(String... args) {
        logger.info("Application starts");

        Handler handler = new Handler();
        handler.sendRequest();

        logger.info("Application ends");
    }
}
```

La `DependencyFactory` classe creata da Maven contiene il metodo `s3Client` factory che crea e restituisce un'istanza. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html) L’istanza `S3Client` utilizza un’istanza del client HTTP basato su Apache. Questo avviene perché si specifica `apache-client` quando Maven chiede quale client HTTP usare.

`DependencyFactory`È mostrato nel codice seguente.

### Classe `DependencyFactory`
<a name="code-collapse2"></a>

```
package org.example;

import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;

/**
 * The module containing all dependencies required by the {@link Handler}.
 */
public class DependencyFactory {

    private DependencyFactory() {}

    /**
     * @return an instance of S3Client
     */
    public static S3Client s3Client() {
        return S3Client.builder()
                       .httpClientBuilder(ApacheHttpClient.builder())
                       .build();
    }
}
```

La classe `Handler` contiene la logica principale del programma. Quando viene creata un’istanza di `Handler` nella classe `App`, `DependencyFactory` fornisce il servizio client `S3Client`. Il codice utilizza l'`S3Client`istanza per chiamare il servizio Amazon S3.

Maven genera la seguente classe `Handler` con un commento `TODO`. Il passaggio successivo del tutorial sostituisce il codice *`TODO`*with.

### Classe `Handler`, generata da Maven
<a name="code-collapsible3"></a>

```
package org.example;

import software.amazon.awssdk.services.s3.S3Client;


public class Handler {
    private final S3Client s3Client;

    public Handler() {
        s3Client = DependencyFactory.s3Client();
    }

    public void sendRequest() {
        // TODO: invoking the api calls using s3Client.
    }
}
```

Per compilare la logica, sostituisci l’intero contenuto della classe `Handler` con il codice seguente. Il metodo `sendRequest` viene compilato e vengono aggiunte le importazioni necessarie.

### Classe `Handler`, implementata
<a name="code-collapse4"></a>

Il codice crea innanzitutto un nuovo bucket S3 con l'ultima parte del nome generata utilizzando per rendere `System.currentTimeMillis()` unico il nome del bucket.

Dopo aver creato il bucket nel `createBucket()` metodo, il programma carica un oggetto utilizzando il metodo di. [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody)](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject(software.amazon.awssdk.services.s3.model.PutObjectRequest,software.amazon.awssdk.core.sync.RequestBody))`S3Client` Il contenuto dell'oggetto è una semplice stringa creata con il `RequestBody.fromString` metodo.

Infine, il programma elimina l'oggetto seguito dal bucket nel `cleanUp` metodo.

```
package org.example;

import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;
import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;
import software.amazon.awssdk.services.s3.model.HeadBucketRequest;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;


public class Handler {
    private final S3Client s3Client;

    public Handler() {
        s3Client = DependencyFactory.s3Client();
    }

    public void sendRequest() {
        String bucket = "bucket" + System.currentTimeMillis();
        String key = "key";

        createBucket(s3Client, bucket);

        System.out.println("Uploading object...");

        s3Client.putObject(PutObjectRequest.builder().bucket(bucket).key(key)
                        .build(),
                RequestBody.fromString("Testing with the {sdk-java}"));

        System.out.println("Upload complete");
        System.out.printf("%n");

        cleanUp(s3Client, bucket, key);

        System.out.println("Closing the connection to {S3}");
        s3Client.close();
        System.out.println("Connection closed");
        System.out.println("Exiting...");
    }

    public static void createBucket(S3Client s3Client, String bucketName) {
        try {
            s3Client.createBucket(CreateBucketRequest
                    .builder()
                    .bucket(bucketName)
                    .build());
            System.out.println("Creating bucket: " + bucketName);
            s3Client.waiter().waitUntilBucketExists(HeadBucketRequest.builder()
                    .bucket(bucketName)
                    .build());
            System.out.println(bucketName + " is ready.");
            System.out.printf("%n");
        } catch (S3Exception e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void cleanUp(S3Client s3Client, String bucketName, String keyName) {
        System.out.println("Cleaning up...");
        try {
            System.out.println("Deleting object: " + keyName);
            DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder().bucket(bucketName).key(keyName).build();
            s3Client.deleteObject(deleteObjectRequest);
            System.out.println(keyName + " has been deleted.");
            System.out.println("Deleting bucket: " + bucketName);
            DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucketName).build();
            s3Client.deleteBucket(deleteBucketRequest);
            System.out.println(bucketName + " has been deleted.");
            System.out.printf("%n");
        } catch (S3Exception e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        System.out.println("Cleanup complete");
        System.out.printf("%n");
    }
}
```

## Fase 4: creare ed eseguire l’applicazione
<a name="get-started-run"></a>

Dopo che il progetto è stato creato e contiene la `Handler` classe completa, create ed eseguite l'applicazione. 

1. Assicurati di avere una sessione IAM Identity Center attiva. Per farlo, esegui il AWS Command Line Interface comando `aws sts get-caller-identity` e controlla la risposta. Se non hai una sessione attiva, consulta [questa sezione](get-started-auth.md#setup-login-sso) per le istruzioni.

1. Apri un terminale o una finestra del prompt dei comandi e vai alla directory del progetto `getstarted`.

1. Usa il seguente comando per creare il tuo progetto:

   ```
   mvn clean package
   ```

1. Utilizzate il seguente comando per eseguire l'applicazione.

   ```
   mvn exec:java -Dexec.mainClass="org.example.App"
   ```

Per visualizzare il nuovo bucket e l'oggetto creati dal programma, effettuate le seguenti operazioni.

1. In`Handler.java`, commenta la riga `cleanUp(s3Client, bucket, key)` del `sendRequest` metodo e salva il file.

1. Ricostruisci il progetto `mvn clean package` eseguendo.

1. Esegui nuovamente `mvn exec:java -Dexec.mainClass="org.example.App"` per caricare l'oggetto di testo ancora una volta.

1. Accedi [alla console S3](https://console.aws.amazon.com/s3/) per visualizzare il nuovo oggetto nel bucket appena creato.

Dopo aver visualizzato il file, elimina l’oggetto e quindi elimina il bucket.

### Completato
<a name="get-started-success"></a>

Se il progetto Maven è stato creato ed eseguito senza errori, congratulazioni\$1 Hai creato con successo la tua prima applicazione Java utilizzando l'SDK for Java 2.x.

### Pulizia
<a name="cleanup"></a>

Per ripulire le risorse create durante questo tutorial, procedi come segue:
+ Se non l'hai già fatto, [nella console S3](https://console.aws.amazon.com/s3/), elimina tutti gli oggetti e i bucket creati durante l'esecuzione dell'applicazione.
+ Elimina la cartella del progetto ()`getstarted`.

## Fasi successive
<a name="get-started-next"></a>

Ora che hai le nozioni di base, puoi scoprire quanto segue:
+  [Lavorare con Amazon S3](examples-s3.md) 
+  [Lavorare con altri Amazon Web Services](work-with-services.md), ad esempio [DynamoDB[Amazon EC2](examples-ec2.md)](examples-dynamodb.md), e [vari servizi di database](examples-databases.md) 
+  [Usa l'SDK](using.md) 
+  [Sicurezza per AWS SDK per Java](security.md) **