

 AWS Cloud9 는 더 이상 신규 고객이 사용할 수 없습니다. AWS Cloud9 의 기존 고객은 정상적으로 서비스를 계속 이용할 수 있습니다. [자세히 알아보기](https://aws.amazon.com/blogs/devops/how-to-migrate-from-aws-cloud9-to-aws-ide-toolkits-or-aws-cloudshell/)

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

# 용 Java 자습서 AWS Cloud9
<a name="sample-java"></a>

**중요**  
2GiB 이상의 메모리가 있는 EC2 인스턴스에서 지원하는 AWS Cloud9 개발 환경을 사용하는 경우 향상된 Java 지원을 활성화하는 것이 좋습니다. 이를 통해 코드 완성, 오류에 대한 linting, 컨텍스트별 작업, 디버깅 옵션(예: 중단점 및 단계별 실행) 등의 생산성 기능에 액세스할 수 있습니다.  
자세한 내용은 [Java 개발을 위한 향상된 지원](enhanced-java.md) 단원을 참조하십시오.

이 자습서를 사용하면 AWS Cloud9 개발 환경에서 일부 Java 코드를 실행할 수 있습니다.

이 자습서를 따르고 이 샘플을 생성하면 AWS 계정에 요금이 발생할 수 있습니다. 여기에는 Amazon EC2 및 Amazon S3 같은 서비스에 대한 발생할 수 있는 요금이 포함됩니다. 자세한 내용은 [Amazon EC2 요금](https://aws.amazon.com/ec2/pricing/) 및 [Amazon S3 요금](https://aws.amazon.com/s3/pricing/)을 참조하세요.

**Topics**
+ [사전 조건](#sample-java-prerequisites)
+ [1단계: 필수 도구 설치](#sample-java-install)
+ [2단계: 코드 추가](#sample-java-code)
+ [3단계: 코드 빌드 및 실행](#sample-java-run)
+ [4단계:를 사용하도록 설정 AWS SDK for Java](#sample-java-sdk)
+ [5단계: 환경에서 AWS 자격 증명 관리 설정](#sample-java-sdk-creds)
+ [6단계: AWS SDK 코드 추가](#sample-java-sdk-code)
+ [7단계: AWS SDK 코드 빌드 및 실행](#sample-java-sdk-run)
+ [8단계: 정리](#sample-java-clean-up)

## 사전 조건
<a name="sample-java-prerequisites"></a>

이 샘플을 사용하기 전에 설정이 다음 요구 사항을 충족하는지 확인하세요.
+ **기존 AWS Cloud9 EC2 개발 환경이 있어야 합니다.** 이 샘플에서는 Amazon Linux 또는 Ubuntu 서버를 실행 중인 Amazon EC2 인스턴스에 연결된 EC2 환경이 이미 있다고 가정합니다. 다른 환경 또는 운영 시스템이라면 이 샘플 지침을 관련 도구를 설치하는 데에 적용해야 합니다. 자세한 내용은 [에서 환경 생성 AWS Cloud9](create-environment.md) 단원을 참조하십시오.
+ **기존 환경의 AWS Cloud9 IDE가 이미 열려 있습니다.** 환경을 열면가 웹 브라우저에서 해당 환경의 IDE를 AWS Cloud9 엽니다. 자세한 내용은 [에서 환경 열기 AWS Cloud9](open-environment.md) 단원을 참조하십시오.

## 1단계: 필수 도구 설치
<a name="sample-java-install"></a>

이 단계에서는 개발 환경에 Java AWS Cloud9 개발 도구 세트를 설치합니다. Oracle JDK 또는 OpenJDK와 같은 Java 개발 도구 세트가 환경에 이미 설치되어 있는 경우 [2단계: 코드 추가](#sample-java-code) 섹션으로 진행합니다. 이 샘플은 OpenJDK 8에서 개발되었으며 다음 절차를 완료하여 사용자 환경에 설치할 수 있습니다.

1. OpenJDK 8이 이미 설치되었는지 확인합니다. 이렇게 하려면 AWS Cloud9 IDE의 터미널 세션에서 ** `-version` ** 옵션을 사용하여 Java 실행기의 명령줄 버전을 실행합니다. (터미널 세션을 새로 시작하려면 메뉴 모음에서 **Window(창)**, **New Terminal(새 터미널)**을 선택합니다.)

   ```
   java -version
   ```

   이전 명령의 출력을 기준으로 다음 중 하나를 수행합니다.
   + 출력에 `java` 명령을 찾을 수 없다고 표시될 경우 이 절차의 2단계를 진행하여 OpenJDK 8을 설치합니다.
   + 출력에 `Java(TM)`, `Java Runtime Environment`, `Java SE`, `J2SE` 또는 `Java2`로 시작하는 값이 포함되어 있는 경우, OpenJDK가 설치되지 않았거나 기본 Java 개발 도구 세트로 설정되지 않은 것입니다. 이 절차의 2단계를 계속 진행하여 OpenJDK 8을 설치한 다음 OpenJDK 8을 사용하도록 전환합니다.
   + 출력에 `java version 1.8` 및 `OpenJDK`로 시작하는 값이 포함되어 있는 경우 [2단계: 코드 추가](#sample-java-code) 섹션으로 건너뜁니다. 이 샘플에 대해 OpenJDK 8이 올바르게 설치되어 있습니다.
   + 출력에 `1.8`보다 이전 `java version`과 `OpenJDK`로 시작하는 값이 포함되어 있는 경우 이 절차의 2단계를 계속 진행하여 설치된 OpenJDK 버전을 OpenJDK 8로 업그레이드합니다.

1. 최신 보안 업데이트 및 버그 수정 사항이 설치되었는지 확인합니다. 이렇게 하려면** `update` **명령을 사용하여 yum 도구(Amazon Linux) 또는 apt 도구(Ubuntu Server)를 실행합니다.

   Amazon Linux의 경우:

   ```
   sudo yum -y update
   ```

   Ubuntu Server:

   ```
   sudo apt update
   ```

1. OpenJDK 8울 설치합니다. 이렇게 하려면 OpenJDK 8 패키지를 지정하고** `install` **명령을 사용하여 yum 도구(Amazon Linux) 또는 apt 도구(Ubuntu Server)를 실행합니다.

   Amazon Linux의 경우:

   ```
   sudo yum -y install java-1.8.0-openjdk-devel
   ```

   Ubuntu Server:

   ```
   sudo apt install -y openjdk-8-jdk
   ```

   자세한 내용은 OpenJDK 웹 사이트에서 [OpenJDK 패키지 다운로드 및 설치 방법](https://openjdk.org/install/)을 참조하세요.

1. 기본 Java 개발 도구 세트를 OpenJDK 8로 전환하거나 업그레이드합니다. 이렇게 하려면** `--config` **옵션을 사용하여** `update-alternatives` **명령을 실행합니다. Java 러너 및 컴파일러의 명령줄 버전을 전환하거나 업그레이드하려면 이 명령을 두 번 실행합니다.

   ```
   sudo update-alternatives --config java
   sudo update-alternatives --config javac
   ```

   각 프롬프트에서 OpenJDK 8의 선택 번호(`java-1.8`이 포함된 번호)를 입력합니다.

1. Java 러너 및 컴파일러의 명령줄 버전이 OpenJDK 8을 사용하고 있는지 확인합니다. 이렇게 하려면 `-version` 옵션을 사용하여 Java 러너 및 컴파일러의 명령줄 버전을 실행합니다.

   ```
   java -version
   javac -version
   ```

   OpenJDK 8이 올바르게 설치되고 설정된 경우, Java 러너 버전 출력에 `openjdk version 1.8`로 시작하는 값이 포함되며, Java 컴파일러 버전 출력이 `javac 1.8`이라는 값으로 시작됩니다.

## 2단계: 코드 추가
<a name="sample-java-code"></a>

 AWS Cloud9 IDE에서 다음 코드가 포함된 파일을 생성하고 이름이 인 파일을 저장합니다`hello.java`. (파일을 생성하려면 메뉴 모음에서 [**파일(File)**], [**새 파일(New File)**]을 선택합니다. 파일을 저장하려면 [**파일(File)**], [**저장(Save)**]을 선택합니다.)

```
public class hello {

  public static void main(String []args) {
    System.out.println("Hello, World!");

    System.out.println("The sum of 2 and 3 is 5.");

    int sum = Integer.parseInt(args[0]) + Integer.parseInt(args[1]);

    System.out.format("The sum of %s and %s is %s.\n",
      args[0], args[1], Integer.toString(sum));
  }
}
```

## 3단계: 코드 빌드 및 실행
<a name="sample-java-run"></a>

1. Java 컴파일러의 명령줄 버전을 사용하여 `hello.java` 파일을 `hello.class` 파일로 컴파일합니다. 이렇게 AWS Cloud9 하려면 IDE의 터미널을 사용하여 `hello.java` 파일과 동일한 디렉터리에서 Java 컴파일러를 실행하고 `hello.java` 파일을 지정합니다.

   ```
   javac hello.java
   ```

1. Java 러너의 명령줄 버전을 사용하여 `hello.class` 파일을 실행합니다. 이렇게 하려면 `hello.class` 파일과 동일한 디렉터리에서 `hello.java` 파일에 선언된 `hello` 클래스의 이름과 추가할 두 개의 정수(예: `5` 및 `9`)를 지정하여 Java 러너를 실행합니다.

   ```
   java hello 5 9
   ```

1. 출력을 비교합니다.

   ```
   Hello, World!
   The sum of 2 and 3 is 5.
   The sum of 5 and 9 is 14.
   ```

## 4단계:를 사용하도록 설정 AWS SDK for Java
<a name="sample-java-sdk"></a>

이 샘플을 개선하여 AWS SDK for Java 를 사용하여 Amazon S3 버킷을 생성하고 사용 가능한 버킷을 나열한 다음 방금 생성한 버킷을 삭제할 수 있습니다.

이 단계에서는 환경에 [Apache Maven](https://maven.apache.org/) 또는 [Gradle](https://gradle.org/)을 설치합니다. Maven과 Gradle은 Java 프로젝트에 사용할 수 있는 일반적인 빌드 자동화 시스템입니다. Maven 또는 Gradle을 설치한 후, 새로운 Java 프로젝트를 생성하는 데 사용합니다. 이 새 프로젝트에서는 AWS SDK for Java에 대한 참조를 추가합니다. 이렇게 AWS SDK for Java 하면 Java 코드에서 Amazon S3와 같은 AWS 서비스와 편리하게 상호 작용할 수 있습니다.

**Topics**
+ [Maven 설정](#sample-java-sdk-maven)
+ [Gradle을 사용하여 설정](#sample-java-sdk-gradle)

### Maven 설정
<a name="sample-java-sdk-maven"></a>

1. 환경에 Maven을 설치합니다. AWS Cloud9 IDE의 터미널을 사용하여 Maven이 이미 설치되어 있는지 확인하려면 ** `-version` ** 옵션과 함께 Maven을 실행합니다.

   ```
   mvn -version
   ```

   성공할 경우, 출력에 Maven 버전 번호가 포함됩니다. Maven이 이미 설치되어 있는 경우 이 절차의 4단계로 건너뛰어 Maven을 사용하여 환경에서 새 Java 프로젝트를 생성합니다.

1. 다음 명령을 실행하는 터미널을 사용하여 Maven을 설치합니다.

   Amazon Linux의 경우, 다음 명령은 Maven이 저장되어 있는 패키지 리포지토리에 대한 정보를 가져오고 이 정보를 사용하여 Maven을 설치합니다.

   ```
   sudo wget http://repos.fedorapeople.org/repos/dchen/apache-maven/epel-apache-maven.repo -O /etc/yum.repos.d/epel-apache-maven.repo
   sudo sed -i s/\$releasever/6/g /etc/yum.repos.d/epel-apache-maven.repo
   sudo yum install -y apache-maven
   ```

   앞의 명령에 대한 자세한 내용은 Fedora Project Wiki 웹 사이트에서 [Extra Packages for Enterprise Linux(EPEL)](https://docs.fedoraproject.org/en-US/epel/)를 참조하세요.

   Ubuntu Server의 경우 다음 명령을 대신 실행합니다.

   ```
   sudo apt install -y maven
   ```

1. **`-version` **옵션을 지정하고 Maven을 실행하여 설치를 확인합니다.

   ```
   mvn -version
   ```

1. Maven을 사용하여 새 Java 프로젝트를 생성합니다. 이렇게 하려면 터미널을 사용하여, Maven이 프로젝트를 생성하도록 하려는 디렉터리(예: 환경의 루트 디렉터리)에서 다음 명령을 실행합니다.

   ```
   mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   ```

   앞의 명령은 사용자 환경에서 프로젝트에 대해 다음과 같은 디렉터리 구조를 생성합니다.

   ```
   my-app
     |- src
     |   `- main
     |        `- java
     |             `- com
     |                 `- mycompany
     |                      `- app
     |                          `-App.java
     |- test
     |   `- java
     |        `- com
     |            `- mycompany
     |                 `- app
     |                     `- AppTest.java
     `- pom.xml
   ```

   앞의 디렉터리 구조에 대한 자세한 내용은 Apache Maven Project 웹 사이트에서 [Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/) 및 [표준 디렉터리 레이아웃 소개](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html)를 참조하세요.

1. 프로젝트의 Project Object Model(POM) 파일을 수정합니다. (POM 파일은 Maven 프로젝트의 설정을 정의합니다.) 이렇게 하려면 [**환경(Environment)**] 창에서 `my-app/pom.xml` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `pom.xml` 파일을 저장합니다.

   ```
   <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/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.mycompany.app</groupId>
     <artifactId>my-app</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <build>
       <plugins>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-assembly-plugin</artifactId>
           <version>3.6.0</version>
           <configuration>
             <descriptorRefs>
               <descriptorRef>jar-with-dependencies</descriptorRef>
             </descriptorRefs>
             <archive>
               <manifest>
                 <mainClass>com.mycompany.app.App</mainClass>
               </manifest>
             </archive>
           </configuration>
           <executions>
             <execution>
               <phase>package</phase>
                 <goals>
                   <goal>single</goal>
                 </goals>
             </execution>
           </executions>
         </plugin>
       </plugins>
     </build>
     <dependencies>
       <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
       </dependency>
       <dependency>
         <groupId>com.amazonaws</groupId>
         <artifactId>aws-java-sdk</artifactId>
         <version>1.11.330</version>
       </dependency>
     </dependencies>
   </project>
   ```

   앞의 POM 파일에는 다음과 같은 선언을 지정하는 프로젝트 설정이 포함되어 있습니다.
   + `my-app`의 `artifactid` 설정은 프로젝트의 루트 디렉터리 이름을 설정하고, `com.mycompany.app`의 `group-id` 설정은 `com/mycompany/app` 하위 디렉터리 구조와 `App.Java` 및 `AppTest.java` 파일의 `package`선언을 설정합니다.
   + `my-app`의 `artifactId` 설정은 `jar`의 `packaging` 설정, `1.0-SNAPSHOT`의 `version` 설정, 그리고 `jar-with-dependencies`의 `descriptorRef` 설정과 함께 출력 JAR 파일의 이름(`my-app-1.0-SNAPSHOT-jar-with-dependencies.jar`)을 설정합니다.
   + `plugin` 섹션은 모든 종속성을 포함하는 단일 JAR이 빌드된다는 것을 선언합니다.
   + 의 `groupId` 설정`com.amazon.aws`과의 `artifactId` 설정이 있는 `dependency` 섹션에는 AWS SDK for Java 라이브러리 파일이 `aws-java-sdk` 포함되어 있습니다. 사용할 AWS SDK for Java 버전은 `version` 설정에 의해 선언됩니다. 다른 버전을 사용하려면 이 버전 번호를 바꿉니다.

[5단계: 환경에서 AWS 자격 증명 관리 설정](#sample-java-sdk-creds) 단원으로 이동합니다.

### Gradle을 사용하여 설정
<a name="sample-java-sdk-gradle"></a>

1. 환경에 Gradle을 설치합니다. AWS Cloud9 IDE의 터미널을 사용하여 Gradle이 이미 설치되어 있는지 확인하려면 ** `-version` ** 옵션과 함께 Gradle을 실행합니다.

   ```
   gradle -version
   ```

   성공할 경우, 출력에 Gradle 버전 번호가 포함됩니다. Gradle이 이미 설치되어 있는 경우 이 절차의 4단계로 건너뛰어 Gradle을 사용하여 환경에서 새 Java 프로젝트를 생성합니다.

1. 다음 명령을 실행하는 터미널을 사용하여 Gradle을 설치합니다. 이 명령은 SDKMAN\$1 도구를 설치하고 실행한 다음, SDKMAN\$1을 사용하여 Gradle 최신 버전을 설치합니다.

   ```
   curl -s "https://get.sdkman.io" | bash
   source "$HOME/.sdkman/bin/sdkman-init.sh"
   sdk install gradle
   ```

   앞의 명령에 대한 자세한 내용은 SDKMAN\$1 웹 사이트의 [설치](https://sdkman.io/install)와 Gradle 웹 사이트의 [패키지 관리자를 사용하여 설치](https://gradle.org/install/#with-a-package-manager)를 참조하세요.

1. **`-version` **옵션을 지정하고 Gradle을 실행하여 설치를 확인합니다.

   ```
   gradle -version
   ```

1. Gradle을 사용하여 환경에서 새 Java 프로젝트를 생성합니다. 이렇게 하려면 터미널에서 다음 명령을 실행하여 프로젝트의 디렉터리를 생성한 다음 디렉터리로 전환합니다.

   ```
   mkdir my-app
   cd my-app
   ```

1. 다음 명령을 실행하여 Gradle이 환경의 `my-app` 디렉터리에 새 Java 애플리케이션 프로젝트를 생성하도록 합니다.

   ```
   gradle init --type java-application
   ```

   앞의 명령은 사용자 환경에서 프로젝트에 대해 다음과 같은 디렉터리 구조를 생성합니다.

   ```
   my-app
     |- .gradle
     |   `- (various supporting project folders and files)
     |- gradle
     |   `- (various supporting project folders and files)
     |- src
     |   |- main
     |   |    `- java
     |   |         `- App.java
     |   `- test
     |        `- java
     |             `- AppTest.java
     |- build.gradle
     |- gradlew
     |- gradlew.bat
     `- settings.gradle
   ```

1. 프로젝트의 `AppTest.java`를 수정합니다. (이렇게 하지 않으면 프로젝트가 정상적으로 빌드되거나 실행되지 않을 수 있습니다.) 이렇게 하려면 [**환경(Environment)**] 창에서 `my-app/src/test/java/AppTest.java` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `AppTest.java` 파일을 저장합니다.

   ```
   import org.junit.Test;
   import static org.junit.Assert.*;
   
   public class AppTest {
     @Test public void testAppExists () {
       try {
         Class.forName("com.mycompany.app.App");
       } catch (ClassNotFoundException e) {
         fail("Should have a class named App.");
       }
     }
   }
   ```

1. 프로젝트의 `build.gradle` 파일을 수정합니다. (`build.gradle` 파일은 Gradle 프로젝트의 설정을 정의합니다.) 이렇게 하려면 [**환경(Environment)**] 창에서 `my-app/build.gradle` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `build.gradle` 파일을 저장합니다.

   ```
   apply plugin: 'java'
   apply plugin: 'application'
   
   repositories {
     jcenter()
     mavenCentral()
   }
   
   buildscript {
     repositories {
       mavenCentral()
     }
     dependencies {
       classpath "io.spring.gradle:dependency-management-plugin:1.0.3.RELEASE"
     }
   }
   
   apply plugin: "io.spring.dependency-management"
   
   dependencyManagement {
     imports {
       mavenBom 'com.amazonaws:aws-java-sdk-bom:1.11.330'
     }
   }
   
   dependencies {
     compile 'com.amazonaws:aws-java-sdk-s3'
     testCompile group: 'junit', name: 'junit', version: '4.12'
   }
   
   run {
     if (project.hasProperty("appArgs")) {
       args Eval.me(appArgs)
     }
   }
   
   mainClassName = 'App'
   ```

   앞의 `build.gradle` 파일에는 다음과 같은 선언을 지정하는 프로젝트 설정이 포함되어 있습니다.
   + `io.spring.dependency-management` 플러그인은 프로젝트의 AWS SDK for Java 종속성을 관리하기 위해 AWS SDK for Java Maven BOM(Bill of Materials)을 가져오는 데 사용됩니다.는 사용할 버전을 `classpath` 선언합니다. 다른 버전을 사용하려면 이 버전 번호를 바꿉니다.
   +  `com.amazonaws:aws-java-sdk-s3`는 AWS SDK for Java 라이브러리 파일의 Amazon S3 부분을 포함합니다. `mavenBom`은 사용할 버전을 선언합니다. 다른 버전을 사용하려면 이 버전 번호를 바꿉니다.

## 5단계: 환경에서 AWS 자격 증명 관리 설정
<a name="sample-java-sdk-creds"></a>

를 사용하여 AWS 서비스를 호출 AWS SDK for Java 할 때마다 호출과 함께 자격 증명 세트를 AWS 제공해야 합니다. 이러한 자격 증명은에 해당 호출을 수행할 수 AWS SDK for Java 있는 적절한 권한이 있는지 여부를 결정합니다. 자격 증명으로 적절한 권한이 확인되지 않는 경우 호출이 실패합니다.

이 단계에서는 환경 내에서 자격 증명을 저장합니다. 이렇게 하려면 [AWS 서비스 의 환경에서 호출 AWS Cloud9](credentials.md) 섹션의 지침을 수행한 다음 이 주제로 돌아옵니다.

자세한 내용은 *AWS SDK for Java 개발자 안내서*에서 [개발을 위한 AWS 자격 증명 및 리전 설정](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html#setup-credentials)을 참조하세요.

## 6단계: AWS SDK 코드 추가
<a name="sample-java-sdk-code"></a>

이 단계에서는 코드를 추가하여 Amazon S3와 상호 작용하고, 버킷을 생성하고, 사용 가능한 버킷을 나열한 다음 막 생성한 버킷을 삭제합니다.

[**환경(Environment)**] 창에서 Maven의 경우 `my-app/src/main/java/com/mycompany/app/App.java` 파일 또는 Gradle의 경우 `my-app/src/main/java/App.java` 파일을 엽니다. 편집기에서 이 파일의 현재 내용을 다음 코드로 바꾼 다음 `App.java` 파일을 저장합니다.

```
package com.mycompany.app;

import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import com.amazonaws.services.s3.model.Bucket;
import com.amazonaws.services.s3.model.CreateBucketRequest;

import java.util.List;

public class App {

    private static AmazonS3 s3;

    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.format("Usage: <the bucket name> <the AWS Region to use>\n" +
                    "Example: my-test-bucket us-east-2\n");
            return;
        }

        String bucket_name = args[0];
        String region = args[1];

        s3 = AmazonS3ClientBuilder.standard()
                .withCredentials(new ProfileCredentialsProvider())
                .withRegion(region)
                .build();

        // List current buckets.
        ListMyBuckets();

        // Create the bucket.
        if (s3.doesBucketExistV2(bucket_name)) {
            System.out.format("\nCannot create the bucket. \n" +
                    "A bucket named '%s' already exists.", bucket_name);
            return;
        } else {
            try {
                System.out.format("\nCreating a new bucket named '%s'...\n\n", bucket_name);
                s3.createBucket(new CreateBucketRequest(bucket_name, region));
            } catch (AmazonS3Exception e) {
                System.err.println(e.getErrorMessage());
            }
        }

        // Confirm that the bucket was created.
        ListMyBuckets();

        // Delete the bucket.
        try {
            System.out.format("\nDeleting the bucket named '%s'...\n\n", bucket_name);
            s3.deleteBucket(bucket_name);
        } catch (AmazonS3Exception e) {
            System.err.println(e.getErrorMessage());
        }

        // Confirm that the bucket was deleted.
        ListMyBuckets();

    }

    private static void ListMyBuckets() {
        List<Bucket> buckets = s3.listBuckets();
        System.out.println("My buckets now are:");

        for (Bucket b : buckets) {
            System.out.println(b.getName());
        }
    }

}
```

## 7단계: AWS SDK 코드 빌드 및 실행
<a name="sample-java-sdk-run"></a>

이전 단계의 코드를 실행하려면 터미널에서 다음 명령을 실행합니다. 이 명령은 Maven 또는 Gradle을 사용하여 프로젝트의 JAR 실행 파일을 만든 다음 Java 러너를 사용하여JAR을 실행합니다. JAR은 Amazon S3에서 생성할 버킷의 이름(예: `my-test-bucket`)과에서 버킷을 입력으로 생성할 AWS 리전의 ID(예: )로 실행됩니다`us-east-2`.

Maven의 경우 다음 명령을 실행합니다.

```
cd my-app
mvn package
java -cp target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar com.mycompany.app.App my-test-bucket us-east-2
```

Gradle의 경우 다음 명령을 실행합니다.

```
gradle build
gradle run -PappArgs="['my-test-bucket', 'us-east-2']"
```

결과를 다음 출력과 비교합니다.

```
My buckets now are:

Creating a new bucket named 'my-test-bucket'...

My buckets now are:

my-test-bucket

Deleting the bucket named 'my-test-bucket'...

My buckets now are:
```

## 8단계: 정리
<a name="sample-java-clean-up"></a>

이 샘플 사용을 완료한 후 AWS 계정에 지속적인 요금이 부과되지 않도록 하려면 환경을 삭제해야 합니다. 지침은 [에서 환경 삭제 AWS Cloud9](delete-environment.md) 단원을 참조하세요.