教程：将应用程序部署到 Amazon ECS - Amazon CodeCatalyst
先决条件 步骤 1：设置 AWS 用户和 AWS CloudShell第 2 步：将占位符应用程序部署到 Amazon ECS步骤 3：创建亚马逊ECR镜像存储库步骤 4：创建生成和部署角色第 5 步：将 AWS 角色添加到 CodeCatalyst步骤 6：创建源存储库步骤 7：添加源文件步骤 8：创建并运行工作流程第 9 步：更改源文件清理

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

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

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

提示

与其完成本教程的学习，不如使用蓝图为您完成完整的Amazon ECS 设置。你需要将 Node.js API 与蓝图一起使用， AWS Fargate或者将 Java API 与 AWS Fargate蓝图一起使用。有关更多信息，请参阅 使用蓝图创建项目。

先决条件

开始前的准备工作：

  • 你需要一个带有关联 AWS 账户的 CodeCatalyst 空间。有关更多信息，请参阅 创建空间。

  • 在你的空间里，你需要一个名为：

    codecatalyst-ecs-project

    使用 “从头开始” 选项来创建此项目。

    有关更多信息，请参阅 在 Amazon 中创建一个空项目 CodeCatalyst。

  • 在你的项目中，你需要一个 CodeCatalyst 名为：

    codecatalyst-ecs-environment

    按如下方式配置此环境：

    • 选择任何类型，例如 “非生产”。

    • 将您的 AWS 账户与之关联。

    • 对于默认IAM角色，请选择任意角色。稍后您将指定其他角色。

    有关更多信息，请参阅 部署到 AWS 账户 和 VPCs。

步骤 1：设置 AWS 用户和 AWS CloudShell

本教程的第一步是在中创建用户 AWS IAM Identity Center，并以该用户的身份启动 AWS CloudShell 实例。在本教程中， CloudShell 是您的开发计算机，也是您配置 AWS 资源和服务的地方。完成教程后删除此用户。

注意

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

有关 Ident IAM ity Center 用户的更多信息 CloudShell，请参阅《AWS IAM Identity Center 用户指南》和《AWS CloudShell 用户指南》。

创建IAM身份中心用户

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

    注意

    请务必使用与您的 CodeCatalyst空间 AWS 账户 相连的登录。您可以通过导航到您的空间并选择 “帐户” 选项卡来验证关联了哪AWS个账户。有关更多信息，请参阅 创建空间。

  2. 在导航窗格中，选择 Users，然后选择 Add user。

  3. 在用户名中，输入：

    CodeCatalystECSUser

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

  5. 在 “电子邮件地址” 和 “确认电子邮件地址” 中，输入 Ident IAM ity Center 中尚不存在的电子邮件地址。

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

    CodeCatalystECSUser

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

    CodeCatalystECSUser CodeCatalystECSUser

  8. 选择下一步。

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

  10. 在查看并添加用户页面上，查看信息并选择添加用户。

    将出现 “一次性密码” 对话框。

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

  12. 选择关闭。

创建权限集

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

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

  2. 选择 “预定义权限集”，然后选择AdministratorAccess。此策略向所有人提供完全权限 AWS 服务。

  3. 选择下一步。

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

    CodeCatalystECSPermissionSet

  5. 选择下一步。

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

将权限集分配给 CodeCatalyst ECSUser

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

  2. 选择分配用户或组。

  3. 选择用户选项卡。

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

  5. 选择下一步。

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

  7. 选择下一步。

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

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

要注销并以身份重新登录 CodeCatalyst ECSUser

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

    注意

    如果您没有此信息，请前往 Ident IAM ity Center 的CodeCatalystECSUser详细信息页面，选择重置密码，生成一次性密码 [...] ，然后再次重置密码以在屏幕上显示信息。

  2. 退出 AWS。

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

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

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

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

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

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

    AWS Management Console 出现了。现在，您已CodeCatalystECSUser使用相应的权限登录。

启动实 AWS CloudShell 例

  1. 在顶部导航栏中，选择 AWS 图标 ( AWS icon )。CodeCatalystECSUser

    的主页 AWS Management Console 随即出现。

  2. 在顶部导航栏中，选择图 AWS CloudShell 标 ( CloudShell icon )。

    CloudShell 打开。等待 CloudShell 环境创建完成。

    注意

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

验证 AWS CLI 是否已安装

  1. 在终 CloudShell 端中输入：

    aws --version

  2. 检查是否出现了版本。

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

第 2 步：将占位符应用程序部署到 Amazon ECS

