Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Création d'une application simple à l'aide du AWS SDK for Java 2.x
<a name="get-started-tutorial"></a>

Ce didacticiel explique comment utiliser [Apache Maven](https://maven.apache.org/) pour définir les dépendances du SDK pour Java 2.x, puis écrire le code permettant de se connecter Amazon S3 pour télécharger un fichier.

Pour terminer ce didacticiel, procédez comme suit :
+  [Étape 1 : Configuration de ce didacticiel](#get-started-setup) 
+  [Étape 2 : Création du projet](#get-started-projectsetup) 
+  [Étape 3 : Écrire le code](#get-started-code) 
+  [Étape 4 : créer et exécuter l'application](#get-started-run) 

## Étape 1 : Configuration pour ce didacticiel
<a name="get-started-setup"></a>

Avant de commencer ce didacticiel, vous aurez besoin des éléments suivants :
+ Autorisation d'accès Amazon S3
+ Un environnement de développement Java configuré pour accéder à Services AWS l'aide de l'authentification unique à AWS IAM Identity Center

Suivez les instructions ci-dessous [Présentation de la configuration](setup.md#setup-overview) pour vous préparer à ce didacticiel. Une fois que vous avez [configuré votre environnement de développement avec un accès par authentification unique](get-started-auth.md#setup-credentials) pour le SDK Java et que vous disposez d'une [session de portail d' AWS accès active](get-started-auth.md#setup-login-sso), passez à l'étape 2 de ce didacticiel.

## Étape 2 : Création du projet
<a name="get-started-projectsetup"></a>

Pour créer le projet pour ce didacticiel, vous devez exécuter une commande Maven qui vous invite à saisir des informations sur la configuration du projet. Une fois toutes les entrées saisies et confirmées, Maven termine la création du projet en créant un `pom.xml` et crée des fichiers Java stub.

1. Ouvrez un terminal ou une fenêtre d’invite de commande et naviguez jusqu’au répertoire de votre choix, par exemple, le dossier `Desktop` ou `Home`.

1. Entrez la commande suivante sur le terminal et appuyez sur`Enter`.

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

1. Entrez la valeur répertoriée dans la deuxième colonne pour chaque invite.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sdk-for-java/latest/developer-guide/get-started-tutorial.html)

1. Une fois la dernière valeur saisie, Maven répertorie les choix que vous avez effectués. Confirmez en saisissant *`Y`*ou entrez à nouveau des valeurs en saisissant *`N`*.

Maven crée le dossier de projet nommé `getstarted` en fonction de la `artifactId` valeur que vous avez saisie. Dans le `getstarted` dossier, trouvez un `README.md` fichier que vous pouvez consulter, un `pom.xml` fichier et un `src` répertoire.

Maven crée l’arborescence de répertoires suivante.

```
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
```

L’exemple suivant affiche le contenu du fichier du projet `pom.xml`.

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

La `dependencyManagement` section contient une dépendance par rapport à Amazon S3 AWS SDK for Java 2.x et possède une dépendance par rapport à Amazon S3. `dependencies` Le projet utilise Java 1.8 en raison de la valeur `1.8` des propriétés `maven.compiler.source` et `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>
```

## Étape 3 : Écriture du code
<a name="get-started-code"></a>

Le code suivant montre la `App` classe créée par Maven. La méthode `main` est le point d’entrée dans l’application, qui crée une instance de la classe `Handler` puis appelle sa méthode `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 créée par Maven contient la méthode `s3Client` factory qui construit et renvoie une [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)instance. L’instance `S3Client` utilise une instance du client HTTP basé sur Apache. Cela est dû au fait que vous avez spécifié `apache-client` quand Maven vous a invité à spécifier le client HTTP à utiliser.

Cela `DependencyFactory` est indiqué dans le code suivant.

### 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` contient la logique principale de votre programme. Lorsqu’une instance de `Handler` est créée dans la classe `App`, la `DependencyFactory` fournit le client de service `S3Client`. Votre code utilise l'`S3Client`instance pour appeler le service Amazon S3.

Maven génère la classe `Handler` suivante avec un commentaire `TODO`. L'étape suivante du didacticiel remplace le code *`TODO`*par.

### Classe `Handler`, générée par 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.
    }
}
```

Pour renseigner la logique, remplacez l’ensemble du contenu de la classe `Handler` par le code suivant. La méthode `sendRequest` est renseignée et les importations nécessaires sont ajoutées.

### Classe `Handler`, implémentée
<a name="code-collapse4"></a>

Le code crée d'abord un nouveau compartiment S3 avec la dernière partie du nom généré `System.currentTimeMillis()` afin de rendre le nom du compartiment unique.

Après avoir créé le compartiment dans la `createBucket()` méthode, le programme télécharge un objet à l'aide de la [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))méthode de`S3Client`. Le contenu de l'objet est une chaîne simple créée avec la `RequestBody.fromString` méthode.

Enfin, le programme supprime l'objet suivi du bucket dans la `cleanUp` méthode.

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

## Étape 4 : Création et exécution de l’application
<a name="get-started-run"></a>

Une fois que le projet est créé et contient la `Handler` classe complète, créez et exécutez l'application. 

1. Assurez-vous que vous disposez d'une session IAM Identity Center active. Pour ce faire, exécutez la AWS Command Line Interface commande `aws sts get-caller-identity` et vérifiez la réponse. Si vous n'avez pas de session active, consultez [cette section](get-started-auth.md#setup-login-sso) pour obtenir des instructions.

1. Ouvrez un terminal ou une fenêtre d’invite de commande et accédez au répertoire de votre projet `getstarted`.

1. Utilisez la commande suivante pour créer votre projet :

   ```
   mvn clean package
   ```

1. Utilisez la commande suivante pour exécuter l'application.

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

Pour afficher le nouveau bucket et le nouvel objet créés par le programme, effectuez les opérations suivantes.

1. Dans`Handler.java`, commentez la ligne `cleanUp(s3Client, bucket, key)` dans la `sendRequest` méthode et enregistrez le fichier.

1. Reconstruisez le projet en exécutant`mvn clean package`.

1. Exécutez à nouveau `mvn exec:java -Dexec.mainClass="org.example.App"` pour télécharger l'objet texte une fois de plus.

1. Connectez-vous à [la console S3](https://console.aws.amazon.com/s3/) pour afficher le nouvel objet dans le compartiment nouvellement créé.

Après avoir consulté le fichier, supprimez l’objet, puis le compartiment.

### Réussite
<a name="get-started-success"></a>

Si votre projet Maven a été créé et exécuté sans erreur, félicitations \$1 Vous avez créé avec succès votre première application Java à l'aide du SDK pour Java 2.x.

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

Pour nettoyer les ressources que vous avez créées au cours de ce didacticiel, procédez comme suit :
+ Si ce n'est pas déjà fait, dans [la console S3](https://console.aws.amazon.com/s3/), supprimez tous les objets et les compartiments créés lors de l'exécution de l'application.
+ Supprimez le dossier du projet (`getstarted`).

## Étapes suivantes
<a name="get-started-next"></a>

Maintenant que vous connaissez les notions de base, vous pouvez en apprendre davantage sur les points suivants :
+  [Travailler avec Amazon S3](examples-s3.md) 
+  [Travailler avec d'autres Amazon Web Services](work-with-services.md) [services de base de données [DynamoDB[Amazon EC2](examples-ec2.md)](examples-dynamodb.md), tels que, et divers](examples-databases.md) 
+  [Utiliser le SDK](using.md) 
+  [Sécurité pour AWS SDK pour Java](security.md) **