教程：将应用程序部署到 Amazon ECS

创建 IAM Identity Center 用户

1. 登录 AWS Management Console，打开 AWS IAM Identity Center 控制台：https://console.aws.amazon.com/singlesignon/。

   注意

   请务必使用连接到 CodeCatalyst 空间的 AWS 账户进行登录。您可以通过导航到您的空间并选择 AWS 账户选项卡来确认已连接哪个账户。有关更多信息，请参阅创建空间。

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

3. 在用户名中，输入：

   CodeCatalystECSUser

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

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

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

   CodeCatalystECSUser

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

   CodeCatalystECSUser CodeCatalystECSUser

8. 选择下一步。

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

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

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

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

12. 选择关闭。

创建权限集

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

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

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

3. 选择下一步。

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

   CodeCatalystECSPermissionSet

5. 选择下一步。

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

将权限集分配给 CodeCatalystECSUser

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

2. 选择分配用户或组。

3. 选择用户选项卡。

4. 选中 CodeCatalystECSUser 旁边的复选框。

5. 选择下一步。

6. 选中 CodeCatalystECSPermissionSet 旁边的复选框。

7. 选择下一步。

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

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

注销并以 CodeCatalystECSUser 身份重新登录

1. 在注销之前，请确保您拥有 AWS 访问门户 URL 以及 CodeCatalystECSUser 的用户名和一次性密码。您应在早些时候将此信息复制到文本编辑器中。

   注意

   如果您没有这些信息，请转至 IAM Identity Center 中的 CodeCatalystECSUser 详细信息页面，选择重置密码和生成一次性密码 [...]，然后再次选择重置密码以在屏幕上显示信息。

2. 注销 AWS。

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

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

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

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

6. 选择 AWS 账户，然后选择您为其分配了 CodeCatalystECSUser 用户和权限集的 AWS 账户 的名称。

7. 在 CodeCatalystECSPermissionSet 旁，选择管理控制台。

   此时会显示 AWS Management Console。现在，您已经以具有适当权限的 CodeCatalystECSUser 的身份登录。

启动 AWS CloudShell 实例

1. 与 CodeCatalystECSUser 一样，在顶部导航栏中，选择 AWS 图标（ ）。

   此时将显示 AWS Management Console的主页。

2. 在顶部导航栏中，选择 AWS CloudShell 图标（ ）。

   此时 CloudShell 打开。在创建 CloudShell 环境时，请等待。

   注意

   如果您看不到 CloudShell 图标，请确保您所在的区域是 CloudShell 支持的区域。本教程假设您位于美国西部（俄勒冈州）区域。

确认已安装 AWS CLI

1. 在 CloudShell 终端中，输入：

   aws --version

2. 检查是否显示了版本。

   已为当前用户 CodeCatalystECSUser 配置 AWS CLI，因此无需像往常那样配置 AWS CLI 密钥和凭证。

创建任务执行角色

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

1. 创建信任策略：

   1. 在 AWS CloudShell 中，输入以下命令：

      cat > codecatalyst-ecs-trust-policy.json

      CloudShell 终端中会出现一个闪烁的提示符。

   2. 在提示符处，输入以下代码：

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

   3. 将光标置于最后一个大括号（}）之后。

   4. 按 Enter 和 Ctrl+d 以保存文件并退出 cat。

2. 创建任务执行角色：

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

3. 将 AWS 托管式 AmazonECSTaskExecutionRolePolicy 策略附加到角色：

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

4. 显示角色的详细信息：

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

5. 请记下角色的 "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

2. （可选）验证是否已成功创建集群：

   aws ecs list-clusters

   codecatalyst-ecs-cluster 集群的 ARN 应显示在列表中，这表示创建成功。

创建任务定义文件

任务定义文件指示运行从 DockerHub 提取的 Apache 2.4 Web 服务器 Docker 映像（httpd:2.4）。

1. 与 CodeCatalystECSUser 一样，在 AWS CloudShell 中，创建任务定义文件：

   cat > taskdef.json

2. 在提示符处，粘贴以下代码：

   {
       "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

   替换为您在创建任务执行角色中记下的任务执行角色的 ARN。

3. 将光标置于最后一个大括号（}）之后。

4. 按 Enter 和 Ctrl+d 以保存文件并退出 cat。

将任务定义文件注册到 Amazon ECS

1. 与 CodeCatalystECSUser 一样，在 AWS CloudShell 中，注册任务定义：

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

