Amazon CodeCatalyst は新規のお客様には提供されなくなりました。既存のお客様は、通常どおりサービスを引き続き使用できます。詳細については、「[CodeCatalyst から移行する方法](migration.md)」を参照してください。

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# チュートリアル: Amazon EKS にアプリケーションをデプロイする
<a name="deploy-tut-eks"></a>

このチュートリアルでは、Amazon CodeCatalyst ワークフロー、Amazon EKS、およびその他のいくつかの AWS サービスを使用して、コンテナ化されたアプリケーションを Amazon Elastic Kubernetes Service にデプロイする方法について説明します。デプロイされたアプリケーションはシンプルな「Hello, World\$1」です。Apache ウェブサーバー Docker イメージ上にビルドされたウェブサイト。このチュートリアルでは、開発マシンや Amazon EKS クラスターのセットアップなど必要な準備作業を説明し、アプリケーションをビルドしてクラスターにデプロイするワークフローの作成方法を説明します。

最初のデプロイが完了すると、チュートリアルでアプリケーションソースを変更するように指示されます。この変更により、新しい Docker イメージがビルドされ、新しいリビジョン情報を使用して Docker イメージリポジトリにプッシュされます。その後、Docker イメージの新しいリビジョンが Amazon EKS にデプロイされます。

