As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Comece a usar o SDK para Kotlin AWS SDK para Kotlin Ele fornece Kotlin APIs para cada um. AWS service (Serviço da AWS) Usando o SDK, você pode criar aplicativos Kotlin que funcionam com Amazon S3, Amazon EC2, Amazon DynamoDB e muito mais. Este tutorial mostra como usar o Gradle para definir dependências para o. AWS SDK para Kotlin Em seguida, você cria um código que grava dados em uma tabela do DynamoDB. Embora você queira usar os recursos de um IDE, tudo o que você precisa para este tutorial é uma janela de terminal e um editor de texto. Siga estas etapas para concluir este tutorial: + [Etapa 1: configurar para este tutorial](#get-started-setup) + [Etapa 2: criar o projeto](#get-started-projectsetup) + [Etapa 3: escrever o código](#get-started-code) + [Etapa 4: compilar e executar o aplicativo](#get-started-run) ## Etapa 1: configurar para este tutorial Antes de começar este tutorial, você precisa de um [conjunto de permissões do IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html) que possa acessar o DynamoDB e precisa de um ambiente de desenvolvimento Kotlin configurado com as configurações de login único do IAM Identity Center para acessar. AWS Siga as instruções [Configuração básica](setup-basic-onetime-setup.md) deste guia para obter a configuração básica deste tutorial. Depois de configurar seu ambiente de desenvolvimento com [acesso de login único](setup-basic-onetime-setup.md#setup-sso-access) para o Kotlin SDK e ter uma [sessão ativa do portal de AWS acesso](setup-basic-onetime-setup.md#setup-login-sso), continue com a Etapa 2. ## Etapa 2: criar o projeto Para criar o projeto para este tutorial, primeiro use o Gradle para criar os arquivos básicos para um projeto Kotlin. Em seguida, atualize os arquivos com as configurações, dependências e código necessários para o. AWS SDK para Kotlin **Para criar um novo projeto usando o Gradle** **nota** Este tutorial usa o Gradle versão 8.11.1 com o `gradle init` comando, que oferece cinco prompts na etapa 3 abaixo. Se você usa uma versão diferente do Gradle, os prompts podem ser diferentes, assim como as versões pré-preenchidas dos artefatos. 1. Crie um novo diretório chamado `getstarted` em um local de sua escolha, como sua área de trabalho ou pasta pessoal. 1. Abra uma janela de terminal ou prompt de comando e navegue até o `getstarted` diretório que você criou. 1. Use o comando a seguir para criar um novo projeto Gradle e uma classe básica do Kotlin. ``` gradle init --type kotlin-application --dsl kotlin ``` + Quando o alvo for solicitado`Java version`, pressione `Enter` (o padrão é). `21` + Quando solicitado`Project name`, pressione `Enter` (o padrão é o nome do diretório, `getstarted` neste tutorial). + Quando solicitado`application structure`, pressione `Enter` (o padrão é). `Single application project` + Quando solicitado`Select test framework`, pressione `Enter` (o padrão é). `kotlin.test` + Quando solicitado`Generate build using new APIs and behavior`, pressione `Enter` (o padrão é). `no` **Para configurar seu projeto com dependências para o AWS SDK para Kotlin e o Amazon S3** + No `getstarted` diretório que você criou no procedimento anterior, substitua o conteúdo do `settings.gradle.kts` arquivo pelo conteúdo a seguir, {{X.Y.Z}} substituindo pela [versão mais recente](https://github.com/awslabs/aws-sdk-kotlin/releases/latest) do SDK para 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") ``` + Navegue até o `gradle` diretório dentro do `getstarted` diretório. Substitua o conteúdo do arquivo de catálogo de versões nomeado `libs.versions.toml` pelo seguinte conteúdo: ``` [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" } ``` + Navegue até o diretório `app` e abra o arquivo `build.gradle.kts`. Substitua o conteúdo pelo código a seguir e salve as alterações. ``` plugins { alias(libs.plugins.kotlin.jvm) application } dependencies { implementation(awssdk.services.s3) // Add dependency on the AWS SDK para 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() } ``` A `dependencies` seção contém uma `implementation` entrada para o módulo Amazon S3 do. AWS SDK para Kotlin O compilador Gradle está configurado para usar o Java 21 na `java` seção. ## Etapa 3: escrever o código Depois que o projeto for criado e configurado, edite a classe padrão do projeto `App` para usar o código de exemplo a seguir. 1. Na pasta do seu projeto`app`, navegue até o diretório`src/main/kotlin/org/example`. Abra o arquivo `App.kt`. 1. Substitua seu conteúdo pelo código a seguir e salve o arquivo. ``` 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!") } ``` ## Etapa 4: compilar e executar o aplicativo Depois que o projeto for criado e contiver a classe de exemplo, crie e execute o aplicativo. 1. Abra uma janela de terminal ou prompt de comando e navegue até o diretório `getstarted` do seu projeto. 1. Use o comando a seguir para criar e executar seu aplicativo: ``` gradle run ``` **nota** Se você receber um`IdentityProviderException`, talvez não tenha uma sessão ativa de login único. Execute o comando `aws sso login` AWS CLI para iniciar uma nova sessão. O aplicativo chama a operação da API [CreateBucket para criar um novo bucket](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/create-bucket.html) do S3 e, em seguida, chama o [PutObject](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/put-object.html) para colocar um novo objeto no novo bucket do S3. Na `cleanUp()` função no final, o aplicativo exclui o objeto e, em seguida, exclui o bucket do S3. **Para ver os resultados no console do Amazon S3** 1. Em`App.kt`, comente a linha `cleanUp(s3)` na `runBlocking` seção e salve o arquivo. 1. Reconstrua o projeto e coloque um novo objeto em um novo bucket do S3 executando. `gradle run` 1. Faça login no [console do Amazon S3](https://console.aws.amazon.com/s3) para visualizar o novo objeto no novo bucket do S3. Depois de visualizar o objeto, exclua o bucket do S3. ### Bem-sucedida Se seu projeto Gradle foi criado e executado sem erros, parabéns. Você construiu com sucesso seu primeiro aplicativo Kotlin usando o. AWS SDK para Kotlin ### Limpeza Quando terminar de desenvolver seu novo aplicativo, exclua todos AWS os recursos que você criou durante este tutorial para evitar cobranças. Talvez você também queira excluir ou arquivar a pasta do projeto (`get-started`) que você criou na Etapa 2. Siga estas etapas para limpar os recursos: + Se você comentou a chamada para a `cleanUp()` função, exclua o bucket do S3 usando o console do [Amazon S3](https://console.aws.amazon.com/s3). ## Próximas etapas Agora que você entendeu o básico, poderá descobrir mais sobre o seguinte: + [Etapas adicionais de configuração para trabalhar com o SDK para Kotlin](setup.md) + [Configuração do SDK para Kotlin](configuration.md) + [Usando o SDK para Kotlin](using.md) + [Segurança para o SDK para Kotlin](security.md)