2. （可选）验证是否已注册任务定义：

   aws ecs list-task-definitions

   codecatalyst-ecs-task-def 任务定义应显示在列表中。

创建 Amazon ECS 服务

Amazon ECS 服务运行 Apache 占位符应用程序的任务（和关联的 Docker 容器），然后运行 Hello World 应用程序的任务。

1. 与 CodeCatalystECSUser 一样，切换到 Amazon Elastic Container Service 控制台（如果您尚未这样做）。

2. 选择您之前创建的集群 codecatalyst-ecs-cluster。

3. 在服务选项卡上，选择创建。

4. 在创建页面上，执行以下操作：

   1. 保留所有默认设置，但接下来列出的设置除外。

   2. 对于 Launch type (启动类型)，选择 FARGATE。

   3. 在任务定义下的系列下拉列表中，选择：

      codecatalyst-ecs-task-def

   4. 对于服务名称，输入：

      codecatalyst-ecs-service

   5. 对于预期任务数，输入：

      3

      在本教程中，每个任务均启动一个 Docker 容器。

   6. 展开联网部分。

   7. 对于 VPC，请选择任意 VPC。

   8. 对于子网，请选择任意子网。

      注意

      仅指定一个子网。这就是本教程要求执行的所有操作。

      注意

      如果您没有 VPC 和子网，请创建它们。请参阅《Amazon VPC 用户指南》中的创建 VPC 和在 VPC 中创建子网。

   9. 对于安全组，选择创建新安全组，然后执行以下操作：

      1. 对于安全组名称，输入：

         codecatalyst-ecs-security-group

      2. 对于安全组描述，输入：

         CodeCatalyst ECS security group

      3. 选择 添加规则。对于类型，选择 HTTP；对于来源，选择任何位置。

   10. 选择底部的创建。

   11. 创建服务时请等待。该过程可能需要几分钟。

5. 选择任务选项卡，然后选择刷新按钮。确认所有三个任务的最后状态列都设置为正在运行。

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

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

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

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

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

在 Amazon ECR 中创建映像存储库

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

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

2. 显示 Amazon ECR 存储库的详细信息：

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

3. 记下 “repositoryUri”: 值，例如 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo。

   稍后在向工作流添加存储库时需要使用它。

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

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

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

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

4. 选择在 AWS 管理控制台中管理角色。

   这将显示将 IAM 角色添加到 Amazon CodeCatalyst 空间页面。您可能需要登录才能访问该页面。

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

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

6. 在该下拉列表中，选择 codecatalyst-ecs-build-role，然后选择添加角色。

   注意

   如果您看到的是 The security token included in the request is invalid，则可能是因为您不具有适当的权限。要解决此问题，请先退出 AWS，然后使用您在创建 CodeCatalyst 空间时所用的 AWS 账户重新登录。

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

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

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

创建源存储库

1. 通过访问 https://codecatalyst.aws/ 打开 CodeCatalyst 控制台。

2. 导航到您的项目 codecatalyst-ecs-project。

3. 在导航窗格中，选择代码，然后选择源存储库。

4. 选择添加存储库，然后选择创建存储库。

5. 在存储库名称中，输入：

   codecatalyst-ecs-source-repository

6. 选择创建。

添加 index.html 文件

1. 在 CodeCatalyst 控制台中，转到您的源存储库 codecatalyst-ecs-source-repository。

2. 在文件中，选择创建文件。

3. 对于文件名，输入：

   public-html/index.html

   重要

   请务必包含 public-html/ 前缀以创建同名文件夹。index.html 应位于此文件夹中。

4. 在文本框中，输入以下代码：

   <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>

5. 选择提交，然后再次选择提交。

   这会将 index.html 添加到存储库中的 public-html 文件夹中。

添加 Dockerfile

1. 在源存储库中，选择创建文件。

2. 对于文件名，输入：

   Dockerfile

   不要包含文件扩展名。

   重要

   Dockerfile 必须位于存储库的根目录文件夹中。工作流的 Docker build 命令期望它在该位置。

3. 在文本框中，输入以下代码：

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

4. 选择提交，然后再次选择提交。

   这会将 Dockerfile 添加到您的存储库中。

添加 taskdef.json 文件

1. 在源存储库中，选择创建文件。

2. 对于文件名，输入：

   taskdef.json

