

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# AWS SDK for Java 2.x로 시작하기
<a name="get-started"></a>

이 주제의 섹션에서는 AWS 서비스에 연결하는 Java 애플리케이션 구축을 시작하는 데 필요한 단계를 안내합니다. 이 섹션에서는 Java를 사용하여 개발 환경을 설정하고 Maven 또는 Gradle 등의 도구를 구축하고, AWS에 대한 보안 인증을 구성하고, 실습 자습서를 통해 첫 번째 작업 애플리케이션을 만드는 방법을 다룹니다. 이 초보자용 주제는 Java를 사용한 AWS 개발의 시작점 역할을 하여 고급 기능을 살펴보기 전에 필요한 기본 사항을 제공합니다.

**Contents**
+ [AWS SDK for Java 2.x 설정](setup.md)
  + [설정 개요](setup.md#setup-overview)
  + [에서 사용할 Java 및 빌드 도구 설치 AWS SDK for Java 2.x](setup-java-buildtool.md)
  + [를 사용하는 Apache Maven 프로젝트 설정 AWS SDK for Java 2.x](setup-project-maven.md)
    + [사전 조건](setup-project-maven.md#prerequisitesmaven)
    + [Maven 프로젝트 만들기](setup-project-maven.md#create-maven-project)
    + [Maven에 Java 컴파일러 구성](setup-project-maven.md#configure-maven-compiler)
    + [SDK를 종속성으로 선언](setup-project-maven.md#sdk-as-dependency)
    + [SDK 모듈에 대한 종속성 설정](setup-project-maven.md#modules-dependencies)
      + [전체 SDK를 프로젝트에 빌드](setup-project-maven.md#build-the-entire-sdk-into-your-project)
    + [프로젝트 빌드](setup-project-maven.md#build-project)
  + [를 사용하는 Gradle 프로젝트 설정 AWS SDK for Java 2.x](setup-project-gradle.md)
  + [를 사용하는 GraalVM 네이티브 이미지 프로젝트 설정 AWS SDK for Java 2.x](setup-project-graalvm.md)
    + [사전 조건](setup-project-graalvm.md#setup-graalvmnativeimage-prereq)
    + [아키타입을 사용하여 프로젝트 생성](setup-project-graalvm.md#setup-graalvmnativeimage-project)
    + [네이티브 이미지를 빌드](setup-project-graalvm.md#build-graalvmnativeimage-project)
+ [를 AWS 사용하여 로 인증 AWS SDK for Java 2.x](get-started-auth.md)
  + [인증 설정](get-started-auth.md#setup-auth)
    + [1. 단기 자격 증명을 사용한 로컬 개발](get-started-auth.md#setup-login)
    + [2. SDK에 Single Sign-On 액세스 설정](get-started-auth.md#setup-credentials)
    + [3. 를 사용하여 로그인 AWS CLI](get-started-auth.md#setup-login-sso)
  + [추가 인증 옵션](get-started-auth.md#setup-additional)
+ [를 사용하여 간단한 애플리케이션 생성 AWS SDK for Java 2.x](get-started-tutorial.md)
  + [1단계: 튜토리얼 설정](get-started-tutorial.md#get-started-setup)
  + [2단계: 프로젝트 생성](get-started-tutorial.md#get-started-projectsetup)
  + [3단계: 코드 작성](get-started-tutorial.md#get-started-code)
  + [4단계: 애플리케이션 빌드 및 실행](get-started-tutorial.md#get-started-run)
    + [Success](get-started-tutorial.md#get-started-success)
    + [정리](get-started-tutorial.md#cleanup)
  + [다음 단계](get-started-tutorial.md#get-started-next)

# AWS SDK for Java 2.x 설정
<a name="setup"></a>

이 단원에서는 AWS SDK for Java 2.x을 사용하기 위한 개발 환경을 설정하는 방법에 대한 정보를 제공합니다.

## 설정 개요
<a name="setup-overview"></a>

AWS SDK for Java를 사용하여AWS 서비스에 액세스하는 애플리케이션을 성공적으로 개발하려면 다음 조건이 필요합니다.
+ 사용자를 대신하여 [요청을 인증](get-started-auth.md#setup-auth)하려면 Java SDK가 자격 증명에 액세스할 수 있어야 합니다.
+ SDK에 구성된 [IAM 역할의 권한](https://docs.aws.amazon.com/singlesignon/latest/userguide/permissionsetsconcept.html)은 애플리케이션에 필요한 AWS 서비스 액세스를 허용해야 합니다. **PowerUserAccess** AWS 관리형 정책과 관련된 권한은 대부분의 개발 요구 사항에 충분합니다.
+ 다음 요소가 포함된 개발 환경
  + 최소 다음 중 하나와 같은 방식으로 설정된 [공유 구성 파일](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html):
    + 이 `config` 파일에는 SDK가 AWS 자격 증명을 가져올 수 있도록 [IAM Identity Center 싱글 사인온 설정](get-started-auth.md#setup-credentials)이 포함되어 있습니다.
    + 이 `credentials` 파일에는 임시 자격 증명이 들어 있습니다.
  + [Java 8 이상 버전 설치](setup-java-buildtool.md).
  + [Maven](https://maven.apache.org/download.cgi) 또는 [Gradle](https://gradle.org/install/)과 같은 [빌드 자동화 도구](setup-java-buildtool.md).
  + 코드 작업을 위한 텍스트 편집기.
  + (선택 사항이지만 권장됨) [IntelliJ IDEA](https://www.jetbrains.com/idea/download/#section=windows), [Eclipse](https://www.eclipse.org/ide/) 또는 [NetBeans](https://netbeans.apache.org/front/main/download/index.html)와 같은 IDE(통합 개발 환경).

    또한 IntelliJ IDEA를 사용하는 경우 [AWS Toolkit for IntelliJ IDEA](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)를 추가하여 IDE에 AWS 서비스 직접 통합하여 개발을 간소화할 수 있습니다.
+ 애플리케이션을 실행할 준비가 되었을 때 활성화된 AWS 액세스 포털 세션. AWS Command Line Interface를 사용하여 IAM Identity Center의 AWS 액세스 포털에 대한 [로그인 프로세스를 시작](get-started-auth.md#setup-login-sso)합니다.

**중요**  
이 설정 단원의 지침에서는 사용자 또는 조직이 IAM Identity Center를 사용한다고 가정합니다. 조직에서 IAM Identity Center와 독립적으로 작동하는 외부 ID 공급자를 사용하는 경우 Java용 SDK에 사용할 임시 자격 증명을 얻는 방법을 알아보세요. [이 지침](credentials-temporary.md#credentials-temporary-from-portal)에 따라 `~/.aws/credentials` 파일에 임시 자격 증명을 추가하세요.  
ID 제공자가 임시 자격 증명을 `~/.aws/credentials` 파일에 자동으로 추가하는 경우 SDK 또는 AWS CLI 에 프로필 이름을 제공할 필요가 없도록 프로필 이름을 `[default]`으로 지정해야 합니다.

# 에서 사용할 Java 및 빌드 도구 설치 AWS SDK for Java 2.x
<a name="setup-java-buildtool"></a>

SDK for Java 2.x로 작업하려면 다음과 같은 Java 개발 환경 요구 사항이 필요합니다.
+ Java 8 이상. 는 [Oracle Java SE 개발 키트](https://www.oracle.com/java/technologies/downloads/) 및 [Amazon Corretto](https://aws.amazon.com/corretto/), Red Hat OpenJDK, [Adoptium](https://adoptium.net/)과 같은 Open Java 개발 키트(OpenJDK) 배포판과 함께 AWS SDK for Java 작동합니다. [ OpenJDK](https://developers.redhat.com/products/openjdk/overview)
+ Apache Maven, Ivy, Gradle 또는 IntelliJ를 사용하는 Apache Ant 등 Maven 호환 빌드 도구입니다.
  + Maven을 설치하고 사용하는 방법에 대한 자세한 내용은 [https://maven.apache.org/](https://maven.apache.org/) 참조하십시오.
  + Apache Ivy 설치 및 사용 방법에 대한 자세한 내용은 [https://ant.apache.org/ivy/](https://ant.apache.org/ivy/) 페이지를 참조하세요.
  + Gradle 설치 및 사용 방법에 대한 자세한 내용은 [https://gradle.org/](https://gradle.org/)을 참조하세요.
  + IntelliJ IDEA 설치 및 사용 방법에 대한 자세한 내용은 [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/)을 참조하세요.

# 를 사용하는 Apache Maven 프로젝트 설정 AWS SDK for Java 2.x
<a name="setup-project-maven"></a>

[Apache Maven](https://maven.apache.org/)을 사용하여 AWS SDK for Java 2.x 프로젝트를 구성 및 빌드하거나 [SDK 자체를 빌드](https://github.com/aws/aws-sdk-java-v2/tree/master#building-from-source)할 수 있습니다.

## 사전 조건
<a name="prerequisitesmaven"></a>

Maven에서 SDK for Java 2.x를 사용하려면 다음이 필요합니다.
+ Java *8.0 이상*. [http://www.oracle.com/technetwork/java/javase/downloads/](https://www.oracle.com/java/technologies/downloads/)에서 최신 Java SE Development Kit 소프트웨어를 다운로드할 수 있습니다. SDK for Java 2.x는 [OpenJDK](https://openjdk.org/) 및 Open Java Development Kit(OpenJDK) 배포 Amazon Corretto판에서도 작동합니다. [https://openjdk.java.net/install/index.html](https://openjdk.org/install/index.html)에서 최신 OpenJDK 버전을 다운로드하십시오. 페이지에서 최신 Amazon Corretto 8 또는 Amazon Corretto 11 버전을 다운로드합니다. [Corretto](https://aws.amazon.com/corretto/) 
+  *Apache Maven*. Maven을 설치해야 하는 경우 [http://maven.apache.org/](https://maven.apache.org/)에서 다운로드하여 설치하십시오.

## Maven 프로젝트 만들기
<a name="create-maven-project"></a>

명령줄에서 Maven 프로젝트를 만들려면 터미널 또는 명령 프롬프트 창````에서 다음 명령을 실행합니다.

```
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
```

**참고**  
*com.example.myapp*을 애플리케이션의 전체 패키지 네임스페이스로 바꿉니다. 또한 *myapp*을 프로젝트 이름으로 바꿉니다. 이는 프로젝트의 디렉터리 이름이 됩니다.  
최신 버전의 아키타입을 사용하려면 *2.X.X*를 [Maven Central의 최신 버전](https://central.sonatype.com/artifact/software.amazon.awssdk/archetype-lambda)으로 바꾸세요.

이 명령은 아키타입 템플릿 툴킷을 사용하여 Maven 프로젝트를 만듭니다. 아키타입은 AWS Lambda 함수 핸들러 프로젝트에 대한 스캐폴딩을 생성합니다. 이 프로젝트 아키타입은 Java SE 8로 컴파일하도록 미리 구성되어 있으며 `-DarchetypeVersion`로 지정된 Java 2.x용 SDK 버전에 대한 종속성을 포함합니다.

Maven 프로젝트 생성 및 구성에 대한 자세한 내용은 [Maven 시작 안내서](https://maven.apache.org/guides/getting-started/)를 참조하십시오.

## Maven에 Java 컴파일러 구성
<a name="configure-maven-compiler"></a>

앞에서 설명한 대로 프로젝트 아키타이프를 사용하여 AWS Lambda 프로젝트를 생성한 경우 Java 컴파일러의 구성이 이미 완료된 것입니다.

이러한 구성이 있는지 확인하려면, 이전 명령을 실행했을 때 만든 프로젝트 폴더(예: `myapp`)에서 `pom.xml` 파일을 엽니다. 이 Maven 프로젝트의 Java 컴파일러 버전 설정과 71\$175행에 Maven 컴파일러 플러그인을 포함시키는 데 필요한 내용을 보려면 11행 및 12행을 살펴보십시오.

```
<project>
  <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>${maven.compiler.plugin.version}</version>
      </plugin>
    </plugins>
  </build>
</project>
```

다른 아키타입이나 다른 방법을 사용하여 프로젝트를 생성하는 경우 Maven 컴파일러 플러그인이 빌드의 일부이고 해당 소스 및 대상 속성이 모두 `pom.xml` 파일에서 **1.8**로 설정되어 있는지 확인해야 합니다.

이러한 필수 설정을 구성하는 한 가지 방법에 대해서는 이전 조각을 참조하십시오.

또는 다음과 같이 플러그인 선언을 통해 컴파일러 구성 인라인을 구성할 수 있습니다.

```
<project>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
```

## SDK를 종속성으로 선언
<a name="sdk-as-dependency"></a>

프로젝트 AWS SDK for Java 에서를 사용하려면 프로젝트 `pom.xml` 파일의 종속성으로 선언해야 합니다.

앞에서 설명한 대로 프로젝트 아키타입를 사용하여 프로젝트를 만들었다면 SDK는 이미 프로젝트에서 종속성으로 구성되어 있습니다.

아키타입은 `software.amazon.awssdk` 그룹 ID에 대한 BOM(재료 명세서) 아티팩트 종속성을 생성합니다. BOM을 사용하면 동일한 그룹 ID를 공유하는 개별 아티팩트 종속성에 대해 Maven 버전을 지정할 필요가 없습니다.

다른 방법으로 Maven 프로젝트를 만든 경우에는 `pom.xml` 파일에 다음 사항이 포함되어 있는지 확인하여 프로젝트에 SDK의 최신 버전을 구성하십시오.

```
<project>
  <properties>
    <aws.java.sdk.version>2.X.X</aws.java.sdk.version>
  </properties>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>bom</artifactId>
        <version>${aws.java.sdk.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>
```

**참고**  
`pom.xml` 파일의 *2.X.X*를 [AWS SDK for Java 2.x의 최신 버전](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)으로 교체하세요.

## SDK 모듈에 대한 종속성 설정
<a name="modules-dependencies"></a>

이제 SDK를 구성했으므로 프로젝트에서 사용할 하나 이상의 AWS SDK for Java 모듈에 대한 종속성을 추가할 수 있습니다.

각 구성 요소의 버전 번호를 지정할 수 있지만 이미 BOM 아티팩트를 사용하여 `dependencyManagement` 섹션에서 SDK 버전을 선언했기 때문에 그럴 필요가 없습니다. 지정된 모듈의 다른 버전을 로드하려면 해당 종속성에 버전 번호를 지정합니다.

앞에서 설명한 대로 프로젝트 아키타입를 사용하여 프로젝트를 만들었다면 프로젝트는 이미 여러 종속성으로 구성되어 있습니다. 여기에는 다음과 같이 AWS Lambda 함수 핸들러와 Amazon S3에 대한 종속성이 포함됩니다.

```
<project>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>url-connection-client</artifactId>
        </dependency>

        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-core</artifactId>
            <version>${aws.lambda.java.version}</version>
        </dependency>
    </dependencies>
</project>
```

**참고**  
위 `pom.xml` 예시에서는 종속성이 서로 다른 `groupId`에 속합니다. `s3` 종속성은 `software.amazon.awssdk`에서 가져온 것이고 `aws-lambda-java-core` 종속성은 `com.amazonaws`에서 가져온 것입니다. BOM 종속성 관리 구성은 `software.amazon.awssdk`의 아티팩트에 영향을 미치므로 `aws-lambda-java-core` 아티팩트에 대한 버전이 필요합니다.  
Java 2.x용 SDK를 사용하여 *Lambda 함수 핸들러*를 개발하는 경우 `aws-lambda-java-core`가 올바른 종속성입니다. 하지만 `listFunctions`, `deleteFunction`, `invokeFunction`, `createFunction` 등의 작업을 사용하여 애플리케이션이 Lambda 리소스를 관리해야 하는 경우 애플리케이션에 다음과 같은 종속성이 필요합니다.  

```
<groupId>software.amazon.awssdk</groupId>
<artifactId>lambda</artifactId>
```

**참고**  
`s3` 종속성에는 `netty-nio-client` 및 `apache-client` 전이적 종속성이 제외됩니다. 아키타입에는 이러한 HTTP 클라이언트 대신 `url-connection-client` 종속성이 포함되므로 [AWS Lambda 함수의 시작 지연 시간을 줄이는 데 도움이 됩니다](lambda-optimize-starttime.md#lambda-quick-url).

프로젝트에 필요한 AWS 서비스 및 기능에 대한 모듈을 프로젝트에 추가합니다. AWS SDK for Java BOM에서 관리하는 모듈(종속성)은 [Maven 중앙 저장소](https://central.sonatype.com/artifact/software.amazon.awssdk/bom)에 나열되어 있습니다.

**참고**  
코드 예제에서 `pom.xml` 파일을 살펴보고 프로젝트에 필요한 종속성을 결정할 수 있습니다. 예를 들어 DynamoDB 서비스의 종속성에 관심이 있다면 GitHub의 [AWS 코드 예제 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2)에서 [이 예제](https://github.com/awsdocs/aws-doc-sdk-examples/blob/da520cb4436f8567a90b6f73f77232fd590a50bf/javav2/example_code/dynamodb/pom.xml)를 참조하세요. ([/javav2/example\$1code/dynamodb](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/dynamodb)에서 `pom.xml` 파일을 찾아보세요.)

### 전체 SDK를 프로젝트에 빌드
<a name="build-the-entire-sdk-into-your-project"></a>

애플리케이션을 최적화하려면 전체 SDK 대신 필요한 구성 요소만 가져오는 것이 좋습니다. 그러나 전체 AWS SDK for Java 를 프로젝트에 빌드하려면 다음과 같이 `pom.xml` 파일에 선언합니다.

```
<project>
  <dependencies>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>aws-sdk-java</artifactId>
      <version>2.X.X</version>
    </dependency>
  </dependencies>
</project>
```

## 프로젝트 빌드
<a name="build-project"></a>

`pom.xml` 파일을 구성한 후에는 Maven을 사용하여 프로젝트를 빌드할 수 있습니다.

명령줄에서 Maven 프로젝트를 빌드하려면 터미널 또는 명령 프롬프트 창을 열고 프로젝트 디렉터리(예: `myapp`)로 이동하여 다음 명령을 입력하거나 붙여넣은 다음 Enter 또는 Return을 누릅니다.

```
mvn package
```

이렇게 하면 `target` 디렉터리(예: `myapp/target`)에 단일 `.jar` 파일(JAR)이 생성됩니다. 이 JAR에는 `pom.xml` 파일에서 종속성으로 지정한 모든 SDK 모듈이 들어 있습니다.

# 를 사용하는 Gradle 프로젝트 설정 AWS SDK for Java 2.x
<a name="setup-project-gradle"></a>

[Gradle](https://gradle.org/)을 사용하여 AWS SDK for Java 2.x 프로젝트를 설정하고 빌드할 수 있습니다.

다음 예시의 초기 단계는 [Gradle 버전 8.4용 시작 가이드](https://docs.gradle.org/current/samples/sample_building_java_applications.html)에서 가져온 것입니다. 다른 버전을 사용하는 경우 결과가 약간 다를 수 있습니다.

**Gradle을 사용하여 Java 애플리케이션을 만들려면(명령줄)**

1. 프로젝트를 보관할 디렉터리를 생성합니다. 이 예에서 디렉터리 이름은 `demo`입니다.

1. `demo` 디렉터리 내에서 `gradle init` 명령을 실행하고 다음 명령줄 출력과 같이 빨간색으로 강조 표시된 값을 입력합니다. 안내에서는 Kotlin을 빌드 스크립트 DSL 언어로 선택했지만 Groovy에 대한 전체 예제도 이 항목의 끝에 표시됩니다.

   ```
   > 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] <Enter>
   
   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): <Enter>
   Source package (default: demo): <Enter>
   Enter target version of Java (min. 7) (default: 11): <Enter>
   Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] <Enter>
   
   > 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. `init` 작업이 완료되면 `demo` 디렉터리에는 다음과 같은 트리 구조가 포함됩니다. 다음 단원에서는 주 빌드 파일 `build.gradle.kts`(빨간색으로 강조 표시됨)을 자세히 살펴보겠습니다.

   ```
   ├── 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
   ```

   `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 {
       // 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>("test") {
       // Use JUnit Platform for unit tests.
       useJUnitPlatform()
   }
   ```

1. 스캐폴딩된 Gradle 빌드 파일을 AWS 프로젝트의 기반으로 사용합니다.

   1. Gradle 프로젝트의 SDK 종속성을 관리하려면 `build.gradle.kts` 파일의 `dependencies` 섹션에에 대한 Maven 재료표(BOM) AWS SDK for Java 2.x 를 추가합니다.

      ```
      ...
      dependencies {
          implementation(platform("software.amazon.awssdk:bom:2.27.21"))
          // With the bom declared, you specify individual SDK dependencies without a version.
       ...
      }
      ...
      ```
**참고**  
이 예제 빌드 파일에서 *2.27.21*을 최신 버전의 Java 2.x용 SDK로 바꿉니다. [Maven 중앙 리포지토리](https://central.sonatype.com/artifact/software.amazon.awssdk/bom/versions)에서 최신 버전을 찾아보세요.

   1. `dependencies` 섹션에서 애플리케이션에 필요한 SDK 모듈을 지정하세요. 예를 들어, 다음은 Amazon Simple Storage Service에 대한 종속성을 추가합니다.

      ```
      ...
      dependencies {    
          implementation(platform("software.amazon.awssdk:bom:2.27.21"))
          implementation("software.amazon.awssdk:s3")
       ...
      }
      ...
      ```

      Gradle은 BOM의 정보를 사용하여 선언된 종속성의 올바른 버전을 자동으로 확인합니다.

다음 예시는 Kotlin과 Groovy DSL의 전체 Gradle 빌드 파일을 보여줍니다. 빌드 파일에는 Amazon S3에 대한 종속성, 인증, 로깅 및 테스트가 포함되어 있습니다. Java의 소스 및 대상 버전은 버전 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>("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()
}
```

------

다음 단계는 Gradle 웹사이트의 시작 가이드를 참고하여 [Gradle 애플리케이션을 빌드하고 실행](https://docs.gradle.org/current/samples/sample_building_java_applications.html#run_the_application)하는 방법에 대한 지침을 확인하세요.

# 를 사용하는 GraalVM 네이티브 이미지 프로젝트 설정 AWS SDK for Java 2.x
<a name="setup-project-graalvm"></a>

버전 2.16.1 이상에서 AWS SDK for Java 2.x 는 GraalVM 네이티브 이미지 애플리케이션에 대한 out-of-the-box 지원을 제공합니다. `archetype-app-quickstart` Maven 아키타입을 사용하여 네이티브 이미지 지원이 내장된 프로젝트를 설정할 수 있습니다.

## 사전 조건
<a name="setup-graalvmnativeimage-prereq"></a>
+ [AWS SDK for Java 2.x 설정](setup.md)의 단계를 완료합니다.
+ [GraalVM Native Image](https://www.graalvm.org/reference-manual/native-image/#install-native-image)를 설치합니다.

## 아키타입을 사용하여 프로젝트 생성
<a name="setup-graalvmnativeimage-project"></a>

기본 제공 네이티브 이미지 지원을 사용하여 Maven 프로젝트를 생성하려면 터미널 또는 명령 프롬프트 창에서 다음 명령을 사용합니다.

**참고**  
`com.example.mynativeimageapp`를 애플리케이션의 전체 패키지 네임스페이스로 바꿉니다. 또한 `mynativeimageapp`을 프로젝트 이름으로 바꿉니다. 이는 프로젝트의 디렉터리 이름이 됩니다.

```
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
```

이 명령은 AWS SDK for Java Amazon S3및 `ApacheHttpClient` HTTP 클라이언트에 대한 종속성으로 구성된 Maven 프로젝트를 생성합니다. 또한 [GraalVM Native Image Maven 플러그인](https://graalvm.github.io/native-build-tools/latest/index.html)에 대한 종속성도 포함되어 있으므로 Maven을 사용하여 네이티브 이미지를 빌드할 수 있습니다.

다른에 대한 종속성을 포함하려면 `-Dservice` 파라미터 값을 해당 서비스의 아티팩트 ID로 Amazon Web Services설정합니다. 예를 들면 `dynamodb`, `comprehend` 및 `pinpoint`입니다. 아티팩트 ID의 전체 목록은 [Maven Central의 software.amazon.awssdk](https://mvnrepository.com/artifact/software.amazon.awssdk/bom/latest)에 대한 관리형 종속성 목록을 참조하세요.

비동기 HTTP 클라이언트를 사용하려면 `-DhttpClient` 파라미터를 `netty-nio-client`로 설정하세요. `apache-client` 대신 `UrlConnectionHttpClient`를 동기 HTTP 클라이언트로 사용하려면 `-DhttpClient` 파라미터를 `url-connection-client`로 설정합니다.

## 네이티브 이미지를 빌드
<a name="build-graalvmnativeimage-project"></a>

프로젝트를 생성한 후 프로젝트 디렉터리에서 예로 `mynativeimageapp`와 같은 다음 명령어를 실행합니다.

```
mvn package -P native-image
```

그러면 `target` 디렉터리에 예로 `target/mynativeimageapp`와 같은 네이티브 이미지 애플리케이션이 생성됩니다.

# 를 AWS 사용하여 로 인증 AWS SDK for Java 2.x
<a name="get-started-auth"></a>

 AWS 서비스를 사용하여 개발할 AWS 때가를 AWS SDK for Java 2.x 인증하는 방법을 설정해야 합니다. SDK는 자격 증명 검색, 서명 작성 및 자격 증명 새로 고침을 백그라운드에서 완전히 관리하므로 애플리케이션 로직에 중점을 둘 수 있습니다.

## 인증 설정
<a name="setup-auth"></a>

 AWS SDKs [및 도구 참조 안내서의 인증 및 액세스](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) 주제에서는 다양한 인증 접근 방식을 설명합니다.

로컬 개발의 경우 콘솔 로그인 자격 증명으로 AWS CLI에 로그인하여 단기 자격 증명을 사용하는 것이 좋습니다. AWS 계정 액세스를 위해 루트, IAM 사용자 또는 IAM과의 페더레이션을 사용하는 경우 권장됩니다. [를 사용하여 대화형 개발 작업을 위한 액세스 자격 증명 AWS SDK for Java 2.x](credentials-temporary.md)의 지침을 따릅니다.

 AWS SDKs 및 도구 참조 안내서의 지침에 따라 SDK가 요청에 서명할 수 있도록 시스템을 설정해야 합니다.

### 1. 단기 자격 증명을 사용한 로컬 개발
<a name="setup-login"></a>

로컬 개발의 경우 콘솔 로그인 자격 증명으로 AWS CLI에 로그인하여 단기 자격 증명을 사용하는 것이 좋습니다. AWS 계정 액세스를 위해 루트, IAM 사용자 또는 IAM과의 페더레이션을 사용하는 경우 권장됩니다.

지침은 [의 자격 증명 공급자 사용을 참조하세요 AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials-temporary.html).

### 2. SDK에 Single Sign-On 액세스 설정
<a name="setup-credentials"></a>

SDK가 IAM Identity Center 인증을 사용하도록 하려면 [프로그래밍 방식 액세스 섹션](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted)의 2단계를 완료한 후, 시스템에 다음 요소가 포함되도록 해야 합니다.
+ 애플리케이션을 실행하기 전에 [AWS 액세스 포털 세션을](#setup-login-sso) 시작하는 데 AWS CLI사용하는 입니다.
+ [기본 프로필](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile)이 포함된 `~/.aws/config` 파일. Java용 SDK는 AWS에 요청을 보내기 전에 프로필의 SSO 토큰 공급자 구성를 사용하여 보안 인증을 얻습니다. `sso_role_name` 값은 IAM 신원 센터 권한 집합에 연결된 IAM 역할로, 애플리케이션에서 사용되는 AWS 서비스 서비스에 대한 액세스를 허용해야 합니다.

  다음 샘플 `config` 파일은 SSO 토큰 공급자 구성으로 설정된 기본 프로필을 보여줍니다. 프로필의 `sso_session` 설정은 이름이 지정된 `sso-session` 섹션을 참조합니다. `sso-session` 섹션에는 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
  ```

SSO 토큰 공급자 구성에 사용되는 설정에 대한 자세한 내용은 AWS SDK 및 도구 참조 안내서의 [SSO 토큰 공급자 구성](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config)을 참조하세요.

개발 환경이 전에 표시된 것처럼 프로그래밍 방식으로 액세스할 수 있도록 설정되지 않은 경우 [SDK 참조 가이드의 2단계](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html#idcGettingStarted)를 따르세요.

### 3. 를 사용하여 로그인 AWS CLI
<a name="setup-login-sso"></a>

에 액세스하는 애플리케이션을 실행하기 전에 SDK가 IAM Identity Center 인증을 사용하여 자격 증명을 확인하려면 활성 AWS 액세스 포털 세션이 AWS 서비스필요합니다. 에서 다음 명령을 실행 AWS CLI 하여 AWS 액세스 포털에 로그인합니다.

```
aws sso login
```

기본 프로필이 설정되어 있으므로 `--profile` 옵션으로 명령을 호출할 필요가 없습니다. SSO 토큰 공급자 구성에서 명명된 프로필을 사용하는 경우 `aws sso login --profile named-profile` 명령을 사용합니다.

이미 활성 세션이 있는지 테스트하려면 다음 AWS CLI 명령을 실행합니다.

```
aws sts get-caller-identity
```

이 명령에 대한 응답은 공유 `config` 파일에 구성된 IAM Identity Center 계정 및 권한 집합을 보고해야 합니다.

**참고**  
이미 활성 AWS 액세스 포털 세션이 있고를 실행하는 경우 `aws sso login`자격 증명을 제공할 필요가 없습니다.  
하지만 정보에 액세스할 수 있는 `botocore` 권한을 요청하는 대화 상자가 표시됩니다. `botocore`는 AWS CLI 기반이 됩니다.  
**허용**을 선택하여 AWS CLI 및 SDK for Java에 대한 정보에 대한 액세스를 승인합니다.

## 추가 인증 옵션
<a name="setup-additional"></a>

프로필 및 환경 변수 사용과 같은 SDK 인증에 대한 자세한 옵션은 SDK 및 도구 참조 안내서의 [구성](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html) 장을 참조하세요. AWS SDKs 

# 를 사용하여 간단한 애플리케이션 생성 AWS SDK for Java 2.x
<a name="get-started-tutorial"></a>

이 자습서에서는 [Apache Maven을](https://maven.apache.org/) 사용하여 Java 2.x용 SDK의 종속성을 정의한 다음 파일을 업로드하기 위해 Amazon S3 에 연결하는 코드를 작성하는 방법을 보여줍니다.

자습서를 완료하려면 이 단계를 따릅니다.
+  [1단계: 튜토리얼 설정](#get-started-setup) 
+  [2단계: 프로젝트 생성](#get-started-projectsetup) 
+  [3단계: 코드 작성](#get-started-code) 
+  [4단계: 애플리케이션 빌드 및 실행](#get-started-run) 

## 1단계: 튜토리얼 설정
<a name="get-started-setup"></a>

이 튜토리얼을 시작하기 전에 다음이 필요합니다.
+ 액세스 권한 Amazon S3
+ 에 대한 Single Sign-On을 AWS 서비스 사용하여에 액세스하도록 구성된 Java 개발 환경 AWS IAM Identity Center

[설정 개요](setup.md#setup-overview)의 지침을 사용하여 이 자습서를 설정하세요. Java SDK에 대한 [Single Sign-On 액세스로 개발 환경을 구성](get-started-auth.md#setup-credentials)하고 [활성 AWS 액세스 포털 세션](get-started-auth.md#setup-login-sso)이 있으면이 자습서의 2단계를 계속 진행합니다.

## 2단계: 프로젝트 생성
<a name="get-started-projectsetup"></a>

이 자습서의 프로젝트를 생성하려면 프로젝트 구성 방법에 대한 입력을 요청하는 Maven 명령을 실행합니다. 모든 입력이 입력되고 확인되면 Maven은 `pom.xml`를 생성하여 프로젝트 빌드를 완료하고 스텁 Java 파일을 생성합니다.

1. 터미널 또는 명령 프롬프트 창을 열고 원하는 디렉터리 (예: `Desktop` 또는 `Home` 폴더)로 이동합니다.

1. 터미널에서 다음 명령을 입력하고 `Enter` 키를 누릅니다.

   ```
   mvn archetype:generate \
     -DarchetypeGroupId=software.amazon.awssdk \
     -DarchetypeArtifactId=archetype-app-quickstart \
     -DarchetypeVersion=2.27.21
   ```

1. 각 프롬프트의 두 번째 열에 나열된 값을 입력합니다.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/sdk-for-java/latest/developer-guide/get-started-tutorial.html)

1. 마지막 값을 입력하면 Maven은 사용자가 선택한 항목을 나열합니다. *`Y`*을 입력하여 확인하거나 *`N`*을 입력하여 값을 다시 입력합니다.

Maven은 입력한 `artifactId` 값을 기반으로 이름이 `getstarted`로 지정된 프로젝트 폴더를 만듭니다. `getstarted` 폴더 안에서 검토할 수 있는 `README.md` 파일, `pom.xml` 파일, `src` 디렉터리를 찾으세요.

Maven은 다음과 같은 디렉터리 트리를 만듭니다.

```
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
```

다음은 `pom.xml` 프로젝트 파일의 콘텐츠를 보여줍니다.

### `pom.xml`
<a name="projectsetup-collapse2"></a>

`dependencyManagement` 단원은 AWS SDK for Java 2.x 대한 종속성을 포함하며 `dependencies` 섹션에는 Amazon S3에 대한 종속성이 있습니다. 프로젝트는 `maven.compiler.source` 및 `maven.compiler.target` 속성의 `1.8` 값 때문에 Java 1.8을 사용합니다.

```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>getstarted</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.shade.plugin.version>3.2.1</maven.shade.plugin.version>
        <maven.compiler.plugin.version>3.6.1</maven.compiler.plugin.version>
        <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
        <aws.java.sdk.version>2.27.21</aws.java.sdk.version> <-------- SDK version picked up from archetype version.
        <slf4j.version>1.7.28</slf4j.version>
        <junit5.version>5.8.1</junit5.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.java.sdk.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>  <-------- S3 dependency
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>sso</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>ssooidc</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId> <-------- HTTP client specified.
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Needed to adapt Apache Commons Logging used by Apache HTTP Client to Slf4j to avoid
        ClassNotFoundException: org.apache.commons.logging.impl.LogFactoryImpl during runtime -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Test Dependencies -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit5.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin.version}</version>
            </plugin>
        </plugins>
    </build>

</project>
```

## 3단계: 코드 작성
<a name="get-started-code"></a>

다음 코드는 Maven이 생성한 `App` 클래스를 보여줍니다. `main` 메서드는 `Handler` 클래스의 인스턴스를 만든 다음 해당 `sendRequest` 메서드를 호출하는 애플리케이션의 진입점입니다.

### `App` 클래스
<a name="projectsetup-collapse2"></a>

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

Maven에서 만든 `DependencyFactory` 클래스에는 [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) 인스턴스를 빌드하고 반환하는 `s3Client` 팩토리 메서드가 포함되어 있습니다. `S3Client` 인스턴스는 Apache 기반 HTTP 클라이언트의 인스턴스를 사용합니다. 이는 Maven에서 사용할 HTTP 클라이언트를 묻는 메시지가 표시될 때 사용자가 `apache-client`를 지정했기 때문입니다.

`DependencyFactory`는 다음 코드에 나와 있습니다.

### `DependencyFactory` 클래스
<a name="code-collapse2"></a>

```
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();
    }
}
```

`Handler` 클래스에는 프로그램의 기본 로직이 들어 있습니다. `App` 클래스에서 `Handler` 인스턴스가 생성되면 `DependencyFactory`는 `S3Client` 서비스 클라이언트를 제공합니다. 코드는 `S3Client` 인스턴스를 사용하여 Amazon S3 서비스를 호출합니다.

Maven은 `TODO` 주석과 함께 다음과 같은 `Handler` 클래스를 생성합니다. 자습서의 다음 단계에서는 *`TODO`*를 코드로 대체합니다.

### Maven에서 생성한 `Handler` 클래스
<a name="code-collapsible3"></a>

```
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.
    }
}
```

로직을 채우려면 `Handler` 클래스의 전체 내용을 다음 코드로 바꾸세요. `sendRequest` 메서드가 채워지고 필요한 임포트가 추가됩니다.

### `Handler` 클래스 구현됨
<a name="code-collapse4"></a>

코드는 먼저 버킷 이름을 고유하게 만들기 위해 `System.currentTimeMillis()`를 사용하여 생성된 이름의 마지막 부분을 사용하여 새 S3 버킷을 만듭니다.

`createBucket()` 메서드에서 버킷을 생성한 후 프로그램은 `S3Client`의 [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)) 메서드를 사용하여 객체를 업로드합니다. 객체의 내용은 `RequestBody.fromString` 메서드로 만든 간단한 문자열입니다.

마지막으로 프로그램은 `cleanUp` 메서드에서 객체를 삭제한 다음 버킷을 삭제합니다.

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

## 4단계: 애플리케이션 빌드 및 실행
<a name="get-started-run"></a>

프로젝트가 생성되고 전체 `Handler` 클래스가 포함된 후 애플리케이션을 빌드하고 실행합니다.

1. IAM IAM Identity Center 세션이 활성화되어 있는지 확인합니다. 이렇게 하려면 AWS Command Line Interface 명령을 실행`aws sts get-caller-identity`하고 응답을 확인합니다. 활성 세션이 없는 경우 [이 단원](get-started-auth.md#setup-login-sso)의 지침을 참조하세요.

1. 터미널 또는 명령 프롬프트 창을 열고 프로젝트 디렉토리 `getstarted`로 이동합니다.

1. 프로젝트를 빌드하려면 다음 명령을 사용합니다.

   ```
   mvn clean package
   ```

1. 애플리케이션을 실행하려면 다음 명령을 사용합니다.

   ```
   mvn exec:java -Dexec.mainClass="org.example.App"
   ```

프로그램이 생성한 새 버킷과 객체를 보려면 다음 단계를 수행합니다.

1. `Handler.java`에서 `sendRequest` 메서드의 `cleanUp(s3Client, bucket, key)` 줄을 주석 처리한 다음 파일을 저장합니다.

1. `mvn clean package`를 실행하여 프로젝트를 다시 빌드합니다.

1. `mvn exec:java -Dexec.mainClass="org.example.App"`를 다시 실행하여 텍스트 객체를 한 번 더 업로드합니다.

1. [S3 콘솔에](https://console.aws.amazon.com/s3/) 로그인하여 새로 생성된 버킷의 새 객체를 확인합니다.

파일을 확인한 후 객체를 삭제한 다음 버킷을 삭제합니다.

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

Maven 프로젝트가 오류 없이 빌드되고 실행되었다면 축하합니다. Java 2.x용 SDK를 사용한 첫 Java 애플리케이션 구축에 성공했습니다.

### 정리
<a name="cleanup"></a>

이 자습서를 진행하는 동안 생성한 리소스를 정리하려면 다음을 수행합니다.
+ 아직 삭제하지 않았다면 [S3 콘솔에서](https://console.aws.amazon.com/s3/) 애플리케이션을 실행할 때 생성된 모든 객체와 버킷을 삭제하세요.
+ 프로젝트 폴더를 삭제합니다(`getstarted`).

## 다음 단계
<a name="get-started-next"></a>

이제 기본 사항을 갖추었으므로, 다음 내용을 배울 수 있습니다.
+  [작업 Amazon S3](examples-s3.md) 
+  , [DynamoDB](examples-dynamodb.md) [Amazon EC2](examples-ec2.md)및 [다양한 데이터베이스 서비스와](examples-databases.md) 같은 [다른 서비스 작업 Amazon Web Services](work-with-services.md) 
+  [SDK 사용](using.md) 
+  [AWS SDK for Java에서의 보안](security.md) **