**ヒント**  
このチュートリアルを進める代わりに、完全な Amazon EKS セットアップを実行するブループリントを使用できます。**[EKS App Deployment]** ブループリントを使用する必要があります。詳細については、「[ブループリントを使用したプロジェクトの作成](projects-create.md#projects-create-console-template)」を参照してください。

**Topics**
+ [前提条件](#deploy-tut-eks-prereqs)
+ [ステップ 1: 開発マシンをセットアップする](#deploy-tut-eks-dev-env-create)
+ [ステップ 2: Amazon EKS クラスターを作成する](#deploy-tut-eks-cluster)
+ [ステップ 3: Amazon ECR イメージリポジトリを作成する](#deploy-tut-eks-ecr)
+ [ステップ 4: ソースファイルを追加する](#deploy-tut-eks-source-files)
+ [ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles)
+ [ステップ 6: CodeCatalyst に AWS ロールを追加する](#deploy-tut-eks-import-roles)
+ [ステップ 7: ConfigMap を更新する](#deploy-tut-eks-configmap)
+ [ステップ 8: ワークフローを作成して実行する](#deploy-tut-eks-workflow)
+ [ステップ 9: ソースファイルを変更する](#deploy-tut-eks-change)
+ [クリーンアップ](#deploy-tut-eks-cleanup)

## 前提条件
<a name="deploy-tut-eks-prereqs"></a>

このチュートリアルを開始する前に:
+ 接続された AWS アカウントを持つ Amazon CodeCatalyst **スペース**が必要です。詳細については、「[スペースを作成する](spaces-create.md)」を参照してください。
+ スペースには、次の名前の空のプロジェクトが必要です。

  ```
  codecatalyst-eks-project
  ```

  このプロジェクトを作成するには、**[ゼロから開始]** オプションを使用します。

  詳細については、「[Amazon CodeCatalyst での空のプロジェクトの作成](projects-create.md#projects-create-empty)」を参照してください。
+ プロジェクトには、次の名前の空白の CodeCatalyst **[ソースリポジトリ]** が必要です。

  ```
  codecatalyst-eks-source-repository
  ```

  詳細については、「[CodeCatalyst のソースリポジトリでコードを保存し、共同作業を行うソースリポジトリでコードを保存して共同作業を行う](source.md)」を参照してください。
+ プロジェクトには、CodeCatalyst CI/CD **環境** (開発環境ではない) が必要です。

  ```
  codecatalyst-eks-environment
  ```

  この環境を次のように設定します。
  + **[非本番稼働用]** など、任意のタイプを選択します。
  +  AWS アカウントを接続します。
  + **[デフォルトの IAM ロール]** で、任意のロールを選択します。後で別のロールを指定します。

  詳細については、「[AWS アカウント と VPCs へのデプロイ](deploy-environments.md)」を参照してください。

## ステップ 1: 開発マシンをセットアップする
<a name="deploy-tut-eks-dev-env-create"></a>

このチュートリアルの最初のステップは、このチュートリアル全体で使用するいくつかのツールを使用して開発マシンを設定することです。これらのロールは次のとおりです。
+ `eksctl` ユーティリティ – クラスター作成用
+ `kubectl` ユーティリティ – `eksctl` の前提条件
+  AWS CLI - の前提条件でもあります。 `eksctl`

これらのツールは、既存の開発マシンにインストールすることも、クラウドベースの CodeCatalyst 開発環境を使用することもできます。CodeCatalyst 開発環境の利点は、スピンアップとテイクダウンが簡単で、他の CodeCatalyst サービスと統合されているため、このチュートリアルをより少ないステップで実行できます。

このチュートリアルでは、CodeCatalyst 開発環境を使用することを前提としています。

次の手順では、CodeCatalyst 開発環境を起動し、必要なツールを使用して設定する簡単な方法について説明しますが、詳細な手順が必要な場合は、次を参照してください。
+ このガイドの「[開発環境の作成](devenvironment-create.md)」を参照してください。
+ 「**Amazon EKS ユーザーガイド**」の「[kubectl のインストール](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)」。
+ 「**Amazon EKS ユーザーガイド**」の「[eksctl のインストールまたはアップグレード](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html)」。
+ 「*AWS Command Line Interface ユーザーガイド*」の「[AWS CLIの最新バージョンのインストールまたは更新](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)」。

**新しい開発環境を起動するには**

1. [https://codecatalyst.aws/](https://codecatalyst.aws/) で CodeCatalyst コンソールを開きます。

1. プロジェクト「`codecatalyst-eks-project`」に移動します。

1. ナビゲーションペインで **[コード]** を選択してから、**[ソースリポジトリ]** を選択します。

1. ソースリポジトリの名前「`codecatalyst-eks-source-repository`」を選択します。

1. 上部近くで **[開発環境を作成]** を選択し、**[AWS Cloud9 (ブラウザで)]** を選択します。

1. **[既存のブランチで作業]** と **[メイン]** が選択されていることを確認してから、**[作成]** を選択します。

   開発環境が新しいブラウザタブで起動し、リポジトリ (`codecatalyst-eks-source-repository`) がそこにクローンされます。

**kubectl をインストールして設定するには**

1. 開発環境ターミナルで、次のように入力します。

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. 次のように入力します。

   ```
   chmod +x ./kubectl
   ```

1. 次のように入力します。

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. 次のように入力します。

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. 次のように入力します。

   ```
   kubectl version --short --client
   ```

1. バージョンが表示されることを確認します。

   `kubectl` がインストールされました。

**eksctl をインストールして設定するには**
**注記**  
`kubectl` を代わりに使用できるため、`eksctl` は必須ではありません。ただし、`eksctl` にはクラスター設定の多くを自動化する利点があるため、このチュートリアルで推奨されるツールです。

1. 開発環境ターミナルで、次のように入力します。

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. 次のように入力します。

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. 次のように入力します。

   ```
   eksctl version
   ```

1. バージョンが表示されることを確認します。

   `eksctl` がインストールされました。

**AWS CLI がインストールされていることを確認するには**

1. 開発環境ターミナルで、次のように入力します。

   ```
   aws --version
   ```

1. バージョンが表示され、 AWS CLI がインストールされていることを確認します。

   残りの手順を完了して、 にアクセスするために必要なアクセス許可 AWS CLI を持つ を設定します AWS。

**を設定するには AWS CLI**

 AWS サービスへのアクセスを許可するには、 アクセスキーとセッショントークン AWS CLI を使用して を設定する必要があります。以下の手順では、キーとトークンを簡単に設定できますが、詳細な手順が必要な場合は、「*AWS Command Line Interface ユーザーガイド*」の「[AWS CLIの設定](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)」を参照してください。

1. IAM アイデンティティセンターユーザーを次のように作成します。

   1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/) で AWS IAM アイデンティティセンター コンソールを開きます。

      (IAM アイデンティティセンターにサインインしたことがない場合は、**[有効化]** を選択する必要があります。)
**注記**  
CodeCatalyst スペース AWS アカウント に接続されている を使用してサインインしてください。スペースに移動し、**[AWS アカウント]** タブを選択することで、接続されているアカウントを確認できます。詳細については、「[スペースを作成する](spaces-create.md)」を参照してください。

   1. ナビゲーションペインで **[Users]** (ユーザー)、**[Add user]** (ユーザーの追加) の順に選択します。

   1. **[ユーザー名]** に次のように入力します。

      ```
      codecatalyst-eks-user
      ```

   1. **[パスワード]** で、**[このユーザーと共有できるワンタイムパスワードを生成]** を選択します。

   1. **[E メールアドレス]** と **[E メールアドレスを確認]** で、IAM アイデンティティセンターにまだ存在しない E メールアドレスを入力します。

   1. **[名（ローマ字）]** に次のように入力します。

      ```
      codecatalyst-eks-user
      ```

   1. **[姓（ローマ字）]** に次のように入力します。

      ```
      codecatalyst-eks-user
      ```

   1. **[表示名]** では、以下を維持します。

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   1. [**次へ**] を選択します。

   1. **[グループにユーザーを追加]** ページで、**[次へ]** を選択します。

   1. 「**ユーザーを確認と追加**」ページで情報を確認し、**[ユーザーを追加]** を選択します。

      **[ワンタイムパスワード]** ダイアログボックスが表示されます。

   1. **[コピー]** を選択し、サインイン情報をテキストファイルに貼り付けます。サインイン情報は、 AWS アクセスポータル URL、ユーザー名、ワンタイムパスワードで構成されます。

   1. [**閉じる**] を選択してください。

1. 次のようにアクセス権限セットを作成します。

   1. ナビゲーションペインで [**アクセス許可セット**] を選択し、[**アクセス許可セットの作成**] を選択します。

   1. **[事前定義されたアクセス許可セットのポリシー]** で **[AdministratorAccess]** を選択します。このポリシーではすべての AWS のサービスアクションに対するアクセス許可が与えられています。

   1. [**次へ**] を選択します。

   1. **[アクセス許可セット名]** で、`AdministratorAccess` を削除して次のように入力します。

      ```
      codecatalyst-eks-permission-set
      ```

   1. [**次へ**] を選択します。

   1. [**確認と作成**] ページで情報を確認し、[**グループの作成**] を選択します。

1. アクセス許可セットを次のように `codecatalyst-eks-user` に設定します。

   1. ナビゲーションペインで を選択し**AWS アカウント**、現在サインイン AWS アカウント している の横にあるチェックボックスをオンにします。

   1. 「**ユーザーまたはグループを割り当て**」を選択します。

   1. **[ユーザー]** タブを選択します。

   1. [`codecatalyst-eks-user`] のチェックボックスをオンにします。

   1. [**次へ**] を選択します。

   1. [`codecatalyst-eks-permission-set`] のチェックボックスをオンにします。

   1. [**次へ**] を選択します。

   1. 情報を確認し、[**送信**] を選択します。

      これで、 `codecatalyst-eks-user`と `codecatalyst-eks-permission-set`を に割り当て AWS アカウント、それらをバインドしました。

1. 次のように、`codecatalyst-eks-user` のアクセスキーとセッショントークンを取得します。

   1. アクセス AWS ポータル URL と、 のユーザー名およびワンタイムパスワードがあることを確認します`codecatalyst-eks-user`。この情報は、事前にテキストエディタにコピーしておく必要があります。
**注記**  
この情報がない場合は、IAM アイデンティティセンターの `codecatalyst-eks-user` 詳細ページに移動し、**[パスワードをリセット]**、**[ワンタイムパスワードを生成 [...]]** を選択して、もう一度 **[パスワードをリセットする]** と、画面に情報が表示されます。

   1. からサインアウトします AWS。

   1.  AWS アクセスポータル URL をブラウザのアドレスバーに貼り付けます。

   1. 次の情報でサインインします。
      + **ユーザー名**:

        ```
        codecatalyst-eks-user
        ```
      + **パスワード**:

        *one-time-password*

   1. **[新しいパスワードを設定]** で、新しいパスワードを入力し、**[新しいパスワードを設定]** を選択します。

      画面に **AWS アカウント** ボックスが表示されます。

   1. **AWS アカウント** を選択し、 AWS アカウント ユーザーとアクセス許可セットを割り当てた `codecatalyst-eks-user` の名前を選択します。

   1. `codecatalyst-eks-permission-set` の隣にある **[コマンドラインまたはプログラムによるアクセス]** を選択します。

   1. ページの中央にあるコマンドをコピーします。次のような内容です。

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ...ここでは *[session-token]* は長いランダムな文字列です。

1. 次のように AWS CLI、アクセスキーとセッショントークンを に追加します。

   1. CodeCatalyst 開発環境に戻ります。

   1. ターミナルプロンプトで、コピーしたコマンドを貼り付けます。[Enter] キーを押します。

      これで、 アクセスキーとセッショントークン AWS CLI を使用して を設定しました。を使用して AWS CLI 、このチュートリアルに必要なタスクを完了できるようになりました。
**重要**  
このチュートリアル中に次のようなメッセージが表示される場合:  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
または:  
`ExpiredToken: The security token included in the request is expired`  
... AWS CLI セッションの有効期限が切れているためです。この場合、`aws configure` コマンドは*実行しないでください*。代わりに、`Obtain codecatalyst-eks-user's access key and session token` で始まるこの手順のステップ 4 の手順を使用して、セッションを更新します。

## ステップ 2: Amazon EKS クラスターを作成する
<a name="deploy-tut-eks-cluster"></a>

このセクションでは、Amazon EKS にクラスターを作成します。以下の手順では、`eksctl` を使用してクラスターを素早く作成する方法について説明しますが、詳細な手順が必要な場合は、次を参照してください。
+ 「**Amazon EKS ユーザーガイド**」の「[eksctl の使用開始](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)」

  または
+ 「**Amazon EKS ユーザーガイド**」の「[コンソールと AWS CLIの開始方法](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) 」(このトピックでは、クラスター作成用の `kubectl` 手順について説明します) 

**注記**  
[[プライベートクラスター]](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) は、Amazon EKS との CodeCatalyst 統合ではサポートされていません。

**[開始する前に]**

開発マシンで次のタスクを完了していることを確認します。
+ `eksctl` ユーティリティをインストールする。
+ `kubectl` ユーティリティをインストールする。
+ をインストール AWS CLI し、アクセスキーとセッショントークンを使用して設定しました。

これらのタスクを完了する方法の詳細については、「[ステップ 1: 開発マシンをセットアップする](#deploy-tut-eks-dev-env-create)」を参照してください。

**クラスターを作成するには**
**重要**  
クラスターが正しく設定されないため、Amazon EKS サービスのユーザーインターフェイスを使用してクラスターを作成しないでください。以下のステップで説明されているように、`eksctl` ユーティリティを使用します。

1. 開発環境に移動します。

1. クラスターおよびノードを作成する

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   コードの説明は以下のとおりです。
   + *[codecatalyst-eks-cluster]* は、クラスターに付ける名前に置き換えられます。
   + *[us-west-2]* を、ご利用のリージョンに置き換えます。

   10～20 分後、次のようなメッセージが表示されます。

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**注記**  
 AWS がクラスターを作成中に複数の `waiting for CloudFormation stack` メッセージが表示されます。これは通常の動作です。

1. クラスターが正常に作成されたことを確認します。

   ```
   kubectl cluster-info
   ```

   クラスターが正常に作成されたことを示す次のようなメッセージが表示されます。

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

## ステップ 3: Amazon ECR イメージリポジトリを作成する
<a name="deploy-tut-eks-ecr"></a>

このセクションでは、Amazon Elastic Container Registry (Amazon ECR) にプライベートイメージリポジトリを作成します。このリポジトリには、チュートリアル用の Docker イメージが保存されます。

Amazon ECR の詳細については、*Amazon Elastic Container Registry User Guide* を参照してください。

**Amazon ECR にイメージリポジトリを作成するには**

1. 開発環境に移動します。

1. Amazon ECR に空白のリポジトリを作成します。

   ```
   aws ecr create-repository --repository-name codecatalyst-eks-image-repo
   ```

   *[codecatalyst-eks-image-repo]* を Amazon ECR リポジトリに付ける名前に置き換えます。

   このチュートリアルでは、リポジトリ に「`codecatalyst-eks-image-repo`」と名前を付けていることを前提としています。

1. Amazon ECR リポジトリの詳細を表示します。

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-eks-image-repo
   ```

1. `“repositoryUri”:` の値、例えば「`111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo`」を書き留めます。

   ワークフローにリポジトリを追加するときは、後にこれが必要となります。

## ステップ 4: ソースファイルを追加する
<a name="deploy-tut-eks-source-files"></a>

このセクションでは、ソースリポジトリ (`codecatalyst-eks-source-repository`) にアプリケーションソースファイルを追加します。これらは以下で構成されます。
+ `index.html` ファイル – 「Hello, World\$1」を表示します。ブラウザのメッセージ。
+ Dockerfile – Docker イメージに使用するベースイメージと、それに適用する Docker コマンドについて説明します。
+ `deployment.yaml` ファイル – Kubernetes サービスとデプロイを定義する Kubernetes マニフェスト。

フォルダは次のような構造になっています。

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml)

### index.html
<a name="deploy-tut-eks-source-files-index"></a>

`index.html` ファイルには「Hello, World\$1」と表示されます。ブラウザのメッセージ。

**index.html ファイルを追加するには**

1. 開発環境に移動します。

1. `codecatalyst-eks-source-repository` に「`public-html`」という名前のフォルダを作成します。

1. `/public-html` に「`index.html`」という名前のファイルを次の内容で作成します。

   ```
   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello, World!</h1>
     </body>
   </html>
   ```

1. ターミナルプロンプトで、次のように入力します。

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. 追加、コミット、プッシュ:

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

   `index.html` は、`public-html` フォルダ内のリポジトリに追加されます。

### Dockerfile
<a name="deploy-tut-eks-source-files-dockerfile"></a>

Dockerfile は、使用するベース Docker イメージと、それに適用する Docker コマンドについて説明します。Dockerfile の詳細については、「[Dockerfile リファレンス](https://docs.docker.com/engine/reference/builder/)」を参照してください。

ここで指定された Dockerfile は、Apache 2.4 ベースイメージ (`httpd`) を使用することを示します。また、ウェブページを提供する Apache サーバーのフォルダに「`index.html`」というソースファイルをコピーする手順も含まれています。Dockerfile の `EXPOSE` 命令は、コンテナがポート 80 でリッスンしていることを Docker に伝えます。

**Dockerfile を追加するには**

1. `codecatalyst-eks-source-repository` に「`Dockerfile`」という名前のファイルを次の内容で作成します。

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

   ファイル名に拡張子は含めないでください。
**重要**  
Dockerfile はリポジトリのルートフォルダに存在する必要があります。ワークフローの `Docker build` コマンドは、ワークフローが存在することを期待します。

1. 追加、コミット、プッシュ:

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

   Dockerfile がリポジトリに追加されます。

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

このセクションでは、リポジトリに `deployment.yaml` ファイルを追加します。`deployment.yaml` ファイルは、Kubernetes マニフェストであり、実行する 2 つの Kubernetes リソースタイプまたは*種類*、つまり「サービス」と「デプロイ」を定義します。
+ 「サービス」はロードバランサーを Amazon EC2 にデプロイします。ロードバランサーには、「Hello, World\$1」を参照するために使用できるインターネット向けパブリック URL と標準ポート (ポート 80) が用意されています。アプリケーションをデプロイします。
+ 「デプロイ」は 3 つのポッドをデプロイし、各ポッドには「Hello, World\$1」を含む Docker コンテナが含まれます。アプリケーションをデプロイします。3 つのポッドは、クラスターの作成時に作成されたノードにデプロイされます。

このチュートリアルのマニフェストは短いですが、マニフェストにはポッド、ジョブ、ingress、ネットワークポリシーなど、任意の数の Kubernetes リソースタイプを含めることができます。さらに、デプロイが複雑な場合は、複数のマニフェストファイルを使用できます。

**deployment.yaml ファイルを追加するには**

1. `codecatalyst-eks-source-repository` に、「`Kubernetes`」という名前のフォルダを作成します。

1. `/Kubernetes` に「`deployment.yaml`」という名前のファイルを次の内容で作成します。

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. 追加、コミット、プッシュ:

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   `deployment.yaml` ファイルは、`Kubernetes` というフォルダのリポジトリに追加されます。

これで、すべてのソースファイルが追加されました。

少し時間を取って作業を再確認し、すべてのファイルを正しいフォルダに配置してください。フォルダは次のような構造になっています。

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## ステップ 5: AWS ロールを作成する
<a name="deploy-tut-eks-roles"></a>

このセクションでは、CodeCatalyst ワークフローが機能するために必要な AWS IAM ロールを作成します。これらのロールは次のとおりです。
+ **ビルドロール** – CodeCatalyst ビルドアクション (ワークフロー内) に AWS 、アカウントにアクセスして Amazon ECR と Amazon EC2 に書き込むためのアクセス許可を付与します。
+ **ロールのデプロイ** – CodeCatalyst **Deploy to Kubernetes クラスター**アクション (ワークフロー内) に AWS 、アカウントと Amazon EKS へのアクセス許可を付与します。

IAM ロールの詳細については、「*AWS Identity and Access Management ユーザーガイド*」の「[IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)」を参照してください。

**注記**  
時間を節約するため、前に一覧表示した 2 つのロールではなく、`CodeCatalystWorkflowDevelopmentRole-spaceName` ロールと呼ばれる 1 つのロールを作成できます。詳細については、「[アカウントとスペース用の **CodeCatalystWorkflowDevelopmentRole-*spaceName*** ロールを作成する](ipa-iam-roles.md#ipa-iam-roles-service-create)」を参照してください。`CodeCatalystWorkflowDevelopmentRole-spaceName` ロールには、セキュリティリスクをもたらす可能性のある非常に広範なアクセス許可があることを理解します。このロールは、セキュリティが懸念されないチュートリアルやシナリオでのみ使用することをお勧めします。このチュートリアルでは、前述の 2 つのロールを作成することを前提としています。

ビルドロールとデプロイロールを作成するには、以下の一連の手順を実行します。

**1. 両方のロールの信頼ポリシーを作成するには**

1. 開発環境に移動します。

1. 次の内容で、`Cloud9-long-string` ディレクトリに「`codecatalyst-eks-trust-policy.json`」という名前のファイルを作成します。

**2. ビルドロールのビルドポリシーを作成するには**
+ 次の内容で、`Cloud9-long-string` ディレクトリに「`codecatalyst-eks-build-policy.json`」という名前のファイルを作成します。

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "ecr:*",
                  "ec2:*"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**注記**  
ロールがワークフローアクションの実行に初めて使用されるときは、リソースポリシーステートメントでワイルドカードを使用し、利用可能になった後にリソース名でポリシーの範囲を絞り込みます。  

  ```
  "Resource": "*"
  ```

**3. デプロイロールにデプロイポリシーを作成するには**
+ 次の内容で、`Cloud9-long-string` ディレクトリに「`codecatalyst-eks-deploy-policy.json`」という名前のファイルを作成します。

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**注記**  
ロールがワークフローアクションの実行に初めて使用されるときは、リソースポリシーステートメントでワイルドカードを使用し、利用可能になった後にリソース名でポリシーの範囲を絞り込みます。  

  ```
  "Resource": "*"
  ```

これで、開発環境に 3 つのポリシードキュメントが追加されました。ディレクトリ構造は次のようになります。

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. ビルドポリシーを に追加するには AWS**

1. 開発環境ターミナルで、次のように入力します。

   ```
   cd /projects
   ```

1. 次のように入力します。

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-build-policy \
       --policy-document file://codecatalyst-eks-build-policy.json
   ```

1. **[Enter]** キーを押します。

1. コマンド出力で、例えば「`arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy`」などの `"arn":` 値を書き留めます。この ARN は後で必要になります。

**5. デプロイポリシーを に追加するには AWS**

1. 次のように入力します。

   ```
   aws iam create-policy \
       --policy-name codecatalyst-eks-deploy-policy \
       --policy-document file://codecatalyst-eks-deploy-policy.json
   ```

1. **[Enter]** キーを押します。

1. コマンド出力で、例えば「`arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy`」などのデプロイポリシーの `"arn":` 値を書き留めます。この ARN は後で必要になります。

**6. ビルドロールを作成するには**

1. 次のように入力します。

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-build-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. **[Enter]** キーを押します。

1. 次のように入力します。

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-eks-build-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy
   ```

   *[arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy]* が、先ほど説明したビルドポリシーの ARN に置き換えられます。

1. **[Enter]** キーを押します。

1. ターミナルプロンプトで、次のように入力します。

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-build-role
   ```

1. **[Enter]** キーを押します。

1. ロールの `"Arn":` の値、例えば「`arn:aws:iam::111122223333:role/codecatalyst-eks-build-role`」を書き留めます。この ARN は後で必要になります。

**7. デプロイロールを作成するには**

1. 次のように入力します。

   ```
   aws iam create-role \
         --role-name codecatalyst-eks-deploy-role \
         --assume-role-policy-document file://codecatalyst-eks-trust-policy.json
   ```

1. **[Enter]** キーを押します。

1. 次のように入力します。

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-eks-deploy-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy
   ```

   *[arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy]* が、先ほど説明したデプロイポリシーの ARN に置き換えられます。

1. **[Enter]** キーを押します。

1. 次のように入力します。

   ```
   aws iam get-role \
         --role-name codecatalyst-eks-deploy-role
   ```

1. **[Enter]** キーを押します。

1. ロールの `"Arn":` の値、例えば「`arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role`」を書き留めます。この ARN は後で必要になります。

これで、ビルドとデプロイのロールが作成され、その ARN が記録されました。

## ステップ 6: CodeCatalyst に AWS ロールを追加する
<a name="deploy-tut-eks-import-roles"></a>

このステップでは、スペースに接続 AWS アカウント した にビルドロール (`codecatalyst-eks-build-role`) を追加し、ロール (`codecatalyst-eks-deploy-role`) をデプロイします。これにより、ロールをワークフローで使用できるようになります。

**ビルドロールとデプロイロールを に追加するには AWS アカウント**

1. CodeCatalyst コンソールで、スペースに移動します。

1. 上部にある **[設定]** をクリックします。

1. ナビゲーションペインで、**[AWS アカウント]** を選択します。アカウントの一覧が表示されます。

1. **Amazon CodeCatalyst の表示名**列で、ビルドロールとデプロイロールを作成した AWS アカウント の表示名をコピーします。(数値である可能性があります。) この値は、ワークフローを作成するときに後で必要になります。

1. 表示名を選択します。

1. ** AWS 管理コンソールからロールの管理**を選択します。

   **[Amazon CodeCatalyst スペースに IAM ロールの追加]** ページが表示されます。ページにアクセスするには、サインインが必要な場合があります。

1. **[IAM で作成した既存のロールを追加]** を選択します。

   ドロップダウンリストが表示されます。この一覧表示には、ビルドロールとデプロイロール、および `codecatalyst-runner.amazonaws.com` と `codecatalyst.amazonaws.com` サービスプリンシパルを含む信頼ポリシーを持つ他の IAM ロールが表示されます。

1. ドロップダウンリストから追加します。
   + `codecatalyst-eks-build-role`
   + `codecatalyst-eks-deploy-role`
**注記**  
`The security token included in the request is invalid` が表示された場合は、適切なアクセス許可がない可能性があります。この問題を修正するには、 からサインアウト AWS して、CodeCatalyst スペースの作成時に使用した AWS アカウントで再度サインインします。

1. CodeCatalyst コンソールに戻り、ページを更新します。

   ビルドロールとデプロイロールが **[IAM ロール]** の下に表示されるようになりました。

   これらのロールが CodeCatalyst ワークフローで使用できるようになりました。

## ステップ 7: ConfigMap を更新する
<a name="deploy-tut-eks-configmap"></a>

**[Kubernetes クラスターにデプロイ]** アクション (ワークフロー内) にクラスターにアクセスして操作できるようにするには、[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles) で作成したデプロイロールを Kubernetes `ConfigMap` ファイルに追加する必要があります。このタスクは、`eksctl` または `kubectl` を使用できます。

**eksctl を使用して Kubernetes ConfigMap ファイルを設定するには**
+ 開発環境ターミナルで、次のように入力します。

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  コードの説明は以下のとおりです。
  + *codecatalyst-eks-cluster* は、Amazon EKS クラスターのクラスター名に置き換えられます。
  +  *[arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role]* は、[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles) で作成したデプロイロールの ARN に置き換えられます。
  +  *[codecatalyst-eks-deploy-role]* (`--username` の隣) は、[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles) で作成したデプロイロールの名前に置き換えられます。
**注記**  
デプロイロールを作成しない場合は、*[codecatalyst-eks-deploy-role]* を `CodeCatalystWorkflowDevelopmentRole-spaceName` ロールの名前に置き換えます。このロールの詳細については、「[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles)」を参照してください。
  +  *[us-west-2]* を、ご利用のリージョンに置き換えます。

  このコマンドの詳細については、[[IAM ユーザーとロールの管理]](https://eksctl.io/usage/iam-identity-mappings/) を参照してください。

  次のようなメッセージが表示されます。

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**kubectl を使用して Kubernetes ConfigMap ファイルを設定するには**

1. 開発環境ターミナルで、次のように入力します。

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

   ConfigMap ファイルが画面に表示されます。

1. 赤い斜体でテキストを追加します。

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   コードの説明は以下のとおりです。
   +  *[arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role]* は、[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles) で作成したデプロイロールの ARN に置き換えられます。
   +  *[codecatalyst-eks-deploy-role]* (`username:` の隣) は、[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles) で作成したデプロイロールの名前に置き換えられます。
**注記**  
デプロイロールを作成しない場合は、*[codecatalyst-eks-deploy-role]* を `CodeCatalystWorkflowDevelopmentRole-spaceName` ロールの名前に置き換えます。このロールの詳細については、「[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles)」を参照してください。

   詳細については、「**Amazon EKS ユーザーガイド**」の「[クラスターへの IAM プリンシパルアクセスを有効化](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html)」を参照してください。

これで、デプロイロールが付与され、さらには Kubernetes クラスターに **[Amazon EKS にデプロイ]** アクション、`system:masters` アクセス許可が付与されました。

## ステップ 8: ワークフローを作成して実行する
<a name="deploy-tut-eks-workflow"></a>

このステップでは、ソースファイルを受け取り、Docker イメージにビルドし、Amazon EKS クラスターのツリーポッドにイメージをデプロイするワークフローを作成します。

ワークフローは、連続して実行される次の構成要素で構成されます。
+ トリガー – このトリガーは、ソースリポジトリに変更をプッシュすると、ワークフローを自動的に開始します。トリガーについての詳細は、「[トリガーを使用したワークフロー実行の自動的な開始](workflows-add-trigger.md)」を参照してください。
+ ビルドアクション (`BuildBackend`) – トリガー時に、アクションは Dockerfile を使用して Docker イメージをビルドし、そのイメージを Amazon ECR にプッシュします。ビルドアクションは、`deployment.yaml` ファイル内の `$REPOSITORY_URI` および `$IMAGE_TAG` 変数を正しい値で更新し、このファイルと `Kubernetes` フォルダ内の他のすべての出力アーティファクトを作成します。このチュートリアルでは、`Kubernetes` フォルダ内の唯一のファイルは `deployment.yaml` ですが、さらにファイルを含めることができます。このアーティファクトは、次のデプロイアクションの入力として使用されます。

  ビルドアクションの詳細については、「[ワークフローを使用したビルド](build-workflow-actions.md)」を参照してください。
+ デプロイアクション (`DeployToEKS`) – ビルドアクションが完了すると、デプロイアクションはビルドアクション (`Manifests`) によって生成された出力アーティファクトを検索し、その内部の `deployment.yaml` ファイルを見つけます。次に、アクションは `deployment.yaml` ファイルの指示に従って 3 つのポッドを実行します。それぞれに 1 つの「Hello, World\$1」が含まれます。Docker コンテナ — Amazon EKS クラスター内。

**ワークフローを作成するには**

1. CodeCatalyst コンソールを移動します。

1. プロジェクト (`codecatalyst-eks-project`) に移動します。

1. ナビゲーションペインで **[CI/CD]**、**[ワークフロー]** の順に選択します。

1. **[ワークフローを作成]** を選択します。

1. **[ソースリポジトリ]** で、`codecatalyst-eks-source-repository` を選択します。

1. **[ブランチ]** で、`main` を選択します。

1. **[作成]** を選択します。

1. YAML サンプルコードを削除します。

1. 次の YAML コードを追加して、新しいワークフロー定義ファイルを作成します。
**注記**  
ワークフロー定義ファイルの詳細については、「[ワークフロー YAML 定義](workflow-reference.md)」を参照してください。
**注記**  
次の YAML コードでは、必要に応じて `Connections:` セクションを省略できます。このセクションを省略する場合は、環境の **[デフォルト IAM ロール]** フィールドで指定されたロールに、[ステップ 6: CodeCatalyst に AWS ロールを追加する](#deploy-tut-eks-import-roles) で記述されている両方のロールのアクセス許可と信頼ポリシーが含まれていることを確認する必要があります。デフォルトの IAM ロールを使用して環境を設定する方法の詳細については、「[環境を作成する](deploy-environments-creating-environment.md)」を参照してください。

   ```
   Name: codecatalyst-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

   上記のコードで置き換えます。
   + [前提条件](#deploy-tut-eks-prereqs) で作成された環境名を持つ *[codecatalyst-eks-environment]* の両方のインスタンス。
   + アカウント接続の表示名を持つ *[codecatalyst-account-connection]* の両方のインスタンス。表示名は数値である場合があります。詳細については、「[ステップ 6: CodeCatalyst に AWS ロールを追加する](#deploy-tut-eks-import-roles)」を参照してください。
   + [ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles) で作成したビルドロールの名前を持つ *[codecatalyst-eks-build-role]*。
   + [ステップ 3: Amazon ECR イメージリポジトリを作成する](#deploy-tut-eks-ecr) で作成された Amazon ECR リポジトリの URI を持つ *[111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo]* (`Value:` プロパティ内)。
   + *[111122223333.dkr.ecr.us-west-2.amazonaws.com]* (`Run: aws ecr` コマンド内) と、イメージサフィックス (`/codecatalyst-eks-image-repo`) のない Amazon ECR リポジトリの URI。
   + [ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles) で作成したデプロイロールの名前を持つ *[codecatalyst-eks-deploy-role]*。
   +  AWS リージョンコードを含む *us-west-2* の両方のインスタンス。リージョンコードの一覧については、「*AWS 全般のリファレンス*」の「[Regional endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html)」を参照してください。
**注記**  
ビルドロールとデプロイロールを作成しない場合は、*[codecatalyst-eks-build-role]* と *[codecatalyst-eks-deploy-role]* を `CodeCatalystWorkflowDevelopmentRole-spaceName` ロールの名前に置き換えます。このロールの詳細については、「[ステップ 5: AWS ロールを作成する](#deploy-tut-eks-roles)」を参照してください。

1. (オプション) **[検証]** を選択して、コミットする前に YAML コードが有効であることを確認します。

1. **[コミット]** を選択します。

1. **[コミットワークフロー]** ダイアログボックスで、次のように入力します。

   1. **[コミットメッセージ]** の場合、テキストを削除して次のように入力します。

      ```
      Add first workflow
      ```

   1. **[レポジトリ]** に `codecatalyst-eks-source-repository` を選択します。

   1. **[ブランチ名]** で、main を選択します。

   1. **[コミット]** を選択します。

   これでワークフローが作成されました。ワークフローの先頭で定義されているトリガーにより、ワークフローの実行が自動的に開始されます。具体的には、`workflow.yaml` ファイルをソースリポジトリにコミット (およびプッシュ) すると、トリガーによってワークフローの実行が開始します。

**ワークフロー実行の進行状況を表示するには**

1. CodeCatalyst コンソールのナビゲーションペインで、**[CI/CD]** を選択し、**[ワークフロー]** を選択します。

1. 先ほど作成したワークフロー「`codecatalyst-eks-workflow`」を選択します。

1. **[BuildBackend]** を選択すると、ビルドの進行状況が表示されます。

1. **[DeployToEKS]** を選択してデプロイの進行状況を確認します。

   実行の詳細を表示する方法については、「[ワークフロー実行のステータスと詳細の表示](workflows-view-run.md)」を参照してください。

**デプロイを確認するには**

1. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) を開いてください。

1. 左側の下部近くにある **[ロードバランサー]** を選択します。

1. Kubernetes デプロイの一部として作成されたロードバランサーを選択します。どのロードバランサーを選択するかわからない場合は、**[タグ]** タブで次のタグを探します。
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. 正しいロードバランサーを選択し、**[説明]** タブを選択します。

1. **[DNS 名]** の値をコピーしてブラウザのアドレスバーに貼り付けます。

   「Hello World\$1」 ウェブページがブラウザに表示され、アプリケーションが正常にデプロイされたことを示します。

## ステップ 9: ソースファイルを変更する
<a name="deploy-tut-eks-change"></a>

このセクションでは、ソースリポジトリ内の `index.html` ファイルを変更します。この変更により、ワークフローは新しい Docker イメージをビルドし、コミット ID でタグ付けして Amazon ECR にプッシュし、Amazon ECS にデプロイします。

**index.html を変更するには**

1. 開発環境に移動します。

1. ターミナルプロンプトで、ソースリポジトリに変更します。

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  最新のワークフロー変更をプルします。

   ```
   git pull
   ```

1. `codecatalyst-eks-source-repository/public-html/index.html` を開きます。

1. 行 14 で、`Hello, World!` テキストを `Tutorial complete!` に変更します。

1. 追加、コミット、プッシュ:

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   ワークフローの実行が自動的に開始します。

1. (オプション) 以下を入力します。

   ```
   git show HEAD
   ```

   `index.html` 変更のコミット ID を書き留めます。このコミット ID は、先ほど開始したワークフロー実行によってデプロイされる Docker イメージにタグ付けされます。

1. デプロイの進行状況を確認します。

   1. CodeCatalyst コンソールのナビゲーションペインで **[CI/CD]**、**[ワークフロー]** の順に選択します。

   1. `codecatalyst-eks-workflow` を選択して最新の実行を表示します。

   1. **[BuildBackend]** および **[DeployToEKS]** を選択して、ワークフローの実行の進行状況を確認します。

1. 次のように、アプリケーションが更新されていることを確認します。

   1. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) を開いてください。

   1. 左側の下部近くにある **[ロードバランサー]** を選択します。

   1. Kubernetes デプロイの一部として作成されたロードバランサーを選択します。

   1. **[DNS 名]** の値をコピーしてブラウザのアドレスバーに貼り付けます。

      これでチュートリアルは完了です。ウェブページがブラウザに表示され、新バージョンのアプリケーションが正常にデプロイされたことを示します。

1. (オプション) で AWS Amazon ECR コンソールに切り替え、新しい Docker イメージがこの手順のステップ 7 のコミット ID でタグ付けされていることを確認します。

## クリーンアップ
<a name="deploy-tut-eks-cleanup"></a>

このチュートリアルで使用されるストレージリソースとコンピューティングリソースに対して不必要に課金されないように、環境をクリーンアップする必要があります。

**次をクリーンアップするには：**

1. クラスターを削除する

   1. 開発環境ターミナルで、次のように入力します。

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     コードの説明は以下のとおりです。
     + *[us-west-2]* を、ご利用のリージョンに置き換えます。
     + *[codecatalyst-eks-cluster]* は、作成したクラスターの名前に置き換えられます。

     5～10 分後、クラスターと関連するリソースは削除されます。これには、 CloudFormation スタック、ノードグループ (Amazon EC2 内）、ロードバランサーが含まれますが、これらに限定されません。
**重要**  
`eksctl delete cluster` コマンドが機能しない場合は、 AWS 認証情報または`kubectl`認証情報を更新する必要がある場合があります。更新する認証情報がわからない場合は、まず AWS 認証情報を更新します。 AWS 認証情報を更新するには、「[「認証情報が見つかりません」および「ExpiredToken」というエラーを解決するにはどうすればよいですか?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks)」を参照してください。`kubectl` 認証情報を更新するには、「[「サーバーに接続できません」というエラーを解決するにはどうすればよいですか?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks)」を参照してください。

1.  AWS コンソールで、次のようにクリーンアップします。

   1. Amazon ECR で、`codecatalyst-eks-image-repo` を削除します。

   1. IAM アイデンティティセンターで削除します。

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. IAM で、次を削除します。
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. CodeCatalyst コンソールで、次のようにクリーンアップします。

   1. `codecatalyst-eks-workflow` を削除します。

   1. `codecatalyst-eks-environment` を削除します。

   1. `codecatalyst-eks-source-repository` を削除します。

   1. 開発環境を削除します。

   1. `codecatalyst-eks-project` を削除します。

このチュートリアルでは、CodeCatalyst ワークフローと Amazon EKS へのデプロイアクションを使用してアプリケーションを **[Kubernetes にデプロイ]** する方法について説明します。