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

# 教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道
<a name="tutorials-ecs-ecr-codedeploy"></a>

在本教程中，您将配置一个管道， AWS CodePipeline 该管道使用支持 Docker 映像的 blue/green 部署部署来部署容器应用程序。在蓝/绿部署中，您可以在运行旧版本应用程序的同时启动新版本应用程序，并在重新路由流量之前测试新版本。您还可以监控部署流程并且在存在问题的情况下迅速回滚。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
本教程适用于 Amazon ECS 的 CodeDeploy 蓝/绿部署操作。 CodePipeline有关使用中的 Amazon ECS 标准部署操作的教程 CodePipeline，请参阅[教程：使用 Amazon ECS 标准部署 CodePipeline](ecs-cd-pipeline.md)。

已完成的管道会检测您的映像的更改，该图像存储在映像存储库（例如 Amazon ECR）中，并用于 CodeDeploy 将流量路由和部署到 Amazon ECS 集群和负载均衡器。 CodeDeploy 使用侦听器将流量重新路由到 AppSpec 文件中指定的已更新容器的端口。有关如何在 blue/green 部署中使用负载均衡器、生产侦听器、目标组和您的 Amazon ECS 应用程序的信息，请参阅[教程：部署 Amazon ECS 服务](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html)。

管道还配置为使用存储您的 Amazon ECS 任务定义的源位置，例如。 CodeCommit在本教程中，您将配置这些 AWS 资源中的每一个，然后创建包含每种资源操作的阶段的管道。

在源代码发生更改时或者新基本映像上传到 Amazon ECR 时，您的持续交付管道将自动构建和部署容器映像。

此流程使用以下项目：
+ 一个 Docker 映像文件，该文件指定容器名称和 Amazon ECR 映像存储库的存储库 URI。
+ 一个 Amazon ECS 任务定义，该定义列出您的 Docker 映像名称、容器名称、Amazon ECS 服务名称和负载均衡器配置。
+ 一个 CodeDeploy AppSpec 文件，它指定 Amazon ECS 任务定义文件的名称、更新的应用程序容器的名称以及 CodeDeploy重新路由生产流量的容器端口。它还可以指定可选的网络配置以及您在部署生命周期事件挂钩期间可运行的 Lambda 函数。

