Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Inizia con l'SDK per Kotlin AWS SDK per Kotlin Fornisce Kotlin APIs per ciascuno. Servizio AWS Utilizzando l'SDK, puoi creare applicazioni Kotlin che funzionano con Amazon S3, Amazon EC2, Amazon DynamoDB e altro ancora. Questo tutorial mostra come usare Gradle per definire le dipendenze per. AWS SDK per Kotlin Quindi, si crea codice che scrive dati in una tabella DynamoDB. Anche se potresti voler utilizzare le funzionalità di un IDE, tutto ciò che ti serve per questo tutorial è una finestra di terminale e un editor di testo. Segui questi passaggi per completare questo tutorial: + [Fase 1: Configurazione per questo tutorial](#get-started-setup) + [Fase 2: Creare il progetto](#get-started-projectsetup) + [Fase 3: Scrivere il codice](#get-started-code) + [Fase 4: Compilare ed eseguire l'applicazione](#get-started-run) ## Fase 1: prepararsi per il tutorial Prima di iniziare questo tutorial, è necessario un [set di autorizzazioni IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) in grado di accedere a DynamoDB e un ambiente di sviluppo Kotlin configurato con le impostazioni single sign-on di IAM Identity Center a cui accedere. AWS Segui le istruzioni contenute in questa guida per configurare le [Configurazione di base](setup-basic-onetime-setup.md) basi di questo tutorial. Dopo aver configurato il tuo ambiente di sviluppo con l'[accesso Single Sign-On](setup-basic-onetime-setup.md#setup-sso-access) per Kotlin SDK e aver avuto una [sessione attiva del portale di AWS accesso](setup-basic-onetime-setup.md#setup-login-sso), continua con il Passaggio 2. ## Fase 2: creare il progetto Per creare il progetto per questo tutorial, usa prima Gradle per creare i file di base per un progetto Kotlin. Quindi, aggiorna i file con le impostazioni, le dipendenze e il codice richiesti per. AWS SDK per Kotlin **Per creare un nuovo progetto usando Gradle** **Nota** Questo tutorial utilizza la versione 8.11.1 di Gradle con il `gradle init` comando, che offre cinque istruzioni nel passaggio 3 seguente. Se si utilizza una versione diversa di Gradle, le istruzioni potrebbero differire, così come le versioni precompilate degli artefatti. 1. Crea una nuova directory chiamata `getstarted` in una posizione a tua scelta, come il desktop o la home directory. 1. Apri un terminale o una finestra del prompt dei comandi e accedi alla `getstarted` directory che hai creato. 1. Usa il seguente comando per creare un nuovo progetto Gradle e una classe Kotlin di base. ``` gradle init --type kotlin-application --dsl kotlin ``` + Quando viene richiesto il bersaglio`Java version`, premete `Enter` (il valore predefinito è). `21` + Quando richiesto`Project name`, premi `Enter` (il valore predefinito è il nome della cartella, in questo tutorial). `getstarted` + Quando richiesto`application structure`, premete (il valore predefinito è`Enter`). `Single application project` + Quando richiesto`Select test framework`, premete (impostazione predefinita su`Enter`). `kotlin.test` + Quando richiesto`Generate build using new APIs and behavior`, premete (impostazione predefinita su`Enter`). `no` **Per configurare il tuo progetto con dipendenze per Amazon S3 AWS SDK per Kotlin ** + Nella `getstarted` directory creata nella procedura precedente, sostituisci il contenuto del `settings.gradle.kts` file con il seguente contenuto, sostituendolo *X.Y.Z* con l'[ultima versione](https://github.com/awslabs/aws-sdk-kotlin/releases/latest) dell'SDK per 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") ``` + Vai alla `gradle` directory all'interno della directory. `getstarted` Sostituite il contenuto del file del catalogo delle versioni denominato `libs.versions.toml` con il seguente contenuto: ``` [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" } ``` + Passare alla directory `app` e aprire il file `build.gradle.kts`. Sostituisci il contenuto con il seguente codice e salva le modifiche. ``` plugins { alias(libs.plugins.kotlin.jvm) application } dependencies { implementation(awssdk.services.s3) // Add dependency on the AWS SDK per 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` sezione contiene una `implementation` voce per il modulo Amazon S3 di. AWS SDK per Kotlin Il compilatore Gradle è configurato per utilizzare Java 21 nella sezione. `java` ## Fase 3: scrivere il codice Dopo aver creato e configurato il progetto, modifica la classe predefinita del progetto `App` per utilizzare il seguente codice di esempio. 1. Nella cartella del progetto`app`, accedi alla directory`src/main/kotlin/org/example`. Apri il file `App.kt`. 1. Sostituitene il contenuto con il codice seguente e salvate il file. ``` 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!") } ``` ## Fase 4: creare ed eseguire l’applicazione Dopo che il progetto è stato creato e contiene la classe di esempio, create ed eseguite l'applicazione. 1. Apri un terminale o una finestra del prompt dei comandi e vai alla directory del progetto `getstarted`. 1. Utilizzate il seguente comando per creare ed eseguire l'applicazione: ``` gradle run ``` **Nota** Se ne ottieni una`IdentityProviderException`, potresti non avere una sessione Single Sign-On attiva. Esegui il comando `aws sso login` AWS CLI per avviare una nuova sessione. L'applicazione chiama l'operazione API [CreateBucket](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/create-bucket.html) per creare un nuovo bucket S3, quindi chiama [putObject](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/put-object.html) per inserire un nuovo oggetto nel nuovo bucket S3. Nella `cleanUp()` funzione alla fine, l'applicazione elimina l'oggetto e quindi elimina il bucket S3. **Per visualizzare i risultati nella console Amazon S3** 1. In`App.kt`, commenta la riga `cleanUp(s3)` nella `runBlocking` sezione e salva il file. 1. Ricostruisci il progetto e inserisci un nuovo oggetto in un nuovo bucket S3 eseguendolo. `gradle run` 1. Accedi alla [console Amazon S3](https://console.aws.amazon.com/s3) per visualizzare il nuovo oggetto nel nuovo bucket S3. Dopo aver visualizzato l'oggetto, elimina il bucket S3. ### Completato Se il tuo progetto Gradle è stato creato ed eseguito senza errori, allora congratulazioni. Hai creato con successo la tua prima applicazione Kotlin utilizzando. AWS SDK per Kotlin ### Pulizia Quando hai finito di sviluppare la tua nuova applicazione, elimina tutte AWS le risorse che hai creato durante questo tutorial per evitare di incorrere in addebiti. Potresti anche voler eliminare o archiviare la cartella di progetto (`get-started`) che hai creato nel passaggio 2. Segui questi passaggi per ripulire le risorse: + [Se hai commentato la chiamata alla `cleanUp()` funzione, elimina il bucket S3 utilizzando la console Amazon S3.](https://console.aws.amazon.com/s3) ## Fasi successive Ora che hai le nozioni di base, puoi scoprire quanto segue: + [Passaggi di configurazione aggiuntivi per lavorare con l'SDK per Kotlin](setup.md) + [Configurazione dell'SDK per Kotlin](configuration.md) + [Utilizzo dell'SDK per Kotlin](using.md) + [Sicurezza per l'SDK per Kotlin](security.md)