本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 开始使用适用于 Kotlin 的开发工具包
<a name="get-started"></a>

为每个 适用于 Kotlin 的 AWS SDK AWS 服务提供了 Kotlin APIs 。使用软件开发工具包，您可以构建适用于亚马逊 S3、亚马逊 EC2、亚马逊 DynamoDB 等的 Kotlin 应用程序。

本教程向您展示如何使用 Gradle 定义依赖关系。 适用于 Kotlin 的 AWS SDK然后，您可以创建将数据写入 DynamoDB 表的代码。尽管您可能想使用 IDE 的功能，但本教程所需要的只是一个终端窗口和一个文本编辑器。

要完成本教程，请执行以下步骤：
+  [步骤 1：为本教程进行设置](#get-started-setup) 
+  [步骤 2：创建项目](#get-started-projectsetup) 
+  [步骤 3：编写代码](#get-started-code) 
+  [步骤 4：构建并运行应用程序](#get-started-run) 

## 步骤 1：为本教程进行设置
<a name="get-started-setup"></a>

在开始本教程之前，您需要一个可以访问 DynamoDB 的 [IAM 身份中心权限集](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html)，并且需要配置有 IAM 身份中心单点登录设置的 Kotlin 开发环境才能访问。 AWS

按照本指南[基本设置](setup-basic-onetime-setup.md)中的说明进行操作，获取本教程的基础设置。

在将开发环境配置为 Kotlin SDK 的[单点登录访问权限](setup-basic-onetime-setup.md#setup-sso-access)并且[AWS 访问门户会话处于活动状态](setup-basic-onetime-setup.md#setup-login-sso)后，请继续步骤 2。

## 步骤 2：创建项目
<a name="get-started-projectsetup"></a>

要为本教程创建项目，请先使用 Gradle 为 Kotlin 项目创建基本文件。然后，使用所需的设置、依赖关系和代码更新文件 适用于 Kotlin 的 AWS SDK。

 **使用 Gradle 创建新项目** 

**注意**  
本教程使用 Gradle 版本 8.11.1 和`gradle init`命令，该命令在下面的步骤 3 中提供了五个提示。如果您使用不同版本的 Gradle，则提示可能会有所不同，预先填充的工件版本也会有所不同。

1. `getstarted`在您选择的位置（例如桌面或主文件夹）创建一个名为的新目录。

1. 打开终端或命令提示符窗口，然后导航到您创建的`getstarted`目录。

1. 使用以下命令创建一个新的 Gradle 项目和一个基本的 Kotlin 类。

   ```
   gradle init --type kotlin-application --dsl kotlin
   ```
   + 当提示输入目标时`Java version`，按`Enter`（默认为`21`）。
   + 出现提示时`Project name`，按`Enter`（在本教程`getstarted`中默认为目录名称）。
   + 出现提示时`application structure`，按`Enter`（默认为`Single application project`）。
   + 出现提示时`Select test framework`，按`Enter`（默认为`kotlin.test`）。
   + 出现提示时`Generate build using new APIs and behavior`，按`Enter`（默认为`no`）。

 **使用 适用于 Kotlin 的 AWS SDK 和 Amazon S3 的依赖项配置您的项目** 
+ 在上一个过程中创建的`getstarted`目录中，将`settings.gradle.kts`文件内容替换为以下内容，{{X.Y.Z}}替换为[最新版本](https://github.com/awslabs/aws-sdk-kotlin/releases/latest)的 Kotlin SDK：

  ```
  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")
  ```
+ 导航到该`gradle`目录内的`getstarted`目录。将名`libs.versions.toml`为的版本目录文件的内容替换为以下内容：

  ```
  [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" }
  ```
+ 导航到 `app` 目录并打开 `build.gradle.kts` 文件。用下面的代码替换相关内容，然后保存更改。

  ```
  plugins {
      alias(libs.plugins.kotlin.jvm)
      application
  }
  
  
  dependencies {
      implementation(awssdk.services.s3) // Add dependency on the 适用于 Kotlin 的 AWS SDK'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>("test") {
      useJUnitPlatform()
  }
  ```

  该`dependencies`部分包含的 Amazon S3 模块的`implementation`条目 适用于 Kotlin 的 AWS SDK。`java`在本节中，Gradle 编译器被配置为使用 Java 21。

## 步骤 3：编写代码
<a name="get-started-code"></a>

创建和配置项目后，编辑项目的默认类`App`以使用以下示例代码。

1. 在您的项目文件夹中`app`，导航到该目录`src/main/kotlin/org/example`。打开 `App.kt` 文件。

1. 将其内容替换为以下代码并保存文件。

   ```
   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!")
   }
   ```

## 步骤 4：构建并运行应用程序
<a name="get-started-run"></a>

创建包含示例类的项目后，生成并运行该应用程序。

1. 打开终端或命令提示符窗口并导航至您的项目目录 `getstarted`。

1. 使用以下命令来构建和运行您的应用程序：

   ```
   gradle run
   ```

**注意**  
如果您获得`IdentityProviderException`，则可能没有有效的单点登录会话。运行 C `aws sso login` AWS LI 命令启动新会话。

该应用程序调用 [CreateBucket](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/create-bucket.html) API 操作来创建新的 S3 存储桶，然后调用 Puto [Bjec](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/s3/aws.sdk.kotlin.services.s3/put-object.html) t 将新对象放入新的 S3 存储桶。

在最后的`cleanUp()`函数中，应用程序删除对象，然后删除 S3 存储桶。

 **在 Amazon S3 控制台中查看结果** 

1. 在中`App.kt`，注释掉该`runBlocking`部分`cleanUp(s3)`中的行并保存该文件。

1. 通过运行重建项目并将新对象放入新的 S3 存储桶中`gradle run`。

1. 登录 [Amazon S3 控制台](https://console.aws.amazon.com/s3)，查看新 S3 存储桶中的新对象。

查看对象后，删除 S3 存储桶。

### 成功
<a name="get-started-success"></a>

如果你的 Gradle 项目构建并运行时没有错误，那么恭喜你。您已经使用成功构建了您的第一个 Kotlin 应用程序。 适用于 Kotlin 的 AWS SDK

### 清理
<a name="cleanup"></a>

开发完新应用程序后，请删除在本教程中创建的所有 AWS 资源，以免产生任何费用。您可能还想删除或存档在步骤 2 中创建的项目文件夹 (`get-started`)。

请按照以下步骤清理资源：
+ 如果您注释掉了对该`cleanUp()`函数的调用，请使用 [Amazon S3 控制台删除 S3](https://console.aws.amazon.com/s3) 存储桶。

## 后续步骤
<a name="get-started-next"></a>

现在您已掌握了基础知识，接下来，您可以了解以下内容：
+  [使用适用于 Kotlin 的 SDK 的其他设置步骤](setup.md) 
+  [Kotlin 开发工具包的配置](configuration.md) 
+  [使用适用于 Kotlin 的开发工具包](using.md) 
+  [适用于 Kotlin 的 SDK 的安全性](security.md)