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

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

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

このチュートリアルでは、ワークフロー、Amazon ECS、およびその他のいくつかの AWS サービスを使用して、サーバーレスアプリケーションを Amazon Elastic Container Service (Amazon ECS) にデプロイする方法について説明します。デプロイされたアプリケーションは、Apache ウェブサーバー Docker イメージ上にビルドされたシンプルな Hello World ウェブサイトです。このチュートリアルでは、クラスターのセットアップなど必要な準備作業を順を追って説明し、アプリケーションをビルドおよびデプロイするためのワークフローを作成する方法について説明します。

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

**Topics**
+ [前提条件](#deploy-tut-ecs-prereqs)
+ [ステップ 1: AWS ユーザーと をセットアップする AWS CloudShell](#deploy-tut-ecs-user-cloudshell)
+ [ステップ 2: プレースホルダーアプリケーションを Amazon ECS にデプロイする](#deploy-tut-ecs-placeholder)
+ [ステップ 1: Amazon ECR イメージリポジトリを作成する](#deploy-tut-ecs-ecr)
+ [ステップ 4: AWS ロールを作成する](#deploy-tut-ecs-build-deploy-roles)
+ [ステップ 5: CodeCatalyst に AWS ロールを追加する](#deploy-tut-ecs-import-roles)
+ [ステップ 6: ソースレポジトリを作成する](#deploy-tut-ecs-source-repo)
+ [ステップ 7: ソースファイルを追加する](#deploy-tut-ecs-source-files)
+ [ステップ 8: ワークフローを作成して実行する](#deploy-tut-ecs-workflow)
+ [ステップ 9: ソースファイルを変更する](#deploy-tut-ecs-change)
+ [クリーンアップ](#deploy-tut-ecs-cleanup)

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

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

  ```
  codecatalyst-ecs-project
  ```

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

  詳細については、「[Amazon CodeCatalyst での空のプロジェクトの作成](projects-create.md#projects-create-empty)」を参照してください。
+ プロジェクトには、以下と呼ばれる CodeCatalyst **[環境]** が必要です。

  ```
  codecatalyst-ecs-environment
  ```

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

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

## ステップ 1: AWS ユーザーと をセットアップする AWS CloudShell
<a name="deploy-tut-ecs-user-cloudshell"></a>

このチュートリアルの最初のステップは、 でユーザーを作成し AWS IAM アイデンティティセンター、このユーザーとしてインスタンスを起動 AWS CloudShell することです。このチュートリアルの期間中、CloudShell は開発用コンピュータであり、 AWS リソースとサービスを設定する場所です。チュートリアルを完了したら、このユーザーを削除してください。

**注記**  
このチュートリアルにルートユーザーを使用しないでください。別のユーザーを作成する必要があります。作成しないと、後で AWS Command Line Interface (CLI) でアクションを実行するときに問題が発生する可能性があります。

IAM アイデンティティセンターユーザーと CloudShell の詳細については、「*AWS IAM アイデンティティセンター ユーザーガイド*」と「*AWS CloudShell ユーザーガイド*」を参照してください。

**IAM アイデンティティセンターユーザーを作成するには**

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/) で AWS IAM アイデンティティセンター コンソールを開きます。
**注記**  
CodeCatalyst スペース AWS アカウント に接続されている を使用してサインインしていることを確認してください。スペースに移動し、**[AWS アカウント]** タブを選択することで、接続されているアカウントを確認できます。詳細については、「[スペースを作成する](spaces-create.md)」を参照してください。

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

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

   ```
   CodeCatalystECSUser
   ```

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

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

1. **[名]** と **[姓]** で、次のように入力します。

   ```
   CodeCatalystECSUser
   ```

1. **[表示名]** で、自動的に生成された名前を保持します。

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

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

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

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

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

1.  AWS アクセスポータル URL やワンタイムパスワードなど、サインイン情報を **[コピー]** して貼り付けます。

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

**アクセス権限セットを作成するには**

このアクセス許可セットは、後で `CodeCatalystECSUser` に割り当てられます。

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

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

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

1. 「**アクセス許可セット名**」に、次のように入力します。

   ```
   CodeCatalystECSPermissionSet
   ```

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

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

**アクセス許可セットを CodeCatalystECSUser に割り当てるには**

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

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

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

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

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

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

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

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

   これで、 `CodeCatalystECSUser`と `CodeCatalystECSPermissionSet`を に割り当て AWS アカウント、それらをバインドしました。

**CodeCatalystECSUser としてサインアウトしてサインインし直すには**

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

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

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

1. `CodeCatalystECSUser` のユーザー名とワンタイムパスワードを使用してサインインします。

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

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

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

1. `CodeCatalystECSPermissionSet` の横にある [**管理コンソール**] を選択します。

    AWS マネジメントコンソール が表示されます。これで、適切なアクセス許可を使用し、`CodeCatalystECSUser` としてサインインしました。

**AWS CloudShell インスタンスを起動するには**

1. 上部のナビゲーションバー`CodeCatalystECSUser`で、 AWS アイコン () を選択します![\[AWS icon\]](http://docs.aws.amazon.com/ja_jp/codecatalyst/latest/userguide/images/deploy/aws-logo.png)。

   のメインページ AWS マネジメントコンソール が表示されます。

1. 上部のナビゲーションバーで、 AWS CloudShell アイコン () を選択します![\[CloudShell icon\]](http://docs.aws.amazon.com/ja_jp/codecatalyst/latest/userguide/images/deploy/CloudShell.png)。

   CloudShell が開きます。CloudShell 環境が作成されるまで待ちます。
**注記**  
CloudShell アイコンが表示されない場合は、[CloudShell でサポートされているリージョン](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available)にいることを確認してください。このチュートリアルは、米国西部 (オレゴン) リージョンにいることを前提としています。

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

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

   ```
   aws --version
   ```

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

    AWS CLI は現在のユーザー 用にすでに設定されているため`CodeCatalystECSUser`、通常どおり、 AWS CLI キーと認証情報を設定する必要はありません。

## ステップ 2: プレースホルダーアプリケーションを Amazon ECS にデプロイする
<a name="deploy-tut-ecs-placeholder"></a>

このセクションでは、プレースホルダーアプリケーションを Amazon ECS に手動でデプロイします。このプレースホルダーアプリケーションは、ワークフローによってデプロイされた Hello World アプリケーションに置き換えられます。プレースホルダーアプリケーションは Apache Web Server です。

Amazon ECS の詳細については、「*Amazon Elastic Container Service デベロッパーガイド*」を参照してください。

プレースホルダーアプリケーションをデプロイするには、以下の一連の手順を実行します。<a name="deploy-tut-ecs-create-task-execution-role"></a>

**タスク実行のロールを作成するには**

このロールは、ユーザーに代わって API コールを行うアクセス AWS Fargate 許可を Amazon ECS に付与します。

1. 信頼ポリシーを作成します。

   1. で AWS CloudShell、次のコマンドを入力します。

      ```
      cat > codecatalyst-ecs-trust-policy.json
      ```

      CloudShell ターミナルに点滅するプロンプトが表示されます。

   1. プロンプトで、次のコードを入力します。

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

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

   1. 最後の角括弧 (`}`) の後にカーソルを置きます。

   1. **Enter** と **Ctrl\$1d** を押してファイルを保存し、終了します。

1. タスク実行ロールを作成する方法

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-task-execution-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1.  AWS 管理`AmazonECSTaskExecutionRolePolicy`ポリシーをロールにアタッチします。

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-task-execution-role \
         --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
   ```

1. ロールの詳細を表示します。

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-task-execution-role
   ```

1. ロールの `"Arn":` 値、例えば `arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role` を書き留めます。この Amazon リソースネーム (ARN) は後で必要になります。

**Amazon ECS クラスターを作成するには**

このクラスターには、Apache プレースホルダーアプリケーションと、それ以降は Hello World アプリケーションが含まれます。

1. として`CodeCatalystECSUser`、 で空のクラスター AWS CloudShellを作成します。

   ```
   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
   ```

1. (オプション) クラスターが正常に作成されたことを確認します。

   ```
   aws ecs list-clusters
   ```

   `codecatalyst-ecs-cluster` クラスターの ARN が一覧表示され、正常に作成されたことを示します。

**新しいタスク定義ファイルを作成するには**

タスク定義ファイルは、DockerHub からプルされた [[Apache 2.4 Web サーバー]](https://hub.docker.com/_/httpd) Docker イメージ (`httpd:2.4`) を実行することを示します。

1. として`CodeCatalystECSUser`、 でタスク定義ファイル AWS CloudShellを作成します。

   ```
   cat > taskdef.json
   ```

1. コマンドプロンプトで、以下を貼り付けます。

   ```
   {
       "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               "image": "httpd:2.4",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "cpu": "256",
       "family": "codecatalyst-ecs-task-def",
       "memory": "512",
       "networkMode": "awsvpc"
   }
   ```

   上記のコードで、*[arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role]* を置き換えます。

   [タスク実行のロールを作成するには](#deploy-tut-ecs-create-task-execution-role) でメモしたタスク実行ロールの ARN を使用します。

1. 最後の角括弧 (`}`) の後にカーソルを置きます。

1. **Enter** と **Ctrl\$1d** を押してファイルを保存し、終了します。

**Amazon ECS でタスク定義ファイルに登録します。**

1. として`CodeCatalystECSUser`、タスク定義 AWS CloudShellを登録します。

   ```
   aws ecs register-task-definition \
       --cli-input-json file://taskdef.json
   ```

1. (オプション) タスク定義が登録されていることを確認します。

   ```
   aws ecs list-task-definitions
   ```

   `codecatalyst-ecs-task-def` タスク定義が一覧表示されます。

**Amazon ECS サービスを作成するには**

Amazon ECS サービスは、Apache プレースホルダーアプリケーションのタスク (および関連する Docker コンテナ) を実行し、その後、Hello World アプリケーションを実行します。

1. `CodeCatalystECSUser` として、Amazon Elastic Container Service コンソールをまだ切り替えていない場合は、切り替えます。

1. 先ほど作成したクラスター「`codecatalyst-ecs-cluster`」を選択します。

1. **[サービス]** タブで、**[作成]** を選択します。

1. **[作成]** ページで、次のとおり設定します。

   1. 次に一覧表示されているものを除き、すべてのデフォルト設定を保持します。

   1. [**Launch type (起動タイプ)**] で、[**FARGATE**] を選択します。

   1. **[タスク定義]** の **[ファミリー]** ドロップダウンリストで、以下を選択します。

      `codecatalyst-ecs-task-def`

   1. **[サービス名]** に次のように入力します。

      ```
      codecatalyst-ecs-service
      ```

   1. **[必要なタスク]** に次のように入力します。

      ```
      3
      ```

      このチュートリアルでは、各タスクが単一の Docker コンテナを起動します。

   1. **[ネットワーク]** セクションを展開します。

   1. **[VPC]** で、任意の VPC を選択します。

   1. **[サブネット]** では、任意のサブネットを選択します。
**注記**  
サブネットは 1 つだけ指定します。このチュートリアルに必要なのはこれだけです。
**注記**  
VPC とサブネットがない場合は、作成します。「*Amazon VPC ユーザーガイド*」で、「[VPC を作成](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC)」、「[VPC にサブネットを作成](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet)」を参照してください。

   1. **[セキュリティグループ]** で、**[新しいセキュリティグループを作成]** を選択し、次の操作を行います。

      1. **[セキュリティグループ名]** に次のように入力します。

         ```
         codecatalyst-ecs-security-group
         ```

      1. **[セキュリティグループの説明]** には、次のように入力します。

         ```
         CodeCatalyst ECS security group
         ```

      1. [**ルールを追加**] を選択してください。**[タイプ]** の場合は、**[HTTP]** を選択し、**[ソース]**の場合は **[任意の場所]** を選択します。

   1. 一番下で **[作成]** を選択します。

   1. サービスが作成されるまで待ちます。このプロセスには数分かかることがあります。

1. **[タスク]** タブを選択し、[更新] を選択します。3 つのタスクすべてで、**[前回のステータス]** 列が **[実行中]** に設定されていることを確認します。

**(オプション) Apache プレースホルダーアプリケーションが実行されていることを確認するには**

1. **[タスク]** タブで、3 つのタスクのいずれかを選択します。

1. **[パブリック IP]** フィールドで、**[オープンアドレス]** を選択します。

   `It Works!` ページが表示されます。これは、Amazon ECS サービスが Apache イメージで Docker コンテナを起動するタスクを正常に開始したことを示します。

   チュートリアルのこの時点で、Amazon ECS クラスター、サービス、タスク定義、および Apache プレースホルダーアプリケーションを手動でデプロイしました。これらの項目がすべて整ったら、Apache プレースホルダーアプリケーションをチュートリアルの Hello World アプリケーションに置き換えるワークフローを作成する準備が整いました。

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

このセクションでは、Amazon Elastic Container Registry (Amazon ECR) にプライベートイメージリポジトリを作成します。このリポジトリには、以前にデプロイした Apache プレースホルダーイメージを置き換えるチュートリアルの Docker イメージが保存されます。

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

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

1. として`CodeCatalystECSUser`、Amazon ECR に空のリポジトリ AWS CloudShellを作成します。

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

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

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

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

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

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

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

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 つのロールを作成することを前提としています。

ビルドロールとデプロイロールを作成するには、 AWS マネジメントコンソール または を使用できます AWS CLI。

------
#### [ AWS マネジメントコンソール ]

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

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

1. ロールのポリシーを以下の手順で作成します。

   1. にサインインします AWS。

   1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) を開きます。

   1. ナビゲーションペインで、**ポリシー** を選択してください。

   1. **[Create policy]** (ポリシーを作成) を選択します。

   1. **JSON** タブを選択します。

   1. 既存のコードを削除します。

   1. 次のコードを貼り付けます。

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

****  

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

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

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

   1. [**Next: Tags (次へ: タグ)**] を選択します。

   1. **[次へ: レビュー]** を選択します。

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

      ```
      codecatalyst-ecs-build-policy
      ```

   1. [**Create policy**] (ポリシーの作成) を選択します。

      これで、アクセス許可ポリシーが作成されました。

1. 次のようにビルドロールを作成します。

   1. ナビゲーションペインで **ロール** を選択してから、**ロールを作成する** を選択します。

   1. **[カスタム信頼ポリシー]** を選択します。

   1. 既存のカスタム信頼ポリシーを削除します。

   1. 次の信頼ポリシーを追加します。

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

   1. **[アクセス許可ポリシー]** で `codecatalyst-ecs-build-policy` を検索し、チェックボックスを選択します。

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

   1. **[ロール名]** には、次のように入力します。

      ```
      codecatalyst-ecs-build-role
      ```

   1. **[ロールの説明]** には、次のように入力します。

      ```
      CodeCatalyst ECS build role
      ```

   1. [**ロールの作成**] を選択してください。

   これで、アクセス許可ポリシーと信頼ポリシーを持つビルドロールが作成されました。

1. 次のようにビルドロール ARN を取得します。

   1. ナビゲーションペインで **Roles (ロール) ** を選択してください。

   1. 検索ボックスに、作成したロールの名前 (`codecatalyst-ecs-build-role`) を入力します。

   1. 使用するロールを一覧から選択します。

      ロールの **[概要]** ページが表示されます。

   1. 上部で、**[ARN]** 値をコピーします。これは後で必要になります。

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

1. ロールのポリシーを以下の手順で作成します。

   1. にサインインします AWS。

   1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) を開きます。

   1. ナビゲーションペインで、**ポリシー** を選択してください。

   1. **[ポリシーを作成]** を選択します。

   1. **JSON** タブを選択します。

   1. 既存のコードを削除します。

   1. 次のコードを貼り付けます。

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**注記**  
ロールがワークフローアクションの実行に初めて使用されるときは、リソースポリシーステートメントでワイルドカードを使用します。その後、リソース名を使用してポリシーをスコープダウンできます。  

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

   1. [**Next: Tags (次へ: タグ)**] を選択します。

   1. **[次へ: レビュー]** を選択します。

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

      ```
      codecatalyst-ecs-deploy-policy
      ```

   1. [**Create policy**] (ポリシーの作成) を選択します。

      これで、アクセス許可ポリシーが作成されました。

1. 次のようにデプロイロールを作成します。

   1. ナビゲーションペインで **ロール** を選択してから、**ロールを作成する** を選択します。

   1. **[カスタム信頼ポリシー]** を選択します。

   1. 既存のカスタム信頼ポリシーを削除します。

   1. 次の信頼ポリシーを追加します。

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

   1. **[アクセス許可ポリシー]** で `codecatalyst-ecs-deploy-policy` を検索し、チェックボックスを選択します。

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

   1. **[ロール名]** には、次のように入力します。

      ```
      codecatalyst-ecs-deploy-role
      ```

   1. **[ロールの説明]** には、次のように入力します。

      ```
      CodeCatalyst ECS deploy role
      ```

   1. [**ロールの作成**] を選択してください。

   これで、信頼ポリシーを使用してデプロイロールが作成されました。

1. デプロイロール ARN を次のように取得します。

   1. ナビゲーションペインで **Roles (ロール) ** を選択してください。

   1. 検索ボックスに、作成したロールの名前 (`codecatalyst-ecs-deploy-role`) を入力します。

   1. 使用するロールを一覧から選択します。

      ロールの **[概要]** ページが表示されます。

   1. 上部で、**[ARN]** 値をコピーします。これは後で必要になります。

------
#### [ AWS CLI ]

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

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

として`CodeCatalystECSUser`、信頼ポリシーファイル AWS CloudShellを作成します。

1. ファイルを作成します。

   ```
   cat > codecatalyst-ecs-trust-policy.json
   ```

1. ターミナルプロンプトで、次のコードを貼り付けます。

1. 最後の角括弧 (`}`) の後にカーソルを置きます。

1. **Enter** と **Ctrl\$1d** を押してファイルを保存し、終了します。

**ビルドポリシーとビルドロールを作成するには**

1. ビルドポリシーを作成します。

   1. として`CodeCatalystECSUser`、 でビルドポリシーファイル AWS CloudShellを作成します。

      ```
      cat > codecatalyst-ecs-build-policy.json
      ```

   1. プロンプトで、次のようにコード入力します。

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

****  

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

------

   1. 最後の角括弧 (`}`) の後にカーソルを置きます。

   1. **Enter** と **Ctrl\$1d** を押してファイルを保存し、終了します。

1. ビルドポリシーを以下に追加します AWS。

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

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

1. ビルドロールーを作成して信頼ポリシーにアタッチします。

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

1. ビルドポリシーをビルドロールにアタッチします。

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

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

1. ビルドロールの詳細を表示します。

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

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

**デプロイポリシーとデプロイロールを作成するには**

1. デプロイポリシーを作成します。

   1. で AWS CloudShell、デプロイポリシーファイルを作成します。

      ```
      cat > codecatalyst-ecs-deploy-policy.json
      ```

   1. プロンプトで、次のようにコード入力します。

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

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

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

   1. 最後の角括弧 (`}`) の後にカーソルを置きます。

   1. **Enter** と **Ctrl\$1d** を押してファイルを保存し、終了します。

1. デプロイポリシーを以下に追加します AWS。

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

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

1. デプロイロールを作成して信頼ポリシーをデプロイロールにアタッチします。

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

1. デプロイポリシーをデプロイロールにアタッチします。ここで、*[arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy]* は、前述のデプロイポリシーの ARN に置き換えられます。

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

1. デプロイロールの詳細を表示します。

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

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

------

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

このステップでは、ビルドロール (`codecatalyst-ecs-build-role`) を追加し、スペース内の CodeCatalyst アカウント接続にロール (`codecatalyst-ecs-deploy-role`) をデプロイします。

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

1. CodeCatalyst で、スペースに移動します。

1. **[AWS アカウント]** を選択します。アカウント接続が一覧表示されます。

1. ビルドロールとデプロイロールを作成したアカウントを表す AWS アカウント接続を選択します。

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

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

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

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

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

1. **[IAM ロールを追加]** を選択し、**[IAM で作成した既存のロールを追加]** を選択し、ドロップダウンリストから [`codecatalyst-ecs-deploy-role`] を選択します。[**Add role**] を選択します。

   これで、ビルドロールとデプロイロールをスペースに追加しました。

1. **[Amazon CodeCatalyst 表示名]** の値をコピーします。この値は、ワークフローを作成するときに後で必要になります。

## ステップ 6: ソースレポジトリを作成する
<a name="deploy-tut-ecs-source-repo"></a>

このステップでは、CodeCatalyst に空のソースリポジトリを作成します。このリポジトリには、タスク定義ファイルなどのチュートリアルのソースファイルが保存されます。

ソースリポジトリの詳細については、「[ソースリポジトリを作成する](source-repositories-create.md)」を参照してください。

**ソースリポジトリを作成するには**

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

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

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

1. **[リポジトリの追加]** を選択し、**[リポジトリの作成]** を選択します。

1. **[リポジトリ名]** に次のように入力します。

   ```
   codecatalyst-ecs-source-repository
   ```

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

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

このセクションでは、Hello World ソースファイルを CodeCatalyst リポジトリ「`codecatalyst-ecs-source-repository`」 に追加します。これらは以下で構成されます。
+ `index.html` ファイル - ブラウザに Hello World メッセージを表示します。
+ Dockerfile – Docker イメージに使用するベースイメージと、それに適用する Docker コマンドについて説明します。
+ `taskdef.json` ファイル - クラスターでタスクを起動するときに使用する Docker イメージを定義します。

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

```
.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json
```

**注記**  
次の手順では、CodeCatalyst コンソールを使用してファイルを追加する方法を示しますが、必要に応じて Git を使用できます。詳細については、「[ソースリポジトリのクローンを作成する](source-repositories-clone.md)」を参照してください。

**Topics**
+ [index.html](#deploy-tut-ecs-source-files-index)
+ [Dockerfile](#deploy-tut-ecs-source-files-dockerfile)
+ [taskdef.json](#deploy-tut-ecs-source-files-taskdef)

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

`index.html` ファイルには、ブラウザに Hello World メッセージが表示されます。

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

1. CodeCatalyst コンソールで、ソースリポジトリ「`codecatalyst-ecs-source-repository`」に移動します。

1. **[ファイル]** で、**[ファイルを作成]** を選択します。

1. **[ファイル名]** に次のように入力します。

   ```
   public-html/index.html
   ```
**重要**  
同じ名前のフォルダを作成するには、必ず `public-html/` プレフィックスを含めてください。`index.html` は、このフォルダにあることが期待されます。

1. テキストボックスに次のコードを入力します。

   ```
   <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. **[コミット]** を選択し、再度 **[コミット]** を選択します。

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

### Dockerfile
<a name="deploy-tut-ecs-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. ソースリポジトリで、**[ファイルを作成]** を選択します。

1. **[ファイル名]** には、次のように入力します。

   ```
   Dockerfile
   ```

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

1. テキストボックスに次のコードを入力します。

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

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

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

### taskdef.json
<a name="deploy-tut-ecs-source-files-taskdef"></a>

このステップで追加した `taskdef.json` ファイルは、[ステップ 2: プレースホルダーアプリケーションを Amazon ECS にデプロイする](#deploy-tut-ecs-placeholder) で既に指定したファイルと同じですが、次の違いがあります。

`image:` フィールド (`httpd:2.4`) でハードコードされた Docker イメージ名を指定する代わりに、ここでのタスク定義は、イメージ「`$REPOSITORY_URI`」と「`$IMAGE_TAG`」を示すためにいくつかの変数を使用します。これらの変数は、後のステップでワークフローを実行するときに、ワークフローのビルドアクションによって生成された実際の値に置き換えられます。

タスク定義パラメータに関する詳細については、「*Amazon Elastic Container Service デベロッパーガイド*」の「[タスク定義パラメータ](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html)」を参照してください。

**taskdef.json ファイルを追加するには**

1. ソースリポジトリで、**[ファイルを作成]** を選択します。

1. **[ファイル名]** には、次のように入力します。

   ```
   taskdef.json
   ```

1. テキストボックスに次のコードを入力します。

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
               # by the workflow at build time (see the build action in the 
               # workflow)
               "image": $REPOSITORY_URI:$IMAGE_TAG,
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "codecatalyst-ecs-task-def"
   }
   ```

   上記のコードで置き換えます。

   *arn:aws:iam::account\$1ID:role/codecatalyst-ecs-task-execution-role*

   [タスク実行のロールを作成するには](#deploy-tut-ecs-create-task-execution-role) でメモしたタスク実行ロールの ARN を使用します。

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

   `taskdef.json` ファイルをリポジトリに追加します。

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

このステップでは、ソースファイルを取得し、Docker イメージにビルドし、そのイメージを Amazon ECS クラスターにデプロイするワークフローを作成します。このデプロイは、既存の Apache プレースホルダーアプリケーションを置き換えます。

ワークフローは、連続して実行される次の構成要素で構成されます。
+ トリガー – このトリガーは、ソースリポジトリに変更をプッシュすると、ワークフローを自動的に開始します。トリガーについての詳細は、「[トリガーを使用したワークフロー実行の自動的な開始](workflows-add-trigger.md)」を参照してください。
+ ビルドアクション (`BuildBackend`) – トリガー時に、アクションは Dockerfile を使用して Docker イメージをビルドし、そのイメージを Amazon ECR にプッシュします。ビルドアクションは、`taskdef.json` を正しい `image` フィールド値で更新し、このファイルの出力アーティファクトを作成します。このアーティファクトは、次のデプロイアクションの入力として使用されます。

  ビルドアクションの詳細については、「[ワークフローを使用したビルド](build-workflow-actions.md)」を参照してください。
+ デプロイアクション (`DeployToECS`) – ビルドアクションが完了すると、デプロイアクションはビルドアクション (`TaskDefArtifact`) によって生成された出力アーティファクトを検索し、その内部の `taskdef.json` を見つけて Amazon ECS サービスに登録します。その後、サービスは `taskdef.json` ファイルの指示に従って、Amazon ECS クラスター内で 3 つの Amazon ECS タスク、および関連付けられた Hello World Docker コンテナを実行します。

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

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

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

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

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

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

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

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

   ```
   Name: codecatalyst-ecs-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-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 taskdef.json
           - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat taskdef.json
           # The output artifact will be a zip file that contains a task definition file.
       Outputs:
         Artifacts:
           - Name: TaskDefArtifact
             Files: 
               - taskdef.json
     DeployToECS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/ecs-deploy@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-deploy-role
       Inputs:
         Sources: []
         Artifacts:
           - TaskDefArtifact
       Configuration:
         region: us-west-2
         cluster: codecatalyst-ecs-cluster
         service: codecatalyst-ecs-service
         task-definition: taskdef.json
   ```

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

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

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

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

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

      ```
      Add first workflow
      ```

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

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

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

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

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

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

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

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

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

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

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

1. Amazon ECS クラシックコンソール ([https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/)) を開きます。

1. `codecatalyst-ecs-cluster` でクラスターを選択します。

1. [**タスク**] タブを選択します。

1. 3 つのタスクのいずれかを選択します。

1. **[パブリック IP]** フィールドで、**[オープンアドレス]** を選択します。

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

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

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

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

1. CodeCatalyst コンソールのナビゲーションペインで、**[コード]** を選択し、**[ソースリポジトリ]** を選択し、リポジトリ「`codecatalyst-ecs-source-repository`」を選択します。

1. [`public-html`] を選択し、[`index.html`] を選択します。

   `index.html` の内容が表示されます。

1. **[編集]** を選択します。

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

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

   コミットにより、新しいワークフローの実行が開始します。

1. (オプション) ソースリポジトリのメインページに移動し、**[コミットを表示]** を選択し、`index.html` 変更のコミット ID を書き留めます。

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

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

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

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

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

   1. Amazon ECS クラシックコンソール ([https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/)) を開きます。

   1. `codecatalyst-ecs-cluster` でクラスターを選択します。

   1. [**タスク**] タブを選択します。

   1. 3 つのタスクのいずれかを選択します。

   1. **[パブリック IP]** フィールドで、**[オープンアドレス]** を選択します。

      `Tutorial complete!` ページが表示されます。

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

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

このチュートリアルで使用されているファイルとサービスをクリーンアップして、料金が発生しないようにします。

で AWS マネジメントコンソール、次の順序でクリーンアップします。

1. Amazon ECS で、以下を実行します。

   1. `codecatalyst-ecs-service` を削除します。

   1. `codecatalyst-ecs-cluster` を削除します。

   1. `codecatalyst-ecs-task-definition` の登録を解除します。

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

1. Amazon EC2 で、`codecatalyst-ecs-security-group` を削除します。

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

   1. `CodeCatalystECSUser`

   1. `CodeCatalystECSPermissionSet`

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

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

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

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

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

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