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. # Commencez avec le SDK pour Kotlin AWS SDK pour Kotlin Il fournit Kotlin APIs pour chacun Service AWS. À l'aide du SDK, vous pouvez créer des applications Kotlin qui fonctionnent avec Amazon S3, Amazon EC2, Amazon DynamoDB, etc. Ce didacticiel vous montre comment utiliser Gradle pour définir les dépendances pour. AWS SDK pour Kotlin Vous créez ensuite du code qui écrit des données dans une table DynamoDB. Bien que vous souhaitiez peut-être utiliser les fonctionnalités d'un IDE, vous n'avez besoin pour ce didacticiel que d'une fenêtre de terminal et d'un éditeur de texte. 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 avez besoin d'un [ensemble d'autorisations IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) pouvant accéder à DynamoDB et d'un environnement de développement Kotlin configuré avec les paramètres d'authentification unique d'IAM Identity Center pour y accéder. AWS Suivez les instructions [Configuration de base](setup-basic-onetime-setup.md) de ce guide pour obtenir les instructions de base de ce didacticiel. Une fois que vous avez configuré votre environnement de développement avec [un accès par authentification unique](setup-basic-onetime-setup.md#setup-sso-access) pour le SDK Kotlin et que vous disposez d'une [session de portail d' AWS accès active](setup-basic-onetime-setup.md#setup-login-sso), passez à l'étape 2. ## Étape 2 : Création du projet Pour créer le projet de ce didacticiel, utilisez d'abord Gradle pour créer les fichiers de base d'un projet Kotlin. Mettez ensuite à jour les fichiers avec les paramètres, les dépendances et le code requis pour le AWS SDK pour Kotlin. **Pour créer un nouveau projet à l'aide de Gradle** **Note** Ce didacticiel utilise la version 8.11.1 de Gradle avec la `gradle init` commande, qui propose cinq instructions à l'étape 3 ci-dessous. Si vous utilisez une version différente de Gradle, les instructions peuvent différer, de même que les versions préremplies des artefacts. 1. Créez un nouveau répertoire appelé `getstarted` à l'emplacement de votre choix, tel que votre bureau ou votre dossier personnel. 1. Ouvrez un terminal ou une fenêtre d'invite de commande et naviguez jusqu'au `getstarted` répertoire que vous avez créé. 1. Utilisez la commande suivante pour créer un nouveau projet Gradle et une classe Kotlin de base. ``` gradle init --type kotlin-application --dsl kotlin ``` + Lorsque vous êtes invité à saisir la cible`Java version`, appuyez sur `Enter` (par défaut sur`21`). + Lorsque vous y êtes invité`Project name`, appuyez sur `Enter` (par défaut, le nom du répertoire, `getstarted` dans ce didacticiel). + Lorsque vous y êtes invité`application structure`, appuyez sur `Enter` (par défaut sur`Single application project`). + Lorsque vous y êtes invité`Select test framework`, appuyez sur `Enter` (par défaut`kotlin.test`). + Lorsque vous y êtes invité`Generate build using new APIs and behavior`, appuyez sur `Enter` (par défaut`no`). **Pour configurer votre projet avec des dépendances pour Amazon S3 AWS SDK pour Kotlin et Amazon S3** + Dans le `getstarted` répertoire que vous avez créé lors de la procédure précédente, remplacez le contenu du `settings.gradle.kts` fichier par le contenu suivant, en le {{X.Y.Z}} remplaçant par la [dernière version](https://github.com/awslabs/aws-sdk-kotlin/releases/latest) du SDK pour Kotlin : ``` dependencyResolutionManagement { repositories { mavenCentral() } versionCatalogs { create("awssdk") { from("aws.sdk.kotlin:version-catalog:[https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)") } } } plugins { // Apply the foojay-resolver plugin to allow automatic download of JDKs. id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0" } rootProject.name = "getstarted" include("app") ``` + Accédez au `gradle` répertoire situé à l'intérieur du `getstarted` répertoire. Remplacez le contenu du fichier de catalogue de versions nommé `libs.versions.toml` par le contenu suivant : ``` [versions] junit-jupiter-engine = "5.10.3" [libraries] junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit-jupiter-engine" } [plugins] kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version = "2.1.0" } ``` + Accédez au répertoire `app` et ouvrez le fichier `build.gradle.kts`. Remplacez son contenu par le code suivant, puis enregistrez vos modifications. ``` plugins { alias(libs.plugins.kotlin.jvm) application } dependencies { implementation(awssdk.services.s3) // Add dependency on the AWS SDK pour Kotlin's S3 client. testImplementation("org.jetbrains.kotlin:kotlin-test-junit5") testImplementation(libs.junit.jupiter.engine) testRuntimeOnly("org.junit.platform:junit-platform-launcher") } java { toolchain { languageVersion = JavaLanguageVersion.of(21) } } application { mainClass = "org.example.AppKt" } tasks.named("test") { useJUnitPlatform() } ``` La `dependencies` section contient une `implementation` entrée pour le module Amazon S3 du AWS SDK pour Kotlin. Le compilateur Gradle est configuré pour utiliser Java 21 dans la `java` section. ## Étape 3 : Écriture du code Une fois le projet créé et configuré, modifiez la classe par défaut du projet `App` pour utiliser l'exemple de code suivant. 1. Dans le dossier de votre projet`app`, naviguez jusqu'au répertoire`src/main/kotlin/org/example`. Ouvrez le fichier `App.kt`. 1. Remplacez son contenu par le code suivant et enregistrez le fichier. ``` package org.example import aws.sdk.kotlin.services.s3.* import aws.sdk.kotlin.services.s3.model.BucketLocationConstraint import aws.smithy.kotlin.runtime.content.ByteStream import kotlinx.coroutines.runBlocking import java.util.UUID val REGION = "us-west-2" val BUCKET = "bucket-${UUID.randomUUID()}" val KEY = "key" fun main(): Unit = runBlocking { S3Client .fromEnvironment { region = REGION } .use { s3 -> setupTutorial(s3) println("Creating object $BUCKET/$KEY...") s3.putObject { bucket = BUCKET key = KEY body = ByteStream.fromString("Testing with the Kotlin SDK") } println("Object $BUCKET/$KEY created successfully!") cleanUp(s3) } } suspend fun setupTutorial(s3: S3Client) { println("Creating bucket $BUCKET...") s3.createBucket { bucket = BUCKET if (REGION != "us-east-1") { // Do not set location constraint for us-east-1. createBucketConfiguration { locationConstraint = BucketLocationConstraint.fromValue(REGION) } } } println("Bucket $BUCKET created successfully!") } suspend fun cleanUp(s3: S3Client) { println("Deleting object $BUCKET/$KEY...") s3.deleteObject { bucket = BUCKET key = KEY } println("Object $BUCKET/$KEY deleted successfully!") println("Deleting bucket $BUCKET...") s3.deleteBucket { bucket = BUCKET } println("Bucket $BUCKET deleted successfully!") } ``` ## Étape 4 : Création et exécution de l’application Une fois le projet créé et contenant l'exemple de classe, créez et exécutez l'application. 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 et exécuter votre application : ``` gradle run ``` **Note** Si vous obtenez un`IdentityProviderException`, il se peut que vous n'ayez pas de session d'authentification unique active. Exécutez la commande `aws sso login` AWS CLI pour démarrer une nouvelle session. L'application appelle l'opération d'API [CreateBucket](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/create-bucket.html) pour créer un nouveau compartiment S3, puis appelle [PutObject](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/put-object.html) pour placer un nouvel objet dans le nouveau compartiment S3. Dans la `cleanUp()` fonction située à la fin, l'application supprime l'objet puis le compartiment S3. **Pour voir les résultats dans la console Amazon S3** 1. Dans`App.kt`, commentez la ligne `cleanUp(s3)` de la `runBlocking` section et enregistrez le fichier. 1. Reconstruisez le projet et placez un nouvel objet dans un nouveau compartiment S3 en exécutant`gradle run`. 1. Connectez-vous à la [console Amazon S3](https://console.aws.amazon.com/s3) pour afficher le nouvel objet dans le nouveau compartiment S3. Après avoir visualisé l'objet, supprimez le compartiment S3. ### Réussite Si votre projet Gradle a été créé et exécuté sans erreur, alors félicitations. Vous avez créé avec succès votre première application Kotlin à l'aide du AWS SDK pour Kotlin. ### Nettoyage Lorsque vous avez terminé de développer votre nouvelle application, supprimez toutes les AWS ressources que vous avez créées au cours de ce didacticiel pour éviter d'encourir des frais. Vous pouvez également supprimer ou archiver le dossier de projet (`get-started`) que vous avez créé à l'étape 2. Pour nettoyer les ressources, procédez comme suit : + Si vous avez commenté l'appel à la `cleanUp()` fonction, supprimez le compartiment S3 à l'aide de la [console Amazon S3](https://console.aws.amazon.com/s3). ## Étapes suivantes Maintenant que vous connaissez les notions de base, vous pouvez en apprendre davantage sur les points suivants : + [Étapes de configuration supplémentaires pour travailler avec le SDK pour Kotlin](setup.md) + [Configuration du SDK pour Kotlin](configuration.md) + [Utilisation du SDK pour Kotlin](using.md) + [Sécurité du SDK pour Kotlin](security.md)