AWS Cloud9 n'est plus disponible pour les nouveaux clients. Les clients existants d’ AWS Cloud9 peuvent continuer à l’utiliser normalement. [En savoir plus](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/) 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. # Tutoriel Java pour AWS Cloud9 **Important** Si vous utilisez un environnement de AWS Cloud9 développement soutenu par une instance EC2 dotée de 2 Go de mémoire ou plus, nous vous recommandons d'activer le support Java amélioré. Cela permet d'accéder à des fonctions de productivité telles que la saisie semi-automatique du code, le linting pour les erreurs, les actions spécifiques au contexte et les options de débogage telles que les points d'arrêt et les étapes. Pour de plus amples informations, veuillez consulter [Prise en charge renforcée pour le développement Java](enhanced-java.md). Ce didacticiel vous permet d'exécuter du code Java dans un environnement de AWS Cloud9 développement. Le fait de suivre ce didacticiel et de créer cet exemple peut entraîner des frais sur votre AWS compte. Il peut s'agir de frais pour des services tels qu'Amazon EC2 et Amazon S3. Pour en savoir plus, consultez les sections [Tarification Amazon EC2](https://aws.amazon.com/ec2/pricing/) et [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/). **Topics** + [Conditions préalables](#sample-java-prerequisites) + [Étape 1 : Installer les outils requis](#sample-java-install) + [Étape 2 : Ajouter du code](#sample-java-code) + [Étape 3 : Créer et exécuter le code](#sample-java-run) + [Étape 4 : Configuration pour utiliser le AWS SDK pour Java](#sample-java-sdk) + [Étape 5 : configurer la gestion des AWS informations d'identification dans votre environnement](#sample-java-sdk-creds) + [Étape 6 : ajouter le code du AWS SDK](#sample-java-sdk-code) + [Étape 7 : créer et exécuter le code du AWS SDK](#sample-java-sdk-run) + [Étape 8 : nettoyer](#sample-java-clean-up) ## Conditions préalables Avant d'utiliser cet exemple, vérifiez que votre configuration respecte les conditions requises suivantes : + **Vous devez disposer d'un environnement de développement AWS Cloud9 EC2 existant.** Cet exemple suppose que vous disposez déjà d'un environnement EC2 connecté à une instance Amazon EC2 s'exécutant sur Amazon Linux ou Ubuntu Server. Si vous utilisez un autre type d'environnement ou de système d'exploitation, vous devrez peut-être adapter les instructions de cet exemple pour configurer les outils associés. Pour de plus amples informations, veuillez consulter [Création d'un environnement dans AWS Cloud9](create-environment.md). + **L' AWS Cloud9 IDE correspondant à l'environnement existant est déjà ouvert.** Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE correspondant à cet environnement dans votre navigateur Web. Pour de plus amples informations, veuillez consulter [Ouvrir un environnement dans AWS Cloud9](open-environment.md). ## Étape 1 : Installer les outils requis Au cours de cette étape, vous allez installer un ensemble d'outils de développement Java dans votre environnement de AWS Cloud9 développement. Si vous disposez déjà d'un ensemble d'outils de développement Java tels que le JDK Oracle ou OpenJDK installé dans votre environnement, vous pouvez passer directement à [Étape 2 : Ajouter du code](#sample-java-code). Cet exemple a été développé avec OpenJDK 8, que vous pouvez installer dans votre environnement en effectuant la procédure suivante. 1. Vérifiez si OpenJDK 8 est déjà installé. Pour ce faire, dans une session de terminal dans l' AWS Cloud9 IDE, exécutez la version en ligne de commande du Java Runner avec l'**`-version`**option. (Pour démarrer une nouvelle séance de terminal, dans la barre de menus, choisissez **Window** (Fenêtre), **New Terminal** (Nouveau terminal).) ``` java -version ``` En fonction de la sortie de la commande précédente, exécutez l'une des actions suivantes : + Si la sortie indique que la commande `java` n'est pas trouvée, passez à l'étape 2 de la procédure pour installer OpenJDK 8. + Si la sortie contient des valeurs commençant par `Java(TM)``Java Runtime Environment`, `Java SE`, `J2SE` ou `Java2`, l'OpenJDK n'est pas installé ou n'est pas défini en tant qu'ensemble d'outils de développement Java par défaut. Continuez avec l'étape 2 de cette procédure pour installer OpenJDK 8, puis passez à l'utilisation d'OpenJDK 8. + Si la sortie contient des valeurs commençant par `java version 1.8` et `OpenJDK`, passez directement à [Étape 2 : Ajouter du code](#sample-java-code). OpenJDK 8 est installé correctement pour cet exemple. + Si la sortie contient une `java version` inférieure à `1.8` et que les valeurs commencent par `OpenJDK`, passez à l'étape 2 de cette procédure pour mettre à niveau la version OpenJDK installée vers OpenJDK 8. 1. Assurez-vous que les dernières mises à jour de sécurité et que les correctifs les plus récents sont installés. Pour ce faire, exécutez l'outil yum (pour Amazon Linux) ou l'outil apt (pour Ubuntu Server) avec la commande ** `update` **. Pour Amazon Linux : ``` sudo yum -y update ``` Pour Ubuntu Server : ``` sudo apt update ``` 1. Installez OpenJDK 8 : Pour ce faire, exécutez l'outil yum (pour Amazon Linux) ou l'outil apt (pour Ubuntu Server) avec la commande ** `install` **, en spécifiant le paquet OpenJDK 8. Pour Amazon Linux : ``` sudo yum -y install java-1.8.0-openjdk-devel ``` Pour Ubuntu Server : ``` sudo apt install -y openjdk-8-jdk ``` Pour plus d'informations, consultez la section [Procédure pour télécharger et installer les packages OpenJDK préintégrés](https://openjdk.org/install/) sur le site web OpenJDK. 1. Basculez ou mettez à niveau le jeu d'outils de développement Java par défaut vers OpenJDK 8. Pour ce faire, exécutez la commande ** `update-alternatives` ** avec l'option ** `--config` **. Exécutez cette commande deux fois pour basculer ou mettre à niveau les versions de ligne de commande de l'exécuteur et compilateur Java. ``` sudo update-alternatives --config java sudo update-alternatives --config javac ``` À chaque invite, tapez le numéro de sélection d'OpenJDK 8 (celui qui contient `java-1.8`). 1. Vérifiez que les versions de ligne de commande de l'exécuteur et compilateur Java utilisent OpenJDK 8. Pour ce faire, exécutez les versions de ligne de commande de l'exécuteur et compilateur Java avec l'option `-version`. ``` java -version javac -version ``` Si OpenJDK 8 est installé et défini correctement, la sortie de la version de l'exécuteur Java contient une valeur commençant par `openjdk version 1.8` et la sortie de la version du compilateur Java commence par la valeur `javac 1.8`. ## Étape 2 : Ajouter du code Dans l' AWS Cloud9 IDE, créez un fichier avec le code suivant, puis enregistrez le fichier sous son nom`hello.java`. (Pour créer un fichier, dans la barre de menus, choisissez **Fichier**, **Nouveau fichier**. Pour l'enregistrer, choisissez **Fichier**, **Enregistrer**.) ``` public class hello { public static void main(String []args) { System.out.println("Hello, World!"); System.out.println("The sum of 2 and 3 is 5."); int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]); System.out.format("The sum of %s and %s is %s.\n", args[0], args[1], Integer.toString(sum)); } } ``` ## Étape 3 : Créer et exécuter le code 1. Utilisez la version de ligne de commande du compilateur Java pour compiler le fichier `hello.java` en un fichier `hello.class`. Pour ce faire, à l'aide du terminal de l' AWS Cloud9 IDE, depuis le même répertoire que le `hello.java` fichier, exécutez le compilateur Java en spécifiant le `hello.java` fichier. ``` javac hello.java ``` 1. Utilisez la version de ligne de commande de l'exécuteur Java pour exécuter le fichier `hello.class`. Pour ce faire, dans le même répertoire que le fichier `hello.class`, exécutez l'exécuteur Java, en spécifiant le nom de la classe `hello` qui a été déclarée dans le fichier `hello.java`, avec deux nombres entiers à ajouter (par exemple, `5` et `9`). ``` java hello 5 9 ``` 1. Comparez votre sortie. ``` Hello, World! The sum of 2 and 3 is 5. The sum of 5 and 9 is 14. ``` ## Étape 4 : Configuration pour utiliser le AWS SDK pour Java Vous pouvez améliorer cet exemple AWS SDK pour Java pour créer un compartiment Amazon S3, répertorier vos compartiments disponibles, puis supprimer le compartiment que vous venez de créer. Dans cette étape, vous installez [Apache Maven](https://maven.apache.org/) ou [Gradle](https://gradle.org/) dans votre environnement. Maven et Gradle sont des systèmes courants d'automatisation de build qui peuvent être utilisés avec les projets Java. Une fois que vous avez installé Maven ou Gradle, vous l'utilisez pour générer un nouveau projet Java. Dans ce nouveau projet, vous ajoutez une référence au kit AWS SDK pour Java. Cela AWS SDK pour Java constitue un moyen pratique d'interagir avec des AWS services tels qu'Amazon S3, à partir de votre code Java. **Topics** + [Configuration avec Maven](#sample-java-sdk-maven) + [Configuration avec Gradle](#sample-java-sdk-gradle) ### Configuration avec Maven 1. Installez Maven dans votre environnement. Pour voir si Maven est déjà installé, à l'aide du terminal de l' AWS Cloud9 IDE, exécutez Maven avec l'**`-version`**option. ``` mvn -version ``` En cas de réussite, la sortie contient le numéro de version Maven. Si Maven est déjà installé, passez directement à l'étape 4 de cette procédure pour utiliser Maven et générer un nouveau projet Java dans votre environnement. 1. Installez Maven en utilisant le terminal pour exécuter les commandes suivantes. Pour Amazon Linux, les commandes suivantes obtiennent des informations sur le répertoire du paquet où Maven est stocké, puis utilisent ces informations pour installer Maven. ``` sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo sudo yum install -y apache-maven ``` Pour plus d'informations sur les commandes précédentes, consultez le [référentiel EPEL (Extra Packages for Enterprise Linux)](https://docs.fedoraproject.org/en-US/epel/) sur le site web Wiki de Fedora Project. Pour Ubuntu Server, exécutez la commande suivante à la place. ``` sudo apt install -y maven ``` 1. Vérifiez l'installation en exécutant Maven avec l'option ** `-version` **. ``` mvn -version ``` 1. Utilisez Maven pour générer un nouveau projet Java. Pour ce faire, utilisez le terminal pour exécuter la commande suivante à partir du répertoire dans lequel vous voulez que Maven génère le projet (par exemple, le répertoire racine de votre environnement). ``` mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false ``` La commande précédente crée la structure de répertoire suivante pour le projet de votre environnement. ``` my-app |- src | `- main | `- java | `- com | `- mycompany | `- app | `-App.java |- test | `- java | `- com | `- mycompany | `- app | `- AppTest.java `- pom.xml ``` Pour plus d'informations sur la structure de répertoire précédente, consultez [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) et [Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html) sur le site web Apache Maven Project. 1. Modifiez le fichier POM (Project Object Model) du projet. (Un fichier POM définit les paramètres d'un projet Maven.) Pour ce faire, depuis la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/pom.xml`. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `pom.xml`. ``` 4.0.0 com.mycompany.app my-app jar 1.0-SNAPSHOT org.apache.maven.plugins maven-assembly-plugin 3.6.0 jar-with-dependencies com.mycompany.app.App package single junit junit 3.8.1 test com.amazonaws aws-java-sdk 1.11.330 ``` Le fichier POM précédent inclut les paramètres de projet qui spécifient les déclarations telles que les suivantes : + Le paramètre `artifactid` de `my-app` définit le nom du répertoire racine du projet, et le paramètre `group-id` de `com.mycompany.app` définit la structure du sous-répertoire `com/mycompany/app` et la déclaration `package` des fichiers `App.Java` et `AppTest.java`. + Le paramètre `artifactId` de `my-app`, avec le paramètre `packaging` de `jar`, le paramètre `version` de `1.0-SNAPSHOT` et le paramètre `descriptorRef` de `jar-with-dependencies` définissent le nom `my-app-1.0-SNAPSHOT-jar-with-dependencies.jar` du fichier JAR de sortie. + La section `plugin` déclare qu'un seul fichier JAR, qui comprend toutes les dépendances, sera créé. + La `dependency` section contenant le `groupId` paramètre de `com.amazon.aws` et le `artifactId` paramètre de `aws-java-sdk` inclut les fichiers de AWS SDK pour Java bibliothèque. La version du kit AWS SDK pour Java à utiliser est déclarée par le paramètre `version`. Pour utiliser une autre version, remplacez ce numéro de version. Passez directement à [Étape 5 : configurer la gestion des AWS informations d'identification dans votre environnement](#sample-java-sdk-creds). ### Configuration avec Gradle 1. Installez Gradle dans votre environnement. Pour voir si Gradle est déjà installé, à l'aide du terminal de l' AWS Cloud9 IDE, exécutez Gradle avec l'**`-version`**option. ``` gradle -version ``` En cas de réussite, la sortie contient le numéro de version Gradle. Si Gradle est déjà installé, passez directement à l'étape 4 de cette procédure pour utiliser Gradle et générer un nouveau projet Java dans votre environnement. 1. Installez Gradle en utilisant le terminal pour exécuter les commandes suivantes. Ces commandes installent et exécutent outil SDKMAN\$1, puis utilisent SDKMAN\$1 pour installer la dernière version de Gradle. ``` curl -s "https://get.sdkman.io" | bash source "$HOME/.sdkman/bin/sdkman-init.sh" sdk install gradle ``` Pour plus d'informations sur les commandes précédentes, consultez [Installation](https://sdkman.io/install) sur le site Web SDKMAN\$1 et [Installer avec un gestionnaire de package](https://gradle.org/install/#with-a-package-manager) sur le site Web Gradle. 1. Vérifiez l'installation en exécutant Gradle avec l'option ** `-version` **. ``` gradle -version ``` 1. Utilisez Gradle pour générer un nouveau projet Java dans votre environnement. Pour ce faire, utilisez le terminal pour exécuter les commandes suivantes pour créer un répertoire pour le projet, puis basculez vers ce répertoire. ``` mkdir my-app cd my-app ``` 1. Exécutez la commande suivante pour que Gradle génère un nouveau projet d'application Java dans le répertoire `my-app` de votre environnement. ``` gradle init --type java-application ``` La commande précédente crée la structure de répertoire suivante pour le projet de votre environnement. ``` my-app |- .gradle | `- (various supporting project folders and files) |- gradle | `- (various supporting project folders and files) |- src | |- main | | `- java | | `- App.java | `- test | `- java | `- AppTest.java |- build.gradle |- gradlew |- gradlew.bat `- settings.gradle ``` 1. Modifiez le fichier `AppTest.java` pour le projet. (Si vous ne le faites pas, le projet risque de ne pas être généré ou de ne pas s'exécuter comme prévu). Pour ce faire, depuis la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/src/test/java/AppTest.java`. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `AppTest.java`. ``` import org.junit.Test; import static org.junit.Assert.*; public class AppTest { @Test public void testAppExists () { try { Class.forName("com.mycompany.app.App"); } catch (ClassNotFoundException e) { fail("Should have a class named App."); } } } ``` 1. Modifiez le fichier `build.gradle` pour le projet. (Un fichier `build.gradle` définit les paramètres d'un projet Maven.) Pour ce faire, depuis la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/build.gradle`. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `build.gradle`. ``` apply plugin: 'java' apply plugin: 'application' repositories { jcenter() mavenCentral() } buildscript { repositories { mavenCentral() } dependencies { classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE" } } apply plugin: "io.spring.dependency-management" dependencyManagement { imports { mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330' } } dependencies { compile 'com.amazonaws:aws-java-sdk-s3' testCompile group: 'junit', name: 'junit', version: '4.12' } run { if (project.hasProperty("appArgs")) { args Eval.me(appArgs) } } mainClassName = 'App' ``` Le fichier `build.gradle` précédent inclut les paramètres de projet qui spécifient les déclarations telles que les suivantes : + Le `io.spring.dependency-management` plugin est utilisé pour importer le AWS SDK pour Java Maven Bill of Materials (BOM) afin de gérer les AWS SDK pour Java dépendances du projet. `classpath`déclare la version à utiliser. Pour utiliser une autre version, remplacez ce numéro de version. + `com.amazonaws:aws-java-sdk-s3` inclut la partie Amazon S3 de la bibliothèque de fichiers de AWS SDK pour Java . `mavenBom` déclare la version à utiliser. Pour utiliser une autre version, remplacez ce numéro de version. ## Étape 5 : configurer la gestion des AWS informations d'identification dans votre environnement Chaque fois que vous utilisez le AWS SDK pour Java pour appeler un AWS service, vous devez fournir un ensemble d' AWS informations d'identification avec l'appel. Ces informations d'identification déterminent s'il AWS SDK pour Java dispose des autorisations appropriées pour effectuer cet appel. Si les informations d'identification ne sont pas associées aux autorisations nécessaires, l'appel échoue. Au cours de cette étape, vous allez stocker vos informations d'identification dans l'environnement. Pour ce faire, suivez les instructions de la rubrique [Téléphoner Services AWS depuis un environnement dans AWS Cloud9](credentials.md), puis revenez à cette rubrique. Pour plus d'informations, consultez la section [Configurer les informations d'identification AWS et la région pour le développement](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials) dans le *Guide du développeur AWS SDK pour Java *. ## Étape 6 : ajouter le code du AWS SDK Au cours de cette étape, vous allez ajouter du code supplémentaire pour interagir avec Amazon S3, créer un compartiment, répertorier les compartiments disponibles, puis supprimer le compartiment que vous venez de créer. Dans la fenêtre **Environment (Environnement)**, ouvrez le fichier `my-app/src/main/java/com/mycompany/app/App.java` pour Maven ou le fichier `my-app/src/main/java/App.java` pour Gradle. Dans l'éditeur, remplacez le contenu du fichier par le code suivant, puis enregistrez le fichier `App.java`. ``` package com.mycompany.app; import com.amazonaws.auth.profile.ProfileCredentialsProvider; import com.amazonaws.services.s3.AmazonS3; import com.amazonaws.services.s3.AmazonS3ClientBuilder; import com.amazonaws.services.s3.model.AmazonS3Exception; import com.amazonaws.services.s3.model.Bucket; import com.amazonaws.services.s3.model.CreateBucketRequest; import java.util.List; public class App { private static AmazonS3 s3; public static void main(String[] args) { if (args.length < 2) { System.out.format("Usage: \n" + "Example: my-test-bucket us-east-2\n"); return; } String bucket_name = args[0]; String region = args[1]; s3 = AmazonS3ClientBuilder.standard() .withCredentials(new ProfileCredentialsProvider()) .withRegion(region) .build(); // List current buckets. ListMyBuckets(); // Create the bucket. if (s3.doesBucketExistV2(bucket_name)) { System.out.format("\nCannot create the bucket. \n" + "A bucket named '%s' already exists.", bucket_name); return; } else { try { System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name); s3.createBucket(new CreateBucketRequest(bucket_name, region)); } catch (AmazonS3Exception e) { System.err.println(e.getErrorMessage()); } } // Confirm that the bucket was created. ListMyBuckets(); // Delete the bucket. try { System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name); s3.deleteBucket(bucket_name); } catch (AmazonS3Exception e) { System.err.println(e.getErrorMessage()); } // Confirm that the bucket was deleted. ListMyBuckets(); } private static void ListMyBuckets() { List buckets = s3.listBuckets(); System.out.println("My buckets now are:"); for (Bucket b : buckets) { System.out.println(b.getName()); } } } ``` ## Étape 7 : créer et exécuter le code du AWS SDK Pour exécuter le code de l'étape précédente, exécutez les commandes suivantes depuis le terminal. Ces commandes utilisent Maven ou Gradle pour créer un fichier exécutable JAR pour le projet, puis l'exécuteur Java pour exécuter le fichier JAR. Le JAR s'exécute avec le nom du compartiment à créer dans Amazon S3 (par exemple,`my-test-bucket`) et l'ID de la AWS région dans laquelle le compartiment doit être créé en entrée (par exemple,`us-east-2`). Pour Maven, exécutez les commandes suivantes. ``` cd my-app mvn package java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2 ``` Pour Gradle, exécutez les commandes suivantes. ``` gradle build gradle run -PappArgs="['my-test-bucket', 'us-east-2']" ``` Comparez le résultat obtenu à la sortie suivante. ``` My buckets now are: Creating a new bucket named 'my-test-bucket'... My buckets now are: my-test-bucket Deleting the bucket named 'my-test-bucket'... My buckets now are: ``` ## Étape 8 : nettoyer Pour éviter que votre AWS compte ne soit débité une fois que vous aurez terminé d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, veuillez consulter [Supprimer un environnement dans AWS Cloud9](delete-environment.md).