3. 在文本框中，输入以下代码：

   {
       "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_ID:role/codecatalyst-ecs-task-execution-role

   替换为您在创建任务执行角色中记下的任务执行角色的 ARN。

4. 选择提交，然后再次选择提交。

   这会将 taskdef.json 文件添加到您的存储库中。

创建工作流

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

2. 选择创建工作流。

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

4. 对于分支，选择 main。

5. 选择创建。

6. 删除 YAML 示例代码。

7. 添加以下 YAML 代码：

   注意

   在接下来的 YAML 代码中，如果需要，可以省略 Connections: 部分。如果您省略这些部分，则必须确保您环境的默认 IAM 角色字段中指定的角色包含步骤 5：将 AWS 角色添加到 CodeCatalyst中描述的两个角色的权限和信任策略。有关使用默认 IAM 角色设置环境的更多信息，请参阅创建环境。

   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 的两个实例替换为您在先决条件中创建的环境的名称。

   • 将 codecatalyst-account-connection 的两个实例替换为账户连接的显示名称。显示名称可能是数字。有关更多信息，请参阅步骤 5：将 AWS 角色添加到 CodeCatalyst。

   • 将 codecatalyst-ecs-build-role 替换为您在步骤 4：创建 AWS 角色中创建的构建角色的名称。

   • 将 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo（在 Value: 属性中）替换为您在步骤 3：创建 Amazon ECR 映像存储库中创建的 Amazon ECR 存储库的 URI。

   • 将 111122223333.dkr.ecr.us-west-2.amazonaws.com（在 Run: aws ecr 命令中）替换为 Amazon ECR 存储库的 URI（不含映像后缀 /codecatalyst-ecs-image-repo）。

   • 将 codecatalyst-ecs-deploy-role 替换为您在步骤 4：创建 AWS 角色中创建的部署角色的名称。

   • 将 us-west-2 的两个实例替换为 AWS 区域代码。有关区域代码的列表，请参阅《AWS 一般参考》中的 Regional endpoints。

   注意

   如果您决定不创建构建角色和部署角色，请将 codecatalyst-ecs-build-role 和 codecatalyst-ecs-deploy-role 替换为 CodeCatalystWorkflowDevelopmentRole-spaceName 角色的名称。有关该角色的更多信息，请参阅 步骤 4：创建 AWS 角色。

   提示

   您可以使用渲染 Amazon ECS 任务定义操作来更新存储库和映像名称，而不是使用前面的工作流代码中显示的 find 和 sed 命令。有关更多信息，请参阅修改 Amazon ECS 任务定义。

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

9. 选择提交。

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

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

       Add first workflow

    2. 对于存储库，选择 codecatalyst-ecs-source-repository。

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

    4. 选择提交。

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

查看工作流运行进度

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

2. 选择您刚刚创建的工作流：codecatalyst-ecs-workflow。

3. 选择 BuildBackend 以查看构建进度。

4. 选择 DeployToECS 以查看部署进度。

   有关查看运行详细信息的更多信息，请参阅查看工作流运行状态和详细信息。

验证部署

1. 打开 Amazon ECS 经典控制台：https://console.aws.amazon.com/ecs/。

2. 选择您的集群：codecatalyst-ecs-cluster。

3. 选择 Tasks 选项卡。

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

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

   浏览器中会出现“Hello World”页面，这表示 Amazon ECS 服务已成功部署您的应用程序。

更改 index.html

1. 在 CodeCatalyst 控制台的导航窗格中，选择代码，再选择源存储库，然后选择您的存储库：codecatalyst-ecs-source-repository。

2. 选择 public-html，然后选择 index.html。

   这将显示 index.html 的内容。

3. 选择编辑。

4. 在第 14 行上，将 Hello World 文本更改为 Tutorial complete!。

5. 选择提交，然后再次选择提交。

   提交会促使启动新的工作流运行。

6. （可选）转到源存储库的主页，选择查看提交，然后记下 index.html 更改的提交 ID。

7. 查看部署进度：

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

   2. 选择 codecatalyst-ecs-workflow 以查看最新运行。

   3. 选择 BuildBackend 和 DeployToECS 以查看工作流运行进度。

8. 验证是否已更新您的应用程序，如下所示：

   1. 打开 Amazon ECS 经典控制台：https://console.aws.amazon.com/ecs/。

   2. 选择您的集群：codecatalyst-ecs-cluster。

   3. 选择 Tasks 选项卡。

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

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

      此时将显示 Tutorial complete! 页面。

9. （可选）在 AWS 中，切换到 Amazon ECR 控制台，确认已使用步骤 6 中的提交 ID 标记新 Docker 映像。