**注意**  
当您把更改提交到 Amazon ECR 映像存储库时，管道源操作会为该提交创建 `imageDetail.json` 文件。有关 `imageDetail.json` 文件的信息，请参阅[用于亚马逊 ECS 部署操作的 imageDetail.json 文件 blue/green](file-reference.md#file-reference-ecs-bluegreen)。

在创建或编辑管道和更新或指定部署阶段更新或指定源项目时，请确保指向要使用的带最新名称和版本的源项目。在设置管道后，在对映像或任务定义进行更改时，您可能需要更新存储库中的源项目文件，然后在管道中编辑部署阶段。

**Topics**
+ [先决条件](#tutorials-ecs-ecr-codedeploy-prereq)
+ [步骤 1：创建映像并推送至 Amazon ECR 存储库](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [第 2 步：创建任务定义和 AppSpec 源文件并推送到 CodeCommit 存储库](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [步骤 3：创建您的应用程序负载均衡器和目标组](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [步骤 4：创建您的 Amazon ECS 集群和服务](#tutorials-ecs-ecr-codedeploy-cluster)
+ [步骤 5：创建您的 CodeDeploy 应用程序和部署组（ECS 计算平台）](#tutorials-ecs-ecr-codedeploy-deployment)
+ [步骤 6：创建管道](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [步骤 7：对您的管道进行更改并验证部署](#tutorials-ecs-ecr-codedeploy-update)

## 先决条件
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

您必须已创建以下资源：
+ 存储 CodeCommit 库。您可以使用您在中创建的 AWS CodeCommit 存储库[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 启动 Amazon EC2 Linux 实例并安装 Docker 以创建映像，如本教程中所示。如果您已有要使用的映像，则可以跳过此先决条件。

## 步骤 1：创建映像并推送至 Amazon ECR 存储库
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

在本节中，您将使用 Docker 创建映像，然后使用创建 Amazon ECR 存储库并将该映像推送到存储库。 AWS CLI 

**注意**  
如果您已有要使用的映像，则可以跳过此步骤。

**创建镜像**

1. 登录到已安装 Docker 的 Linux 实例。

   下拉 `nginx` 的映像。此命令提供 `nginx:latest` 映像：

   ```
   docker pull nginx
   ```

1. 运行 **docker images**。您将在列表中看到该映像。

   ```
   docker images
   ```

**创建 Amazon ECR 存储库并推送映像**

1. 创建用于存储您的 映像的 Amazon ECR 存储库。记下输出中的 `repositoryUri`。

   ```
   aws ecr create-repository --repository-name nginx
   ```

   输出：

   ```
   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }
   ```

1. 使用上一步中的 `repositoryUri` 值标记映像。

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. 运行 **aws ecr get-login-password** 命令，如 `us-west-2` 区域和 111122223333 账户 ID 的此示例中所示。

   ```
   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx
   ```

1. 使用上一步中的 `repositoryUri` 将映像推送至 Amazon ECR。

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

## 第 2 步：创建任务定义和 AppSpec 源文件并推送到 CodeCommit 存储库
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

在此部分中，您将创建一个任务定义 JSON 文件并将该文件注册到 Amazon ECS。然后，您可以为创建 AppSpec 文件 CodeDeploy 并使用 Git 客户端将这些文件推送到您的 CodeCommit 存储库。

**为您的映像创建任务定义**

1. 使用以下内容创建名为 `taskdef.json` 的文件。对于 `image`，输入您的映像名称，如 nginx。此值会在管道运行时进行更新。
**注意**  
请确保在任务定义中指定的执行角色包含 `AmazonECSTaskExecutionRolePolicy`。有关更多信息，请参阅 *Amazon ECS 开发者指南* 中的 [Amazon ECS 任务执行 IAM 角色](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)。

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

1. 使用 `taskdef.json` 文件注册任务定义。

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

1. 注册任务定义后，编辑您的文件以删除映像名称并将 `<IMAGE1_NAME>` 占位符文本包含在映像字段中。

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

**创建 AppSpec 文件**
+ 该 AppSpec 文件用于 CodeDeploy 部署。该文件（包含可选字段）使用以下格式：

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"
  ```

  有关该 AppSpec 文件的更多信息（包括示例），请参阅[CodeDeploy AppSpec 文件引用](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。

  使用以下内容创建名为 `appspec.yaml` 的文件。对于 `TaskDefinition`，请勿更改 `<TASK_DEFINITION>` 占位符文本。此值会在管道运行时进行更新。

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80
  ```

**将文件推送到您的 CodeCommit 存储库**

1. 将文件推送或上传到您的 CodeCommit 存储库。这些文件是由**创建管道**向导针对您在 CodePipeline 中的部署操作创建的源构件。您的文件在本地目录中应如下所示：

   ```
   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json
   ```

1. 选择要用于上传文件的方法：

   1. 在本地计算机上从克隆的存储库使用 Git 命令行：

      1. 将目录更改为本地存储库：

         ```
         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo
         ```

      1. 运行以下命令以立即暂存您的所有文件：

         ```
         git add -A
         ```

      1. 运行以下命令以提交带有提交消息的文件：

         ```
         git commit -m "Added task definition files"
         ```

      1. 运行以下命令将本地存储库中的文件推送到存储 CodeCommit 库：

         ```
         git push
         ```

   1. 要使用 CodeCommit 控制台上传文件，请执行以下操作：

      1. 打开 CodeCommit 控制台，然后从 “存储库” 列表中选择您的**存储库**。

      1. 选择**添加文件**，然后选择**上传文件**。

      1. 选择**选择文件**，然后浏览以找到您的文件。通过输入您的用户名和电子邮件地址来提交更改。选择**提交更改**。

      1. 对要上传的每个文件重复此步骤。

## 步骤 3：创建您的应用程序负载均衡器和目标组
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

在此部分中，您将创建一个 Amazon EC2 应用程序负载均衡器。在创建 Amazon ECS 服务时，您可以使用稍后将通过负载均衡器创建的子网名称和目标组值。您可以创建应用程序负载均衡器或网络负载均衡器。负载均衡器必须使用在不同的可用区中具有两个公有子网的 VPC。在这些步骤中，您将确认您的默认 VPC，创建负载均衡器，然后为负载均衡器创建两个目标组。有关更多信息，请参阅[您的网络负载均衡器的目标组](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html)。

**验证您的默认 VPC 和公有子网**

1. 登录 AWS 管理控制台 并打开 Amazon VPC 控制台，网址为[https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。

1. 验证要使用的默认 VPC。在导航窗格中，选择**您的 VPCs**。请注意哪个 VPC 在**默认 VPC** 列中显示为**是**。这是默认 VPC。它包含可供您选择的默认子网。

1. 选择**子网**。选择两个在**默认子网**列中显示**是**的子网。
**注意**  
记下您的子网 IDs。本教程后面将会用到这些 ID。

1. 选择子网，然后选择**描述**选项卡。验证要使用的子网是否位于不同的可用区中。

1. 选择子网，然后选择**路由表**选项卡。为了验证要使用的每个子网是否为公有子网，请确认网关行包含在路由表中。

**创建 Amazon EC2 应用程序负载均衡器**

1. 登录 AWS 管理控制台 并打开 Amazon EC2 控制台，网址为[https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)。

1. 在导航窗格中，选择**负载均衡器**。

1. 选择 **Create Load Balancer（创建负载均衡器）**。

1. 选择 **Application Load Balancer（应用程序负载均衡器）**，然后选择 **Create（创建）**。

1. 在 **Name（名称）**中，输入负载均衡器的名称。

1. 在 **Scheme（模式）**中，选择 **internet-facing（面向 internet）**。

1. 在 **IP 地址类型**中，选择 **ipv4**。

1. 为您的负载均衡器配置两个侦听器端口：

   1. 在**负载均衡器协议**下，选择 **HTTP**。在**负载均衡器端口**下，输入 **80**。

   1. 选择**添加侦听器**。

   1. 在第二个侦听器的**负载均衡器协议**下，选择 **HTTP**。在 **Load Balancer Port（负载均衡器端口）**下，输入 **8080**。

1. 在**可用区**下，在 **VPC** 中，选择默认 VPC。接下来，选择要使用的两个默认子网。

1. 选择**下一步：配置安全设置**。

1. 选择**下一步：配置安全组**。

1. 选择**选择现有安全组**，然后记下安全组 ID。

1. 选择**下一步：配置路由**。

1. 在**目标组**中，选择**新建目标组**并配置您的第一个目标组：

   1. 在**名称**中，输入目标组名称（例如，**target-group-1**）。

   1. 在 **Target type（目标类型）**中，选择 **IP**。

   1. 在 **Protocol（协议）**中，选择 **HTTP**。在 **Port（端口）**中，输入 **80**。

   1. 选择**下一步：注册目标**。

1. 选择 **Next: Review（下一步：审核）**，然后选择 **Create（创建）**。

**为您的负载均衡器创建第二个目标组**

1. 在预配置您的负载均衡器后，打开 Amazon EC2 控制台。在导航窗格中，选择**目标组**。

1. 选择**创建目标组**。

1. 在 **Name（名称）**中，输入目标组名称（例如，**target-group-2**）。

1. 在 **Target type（目标类型）**中，选择 **IP**。

1. 在 **Protocol（协议）**中，选择 **HTTP**。在 **Port（端口）**中，输入 **8080**。

1. 在 **VPC** 中，选择默认 VPC。

1. 选择**创建**。
**注意**  
要使部署运行，您必须为您的负载均衡器创建了两个目标组。您只需记下第一个目标组的 ARN。在下一步中，此 ARN 将用于 `create-service` JSON 文件。

**更新您的负载均衡器以包含第二个目标组**

1. 打开 Amazon EC2 控制台。在导航窗格中，选择**负载均衡器**。

1. 选择您的负载均衡器，然后选择**侦听器**选项卡。选择具有端口 8080 的侦听器，然后选择**编辑**。

1. 选择**转发至**旁的铅笔图标。选择您的第二个目标组，然后选择复选标记。选择**更新**以保存更新。

## 步骤 4：创建您的 Amazon ECS 集群和服务
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

在本节中，您将创建一个 Amazon ECS 集群和服务，用于在部署期间 CodeDeploy 路由流量（到 Amazon ECS 集群而不是 EC2 实例）。要创建 Amazon ECS 服务，您必须使用通过负载均衡器创建的子网名称、安全组和目标组值来创建服务。

**注意**  
使用这些步骤创建 Amazon ECS 集群时，您将使用**仅限联网**的集群模板，该模板预配置 AWS Fargate 容器。 AWS Fargate 是一项为您管理容器实例基础设施的技术。您不需要为 Amazon ECS 集群选择或手动创建 Amazon EC2 实例。

**要创建 Amazon ECS 集群**

1. 打开 Amazon ECS 经典控制台，网址为[https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/)。

1. 在导航窗格中，选择**集群**。

1. 选择**创建集群**。

1. 选择使用 AWS Fargate 的**仅限联网**集群模板，然后选择**下一步**。

1. 在**配置集群**页面上，输入集群名称。您可以为资源添加可选标签。选择**创建**。

**创建 Amazon ECS 服务**

使用在 AWS CLI Amazon ECS 中创建您的服务。

1. 创建一个 JSON 文件并将其命名为 `create-service.json`。将以下内容粘贴到 JSON 文件中。

   对于 `taskDefinition` 字段，当您在 Amazon ECS 中注册任务定义时，请提供一个系列。这类似于使用修订号指定的任务定义的多个版本的名称。在此示例中，对文件中的系列和修订号使用“`ecs-demo:1`”。使用您在[步骤 3：创建您的应用程序负载均衡器和目标组](#tutorials-ecs-ecr-codedeploy-loadbal)中随负载均衡器创建的子网名称、安全组和目标组值。
**注意**  
您需要在此文件中包含您的目标组 ARN。打开 Amazon EC2 控制台，然后在导航窗格中的**负载均衡**下，选择**目标组**。选择您的第一个目标组。从**描述**选项卡复制您的 ARN。

   ```
   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }
   ```

1. 运行 **create-service** 命令，并指定 JSON 文件：
**重要**  
务必在文件名前包含 `file://`。此命令中需要该项。

   此示例创建一个名为 `my-service` 的服务。
**注意**  
此示例命令创建一个名为 my-service 服务。如果您已有一个具有该名称的服务，则命令会返回错误。

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   输出将返回您的服务的描述字段。

1. 运行 **describe-services** 命令以验证是否已创建您的服务。

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## 步骤 5：创建您的 CodeDeploy 应用程序和部署组（ECS 计算平台）
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

当您为 Amazon ECS 计算平台创建 CodeDeploy 应用程序和部署组时，将在部署期间使用该应用程序来引用正确的部署组、目标组、侦听器和流量重新路由行为。

**创建 CodeDeploy 应用程序**

1. 打开 CodeDeploy 控制台并选择**创建应用程序**。

1. 在**应用程序名称**中，输入要使用的名称。

1. 在**计算平台**中，选择 **Amazon ECS**。

1. 选择**创建应用程序**。

**创建 CodeDeploy 部署组**

1. 在应用程序页面的**部署组**选项卡上，选择**创建部署组**。

1. 在**部署组名称**中，输入一个描述部署组的名称。

1. 在**服务角色**中，选择一个授予 CodeDeploy对 Amazon ECS 访问权限的服务角色。若要创建新的服务角色，请按照以下步骤操作：

   1. 打开 IAM 控制台，网址为 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

   1. 在控制台控制面板中，选择**角色**。

   1. 选择**创建角色**。

   1. 在**选择受信任实体的类型**下，选择 **AWS 服务**。在 **“选择用例**” 下，选择**CodeDeploy**。在 **“选择您的用例**” 下，选择 **CodeDeploy -ECS**。选择**下一步: 权限**。`AWSCodeDeployRoleForECS` 托管策略已附加到角色。

   1. 选择**下一步：标签**，然后选择**下一步：审核**。

   1. 输入角色的名称（例如 **CodeDeployECSRole**），然后选择**创建角色**。

1. 在**环境配置**中，选择 Amazon ECS 集群名称和服务名称。

1. 从**负载均衡器**中，选择将流量提供给 Amazon ECS 服务的负载均衡器的名称。

1. 在**生产侦听器端口**中，选择将生产流量路由至您的 Amazon ECS 服务的侦听器的端口和协议。在**测试侦听器端口**中，选择测试侦听器的端口和协议。

1. 从**目标组 1 名称**和**目标组 2 名称**中，选择用于在部署期间路由流量的目标组。请确保它们是您为负载均衡器创建的目标组。

1. 选择**立即重新路由流量**以确定成功部署后将流量重新路由到更新后的 Amazon ECS 任务的时长。

1. 选择 **Create deployment group（创建部署组）**。

## 步骤 6：创建管道
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一种 CodeCommit 操作，其中源对象是任务定义和 AppSpec 文件。
+ 一个带 Amazon ECR 源操作的源阶段，其中源构件是映像文件。
+ 具有 Amazon ECS 部署操作的部署阶段，其中部署与 CodeDeploy 应用程序和部署组一起运行。

**使用向导创建两阶段管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyImagePipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **AWS CodeCommit**。在 **Repository name (存储库名称)** 中，选择您在[步骤 1：创建 CodeCommit 存储库](tutorials-simple-codecommit.md#codecommit-create-repository)中创建的 CodeCommit 存储库的名称。在**分支名称**中，选择包含最新的代码更新的分支的名称。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中：

   1. 在**部署提供商**中，选择 **Amazon ECS（蓝/绿）**。在**应用程序名称**中，输入应用程序名称或从列表中选择应用程序名称，例如 `codedeployapp`。在**部署组**中，输入部署组名称或从列表中选择部署组名称，例如 `codedeploydeplgroup`。

       
**注意**  
名称“Deploy”是在 **步骤 4：部署**步骤中创建的阶段的默认名称，正如“Source”是管道第一阶段的名称一样。

   1. 在 **Amazon ECS 任务定义**下，选择**SourceArtifact**。在字段中，输入 **taskdef.json**。

   1. 在 “**AWS CodeDeploy AppSpec 文件**” 下，选择**SourceArtifact**。在字段中，输入 **appspec.yaml**。
**注意**  
此时，请不要在**动态更新任务定义映像**下填写任何信息。

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

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

**向管道添加 Amazon ECR 源操作**

查看您的管道并向其添加 Amazon ECR 源操作。

1. 选择您的管道。在左上方，选择**编辑**。

1. 在源阶段中，选择**编辑阶段**。

1. 选择 CodeCommit 源操作旁边的 **\$1 添加动作**，即可添加并行动作。

1. 在**操作名称**中，输入名称（例如 **Image**）。

1. 在**操作提供程序**中，选择 **Amazon ECR**。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ECR-source-action.png)

1. 在**存储库名称**中，选择 Amazon ECR 存储库的名称。

1. 在**映像标签**中，指定映像名称和版本（如果与最新版本不同）。

1. 在**输出构件**中，选择默认输出构件（例如 `MyImage`），其中包含您希望下一阶段使用的映像名称和存储库 URI 信息。

1. 在操作屏幕上选择**保存**。在阶段屏幕上选择**完成**。在管道上选择**保存**。一条消息显示了要为 Amazon CloudWatch ECR 源操作创建的 Amazon Events 规则。

**将您的源构件连接到部署操作**

1. 在部署阶段上选择**编辑**，然后选择图标以编辑 **Amazon ECS（蓝色/绿色）**操作。

1. 滚动到窗格底部。在**输入项目**中，选择**添加**。从您的新 Amazon ECR 存储库（例如，`MyImage`）添加源构件。

1. 在 “**任务定义**” 中 **SourceArtifact**，选择，然后输入验证**taskdef.json**。

1. 在**AWS CodeDeploy AppSpec 文件**中 **SourceArtifact**，选择，然后输入验证**appspec.yaml**信息。

1. 在**动态更新任务定义图像**中，在**带图像 URI 的 Input Ar** tifact 中 **MyImage**，选择，然后输入`taskdef.json`文件中使用的占位符文本：** IMAGE1\$1NAME**。选择**保存**。

1. 在 AWS CodePipeline 窗格中，选择 “**保存管道更改**”，然后选择 “**保存更改**”。查看已更新的管道。

   创建此示例管道后，控制台条目的操作配置按如下所示在管道结构中显示：

   ```
   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   ```

1. 要提交所做的更改并开始管道构建，请选择**发布更改**，然后选择**发布**。

1. 选择要查看的部署操作 CodeDeploy 并查看流量转移的进度。
**注意**  
您可能会看到一个部署步骤，显示可选的等待时间。默认情况下，在成功部署后 CodeDeploy 等待一小时才终止原始任务集。您可以利用此时间回滚或终止任务，但在任务集终止时，您的部署也会完成。

## 步骤 7：对您的管道进行更改并验证部署
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

对您的映像进行更改，然后将更改推送至您的 Amazon ECR 存储库。这将触发您的管道运行。验证是否已部署您的映像源更改。