在本节中，您将手动将占位符应用程序部署到 Amazon ECS。此占位符应用程序将被您的工作流程部署的 Hello World 应用程序所取代。占位符应用程序是 Apache Web 服务器。

有关亚马逊的更多信息ECS，请参阅亚马逊弹性容器服务开发者指南。

完成以下一系列步骤来部署占位符应用程序。

创建任务执行角色

此角色授予 Amazon ECS 代表您API拨打电话的 AWS Fargate 权限。

  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的应出现在列表中，表示已成功创建。

创建任务定义文件

任务定义文件指示运行从中提取的 Apache 2.4 Web 服务器 Docker 镜像 (httpd:2.4)。 DockerHub

  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 弹性容器服务控制台，请切换到该控制台。

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

  3. 在 “服务” 选项卡中，选择 “创建”。

  4. 在 “创建” 页面中，执行以下操作：

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

    2. 对于 “启动类型”，选择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!页面。这表明亚马逊ECS服务成功启动了一项任务，该任务启动了带有 Apache 映像的 Docker 容器。

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

步骤 3：创建亚马逊ECR镜像存储库

在本节中，您将在 Amazon 弹性容器注册表 (AmazonECR) 中创建私有镜像存储库。此存储库存储本教程的 Docker 镜像，该镜像将替换您之前部署的 Apache 占位符镜像。

有关亚马逊的更多信息ECR，请参阅《亚马逊弹性容器注册表用户指南》。

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

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

步骤 4：创建 AWS 角色

在本节中，您将创建 CodeCatalyst 工作流程运行所需的 AWS IAM角色。这些角色是：

  • 构建角色-授予 CodeCatalyst 构建操作（在工作流程中）访问您的 AWS 账户并写入亚马逊ECR和亚马逊的权限EC2。

  • 部署角色-授予 CodeCatalyst 部署到ECS操作（在工作流程中）访问您的 AWS 账户ECS、Amazon 和其他一些 AWS 服务的权限。

有关IAM角色的更多信息，请参阅《AWS Identity and Access Management 用户指南》中的IAM角色。

注意

为了节省时间，您可以创建一个名为角色的CodeCatalystWorkflowDevelopmentRole-spaceName角色，而不是前面列出的两个角色。有关更多信息，请参阅 为您的账户和空间创建CodeCatalystWorkflowDevelopmentRole-spaceName角色。了解该CodeCatalystWorkflowDevelopmentRole-spaceName角色具有非常广泛的权限，这可能会带来安全风险。我们建议您仅在教程和安全性较低的场景中使用此角色。本教程假设您正在创建前面列出的两个角色。

要创建生成和部署角色，您可以使用 AWS Management Console 或 AWS CLI。

AWS Management Console

要创建生成和部署角色，请完成以下一系列步骤。

创建生成角色

  1. 为该角色创建策略，如下所示：

    1. 登录到 AWS。

    2. 从 IAM 打开 https://console.aws.amazon.com/iam/ 控制台。

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

    4. 选择创建策略。

    5. 选择 JSON 选项卡。

    6. 删除现有代码。

    7. 粘贴以下代码：

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

      首次使用该角色运行工作流程操作时，请在资源策略语句中使用通配符，然后在策略可用后使用资源名称缩小策略范围。

      "Resource": "*"

    8. 选择下一步：标签。

    9. 选择下一步：审核。

    10. 在名称中，输入：

      codecatalyst-ecs-build-policy

    11. 选择 创建策略。

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

  2. 创建生成角色，如下所示：

    1. 在导航窗格中，选择 Roles（角色），然后选择 Create role（创建角色）。

    2. 选择自定义信任策略。

    3. 删除现有的自定义信任策略。

    4. 添加以下自定义信任策略：

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

    5. 选择下一步。

    6. 在权限策略中codecatalyst-ecs-build-policy，搜索并选中其复选框。

    7. 选择下一步。

    8. 在 “角色名称” 中，输入：

      codecatalyst-ecs-build-role

    9. 在角色描述中，输入：

      CodeCatalyst ECS build role

    10. 选择 创建角色。

    现在，您已经创建了一个包含权限策略和信任策略的构建角色。

  3. 按如下方式获取构建角色ARN：

    1. 在导航窗格中，选择角色。

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

    3. 从列表中选择角色。

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

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

