

 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>

**重要**  
2 GiB 以上のメモリを持つ 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 Server を実行する 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 が既にインストールされているかどうかを確認します。これを行うには、IDE AWS Cloud9 のターミナルセッションで、 **`-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 が正しくインストールされます。
   + 出力に `java version` 未満の `1.8` と `OpenJDK` で始まる値が含まれている場合、この手順のステップ 2 に進んで、インストールされた OpenJDK バージョンを OpenJDK 8 にアップグレードします。

1. 最新のセキュリティ更新およびバグ修正がインストールされていることを確認します。これを行うには、yum ツール (Amazon Linux の場合) または apt ツール (Ubuntu Server の場合) を** `update` **コマンドを実行します。

   Amazon Linux の場合:

   ```
   sudo yum -y update
   ```

   Ubuntu Server の場合:

   ```
   sudo apt update
   ```

1. OpenJDK 8 をインストールします。これを行うには、yum ツール (Amazon Linux の場合) または apt ツール (Ubuntu Server の場合) を** `install` **コマンドを使用して OpenJDK 8 パッケージを実行します。

   Amazon Linux の場合:

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

   Ubuntu Server の場合:

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

   詳細については、OpenJDK ウェブサイトで「[How to download and install prebuilt OpenJDK packages](https://openjdk.org/install/)」を参照してください。

1. デフォルトの Java 開発ツールセットを OpenJDK 8 に切り替えるかアップグレードします。これを行うには、** `--config` ** オプションを使用して ** `update-alternatives` ** コマンドを実行します。このコマンドを 2 回実行し、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`。(メニューバーでファイルを作成するには、**ファイル**、**New File (新しいファイル)**を選択します。 ファイルを保存するには、**ファイル**、**保存**を選択します。)

```
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` ファイルにコンパイルします。これを行うには、IDE AWS Cloud9 のターミナルを使用して、 `hello.java` ファイルと同じディレクトリから、 `hello.java` ファイルを指定して Java コンパイラを実行します。

   ```
   javac hello.java
   ```

1. Java ランナーのコマンドラインバージョンを使用して `hello.class` ファイルを実行します。これを行うには、`hello.class` ファイルと同じディレクトリから、追加する 2 つの整数 (`hello` と `hello.java` など) を使用して、`5` ファイルで宣言した `9` クラスの名前を指定します。

   ```
   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 をインストールします。Maven が既にインストールされているかどうかを確認するには、IDE AWS Cloud9 のターミナルを使用して、 **`-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 サーバーでは、代わりに以下のコマンドを実行します。

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

1. **`-version`** オプションを指定して Maven を実行し、インストールされていることを確認します。

   ```
   mvn -version
   ```

1. 新しい Java プロジェクトを生成するには Maven を使用します。これを行うには、ターミナルを使用して、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 プロジェクトウェブサイトの「[Maven Quickstart Archetype](https://maven.apache.org/archetypes/maven-archetype-quickstart/)」と「[Introduction to the Standard Directory Layout](https://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html)」を参照してください。

1. プロジェクトのプロジェクトオブジェクトモデル (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 ファイルには、以下のように宣言を指定するプロジェクト設定が含まれています。
   + `artifactid` の `my-app` 設定は、プロジェクトのルートディレクトリを設定し、`group-id` の `com.mycompany.app` 設定は `com/mycompany/app` および `package` ファイルで `App.Java` サブディレクトリ構造と `AppTest.java` 宣言を設定します。
   + `artifactId` の `my-app` 設定に加えて、`packaging` の `jar` 設定、`version` の `1.0-SNAPSHOT` 設定、`descriptorRef` の `jar-with-dependencies` 設定は、出力 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 をインストールします。Gradle が既にインストールされているかどうかを確認するには、IDE AWS Cloud9 のターミナルを使用して、 **`-version`**オプションを使用して Gradle を実行します。

   ```
   gradle -version
   ```

   成功すると、出力に Gradle のバージョン番号が表示されます。Gradle が既にインストールされている場合、この手順のステップ 4 に進んで Gradle を使用し、環境で新しい Java プロジェクトを生成します。

1. ターミナルを使用して以下のコマンドを実行し、Gradle をインストールします。以下のコマンドでは、SDKMAN\$1 ツールをインストールして実行し、次に SDKMAN\$1 を使用して最新バージョンの Node.js をインストールします。

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

   上記のコマンドの詳細については、SDKMAN\$1 ウェブサイトの「[Installation](https://sdkman.io/install)」と Gradle ウェブサイトの「[Install with a package manager](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 Maven 部品表 (BOM) をインポートしてプロジェクトの AWS SDK for Java 依存関係を管理するために使用されます。 は使用するバージョンを`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)」を参照してください。