Tutoriel Java pour AWS Cloud9 - AWS Cloud9
PrérequisÉtape 1 : Installer les outils requisÉtape 2 : Ajouter du codeÉtape 3 : Créer et exécuter le codeÉtape 4 : Configurer l'utilisation du kit AWS SDK for JavaÉtape 5 : Configurer la gestion des informations d'identification AWS dans votre environnementÉtape 6 : Ajouter du code SDK AWSÉtape 7 : Générer et exécuter le code du kit SDK AWSÉtape 8 : Nettoyer

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 développement AWS Cloud9 soutenu par une instance EC2 dotée de 2 Go ou plus de mémoire, nous vous recommandons d'activer la prise en charge améliorée de Java. 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 plus d'informations, veuillez consulter Prise en charge renforcée pour le développement Java.

Ce didacticiel vous permet d'exécuter du code Java dans un environnement de AWS Cloud9 développement.

La suite de ce didacticiel et la création de cet exemple peuvent 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 et Tarification Amazon S3.

Prérequis

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 plus d'informations, veuillez consulter Création d'un environnement dans AWS Cloud9.

  • L'IDE AWS Cloud9 correspondant à l'environnement existant est déjà ouvert. Lorsque vous ouvrez un environnement, AWS Cloud9 ouvre l'IDE associé à cet environnement dans votre navigateur web. Pour plus d'informations, veuillez consulter Ouverture d'un environnement dans AWS Cloud9.

Étape 1 : Installer les outils requis

Dans cette étape, vous installez un ensemble d'outils de développement Java dans votre environnement de développement AWS Cloud9. 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. 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'IDE AWS Cloud9, exécutez la version de ligne de commande de l'exécuteur Java avec l'option -version . (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. 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.

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

  3. 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 sur le site web OpenJDK.

  4. 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).

  5. 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'IDE AWS Cloud9, créez un fichier avec le code suivant et enregistrez le fichier sous le 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'IDE AWS Cloud9, dans le même répertoire que le fichier hello.java, exécutez le compilateur Java, en spécifiant le fichier hello.java.

    javac hello.java

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

  3. Comparez votre sortie.

    Hello, World!
The sum of 2 and 3 is 5.
The sum of 5 and 9 is 14.

Étape 4 : Configurer l'utilisation du kit AWS SDK for Java

Vous pouvez améliorer cet exemple afin d'utiliser le kit AWS SDK for 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 ou Gradle 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 for Java. Ce kit AWS SDK for Java permet d'interagir facilement avec les services AWS, tels qu'Amazon S3, à partir de votre code Java.

Configuration avec Maven

  1. Installez Maven dans votre environnement. Pour voir si Maven est déjà installé, à l'aide du terminal de l'IDE AWS Cloud9, exécutez la commande Maven avec l'option -version .

    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.

  2. 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) sur le site web Wiki de Fedora Project.

    Pour Ubuntu Server, exécutez la commande suivante à la place.

    sudo apt install -y maven

  3. Vérifiez l'installation en exécutant Maven avec l'option -version .

    mvn -version

  4. 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 et Introduction to the Standard Directory Layout sur le site web Apache Maven Project.

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

    <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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.mycompany.app</groupId>
  <artifactId>my-app</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.6.0</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <archive>
            <manifest>
              <mainClass>com.mycompany.app.App</mainClass>
            </manifest>
          </archive>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
              <goals>
                <goal>single</goal>
              </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.amazonaws</groupId>
      <artifactId>aws-java-sdk</artifactId>
      <version>1.11.330</version>
    </dependency>
  </dependencies>
</project>

    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 section dependency avec le paramètre groupId de com.amazon.aws et le paramètre artifactId de aws-java-sdk inclut les fichiers de bibliothèque du kit AWS SDK for Java. La version du kit AWS SDK for 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 informations d'identification AWS dans votre environnement.

Configuration avec Gradle

  1. Installez Gradle dans votre environnement. Pour voir si Gradle est déjà installé, à l'aide du terminal de l'IDE AWS Cloud9, exécutez Gradle avec l'option -version .

    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.

  2. Installez Gradle en utilisant le terminal pour exécuter les commandes suivantes. Ces commandes installent et exécutent outil SDKMAN!, puis utilisent SDKMAN! 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 sur le site Web SDKMAN! et Installer avec un gestionnaire de package sur le site Web Gradle.

  3. Vérifiez l'installation en exécutant Gradle avec l'option -version .

    gradle -version

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

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

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

  7. 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 plug-in io.spring.dependency-management est utilisé pour importer la nomenclature du kit AWS SDK for Java afin de gérer les dépendances du kit AWS SDK for Java pour le 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 for Java. mavenBom déclare la version à utiliser. Pour utiliser une autre version, remplacez ce numéro de version.

Étape 5 : Configurer la gestion des informations d'identification AWS dans votre environnement

Chaque fois que vous utilisez le kit AWS SDK for Java pour appeler un service AWS, vous devez fournir un ensemble d'informations d'identification AWS avec l'appel. Ces informations d'identification déterminent si le kit AWS SDK for Java possède les 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 Appel des Services AWS à partir d'un environnement dans AWS Cloud9, 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 dans le Guide du développeur AWS SDK for Java.

Étape 6 : Ajouter du code SDK AWS

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: <the bucket name> <the AWS Region to use>\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<Bucket> buckets = s3.listBuckets();
        System.out.println("My buckets now are:");

        for (Bucket b : buckets) {
            System.out.println(b.getName());
        }
    }

}

Étape 7 : Générer et exécuter le code du kit SDK AWS

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 fichier JAR s'exécute avec comme données d'entrée le nom du compartiment à créer dans Amazon S3 (par exemple my-test-bucket) et l'ID de la région AWS dans laquelle créer le compartiment (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

Afin d'éviter des frais permanents sur votre compte AWS une fois que vous avez fini d'utiliser cet exemple, vous devez supprimer l'environnement. Pour obtenir des instructions, consultez Suppression d'un environnement dans AWS Cloud9.