创建部署角色

  1. 为该角色创建策略，如下所示：

    1. 登录到 AWS。

    2. 从 IAM 打开 https://console.aws.amazon.com/iam/ 控制台。

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

    4. 选择创建策略。

    5. 选择 JSON 选项卡。

    6. 删除现有代码。

    7. 粘贴以下代码：

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

    8. 选择下一步：标签。

    9. 选择下一步：审核。

    10. 在名称中，输入：

      codecatalyst-ecs-deploy-policy

    11. 选择 创建策略。

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

  2. 创建部署角色，如下所示：

    1. 在导航窗格中，选择 Roles（角色），然后选择 Create role（创建角色）。

    2. 选择自定义信任策略。

    3. 删除现有的自定义信任策略。

    4. 添加以下自定义信任策略：

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

    5. 选择下一步。

    6. 在权限策略中codecatalyst-ecs-deploy-policy，搜索并选中其复选框。

    7. 选择下一步。

    8. 在 “角色名称” 中，输入：

      codecatalyst-ecs-deploy-role

    9. 在角色描述中，输入：

      CodeCatalyst ECS deploy role

    10. 选择 创建角色。

    现在，您已经使用信任策略创建了一个部署角色。

  3. 按如下方式获取部署角色ARN：

    1. 在导航窗格中，选择角色。

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

    3. 从列表中选择角色。

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

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

AWS CLI

要创建生成和部署角色，请完成以下一系列步骤。

为两个角色创建信任策略

在中 CodeCatalystECSUser AWS CloudShell，创建信任策略文件：

  1. 创建文件：

    cat > codecatalyst-ecs-trust-policy.json

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

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

  3. 将光标放在最后一个大括号 (}) 之后。

  4. 按下Enter然后Ctrl+d保存文件并退出 cat。

创建生成策略和生成角色

  1. 创建构建策略：

    1. 在中 CodeCatalystECSUser AWS CloudShell，创建生成策略文件：

      cat > codecatalyst-ecs-build-policy.json

    2. 出现提示时，输入以下代码：

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

    3. 将光标放在最后一个大括号 (}) 之后。

    4. 按下Enter然后Ctrl+d保存文件并退出 cat。

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

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

  3. 在命令输出中，记下该"arn":值，例如arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy。你ARN稍后需要这个。

  4. 创建构建角色并将信任策略附加到该角色上：

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

  5. 将构建策略附加到构建角色：

    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的构建策略。

  6. 显示构建角色的详细信息：

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

  7. 请注意角色的"Arn":值，例如arn:aws:iam::111122223333:role/codecatalyst-ecs-build-role。你ARN稍后需要这个。

创建部署策略和部署角色

  1. 创建部署策略：

    1. 在中 AWS CloudShell，创建部署策略文件：

      cat > codecatalyst-ecs-deploy-policy.json

    2. 出现提示时，输入以下代码：

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

    3. 将光标放在最后一个大括号 (}) 之后。

    4. 按下Enter然后Ctrl+d保存文件并退出 cat。

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

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

  3. 在命令输出中，记下部署策略的"arn":值，例如arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy。你ARN稍后需要这个。

  4. 创建 deploy 角色并将信任策略附加到该角色上：

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

  5. 将部署策略附加到部署角色，其中 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

  6. 显示部署角色的详细信息：

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

  7. 请注意角色的"Arn":值，例如arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role。你ARN稍后需要这个。

第 5 步：将 AWS 角色添加到 CodeCatalyst

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

向账户连接中添加构建和部署角色

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

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

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

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

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

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

    将出现一个下拉列表。该列表显示了所有具有信任策略的IAM角色，其中包括codecatalyst-runner.amazonaws.com和codecatalyst.amazonaws.com服务委托人。

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

    注意

    如果你看见The security token included in the request is invalid，可能是因为你没有正确的权限。要解决此问题，请使用您在创建 CodeCatalyst空间时使用的 AWS 账号退出并重新登录。 AWS

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

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

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

步骤 6：创建源存储库

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

有关源存储库的更多信息，请参阅创建源存储库。

创建源存储库

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

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

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

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

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

    codecatalyst-ecs-source-repository

  6. 选择创建。

步骤 7：添加源文件

在本节中，您将将 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。有关更多信息，请参阅 克隆源存储库。

index.html

该index.html文件在浏览器中显示 Hello World 消息。

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

Dockerfile 描述了要使用的基本 Docker 镜像以及要应用于它的 Docker 命令。有关 Dockerfile 的更多信息，请参阅 Dockerfile 参考。

此处指定的 Dockerfile 表示要使用 Apache 2.4 基础镜像 ()。httpd它还包括将名为的源文件复制index.html到提供网页的 Apache 服务器上的文件夹的说明。Dockerfile 中的EXPOSE指令告诉 Docker 容器正在端口 80 上监听。

