亚马逊 CodeCatalyst 不再向新买家开放。现有客户可以继续正常使用该服务。有关更多信息，请参阅 [如何从中迁移 CodeCatalyst](migration.md)。

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 使用工作流部署到 Amazon ECS
<a name="deploy-action-ecs"></a>

本节介绍如何使用工作流程将容器化应用程序部署到 Amazon 弹性容器服务集群中。 CodeCatalyst 为此，您必须将**部署到 Amazon ECS** 操作添加到工作流。此操作将注册您提供的[任务定义](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions)文件。注册后，任务定义将由在 [Amazon ECS 集群](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters)中运行的 [Amazon ECS 服务](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html)实例化。“实例化任务定义”等效于将应用程序部署到 Amazon ECS 中。

要使用此操作，您必须已拥有 Amazon ECS 集群、服务和任务定义文件。

有关 Amazon ECS 的更多信息，请参阅《Amazon Elastic Container Service 开发人员指南》**。

**提示**  
有关说明如何使用**部署到 Amazon ECS** 操作的教程，请参阅[教程：将应用程序部署到 Amazon ECS](deploy-tut-ecs.md)。

**提示**  
对于**部署到 Amazon ECS** 操作的工作示例，请使用**带 AWS Fargate的 Node.js API** 或**带 AWS Fargate的 Java API** 蓝图创建一个项目。有关更多信息，请参阅 [使用蓝图创建项目](projects-create.md#projects-create-console-template)。

**Topics**
+ [“部署到 Amazon ECS”操作使用的运行时映像](#deploy-action-ecs-runtime)
+ [教程：将应用程序部署到 Amazon ECS](deploy-tut-ecs.md)
+ [添加“部署到 Amazon ECS”操作](deploy-action-ecs-adding.md)
+ [“部署到 Amazon ECS”变量](deploy-action-ecs-variables.md)
+ [“部署到 Amazon ECS”操作 YAML](deploy-action-ref-ecs.md)

## “部署到 Amazon ECS”操作使用的运行时映像
<a name="deploy-action-ecs-runtime"></a>

**部署到 Amazon ECS** 操作在 [2022 年 11 月版映像](build-images.md#build.previous-image)上运行。有关更多信息，请参阅 [活动映像](build-images.md#build-curated-images)。

# 教程：将应用程序部署到 Amazon ECS
<a name="deploy-tut-ecs"></a>

在本教程中，您将学习如何使用工作流程、Amazon ECS 和其他一些服务将无服务器应用程序部署到亚马逊弹性容器服务 (Amazon ECS) 中。 AWS 部署的应用程序是一个基于 Apache Web 服务器 Docker 映像构建的简单 Hello World 网站。本教程将引导您完成所需的准备工作（例如设置集群），然后介绍如何创建用于构建和部署应用程序的工作流。

**提示**  
您可以使用蓝图来执行完整的 Amazon ECS 设置，而不是按照本教程的说明操作。您将需要使用**带 AWS Fargate的 Node.js API** 或**带 AWS Fargate的 Java API** 蓝图。有关更多信息，请参阅 [使用蓝图创建项目](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)
+ [步骤 3：创建 Amazon ECR 映像存储库](#deploy-tut-ecs-ecr)
+ [步骤 4：创建 AWS 角色](#deploy-tut-ecs-build-deploy-roles)
+ [第 5 步：将 AWS 角色添加到 CodeCatalyst](#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 Identity Center，并以该用户的身份启动 AWS CloudShell 实例。在本教程中， CloudShell 是您的开发计算机，也是您配置 AWS 资源和服务的地方。完成本教程后，请删除此用户。

**注意**  
在本教程中，请不要使用根用户。您必须创建单独的用户，否则以后在 AWS Command Line Interface (CLI) 中执行操作时可能会遇到问题。

有关 IAM Identity Center 用户的更多信息以及 CloudShell，请参阅*AWS IAM Identity Center 用户指南*和*AWS CloudShell 用户指南*。

**创建 IAM Identity Center 用户**

1. 登录 AWS 管理控制台 并打开 AWS IAM Identity Center 控制台，网址为[https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/)。
**注意**  
请务必使用与您的 CodeCatalyst空间 AWS 账户 相连的登录。您可以通过导航到您的空间并选择 **AWS 账户**选项卡来确认已连接哪个账户。有关更多信息，请参阅 [创建空间](spaces-create.md)。

1. 在导航窗格中，选择**用户**，然后选择**添加用户**。

1. 在**用户名**中，输入：

   ```
   CodeCatalystECSUser
   ```

1. 在**密码**下，选择**生成可与此用户共享的一次性密码**。

1. 在**电子邮件地址**和**确认电子邮件地址**中，输入 IAM Identity Center 中不存在的电子邮件地址。

1. 在**名字**和**姓氏**中，输入：

   ```
   CodeCatalystECSUser
   ```

1. 在**显示名称**中，保留自动生成的名称：

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

1. 选择**下一步**。

1. 在**将用户添加到组**页面上，选择**下一步**。

1. 在**查看并添加用户**页面上，检查相应信息，然后选择**添加用户**。

   这将显示**一次性密码**对话框。

1. 选择**复制**，然后粘贴登录信息，包括 AWS 访问门户 URL 和一次性密码。

1. 选择**关闭**。

**创建权限集**

您稍后会将此权限集分配给 `CodeCatalystECSUser`。

1. 在导航窗格中，选择**权限集**，然后选择**创建权限集**。

1. 选择 “**预定义权限集**”，然后选择**AdministratorAccess**。该策略为所有 AWS 服务提供完全权限。

1. 选择**下一步**。

1. 在**权限集名称**中，输入：

   ```
   CodeCatalystECSPermissionSet
   ```

1. 选择**下一步**。

1. 在**查看和创建**页面上，检查相应信息，然后选择**创建**。

**将权限集分配给 CodeCatalyst ECSUser**

1. 在导航窗格中 **AWS 账户**，选择，然后选中您当前登录 AWS 账户 的旁边的复选框。

1. 选择**分配用户或组**。

1. 选择**用户**选项卡。

1. 选中 `CodeCatalystECSUser` 旁边的复选框。

1. 选择**下一步**。

1. 选中 `CodeCatalystECSPermissionSet` 旁边的复选框。

1. 选择**下一步**。

1. 检查相应信息，然后选择**提交**。

   现在，你已经`CodeCatalystECSPermissionSet`将`CodeCatalystECSUser`和分配给你的 AWS 账户，将它们绑定在一起。

**要注销并重新登录，请使用以下身份登录 CodeCatalyst ECSUser**

1. 在注销之前，请确保您拥有 AWS 访问门户 URL 以及的用户名和一次性密码`CodeCatalystECSUser`。您应在早些时候将此信息复制到文本编辑器中。
**注意**  
如果您没有这些信息，请转至 IAM Identity Center 中的 `CodeCatalystECSUser` 详细信息页面，选择**重置密码**和**生成一次性密码 [...]**，然后再次选择**重置密码**以在屏幕上显示信息。

1. 退出 AWS。

1. 将 AWS 访问门户 URL 粘贴到浏览器的地址栏中。

1. 使用 `CodeCatalystECSUser` 的用户名和一次性密码进行登录。

1. 在**新密码**中，输入一个密码，然后选择**设置新密码**。

   屏幕上会出现一个 **AWS 账户**框。

1. 选择 **AWS 账户**，然后选择 AWS 账户 向其分配`CodeCatalystECSUser`用户和权限集的名称。

1. 在 `CodeCatalystECSPermissionSet` 旁，选择**管理控制台**。

    AWS 管理控制台 出现了。现在，您已经以具有适当权限的 `CodeCatalystECSUser` 的身份登录。

**启动实 AWS CloudShell 例**

1. 在顶部导航栏中，选择 AWS 图标 (![\[AWS icon\]](http://docs.aws.amazon.com/zh_cn/codecatalyst/latest/userguide/images/deploy/aws-logo.png))。`CodeCatalystECSUser`

   的主页 AWS 管理控制台 随即出现。

1. 在顶部导航栏中，选择图 AWS CloudShell 标 (![\[CloudShell icon\]](http://docs.aws.amazon.com/zh_cn/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 服务器。

有关 Amazon ECS 的更多信息，请参阅《Amazon Elastic Container Service 开发人员指南》**。

完成以下一系列过程可部署占位符应用程序。<a name="deploy-tut-ecs-create-task-execution-role"></a>

**创建任务执行角色**

此角色授予 Amazon ECS 和代表您进行 API 调用的 AWS Fargate 权限。

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** 以保存文件并退出 cat。

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 应显示在列表中，这表示创建成功。

**创建任务定义文件**

任务定义文件指示运行从中提取的 [Apache 2.4 Web 服务器](https://hub.docker.com/_/httpd) Docker 镜像 (`httpd:2.4`)。 DockerHub

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** 以保存文件并退出 cat。

**将任务定义文件注册到 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. 对于**子网**，请选择任意子网。
**注意**  
仅指定一个子网。这就是本教程要求执行的所有操作。
**注意**  
如果您没有 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. 选择**任务**选项卡，然后选择刷新按钮。确认所有三个任务的**最后状态**列都设置为**正在运行**。

**（可选）验证 Apache 占位符应用程序是否正在运行**

1. 在**任务**选项卡中，选择三个任务之一。

1. 在**公有 IP** 字段中，选择**开放地址**。

   此时将显示 `It Works!` 页面。这表明 Amazon ECS 服务已成功启动一项任务，该任务会启动带 Apache 映像的 Docker 容器。

   在本教程中，此时您已手动部署 Amazon ECS 集群、服务和任务定义以及 Apache 占位符应用程序。在所有这些项目准备就绪后，便可创建一个工作流以将 Apache 占位符应用程序替换为教程中的 Hello World 应用程序。

## 步骤 3：创建 Amazon ECR 映像存储库
<a name="deploy-tut-ecs-ecr"></a>

在此部分中，您将在 Amazon Elastic Container Registry（Amazon ECR）中创建私有映像存储库。此存储库存储教程中的 Docker 映像，该映像将替换您之前部署的 Apache 占位符映像。

有关 Amazon ECR 的更多信息，请参阅 *Amazon Elastic Container Registry 用户指南*。

**在 Amazon ECR 中创建映像存储库**

1. 在中 `CodeCatalystECSUser` AWS CloudShell，在 Amazon ECR 中创建一个空存储库：

   ```
   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 **部署到 ECS**” 操作（在工作流程中）访问您的 AWS 账户、Amazon ECS 和其他一些 AWS 服务的权限。

有关 IAM 角色的更多信息，请参阅《AWS Identity and Access Management 用户指南》**中的 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)。

**注意**  
要节省时间，您可以创建一个名为 `CodeCatalystWorkflowDevelopmentRole-spaceName` 角色的角色，而不是前面列出的两个角色。有关更多信息，请参阅 [为您的账户和空间创建 **CodeCatalystWorkflowDevelopmentRole-*spaceName*** 角色](ipa-iam-roles.md#ipa-iam-roles-service-create)。了解 `CodeCatalystWorkflowDevelopmentRole-spaceName` 角色具有非常广泛的权限，这可能会带来安全风险。我们建议您仅在教程和安全要求较低的场景中使用此角色。本教程假定您创建的是前面列出的两个角色。

要创建生成和部署角色，您可以使用 AWS 管理控制台 或 AWS CLI。

------
#### [ AWS 管理控制台 ]

要创建构建和部署角色，请完成以下一系列过程。

**创建构建角色**

1. 按如下步骤操作，为角色创建策略：

   1. 登录到 AWS。

   1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 IAM 控制台。

   1. 在导航窗格中，选择**策略**。

   1. 选择**创建策略**。

   1. 选择 **JSON** 选项卡。

   1. 删除现有代码。

   1. 粘贴以下代码：

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

****  

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

------
**注意**  
第一次使用该角色运行工作流操作时，请在资源策略语句中使用以下通配符，然后在策略可用后使用资源名称缩小策略范围。  

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

   1. 选择**下一步：标签**。

   1. 选择**下一步：审核**。

   1. 在**名称**中，输入：

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

   1. 选择**创建策略**。

      现在，您已经创建了权限策略。

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. 在导航窗格中，选择**角色**。

   1. 在搜索框中，输入刚创建的角色的名称（`codecatalyst-ecs-build-role`）。

   1. 从列表中选择该角色。

      此时将显示该角色的**摘要**页面。

   1. 在顶部，复制 **ARN** 值。稍后您将需要用到它。

**创建部署角色**

1. 按如下步骤操作，为角色创建策略：

   1. 登录到 AWS。

   1. 使用 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 打开 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. 选择**下一步：标签**。

   1. 选择**下一步：审核**。

   1. 在**名称**中，输入：

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

   1. 选择**创建策略**。

      现在，您已经创建了权限策略。

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. 在导航窗格中，选择**角色**。

   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** 以保存文件并退出 cat。

**创建构建策略和构建角色**

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** 以保存文件并退出 cat。

1. 将构建策略添加到 AWS：

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

1. 在命令输出中，记下 `"arn":` 值，例如 `arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy`。稍后您将需要此 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** 以保存文件并退出 cat。

1. 将部署策略添加到 AWS：

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

1. 在命令输出中，记下部署策略的 `"arn":` 值，例如 `arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy`。稍后您将需要此 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 步：将 AWS 角色添加到 CodeCatalyst
<a name="deploy-tut-ecs-import-roles"></a>

在此步骤中，您将构建角色 (`codecatalyst-ecs-build-role`) 和部署角色 (`codecatalyst-ecs-deploy-role`) 添加到空间中的 CodeCatalyst 账户连接。

**将构建角色和部署角色添加到账户连接**

1. 在中 CodeCatalyst，导航到您的空间。

1. 选择 **AWS accounts (账户)**。此时将显示账户连接列表。

1. 选择代表您在其中创建构建和部署角色的 AWS 账户的账户连接。

1. **从管理控制台中选择 “ AWS 管理角色**”。

   此时将出现 “**将 IAM 角色添加到 Amazon CodeCatalyst 空间**” 页面。您可能需要登录才能访问该页面。

1. 选择**添加您在 IAM 中创建的现有角色**。

   这将显示一个下拉列表。该列表显示所有具有包含 `codecatalyst-runner.amazonaws.com` 和 `codecatalyst.amazonaws.com` 服务主体的信任策略的 IAM 角色。

1. 在该下拉列表中，选择 `codecatalyst-ecs-build-role`，然后选择**添加角色**。
**注意**  
如果您看到的是 `The security token included in the request is invalid`，则可能是因为您不具有适当的权限。要解决此问题，请使用您在创建 CodeCatalyst空间时使用的 AWS 账号退出并重新登录。 AWS 

1. 选择**添加 IAM 角色**，再选择**添加您在 IAM 中创建的现有角色**，然后在下拉列表中选择 `codecatalyst-ecs-deploy-role`。选择**添加角色**。

   现在，您已将构建角色和部署角色添加到您的空间。

1. 复制 A **mazon CodeCatalyst 显示名称**的值。您稍后在创建工作流时将需要此值。

## 步骤 6：创建源存储库
<a name="deploy-tut-ecs-source-repo"></a>

在此步骤中，您将在中创建源存储库 CodeCatalyst。此存储库将存储教程的源文件，例如任务定义文件。

有关源存储库的更多信息，请参阅[创建源存储库](source-repositories-create.md)。

**创建源存储库**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

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 Reference](https://docs.docker.com/engine/reference/builder/)。

此处指定的 Dockerfile 指示使用 Apache 2.4 基本映像（`httpd`）。它还包括用于将名为 `index.html` 的源文件复制到提供网页的 Apache 服务器上的文件夹中的指令。Dockerfile 中的 `EXPOSE` 指令告知 Docker 容器正在端口 80 上侦听。

**添加 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)中指定的文件相同，但有以下区别：

此处的任务定义使用变量 `$REPOSITORY_URI` 和 `$IMAGE_TAG` 来表示映像，而不是在 `image:` 字段（`httpd:2.4`）中指定硬编码的 Docker 映像名称。当您在下一个步骤中运行工作流时，这些变量将被替换为工作流的构建操作所生成的实际值。

有关任务定义参数的详细信息，请参阅《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。构建操作还将使用正确的 `image` 字段值更新 `taskdef.json`，然后创建此文件的输出构件。此构件将用作接下来的部署操作的输入。

  有关构建操作的更多信息，请参阅[使用工作流进行构建](build-workflow-actions.md)。
+ 部署操作（`DeployToECS`）– 构建操作完成后，部署操作将查找构建操作（`TaskDefArtifact`）所生成的输出构件，查找其中包含的 `taskdef.json` 并将它注册到您的 Amazon ECS 服务。之后，该服务按照 `taskdef.json` 文件中的说明，在您的 Amazon ECS 集群中运行三个 Amazon ECS 任务以及关联的 Hello World Docker 容器。

**创建工作流**

1. **在 CodeCatalyst 控制台的导航窗格中，选择 C **I/CD**，然后选择工作流程。**

1. 选择**创建工作流**。

1. 对于**源存储库**，选择 `codecatalyst-ecs-source-repository`。

1. 对于**分支**，选择 `main`。

1. 选择**创建**。

1. 删除 YAML 示例代码。

1. 添加以下 YAML 代码：
**注意**  
在接下来的 YAML 代码中，如果需要，可以省略 `Connections:` 部分。如果您省略这些部分，则必须确保您环境的**默认 IAM 角色**字段中指定的角色包含[第 5 步：将 AWS 角色添加到 CodeCatalyst](#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
   ```

   在上述代码中，进行如下替换：
   + 的两个实例都*codecatalyst-ecs-environment*与您在中创建的环境名称相同[先决条件](#deploy-tut-ecs-prereqs)。
   + 的两个实例都*codecatalyst-account-connection*带有您的账户连接的显示名称。显示名称可能是数字。有关更多信息，请参阅 [第 5 步：将 AWS 角色添加到 CodeCatalyst](#deploy-tut-ecs-import-roles)。
   + *codecatalyst-ecs-build-role*使用您在中创建的构建角色的名称[步骤 4：创建 AWS 角色](#deploy-tut-ecs-build-deploy-roles)。
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo*（在`Value:`属性中），其中包含您在中创建的 Amazon ECR 存储库的 URI。[步骤 3：创建 Amazon ECR 映像存储库](#deploy-tut-ecs-ecr)
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*（在`Run: aws ecr`命令中）使用 Amazon ECR 存储库的 URI，不带图像后缀 () `/codecatalyst-ecs-image-repo`。
   + *codecatalyst-ecs-deploy-role*使用您在中创建的部署角色的名称[步骤 4：创建 AWS 角色](#deploy-tut-ecs-build-deploy-roles)。
   + 两个实例都*us-west-2*使用您的 AWS 地区代码。有关区域代码的列表，请参阅《AWS 一般参考》**中的 [Regional endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints)。
**注意**  
如果您决定不创建生成和部署角色，请*codecatalyst-ecs-deploy-role*使用`CodeCatalystWorkflowDevelopmentRole-spaceName`角色名称替换*codecatalyst-ecs-build-role*和。有关该角色的更多信息，请参阅[步骤 4：创建 AWS 角色](#deploy-tut-ecs-build-deploy-roles)。
**提示**  
您可以使用**渲染 Amazon ECS 任务定义**操作来更新存储库和映像名称，而不是使用前面的工作流代码中显示的 `find` 和 `sed` 命令。有关更多信息，请参阅 [修改 Amazon ECS 任务定义](render-ecs-action.md)。

1. （可选）选择**验证**，确保 YAML 代码在提交之前有效。

1. 选择**提交**。

1. 在**提交工作流**对话框中，输入以下内容：

   1. 对于**提交消息**，移除文本并输入：

      ```
      Add first workflow
      ```

   1. 对于**存储库**，选择 `codecatalyst-ecs-source-repository`。

   1. 对于**分支名称**，选择“主”。

   1. 选择**提交**。

   现在，您已创建工作流。由于在工作流顶部定义了触发器，因此工作流运行会自动启动。具体而言，当您将 `workflow.yaml` 文件提交（并推送）到源存储库时，触发器启动了工作流运行。

**查看工作流运行进度**

1. **在 CodeCatalyst 控制台的导航窗格中，选择 C **I/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. 选择 **Tasks** 选项卡。

1. 选择三项任务中的任一项。

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. 选择 **Tasks** 选项卡。

   1. 选择三项任务中的任一项。

   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 Identity Center 中，删除：

   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** 服务。

# 添加“部署到 Amazon ECS”操作
<a name="deploy-action-ecs-adding"></a>

按照以下说明，将**部署到 Amazon ECS** 操作添加到工作流。

------
#### [ Visual ]

**使用可视化编辑器添加“部署到 Amazon ECS”操作**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

1. 选择工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择**可视化**。

1. 在左上角，选择 **\$1 操作**打开操作目录。

1. 从下拉列表中选择 A **mazon CodeCatalyst**。

1. 搜索**部署到 Amazon ECS** 操作，然后执行下列操作之一：
   + 选择加号（**\$1**），将操作添加到工作流图表中并打开其配置窗格。

     或
   + 选择**部署到 Amazon ECS**。此时会显示操作详细信息对话框。在此对话框中：
     + （可选）选择**下载**以[查看操作的源代码](workflows-view-source.md#workflows-view-source.title)。
     + 选择**添加到工作流**，将操作添加到工作流图表中并打开其配置窗格。

1. 在**输入**和**配置**选项卡中，根据需要填写字段。有关每个字段的描述，请参阅[“部署到 Amazon ECS”操作 YAML](deploy-action-ref-ecs.md)。本参考提供了有关在 YAML 编辑器和可视化编辑器中显示的每个字段（以及对应的 YAML 属性值）的详细信息。

1. （可选）选择**验证**，在提交之前验证工作流的 YAML 代码。

1. 选择**提交**，输入提交消息，然后再次选择**提交**。

------
#### [ YAML ]

**使用 YAML 编辑器添加“部署到 Amazon ECS”操作**

1. 打开 CodeCatalyst 控制台，[网址为 https://codecatalyst.aws/](https://codecatalyst.aws/)。

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**工作流**。

1. 选择工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择 **YAML**。

1. 在左上角，选择 **\$1 操作**打开操作目录。

1. 从下拉列表中选择 A **mazon CodeCatalyst**。

1. 搜索**部署到 Amazon ECS** 操作，然后执行下列操作之一：
   + 选择加号（**\$1**），将操作添加到工作流图表中并打开其配置窗格。

     或
   + 选择**部署到 Amazon ECS**。此时会显示操作详细信息对话框。在此对话框中：
     + （可选）选择**下载**以[查看操作的源代码](workflows-view-source.md#workflows-view-source.title)。
     + 选择**添加到工作流**，将操作添加到工作流图表中并打开其配置窗格。

1. 根据需求修改 YAML 代码中的属性。[“部署到 Amazon ECS”操作 YAML](deploy-action-ref-ecs.md)中提供了每个可用属性的解释。

1. （可选）选择**验证**，在提交之前验证工作流的 YAML 代码。

1. 选择**提交**，输入提交消息，然后再次选择**提交**。

------

# “部署到 Amazon ECS”变量
<a name="deploy-action-ecs-variables"></a>

**部署到 Amazon ECS** 操作在运行时会生成并设置以下变量。这些变量被称为*预定义变量*。

有关在工作流中引用这些变量的信息，请参阅 [使用预定义变量](workflows-using-predefined-variables.md)。


| 键 | 值 | 
| --- | --- | 
|  cluster  |  在工作流运行期间部署到的 Amazon ECS 集群的名称。 示例：`codecatalyst-ecs-cluster`  | 
|  deployment-platform  |  部署平台的名称。 硬编码为 `AWS:ECS`。  | 
|  service  |  在工作流运行期间部署到的 Amazon ECS 服务的名称。 示例：`codecatalyst-ecs-service`  | 
|  task-definition-arn  |  在工作流运行期间注册的任务定义的 Amazon 资源名称（ARN）。 示例：`arn:aws:ecs:us-west-2:111122223333:task-definition/codecatalyst-task-def:8`前面的示例中的 `:8` 表示已注册的修订。  | 
|  deployment-url  |  指向 Amazon ECS 控制台的**事件**选项卡的链接，可以在其中查看与工作流运行关联的 Amazon ECS 部署的详细信息。 示例：`https://console.aws.amazon.com/ecs/home?region=us-west-2#/clusters/codecatalyst-ecs-cluster/services/codecatalyst-ecs-service/events`  | 
|  region  |  在工作流程运行期间部署到的的区域代码。 AWS 区域  示例：`us-west-2`  | 

# “部署到 Amazon ECS”操作 YAML
<a name="deploy-action-ref-ecs"></a>

下面是**部署到 Amazon ECS** 操作的 YAML 定义。要了解如何使用此操作，请参阅[使用工作流部署到 Amazon ECS](deploy-action-ecs.md)。

此操作定义部分包含在更广泛的工作流定义文件中。有关此文件的更多信息，请参阅[工作流 YAML 定义](workflow-reference.md)。

**注意**  
接下来的大多数 YAML 属性在可视化编辑器中都有对应的 UI 元素。要查找 UI 元素，请使用 **Ctrl\$1F**。该元素将与其关联的 YAML 属性一起列出。

```
# The workflow definition starts here.
# See 顶级属性 for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  ECSDeployAction\$1nn: 
    Identifier: aws/ecs-deploy@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - task-definition-artifact
    Configuration: 
      region: us-east-1 
      cluster: ecs-cluster
      service: ecs-service
      task-definition: task-definition-path
      force-new-deployment: false|true
      codedeploy-appspec: app-spec-file-path
      codedeploy-application: application-name
      codedeploy-deployment-group: deployment-group-name
      codedeploy-deployment-description: deployment-description
```

## ECSDeployAction
<a name="deploy.action.ecs.name"></a>

（必需）

指定操作的名称。工作流中的所有操作名称都必须是唯一的。操作名称仅限于字母数字字符（a-z、A-Z、0-9）、连字符（-）和下划线（\$1）。不允许使用空格。不能使用引号在操作名称中包含特殊字符和空格。

默认值：`ECSDeployAction_nn`。

对应的 UI：“配置”选项卡/**操作显示名称**

## Identifier
<a name="deploy.action.ecs.identifier"></a>

(*ECSDeployAction*/**Identifier**)

（必需）

标识操作。除非您要更改版本，否则不要更改此属性。有关更多信息，请参阅[指定要使用的操作版本](workflows-action-versions.md)。

默认值：`aws/ecs-deploy@v1`。

**对应的用户界面：工作流程图/ ECSDeploy action\$1nn/ aws/ecs-deploy @v1 标签**

## DependsOn
<a name="deploy.action.ecs.dependson"></a>

(*ECSDeployAction*/**DependsOn**)

（可选）

指定必须成功运行才能使该操作运行的操作、操作组或阶段门。

有关“依赖于”功能的更多信息，请参阅[顺序操作](workflows-depends-on.md)。

对应的 UI：“输入”选项卡/**依赖于 – 可选**

## Compute
<a name="deploy.action.ecs.computename"></a>

(*ECSDeployAction*/**Compute**)

（可选）

用于运行工作流操作的计算引擎。您可以在工作流级别或操作级别指定计算，但不能同时在这两个级别指定计算。在工作流级别指定计算时，计算配置将应用于工作流中定义的所有操作。在工作流级别，您还可以在同一个实例上运行多个操作。有关更多信息，请参阅[跨操作共享计算](compute-sharing.md)。

对应的 UI：*无*

## Type
<a name="deploy.action.ecs.computetype"></a>

(*ECSDeployAction*/Compute/**Type**)

（如果包含 [Compute](#deploy.action.ecs.computename)，则为必需）

计算引擎的类型。可以使用下列值之一：
+ **EC2**（可视化编辑器）或 `EC2`（YAML 编辑器）

  已经过优化，提高了操作运行期间的灵活性。
+ **Lambda**（可视化编辑器）或 `Lambda`（YAML 编辑器）

  优化了操作启动速度。

有关计算类型的更多信息，请参阅[计算类型](workflows-working-compute.md#compute.types)。

**相应的 UI：配置 tab/Advanced -可选/计算类型**

## Fleet
<a name="deploy.action.ecs.computefleet"></a>

(*ECSDeployAction*/Compute/**Fleet**)

（可选）

指定将运行您的工作流或工作流操作的计算机或实例集。对于按需实例集，当操作开始时，工作流会预置操作所需的资源，操作完成后计算机就会被销毁。按需实例集的示例：`Linux.x86-64.Large`、`Linux.x86-64.XLarge`。有关按需实例集的更多信息，请参阅[按需实例集属性](workflows-working-compute.md#compute.on-demand)。

使用预置的实例集，您可以配置一组专用计算机来运行工作流操作。这些计算机保持空闲状态，可随时开始立即处理操作。有关预置实例集的更多信息，请参阅[预置实例集属性](workflows-working-compute.md#compute.provisioned-fleets)。

如果省略 `Fleet`，则默认值为 `Linux.x86-64.Large`。

**相应的 UI：配置 tab/Advanced -可选/计算舰队**

## Timeout
<a name="deploy.action.ecs.timeout"></a>

(*ECSDeployAction*/**Timeout**)

（可选）

指定操作在 CodeCatalyst 结束操作之前可以运行的时间（以分钟（YAML 编辑器）或小时和分钟（可视化编辑器）为单位。最小值为 5 分钟，最大值如 [中的工作流程配额 CodeCatalyst](workflows-quotas.md) 中描述。默认超时值与最大超时值相同。

对应的 UI：“配置”选项卡/**超时 – 可选**

## Environment
<a name="deploy.action.ecs.environment"></a>

(*ECSDeployAction*/**Environment**)

（必需）

指定要用于操作的 CodeCatalyst 环境。该操作连接到在所选环境中指定的 AWS 账户 和可选的 Amazon VPC。该操作使用环境中指定的默认 IAM 角色连接到 AWS 账户，并使用在 A [mazon VPC 连接](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html)中指定的 IAM 角色连接到亚马逊 VPC。

**注意**  
如果默认 IAM 角色不具有操作所需的权限，则可以将操作配置为使用其他角色。有关更多信息，请参阅[更改操作的 IAM 角色](deploy-environments-switch-role.md)。

有关环境的更多信息，请参阅[部署到 AWS 账户 和 VPCs](deploy-environments.md)和[创建环境](deploy-environments-creating-environment.md)。

对应的 UI：“配置”选项卡/**环境**

## Name
<a name="deploy.action.ecs.environment.name"></a>

(*ECSDeployAction*/Environment/**Name**)

（如果包含 [Environment](#deploy.action.ecs.environment)，则为必需）

指定要与操作关联的现有环境的名称。

对应的 UI：“配置”选项卡/**环境**

## Connections
<a name="deploy.action.ecs.environment.connections"></a>

(*ECSDeployAction*/Environment/**Connections**)

（在新版本的操作中为可选；在旧版本中为必需）

指定要与操作关联的账户连接。您在 `Environment` 下最多只能指定一个账户连接。

如果您不指定账户连接：
+ 该操作使用 CodeCatalyst 控制台环境中指定的 AWS 账户 连接和默认 IAM 角色。有关向环境添加账户连接和默认 IAM 角色的信息，请参阅[创建环境](deploy-environments-creating-environment.md)。
+ 默认 IAM 角色必须包含操作所需的策略和权限。要具体确定这些策略和权限，请参阅操作的 YAML 定义文档中 **Role** 属性的描述。

有关账户连接的更多信息，请参阅[允许在已连接的情况下访问 AWS 资源 AWS 账户](ipa-connect-account.md)。有关向环境添加账户连接的信息，请参阅[创建环境](deploy-environments-creating-environment.md)。

对应的 UI：根据操作版本的不同，为下列项之一：
+ （新版本）配置tab/Environment/What在*my-environment*吗？ **/三点菜单/ 切换角色**
+ **（旧版本）配置选项卡/ Environment/account/role ''/账户连接AWS **

## Name
<a name="deploy.action.ecs.environment.connections.name"></a>

(*ECSDeployAction*/Environment/Connections/**Name**)

（如果包含 [Connections](#deploy.action.ecs.environment.connections)，则为必需）

指定账户连接的名称。

对应的 UI：根据操作版本的不同，为下列项之一：
+ （新版本）配置tab/Environment/What在*my-environment*吗？ **/三点菜单/ 切换角色**
+ **（旧版本）配置选项卡/ Environment/account/role ''/账户连接AWS **

## Role
<a name="deploy.action.ecs.environment.connections.role"></a>

(*ECSDeployAction*/Environment/Connections/**Role**)

（如果包含 [Connections](#deploy.action.ecs.environment.connections)，则为必需）

指定**部署到 Amazon ECS** 操作用于访问 AWS的 IAM 角色的名称。请确保您已将[该角色添加到您的 CodeCatalyst 空间](ipa-connect-account-addroles.md)，并且该角色包含以下策略。

如果您未指定 IAM 角色，则该操作将使用 CodeCatalyst 控制台中[环境](deploy-environments.md)中列出的默认 IAM 角色。如果您使用此环境中的默认角色，请确保该角色具有以下策略。
+ 以下权限策略：
**警告**  
将权限限制在以下策略所示的范围内。使用具有更广泛权限的角色可能会带来安全风险。

------
#### [ 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": "*"
  ```
+ 以下自定义信任策略：

**注意**  
如果需要，可以在此操作中使用 `CodeCatalystWorkflowDevelopmentRole-spaceName` 角色。有关该角色的更多信息，请参阅[为您的账户和空间创建 **CodeCatalystWorkflowDevelopmentRole-*spaceName*** 角色](ipa-iam-roles.md#ipa-iam-roles-service-create)。了解 `CodeCatalystWorkflowDevelopmentRole-spaceName` 角色具有完全访问权限可能会带来安全风险。我们建议您仅在教程和安全要求较低的场景中使用此角色。

对应的 UI：根据操作版本的不同，为下列项之一：
+ （新版本）配置tab/Environment/What在*my-environment*吗？ **/三点菜单/ 切换角色**
+ **（旧版本）“配置” 选项卡/' '/ 角色 Environment/account/role**

## Inputs
<a name="deploy.action.ecs.inputs"></a>

(*ECSDeployAction*/**Inputs**)

（可选）

`Inputs` 部分中定义了工作流运行期间 `ECSDeployAction` 所需的数据。

**注意**  
每个**部署到 Amazon ECS** 操作只能有一个输入（可以是源或构件）。

对应的 UI：**输入**选项卡

## Sources
<a name="deploy.action.ecs.inputs.sources"></a>

(*ECSDeployAction*/Inputs/**Sources**)

（如果您的任务定义文件存储在源存储库中，则为必需项）

如果您的任务定义文件存储在源存储库中，请指定该源存储库的标签。目前，唯一支持的标签是 `WorkflowSource`。

如果您的任务定义文件不包含在源存储库中，则必须位于另一个操作生成的构件中。

有关来源的更多信息，请参阅[将源存储库连接到工作流](workflows-sources.md)。

对应的 UI：“输入”选项卡/**来源 – 可选**

## Artifacts - input
<a name="deploy.action.ecs.inputs.artifacts"></a>

(*ECSDeployAction*/Inputs/**Artifacts**)

（如果您的任务定义文件存储在上一操作生成的[输出构件](workflows-working-artifacts-output.md)中，则为必需项）

如果要部署的任务定义文件包含在上一操作生成的构件中，请在此处指定该构件。如果您的任务定义文件不包含在构件中，则必须位于源存储库中。

有关构件的更多信息（包括示例），请参阅[在操作之间共享构件和文件](workflows-working-artifacts.md)。

对应的 UI：“配置”选项卡/**构件 – 可选**

## Configuration
<a name="deploy.action.ecs.configuration"></a>

(*ECSDeployAction*/**Configuration**)

（必需）

可在其中定义操作的配置属性的部分。

对应的 UI：**配置**选项卡

## region
<a name="deploy.action.ecs.region"></a>

(Configuration/**region**)

（必需）

指定您的 Amazon ECS 集群和服务所在的 AWS 区域。有关区域代码的列表，请参阅《AWS 一般参考》**中的 [Regional endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints)。

对应的 UI：“配置”选项卡/**区域**

## cluster
<a name="deploy.action.ecs.cluster"></a>

(*ECSDeployAction*/Configuration/**cluster**)

（必需）

指定现有 Amazon ECS 集群的名称。**部署到 Amazon ECS** 操作会将容器化应用程序作为任务部署到该集群中。有关 Amazon ECS 集群的更多信息，请参阅《Amazon Elastic Container Service 开发人员指南》**中的[集群](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters)。

对应的 UI：“配置”选项卡/**集群**

## service
<a name="deploy.action.ecs.service"></a>

(*ECSDeployAction*/Configuration/**service**)

（必需）

指定将实例化任务定义文件的现有 Amazon ECS 服务的名称。此服务必须位于 `cluster` 字段中指定的集群下。有关 Amazon ECS 服务的更多信息，请参阅《Amazon Elastic Container Service 开发人员指南》**中的 [Amazon ECS 服务](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html)。

对应的 UI：“配置”选项卡/**服务**

## task-definition
<a name="deploy.action.ecs.task.definition"></a>

(*ECSDeployAction*/Configuration/**task-definition**)

（必需）

指定现有任务定义文件的路径。如果文件位于源存储库中，则该路径相对于源存储库根文件夹。如果文件位于上一工作流操作生成的构件中，则该路径相对于构件根文件夹。有关任务定义文件的更多信息，请参阅《Amazon Elastic Container Service 开发人员指南》**中的[任务定义](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions)。

对应的 UI：“配置”选项卡/**任务定义**

## force-new-deployment
<a name="deploy.action.ecs.forcenewdeployment"></a>

(*ECSDeployAction*/Configuration/**force-new-deployment**)

（必需）

如果启用此项，则 Amazon ECS 服务无需更改服务定义即可启动新的部署。强制部署会导致服务停止所有当前正在运行的任务并启动新任务。有关强制重新部署更多信息，请参阅《Amazon Elastic Container Service 开发人员指南》**中的[更新服务](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service.html)。

默认值：`false`

对应的 UI：“配置”选项卡/**强制重新部署该服务**

## codedeploy-appspec
<a name="deploy.action.ecs.codedeploy.appspec"></a>

(*ECSDeployAction*/Configuration/**codedeploy-appspec**)

（如果您已将 Amazon ECS 服务配置为使用 blue/green 部署，则为必填项，否则省略）

指定现有 CodeDeploy 应用程序规范 (AppSpec) 文件的名称和路径。此文件必须位于 CodeCatalyst 源存储库的根目录中。有关 AppSpec 文件的更多信息，请参阅《*AWS CodeDeploy 用户指南》*中的[CodeDeploy 应用程序规范 (AppSpec) 文件](https://docs.aws.amazon.com/codedeploy/latest/userguide/application-specification-files.html)。

**注意**  
只有在您已将 Amazon ECS 服务配置为执行 blue/green 部署时，才提供 CodeDeploy 信息。对于滚动更新部署（默认），请省略 CodeDeploy 信息。有关更多信息，请参阅《Amazon Elastic Container Service 开发人员指南》**中的 [Amazon ECS 部署类型](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html)。

**注意**  
这些**CodeDeploy**字段可能隐藏在可视化编辑器中。要显示该字段，请参阅[为什么可视化编辑器中缺少 CodeDeploy 字段？](troubleshooting-workflows.md#troubleshooting-workflows-codedeploy)。

对应的 UI：“配置” 选项卡/ **CodeDeploy AppSpec**

## codedeploy-application
<a name="deploy.action.ecs.codedeploy.application"></a>

(*ECSDeployAction*/Configuration/**codedeploy-application**)

（如果包含 `codedeploy-appspec`，则为必需）

指定现有 CodeDeploy 应用程序的名称。有关 CodeDeploy 应用程序的更多信息，请参阅《*AWS CodeDeploy 用户指南》 CodeDeploy*[中的使用应用程序](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html)。

**相应的 UI：配置选项卡/应用程序 CodeDeploy **

## codedeploy-deployment-group
<a name="deploy.action.ecs.codedeploy.deploymentgroup"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-group**)

（如果包含 `codedeploy-appspec`，则为必需）

指定现有 CodeDeploy 部署组的名称。有关 CodeDeploy 部署组的更多信息，请参阅《*AWS CodeDeploy 用户指南》 CodeDeploy*[中的使用部署组](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html)。

相应的 UI：“配置” 选项卡/ **CodeDeploy 部署组**

## codedeploy-deployment-description
<a name="deploy.action.ecs.codedeploy.deploymentdescription"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-description**)

（可选）

指定此操作将创建的部署的描述。有关更多信息，请参阅《*AWS CodeDeploy 用户指南》 CodeDeploy*[中的使用部署](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments.html)。

对应的 UI：“配置” 选项卡/ **CodeDeploy 部署描述**