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. # Commencer à utiliser la version AWS SDK pour Java 2.x Les sections de cette rubrique vous expliquent les étapes essentielles pour commencer à créer des applications Java qui se connectent à Service AWS. Les sections traitent de la configuration de votre environnement de développement avec Java et de la création d'outils tels que Maven ou Gradle, de la configuration de l'authentification sécurisée et de la création de votre première application fonctionnelle grâce à un didacticiel pratique. AWS Ce sujet, adapté aux débutants, constitue votre point d'entrée dans AWS le développement avec Java et fournit les bases dont vous aurez besoin pour explorer des fonctionnalités plus avancées. **Contents** + [Configuration de la version AWS SDK pour Java 2.x](setup.md) + [Présentation de la configuration](setup.md#setup-overview) + [Installez Java et un outil de compilation pour fonctionner avec AWS SDK for Java 2.x](setup-java-buildtool.md) + [Configurez un projet Apache Maven qui utilise AWS SDK for Java 2.x](setup-project-maven.md) + [Conditions préalables](setup-project-maven.md#prerequisitesmaven) + [Création d’un projet Maven](setup-project-maven.md#create-maven-project) + [Configuration du compilateur Java pour Maven](setup-project-maven.md#configure-maven-compiler) + [Déclaration du kit SDK comme dépendance](setup-project-maven.md#sdk-as-dependency) + [Définition des dépendances pour les modules SDK](setup-project-maven.md#modules-dependencies) + [Construction de l'intégralité du kit SDK dans votre projet](setup-project-maven.md#build-the-entire-sdk-into-your-project) + [Génération de votre projet](setup-project-maven.md#build-project) + [Configurez un projet Gradle qui utilise le AWS SDK for Java 2.x](setup-project-gradle.md) + [Configurez un projet GraalVM Native Image qui utilise AWS SDK for Java 2.x](setup-project-graalvm.md) + [Conditions préalables](setup-project-graalvm.md#setup-graalvmnativeimage-prereq) + [Créez un projet à l'aide de l'archétype](setup-project-graalvm.md#setup-graalvmnativeimage-project) + [Créez une image native](setup-project-graalvm.md#build-graalvmnativeimage-project) + [Authentification à l' AWS aide du AWS SDK for Java 2.x](get-started-auth.md) + [Configuration pour l'authentification](get-started-auth.md#setup-auth) + [1. Développement local grâce à des qualifications à court terme](get-started-auth.md#setup-login) + [2. Configuration de l'accès par authentification unique pour le SDK](get-started-auth.md#setup-credentials) + [3. Connectez-vous à l'aide du AWS CLI](get-started-auth.md#setup-login-sso) + [Options d'authentification supplémentaires](get-started-auth.md#setup-additional) + [Création d'une application simple à l'aide du AWS SDK for Java 2.x](get-started-tutorial.md) + [Étape 1 : Configuration pour ce didacticiel](get-started-tutorial.md#get-started-setup) + [Étape 2 : Création du projet](get-started-tutorial.md#get-started-projectsetup) + [Étape 3 : Écriture du code](get-started-tutorial.md#get-started-code) + [Étape 4 : Création et exécution de l’application](get-started-tutorial.md#get-started-run) + [Réussite](get-started-tutorial.md#get-started-success) + [Nettoyage](get-started-tutorial.md#cleanup) + [Étapes suivantes](get-started-tutorial.md#get-started-next) # Configuration de la version AWS SDK pour Java 2.x Cette section fournit des informations sur la façon de configurer votre environnement de développement et les projets pour utiliser le AWS SDK for Java 2.x. ## Présentation de la configuration Pour développer avec succès des applications qui accèdent à l' Services AWS aide de AWS SDK pour Java, les conditions suivantes sont requises : + Le SDK Java doit avoir accès aux informations d'identification pour [authentifier les demandes](get-started-auth.md#setup-auth) en votre nom. + Les [autorisations du rôle IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) configuré pour le SDK doivent autoriser l'accès à Services AWS ce dont votre application a besoin. Les autorisations associées à la politique **PowerUserAccess** AWS gérée sont suffisantes pour répondre à la plupart des besoins de développement. + Un environnement de développement comprenant les éléments suivants : + [Fichiers de configuration partagés](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) configurés selon au moins l'une des méthodes suivantes : + Le `config` fichier contient les [paramètres d'authentification unique d'IAM Identity Center](get-started-auth.md#setup-credentials) afin que le SDK puisse obtenir des informations d'identification. AWS + Le `credentials` fichier contient des informations d'identification temporaires. + Une [installation de Java 8](setup-java-buildtool.md) ou version ultérieure. + Un [outil d'automatisation de build](setup-java-buildtool.md) tel que [Maven](https://maven.apache.org/download.cgi) ou [Gradle](https://gradle.org/install/). + Un éditeur de texte pour travailler avec du code. + (Facultatif, mais recommandé) Un IDE (environnement de développement intégré) tel que [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows), [Eclipse](https://www.eclipse.org/ide/) ou. [NetBeans](https://netbeans.apache.org/front/main/download/index.html) Si vous utilisez IntelliJ IDEA, vous pouvez également ajouter l'[AWS Toolkit for IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html) à intégrer Services AWS directement dans l'IDE afin de rationaliser le développement. + Une session de portail AWS d'accès active lorsque vous êtes prêt à exécuter votre application. Vous utilisez le AWS Command Line Interface pour [lancer le processus de connexion](get-started-auth.md#setup-login-sso) au portail d' AWS accès d'IAM Identity Center. **Important** Les instructions de cette section de configuration supposent que vous ou votre organisation utilisez IAM Identity Center. Si votre entreprise utilise un fournisseur d'identité externe qui fonctionne indépendamment d'IAM Identity Center, découvrez comment obtenir des informations d'identification temporaires à utiliser par le SDK for Java. Suivez [ces instructions](credentials-temporary.md#credentials-temporary-from-portal) pour ajouter des informations d'identification temporaires au `~/.aws/credentials` fichier. Si votre fournisseur d'identité ajoute automatiquement des informations d'identification temporaires au `~/.aws/credentials` fichier, assurez-vous que le nom du profil est `[default]` tel que vous n'avez pas besoin de fournir un nom de profil au SDK ou AWS CLI. # Installez Java et un outil de compilation pour fonctionner avec AWS SDK for Java 2.x Pour utiliser le SDK for Java 2.x, vous devez satisfaire aux exigences suivantes en matière d'environnement de développement Java : + Java 8 ou version ultérieure. [Il AWS SDK pour Java fonctionne avec le kit de [développement Oracle Java SE et avec les distributions du kit](https://www.oracle.com/java/technologies/downloads/) de développement Open Java (OpenJDK) [Amazon Corretto](https://aws.amazon.com/corretto/)telles que [Red Hat OpenJDK](https://developers.redhat.com/products/openjdk/overview) et Adoptium.](https://adoptium.net/) + Un outil de compilation compatible avec Maven, comme Apache Maven, Apache Ant avec Ivy, Gradle ou IntelliJ. + Pour plus d'informations sur l'installation et l'utilisation de Maven, consultez [https://maven.apache.org/](https://maven.apache.org/). + Pour plus d'informations sur l'installation et l'utilisation d'Apache Ivy, consultez [https://ant.apache.org/ivy/](https://ant.apache.org/ivy/). + Pour plus d'informations sur l'installation et l'utilisation de Gradle, consultez [https://gradle.org/](https://gradle.org/). + Pour plus d'informations sur l'installation et l'utilisation d'IntelliJ IDEA, consultez. [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) # Configurez un projet Apache Maven qui utilise AWS SDK for Java 2.x Vous pouvez utiliser [Apache Maven](https://maven.apache.org/) pour configurer et créer AWS SDK for Java 2.x des projets, ou pour [créer le SDK lui-même](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source). ## Conditions préalables Pour utiliser le SDK pour Java 2.x avec Maven, vous avez besoin des éléments suivants : + Java *version 8.0 ou ultérieure*. Vous pouvez télécharger le dernier logiciel du kit de développement Java SE [sur http://www.oracle. com/technetwork/java/javase/downloads](https://www.oracle.com/java/technologies/downloads/)/. Le SDK pour Java 2.x fonctionne également avec [OpenJDK](https://openjdk.org/) Amazon Corretto et une distribution du kit de développement Open Java (OpenJDK). Téléchargez la dernière version d'OpenJDK sur. [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html) Téléchargez la dernière version Amazon Corretto 8 ou Amazon Corretto 11 depuis [la Corretto page](https://aws.amazon.com/corretto/). + *Apache Maven*. Si vous devez installer Maven, accédez à [http://maven.apache.org/](https://maven.apache.org/) pour le télécharger et l'installer. ## Création d’un projet Maven Pour créer un projet Maven à partir de la ligne de commande, exécutez la commande suivante depuis un terminal ou une fenêtre `` `` d'invite de commande. ``` mvn -B archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-lambda -Dservice=s3 -Dregion=US_WEST_2 \ -DarchetypeVersion=2.X.X \ -DgroupId=com.example.myapp \ -DartifactId=myapp ``` **Note** Remplacez *com.example.myapp* par l'espace de noms complet du package de votre application. Remplacez également *myapp* par le nom de votre projet. Cette valeur devient le nom du répertoire de votre projet. Pour utiliser la dernière version de l'archétype, *2.X.X* remplacez-la par la [dernière version de Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda) Central. Cette commande crée un projet Maven à l'aide de la boîte à outils de modélisation des archétypes. L'archétype génère l'échafaudage d'un projet de gestionnaire de fonctions. AWS Lambda Cet archétype de projet est préconfiguré pour être compilé avec Java SE 8 et inclut une dépendance à la version du SDK pour Java 2.x spécifiée avec. `-DarchetypeVersion` Pour de plus amples informations sur la création et la configuration de projets Maven, veuillez consulter le document [Maven Getting Started Guide](https://maven.apache.org/guides/getting-started/). ## Configuration du compilateur Java pour Maven Si vous avez créé votre projet en utilisant l'archétype du AWS Lambda projet tel que décrit précédemment, la configuration du compilateur Java est déjà terminée pour vous. Pour vérifier que cette configuration est présente, commencez par ouvrir le fichier `pom.xml` à partir du dossier de projet que vous avez créé (par exemple, `myapp`) lors de l’exécution de la commande précédente. Regardez le paramètre de version du compilateur Java pour ce projet Maven aux lignes 11 et 12, ainsi que l'inclusion requise du plug-in du compilateur Maven aux lignes 71 à 75. ``` 1.8 1.8 org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` Si vous créez votre projet avec un archétype différent ou en utilisant une autre méthode, vous devez vous assurer que le plug-in du compilateur Maven fait partie de la génération et que ses propriétés source et cible sont toutes deux définies sur **1.8** dans le fichier `pom.xml`. L'extrait précédent présente une façon de configurer ces paramètres requis. Vous pouvez également définir la configuration du compilateur en ligne avec la déclaration du plug-in, comme suit. ``` org.apache.maven.plugins maven-compiler-plugin 1.8 1.8 ``` ## Déclaration du kit SDK comme dépendance Pour utiliser le AWS SDK pour Java dans votre projet, vous devez le déclarer en tant que dépendance dans le `pom.xml` fichier de votre projet. Si vous avez créé votre projet à l'aide de l'archétype de projet tel que décrit précédemment, la dernière version du SDK est déjà configurée en tant que dépendance dans votre projet. L'archétype génère une dépendance à un artefact BOM (nomenclature) pour l'identifiant du groupe. `software.amazon.awssdk` Avec une nomenclature, il n'est pas nécessaire de spécifier la version maven pour les dépendances d'artefacts individuels qui partagent le même identifiant de groupe. Si vous avez créé votre projet Maven d'une autre manière, configurez la dernière version du kit SDK pour votre projet en vous assurant que le fichier `pom.xml` contient les éléments suivants. ``` 2.X.X software.amazon.awssdk bom ${aws.java.sdk.version} pom import ``` **Note** Remplacez *2.X.X* le `pom.xml` fichier par la [dernière version du AWS SDK for Java 2.x](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). ## Définition des dépendances pour les modules SDK Maintenant que vous avez configuré le SDK, vous pouvez ajouter des dépendances pour un ou plusieurs AWS SDK pour Java modules à utiliser dans votre projet. Bien que vous puissiez spécifier le numéro de version pour chaque composant, cela n'est pas nécessaire car vous avez déjà déclaré la version du SDK dans la `dependencyManagement` section à l'aide de l'artefact de nomenclature. Pour charger une version différente d'un module donné, spécifiez un numéro de version pour sa dépendance. Si vous avez créé votre projet à l'aide de l'archétype de projet tel que décrit précédemment, votre projet est déjà configuré avec plusieurs dépendances. Il s'agit notamment des dépendances pour les gestionnaires de AWS Lambda fonctions et Amazon S3, comme suit. ``` software.amazon.awssdk s3 software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk url-connection-client com.amazonaws aws-lambda-java-core ${aws.lambda.java.version} ``` **Note** Dans l'`pom.xml`exemple ci-dessus, les dépendances proviennent de `groupId` s différents. La `s3` dépendance vient de`software.amazon.awssdk`, alors que la `aws-lambda-java-core` dépendance vient de`com.amazonaws`. La configuration de gestion des dépendances des nomenclatures affecte les artefacts`software.amazon.awssdk`, une version est donc nécessaire pour l'`aws-lambda-java-core`artefact. Pour le développement de *gestionnaires de fonctions Lambda* à l'aide du SDK pour Java 2.x`aws-lambda-java-core`, quelle est la bonne dépendance ? Toutefois, si votre application doit gérer des ressources Lambda, l'utilisation d'opérations telles que`listFunctions`,`deleteFunction`, et `invokeFunction``createFunction`, votre application nécessite la dépendance suivante. ``` software.amazon.awssdk lambda ``` **Note** La `s3` dépendance exclut les dépendances transitives `netty-nio-client` et les dépendances `apache-client` transitives. À la place de l'un ou l'autre de ces clients HTTP, l'archétype inclut la `url-connection-client` dépendance, ce qui permet de [réduire la latence de démarrage des AWS Lambda fonctions](lambda-optimize-starttime.md#lambda-quick-url). Ajoutez à votre projet les modules Service AWS et les fonctionnalités dont vous avez besoin pour votre projet. Les modules (dépendances) gérés par le AWS SDK pour Java BOM sont répertoriés dans le référentiel [central Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom). **Note** Vous pouvez rechercher le fichier `pom.xml` à partir d'un exemple de code pour déterminer les dépendances dont vous avez besoin pour votre projet. Par exemple, si vous êtes intéressé par les dépendances du service DynamoDB, [consultez cet](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml) exemple extrait du référentiel d'exemples de [code AWS sur](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2). GitHub (Recherchez le `pom.xml` fichier sous [/javav2/example\$1code/dynamodb.)](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb) ### Construction de l'intégralité du kit SDK dans votre projet Pour optimiser votre application, nous vous recommandons vivement d'extraire uniquement les composants dont vous avez besoin au lieu de l'intégralité du kit SDK. Toutefois, pour AWS SDK pour Java intégrer l'intégralité à votre projet, déclarez-le dans votre `pom.xml` fichier de la manière suivante. ``` software.amazon.awssdk aws-sdk-java 2.X.X ``` ## Génération de votre projet Après avoir configuré le fichier `pom.xml`, vous pouvez utiliser Maven pour construire votre projet. Pour construire votre projet Maven à partir de la ligne de commande, ouvrez une fenêtre de terminal ou d'invite de commande, accédez à votre répertoire de projet (par exemple, `myapp`), entrez ou collez la commande suivante, puis appuyez sur Entrée ou Retour. ``` mvn package ``` Cela crée un fichier `.jar` unique (JAR) dans le répertoire `target` (par exemple, `myapp/target`). Ce fichier JAR contient tous les modules de kit SDK que vous avez spécifiés comme dépendances dans votre fichier `pom.xml`. # Configurez un projet Gradle qui utilise le AWS SDK for Java 2.x Vous pouvez utiliser [Gradle](https://gradle.org/) pour configurer et créer des AWS SDK for Java 2.x projets. Les étapes initiales de l'exemple suivant proviennent du [guide de démarrage de Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html) pour la version 8.4. Si vous utilisez une version différente, les résultats peuvent légèrement différer. **Pour créer une application Java avec Gradle (ligne de commande)** 1. Créez un répertoire pour héberger votre projet. Dans cet exemple, `demo` c'est le nom du répertoire. 1. Dans le `demo` répertoire, exécutez la `gradle init` commande et fournissez les valeurs surlignées en rouge, comme indiqué dans la sortie de ligne de commande suivante. Pour la procédure pas à pas, nous avons choisi Kotlin comme langage DSL pour les scripts de construction, mais un exemple complet pour Groovy est également présenté à la fin de cette rubrique. ``` > gradle init Starting a Gradle Daemon (subsequent builds will be faster) Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 2 Select implementation language: 1: C++ 2: Groovy 3: Java 4: Kotlin 5: Scala 6: Swift Enter selection (default: Java) [1..6] 3 Generate multiple subprojects for application? (default: no) [yes, no] no Select build script DSL: 1: Kotlin 2: Groovy Enter selection (default: Kotlin) [1..2] Select test framework: 1: JUnit 4 2: TestNG 3: Spock 4: JUnit Jupiter Enter selection (default: JUnit Jupiter) [1..4] 4 Project name (default: demo): Source package (default: demo): Enter target version of Java (min. 7) (default: 11): Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] > Task :init To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.4/samples/sample_building_java_applications.html BUILD SUCCESSFUL in 3m 43s 2 actionable tasks: 2 executed ``` 1. Une fois la `init` tâche terminée, le `demo` répertoire contient la structure arborescente suivante. Nous examinerons de plus près le fichier de compilation principal `build.gradle.kts` (surligné en rouge) dans la section suivante. ``` ├── app │   ├── build.gradle.kts │   └── src │   ├── main │   │   ├── java │   │   │   └── demo │   │   │   └── App.java │   │   └── resources │   └── test │   ├── java │   │   └── demo │   │   └── AppTest.java │   └── resources ├── gradle │   └── wrapper │   ├── gradle-wrapper.jar │   └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle.kts ``` Le `build.gradle.kts` fichier contient le contenu échafaudé suivant. ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { // Use JUnit Jupiter for testing. testImplementation("org.junit.jupiter:junit-jupiter:5.9.3") testRuntimeOnly("org.junit.platform:junit-platform-launcher") // This dependency is used by the application. implementation("com.google.guava:guava:33.3.0-jre") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` 1. Utilisez le fichier de construction Gradle échafaudé comme base de votre projet. AWS 1. Pour gérer les dépendances du SDK pour votre projet Gradle, ajoutez la nomenclature Maven (BOM) AWS SDK for Java 2.x pour la `dependencies` section du fichier. `build.gradle.kts` ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) // With the bom declared, you specify individual SDK dependencies without a version. ... } ... ``` **Note** Dans cet exemple de fichier de compilation, remplacez *2.27.21* par la dernière version du SDK pour Java 2.x. Trouvez la dernière version disponible dans le [référentiel central de Maven](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions). 1. Spécifiez les modules du SDK dont votre application a besoin dans la `dependencies` section. À titre d'exemple, ce qui suit ajoute une dépendance à Amazon Simple Storage Service. ``` ... dependencies { implementation(platform("software.amazon.awssdk:bom:2.27.21")) implementation("software.amazon.awssdk:s3") ... } ... ``` Gradle résout automatiquement la version correcte des dépendances déclarées en utilisant les informations de la nomenclature. Les exemples suivants montrent des fichiers de construction complets de Gradle à la fois dans Kotlin et Groovy. DSLs Le fichier de compilation contient les dépendances pour Amazon S3, l'authentification, la journalisation et les tests. La version source et cible de Java est la version 11. ------ #### [ Kotlin DSL (build.gradle.kts) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. application } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation(platform("software.amazon.awssdk:bom:2.20.56")) implementation("software.amazon.awssdk:s3") implementation("software.amazon.awssdk:sso") implementation("software.amazon.awssdk:ssooidc") implementation(platform("org.apache.logging.log4j:log4j-bom:2.20.0")) implementation("org.apache.logging.log4j:log4j-slf4j2-impl") implementation("org.apache.logging.log4j:log4j-1.2-api") testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion.set(JavaLanguageVersion.of(11)) } } application { // Define the main class for the application. mainClass.set("demo.App") } tasks.named("test") { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ #### [ Groovy DSL (build.gradle) ] ``` /* * This file was generated by the Gradle 'init' task. * * This generated file contains a sample Java application project to get you started. * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.4/userguide/building_java_projects.html in the Gradle documentation. */ plugins { // Apply the application plugin to add support for building a CLI application in Java. id 'application' } repositories { // Use Maven Central for resolving dependencies. mavenCentral() } dependencies { implementation platform('software.amazon.awssdk:bom:2.27.21') implementation 'software.amazon.awssdk:s3' implementation 'software.amazon.awssdk:sso' implementation 'software.amazon.awssdk:ssooidc' implementation platform('org.apache.logging.log4j:log4j-bom:2.20.0') implementation 'org.apache.logging.log4j:log4j-slf4j2-impl' implementation 'org.apache.logging.log4j:log4j-1.2-api' testImplementation platform('org.junit:junit-bom:5.10.0') testImplementation 'org.junit.jupiter:junit-jupiter' } // Apply a specific Java toolchain to ease working on different environments. java { toolchain { languageVersion = JavaLanguageVersion.of(11) } } application { // Define the main class for the application. mainClass = 'demo_groovy.App' } tasks.named('test') { // Use JUnit Platform for unit tests. useJUnitPlatform() } ``` ------ Pour les étapes suivantes, consultez le guide de démarrage sur le site Web de Gradle pour obtenir des instructions sur la [création et l'exécution d'une application Gradle](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application). # Configurez un projet GraalVM Native Image qui utilise AWS SDK for Java 2.x Avec les versions 2.16.1 et ultérieures, il prend en out-of-the-box charge les AWS SDK for Java 2.x applications GraalVM Native Image. Utilisez l'archétype `archetype-app-quickstart` Maven pour configurer un projet avec prise en charge native intégrée des images. ## Conditions préalables + Suivez les étapes décrites dans [Configuration de la version AWS SDK pour Java 2.x](setup.md). + Installez [GraalVM Native Image](https://www.graalvm.org/reference-manual/native-image/#install-native-image). ## Créez un projet à l'aide de l'archétype Pour créer un projet Maven avec prise en charge native intégrée des images, dans un terminal ou une fenêtre d'invite de commande, utilisez la commande suivante. **Note** `com.example.mynativeimageapp`Remplacez-le par l'espace de noms de package complet de votre application. Remplacez également `mynativeimageapp` par le nom de votre projet. Cette valeur devient le nom du répertoire de votre projet. ``` mvn archetype:generate \ -DarchetypeGroupId=software.amazon.awssdk \ -DarchetypeArtifactId=archetype-app-quickstart \ -DarchetypeVersion=2.27.21\ -DnativeImage=true \ -DhttpClient=apache-client \ -Dservice=s3 \ -DgroupId=com.example.mynativeimageapp \ -DartifactId=mynativeimageapp \ -DinteractiveMode=false ``` Cette commande crée un projet Maven configuré avec des dépendances pour le AWS SDK pour Java, Amazon S3, et le client `ApacheHttpClient` HTTP. Il inclut également une dépendance pour le [plugin GraalVM Native Image Maven](https://graalvm.github.io/native-build-tools/latest/index.html), afin que vous puissiez créer des images natives à l'aide de Maven. Pour inclure les dépendances d'un autre service Amazon Web Services, définissez la valeur du `-Dservice` paramètre sur l'ID d'artefact de ce service. Exemples : `dynamodb`, `comprehend` et `pinpoint`. Pour obtenir la liste complète des artefacts IDs, consultez la liste des dépendances gérées pour [software.amazon.awssdk](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest) sur Maven Central. Pour utiliser un client HTTP asynchrone, définissez le `-DhttpClient` paramètre sur. `netty-nio-client` Pour l'utiliser `UrlConnectionHttpClient` en tant que client HTTP synchrone au lieu de`apache-client`, définissez le `-DhttpClient` paramètre sur`url-connection-client`. ## Créez une image native Après avoir créé le projet, exécutez la commande suivante depuis le répertoire de votre projet, par exemple `mynativeimageapp` : ``` mvn package -P native-image ``` Cela crée une application d'image native dans le `target` répertoire, par exemple,`target/mynativeimageapp`. # Authentification à l' AWS aide du AWS SDK for Java 2.x Vous devez établir la manière dont ils AWS SDK for Java 2.x s'authentifient AWS lorsque vous développez avec des AWS services. Le SDK gère la découverte des informations d'identification, la création de signatures et l'actualisation des informations d'identification complètement en arrière-plan, ce qui vous permet de vous concentrer sur la logique de votre application. ## Configuration pour l'authentification La rubrique [Authentification et accès](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) du guide de référence sur les outils AWS SDKs and décrit les différentes approches d'authentification. Pour le développement local, l'approche recommandée consiste à utiliser des informations d'identification à court terme en vous connectant à la AWS CLI avec vos informations de connexion à la console. Recommandé si vous utilisez root, des utilisateurs IAM ou une fédération avec IAM pour accéder au AWS compte. Suivez les instructions décrites dans [Identifiants d'accès pour les travaux de développement interactifs à l'aide de AWS SDK for Java 2.x](credentials-temporary.md). Après avoir suivi les instructions AWS SDKs et le guide de référence des outils, votre système doit être configuré pour autoriser le SDK à signer les demandes : ### 1. Développement local grâce à des qualifications à court terme Pour le développement local, l'approche recommandée consiste à utiliser des informations d'identification à court terme en vous connectant à la AWS CLI avec vos informations de connexion à la console. Recommandé si vous utilisez root, des utilisateurs IAM ou une fédération avec IAM pour accéder au AWS compte. Pour obtenir des instructions, consultez la section [Utilisation des fournisseurs d'informations d'identification dans le AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-temporary.html). ### 2. Configuration de l'accès par authentification unique pour le SDK Une fois que vous avez terminé l'étape 2 de la [section Accès par programmation](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted) afin que le SDK puisse utiliser l'authentification IAM Identity Center, votre système doit contenir les éléments suivants. + Le AWS CLI, que vous utilisez pour démarrer une [session de portail d'AWS accès](#setup-login-sso) avant d'exécuter votre application. + `~/.aws/config`Fichier contenant un [profil par défaut](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile). Le SDK for Java utilise la configuration du fournisseur de jetons SSO du profil pour obtenir des informations d'identification avant d'envoyer des demandes à. AWS La valeur `sso_role_name`, qui est un rôle IAM connecté à un ensemble d'autorisations IAM Identity Center, doit autoriser l'accès aux Services AWS utilisés dans votre application. Le `config` fichier d'exemple suivant montre un profil par défaut configuré avec la configuration du fournisseur de jetons SSO. Le paramètre `sso_session` du profil fait référence à la section `sso-session` nommée. La section `sso-session` contient les paramètres permettant de lancer une session de portail d'accès AWS . ``` [default] sso_session = my-sso sso_account_id = 111122223333 sso_role_name = SampleRole region = us-east-1 output = json [sso-session my-sso] sso_region = us-east-1 sso_start_url = https://provided-domain.awsapps.com/start sso_registration_scopes = sso:account:access ``` Pour plus de détails sur les paramètres utilisés dans la configuration du fournisseur de jetons SSO, consultez la section Configuration du [fournisseur de jetons SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) dans le guide de référence des outils AWS SDKs et. Si votre environnement de développement n'est pas configuré pour l'accès par programmation comme indiqué précédemment, suivez l'[étape 2 du guide de SDKs référence](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted). ### 3. Connectez-vous à l'aide du AWS CLI Avant d'exécuter une application qui y accède Services AWS, vous devez disposer d'une session de portail d' AWS accès active afin que le SDK puisse utiliser l'authentification IAM Identity Center pour résoudre les informations d'identification. Exécutez la commande suivante dans le AWS CLI pour vous connecter au portail AWS d'accès. ``` aws sso login ``` Étant donné que vous disposez d’une configuration de profil par défaut, il n'est pas nécessaire d'appeler la commande avec l’option `--profile`. Si la configuration de votre fournisseur de jetons SSO utilise un profil nommé, la commande est `aws sso login --profile named-profile`. Pour vérifier si vous avez déjà une session active, exécutez la commande AWS CLI suivante. ``` aws sts get-caller-identity ``` La réponse à cette commande doit indiquer le compte IAM Identity Center et l'ensemble d'autorisations configurés dans le fichier partagé `config`. **Note** Si vous disposez déjà d'une session active sur le portail AWS d'accès et que vous l'exécutez`aws sso login`, il ne vous sera pas demandé de fournir d'informations d'identification. Cependant, vous verrez une boîte de dialogue demandant l'autorisation d'accéder `botocore` à vos informations. `botocore`est le fondement du AWS CLI . Sélectionnez **Autoriser** pour autoriser l'accès à vos informations pour le AWS CLI et le SDK for Java. ## Options d'authentification supplémentaires Pour plus d'options d'authentification pour le SDK, telles que l'utilisation de profils et de variables d'environnement, consultez le chapitre de [configuration](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) du guide de référence des outils AWS SDKs et des outils. # Création d'une application simple à l'aide du AWS SDK for Java 2.x 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 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 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` 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`. ``` 4.0.0 org.example getstarted 1.0-SNAPSHOT jar UTF-8 1.8 1.8 3.2.1 3.6.1 1.6.0 2.27.21 <-------- SDK version picked up from archetype version. 1.7.28 5.8.1 software.amazon.awssdk bom ${aws.java.sdk.version} pom import software.amazon.awssdk s3 <-------- S3 dependency software.amazon.awssdk netty-nio-client software.amazon.awssdk apache-client software.amazon.awssdk sso <-------- Required for identity center authentication. software.amazon.awssdk ssooidc <-------- Required for identity center authentication. software.amazon.awssdk apache-client <-------- HTTP client specified. commons-logging commons-logging org.slf4j slf4j-api ${slf4j.version} org.slf4j slf4j-simple ${slf4j.version} org.slf4j jcl-over-slf4j ${slf4j.version} org.junit.jupiter junit-jupiter ${junit5.version} test org.apache.maven.plugins maven-compiler-plugin ${maven.compiler.plugin.version} ``` ## Étape 3 : Écriture du code 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` ``` 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` ``` 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 ``` 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 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 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 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 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 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) **