添加 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 已添加到您的存储库中。

任务定义.json

您在此步骤中添加taskdef.json的文件与您已经在中指定的文件相同，但第 2 步：将占位符应用程序部署到 Amazon ECS有以下区别：

此处的任务定义没有在 (httpd:2.4) image: 字段中指定硬编码的 Docker 映像名称，而是使用几个变量来表示图像：和。$REPOSITORY_URI $IMAGE_TAG当您在后续步骤中运行工作流程时，这些变量将被工作流程的生成操作生成的实际值所取代。

有关任务定义参数的详细信息，请参阅《Amazon 弹性容器服务开发者指南》中的任务定义参数。

添加 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文件已添加到您的存储库中。

步骤 8：创建并运行工作流程

在此步骤中，您将创建一个工作流程，该工作流程用于获取源文件，将其构建为 Docker 映像，然后将该映像部署到您的 Ama ECS zon 集群。此部署取代了现有的 Apache 占位符应用程序。

该工作流由以下按顺序运行的构建块组成：

  • 触发器-当您将更改推送到源存储库时，此触发器会自动启动工作流程运行。有关触发器的更多信息，请参阅启动工作流程使用触发器自动运行。

  • 构建操作 (BuildBackend) — 触发后，该操作使用 Dockerfile 构建 Docker 镜像并将镜像推送到亚马逊。ECR构建操作还会taskdef.json使用正确的image字段值更新，然后创建此文件的输出构件。此构件用作部署操作的输入，接下来是部署操作。

    有关生成操作的更多信息，请参阅使用工作流程进行构建。

  • 部署操作 (DeployToECS)-构建操作完成后，部署操作将查找构建操作 (TaskDefArtifact) 生成的输出项目，找到其taskdef.json内部并将其注册到您的 Amazon ECS 服务。然后，该服务按照taskdef.json文件中的说明在您的亚马逊集群中运行三个亚马逊ECS任务以及关联的 Hello World Docker 容器。ECS

创建工作流

  1. 在 CodeCatalyst 控制台的导航窗格中，选择 C I/CD，然后选择 Workflows。

  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:属性中）使用您在中创建URI的 Amazon ECR 存储库的步骤 3：创建亚马逊ECR镜像存储库。

    • 111122223333.dkr.ecr.us-west-2.amazonaws.com （在Run: aws ecr命令中）使用不带图像后缀 (/codecatalyst-ecs-image-repo) 的 Amazon ECR 存储库。URI

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

    • 两个实例 us-west-2 使用您的 AWS 地区代码。有关区域代码的列表，请参阅中的区域终端节点AWS 一般参考。

    注意

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

    提示

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

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

  9. 选择 Commit (提交)。

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

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

      Add first workflow

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

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

    4. 选择 Commit (提交)。

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

查看工作流程运行进度

  1. 在 CodeCatalyst 控制台的导航窗格中，选择 C I/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” 页面，表示亚马逊ECS服务成功部署了您的应用程序。

第 9 步：更改源文件

在本节中，您将对源存储库中的index.html文件进行更改。此更改会导致工作流程生成新的 Docker 映像，使用提交 ID 对其进行标记，将其推送到亚马逊ECR，然后将其部署到亚马逊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. 在导航窗格中，选择 C I/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 控制台，确认新 Docker 镜像已使用步骤 6 中的提交 ID 进行标记。

清理

清理本教程中使用的文件和服务，以免被收费。

在中 AWS Management Console，按以下顺序进行清理：

  1. 在 Amazon 中ECS，执行以下操作：

    1. 删除codecatalyst-ecs-service。

    2. 删除codecatalyst-ecs-cluster。

    3. 取消注册 codecatalyst-ecs-task-definition。

  2. 在亚马逊中ECR，删除codecatalyst-ecs-image-repo。

  3. 在亚马逊中EC2，删除codecatalyst-ecs-security-group。

  4. 在 “IAM身份中心” 中，删除：

    1. CodeCatalystECSUser

    2. CodeCatalystECSPermissionSet

在 CodeCatalyst 控制台中，按如下方式进行清理：

  1. 删除codecatalyst-ecs-workflow。

  2. 删除codecatalyst-ecs-environment。

  3. 删除codecatalyst-ecs-source-repository。

  4. 删除codecatalyst-ecs-project。

在本教程中，您学习了如何使用 CodeCatalyst 工作流程和 “部署到亚马逊” ECS 操作将应用程序部署到亚马逊ECS服务。