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

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

# 使用工作流进行部署
<a name="deploy"></a>



使用[CodeCatalyst 工作流程](workflow.md)，您可以将应用程序和其他资源部署到各种目标， AWS Lambda例如 Amazon ECS 等。

## 如何部署应用程序？
<a name="deploy-concepts"></a>

要通过部署应用程序或资源 CodeCatalyst，首先要创建一个工作流，然后在其中指定部署操作。*部署操作*是一个工作流程构造块，它定义了要部署的*内容*、部署*位置*以及部署*方式*（例如，使用 blue/green 方案）。您可以使用 CodeCatalyst 控制台的可视化编辑器或 YAML 编辑器向工作流程添加部署操作。

部署应用程序或资源的步骤大致如下。

**部署应用程序（高级别任务）**

1. 在您的 CodeCatalyst 项目中，您可以为要部署的应用程序**添加源代码**。有关更多信息，请参阅 [将源代码存储在项目的存储库中 CodeCatalyst](source-repositories.md)。

1. 在您的 CodeCatalyst 项目中，您可以**添加一个环境**来定义目标 AWS 账户 和要部署到的可选亚马逊虚拟私有云 (VPC)。有关更多信息，请参阅 [部署到 AWS 账户 和 VPCs](deploy-environments.md)。

1. 在您的 CodeCatalyst 项目中，您可以**创建工作流程**。在工作流中，您可以定义如何构建、测试和部署应用程序。有关更多信息，请参阅 [入门工作流](workflows-getting-started.md)。

1. 在工作流中，您可以**添加触发器**、**构建操作**以及（可选）**测试操作**。有关更多信息，请参阅[使用触发器自动启动工作流运行](workflows-add-trigger.md)、[添加构建操作](build-add-action.md)和[添加测试操作](test-add-action.md)。

1. 在工作流中，您可以**添加部署操作**。您可以从 CodeCatalyst提供的多个将应用程序部署到不同目标（例如 Amazon ECS）的操作中进行选择。（您也可以使用生成操作或 GitHub 操作来部署应用程序。 有关生成 GitHub 操作和操作的更多信息，请参阅[部署操作的替代方案](#deploy-concepts-alternatives)。）

1. 您可以手动**启动工作流**，也可以通过触发器自动启动工作流。该工作流按顺序运行构建、测试和部署操作，以将您的应用程序和资源部署到目标。有关更多信息，请参阅 [手动启动工作流运行](workflows-manually-start.md)。

## 部署操作列表
<a name="deploy-concepts-action-supported"></a>

提供了以下部署操作：
+ 部署 CloudFormation 堆栈-此操作 AWS 基于您提供的[CloudFormation 模板或[AWS Serverless Application Model 模板](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html)在中创建 CloudFormation 堆栈。有关更多信息，请参阅 [部署 CloudFormation 堆栈](deploy-action-cfn.md)。
+ 部署到 Amazon ECS – 此操作将注册您提供的[任务定义](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions)文件。有关更多信息，请参阅 [使用工作流部署到 Amazon ECS](deploy-action-ecs.md)。
+ 部署到 Kubernetes 集群 – 此操作将应用程序部署到 Amazon Elastic Kubernetes Service 集群。有关更多信息，请参阅 [使用工作流部署到 Amazon EKS](deploy-action-eks.md)。
+ AWS CDK 部署-此操作将[AWS CDK 应用程序](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_concepts)部署到。 AWS有关更多信息，请参阅 [使用工作流程部署 AWS CDK 应用程序](cdk-dep-action.md)。

**注意**  
还有其他可以部署资源的 CodeCatalyst 操作；但是，它们不被视为*部署*操作，因为它们的部署信息不会显示在 “**环境**” 页面上。要详细了解**环境**页面和查看部署，请参阅[部署到 AWS 账户 和 VPCs](deploy-environments.md)和[查看部署信息](deploy-view-deployment-info.md)。

## 部署操作的优势
<a name="deploy-concepts-why-use"></a>

在工作流中使用部署操作有以下益处：
+ **部署历史记录** – 查看部署历史记录，帮助管理和传达已部署软件中的更改。
+ **可追溯性**-通过 CodeCatalyst 控制台跟踪部署状态，并查看每个应用程序修订的部署时间和地点。
+ **回滚** – 如果出现错误，则自动回滚部署。您还可以配置警报以激活部署回滚。
+ **监控** – 观察工作流的各个阶段的部署进展。
+ **与其他 CodeCatalyst 功能集成** — 存储源代码，然后通过一个应用程序构建、测试和部署源代码。

## 部署操作的替代方案
<a name="deploy-concepts-alternatives"></a>

未强制您使用部署操作，但建议您这样做，因为部署操作可提供上一部分中列明的好处。相反，您可以使用以下[CodeCatalyst 操作](workflows-actions.md#workflows-actions-types-cc)：
+ **构建**操作。

  通常，如果要部署到没有相应的部署操作的目标，或者要对部署过程进行更多控制，则可以使用构建操作。有关使用构建操作来部署资源的更多信息，请参阅[使用工作流进行构建](build-workflow-actions.md)。
+ 一个**GitHub 动作**。

  您可以在 CodeCatalyst 工作流程中使用[GitHub 操作](workflows-actions.md#workflows-actions-types-github)来部署应用程序和资源（而不是 CodeCatalyst操作）。有关如何在 CodeCatalyst 工作流程中使用 GitHub 操作的信息，请参阅 [与 GitHub 操作集成](integrations-github-actions.md)

如果您不想使用 CodeCatalyst 工作流程来部署应用程序，也可以使用以下 AWS 服务来部署应用程序：
+ AWS CodeDeploy — 看看[什么是 CodeDeploy？](https://docs.aws.amazon.com/codedeploy/latest/userguide/welcome.html)
+ AWS CodeBuild 而且 AWS CodePipeline — 参见[什么是 AWS CodeBuild？](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html) [还有什么 AWS CodePipeline？](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)
+ CloudFormation — 看看[什么是 CloudFormation？](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)

使用 CodeDeploy、 CodeBuild CodePipeline、和 CloudFormation 服务进行复杂的企业部署。

**Topics**
+ [如何部署应用程序？](#deploy-concepts)
+ [部署操作列表](#deploy-concepts-action-supported)
+ [部署操作的优势](#deploy-concepts-why-use)
+ [部署操作的替代方案](#deploy-concepts-alternatives)
+ [使用工作流部署到 Amazon ECS](deploy-action-ecs.md)
+ [使用工作流部署到 Amazon EKS](deploy-action-eks.md)
+ [部署 CloudFormation 堆栈](deploy-action-cfn.md)
+ [使用工作流程部署 AWS CDK 应用程序](cdk-dep-action.md)
+ [使用工作流程引导 AWS CDK 应用程序](cdk-boot-action.md)
+ [使用工作流将文件发布到 Amazon S3](s3-pub-action.md)
+ [部署到 AWS 账户 和 VPCs](deploy-environments.md)
+ [在工作流图中显示应用程序 URL](deploy-app-url.md)
+ [移除部署目标](deploy-remove-target.md)
+ [通过提交跟踪部署状态](track-changes.md)
+ [查看部署日志](deploy-deployment-logs.md)
+ [查看部署信息](deploy-view-deployment-info.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 部署描述**

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

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

本节介绍如何使用工作流程将容器化应用程序部署到 Kubernetes 集群中。 CodeCatalyst 为此，您必须将**部署到 Kubernetes 集群**操作添加到工作流。此操作使用一个或多个 Kubernetes 清单文件将您的应用程序部署到您在 Amazon Elastic Kubernetes Service（EKS）中设置的 Kubernetes 集群。有关示例清单，请参阅[教程：将应用程序部署到 Amazon EKS](deploy-tut-eks.md) 中的 [部署 .yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml)。

有关 Kubernetes 的更多信息，请参阅 [Kubernetes 文档](https://kubernetes.io/docs/home/)。

有关 Amazon EKS 的更多信息，请参阅《Amazon EKS 用户指南》**中的[什么是 Amazon EKS？](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html)

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

## “部署到 Kubernetes 集群”操作的工作原理
<a name="deploy-action-eks-howitworks"></a>

**部署到 Kubernetes 集群**操作的工作原理如下：

1. 在运行时，该操作将 Kubernetes `kubectl` 实用程序安装到运行该操作的 CodeCatalyst计算机上。该操作将 `kubectl` 配置为指向您在配置该操作时提供的 Amazon EKS 集群。接下来，`kubectl` 实用工具是运行 `kubectl apply` 命令所必需的。

1. 该操作运行`kubectl apply -f my-manifest.yaml`命令，该命令执行中的说明，将您的应用程序作为一组容器和容器部署*my-manifest.yaml*到已配置的集群中。有关此命令的更多信息，请参阅《Kubernetes 参考文档》**中的 [kubectl 应用](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply)主题。

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

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

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

在本教程中，您将学习如何使用亚马逊工作流程、Amazon EKS 和其他一些服务将容器化应用程序部署到亚马逊 Elastic Kubernetes S CodeCatalyst ervice 中。 AWS 部署的应用程序是简单“Hello, World\$1” 基于 Apache Web 服务器 Docker 映像构建的网站。本教程将引导您完成所需的准备工作（例如设置开发机器和 Amazon EKS 集群），然后介绍如何创建用于构建应用程序并将其部署到集群中的工作流。

初始部署完成后，本教程将指导您对应用程序源进行更改。此更改会构建新的 Docker 映像并将其与新修订信息一起推送到 Docker 映像存储库。之后，Docker 映像的新修订将部署到 Amazon EKS 中。

**提示**  
您可以使用蓝图来执行完整的 Amazon EKS 设置，而不是按照本教程的说明操作。您将需要使用 **EKS 应用程序部署**蓝图。有关更多信息，请参阅 [使用蓝图创建项目](projects-create.md#projects-create-console-template)。

**Topics**
+ [先决条件](#deploy-tut-eks-prereqs)
+ [步骤 1：设置开发机器](#deploy-tut-eks-dev-env-create)
+ [步骤 2：创建 Amazon EKS 集群](#deploy-tut-eks-cluster)
+ [步骤 3：创建 Amazon ECR 映像存储库](#deploy-tut-eks-ecr)
+ [步骤 4：添加源文件](#deploy-tut-eks-source-files)
+ [步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)
+ [步骤 6：将 AWS 角色添加到 CodeCatalyst](#deploy-tut-eks-import-roles)
+ [步骤 7：更新 ConfigMap](#deploy-tut-eks-configmap)
+ [步骤 8：创建并运行工作流](#deploy-tut-eks-workflow)
+ [步骤 9：对源文件进行更改](#deploy-tut-eks-change)
+ [清理](#deploy-tut-eks-cleanup)

## 先决条件
<a name="deploy-tut-eks-prereqs"></a>

在开始本教程之前：
+ 您需要一个带有关联 AWS 账户的 Amazon CodeCatalyst **空间**。有关更多信息，请参阅 [创建空间](spaces-create.md)。
+ 在您的空间中，您需要一个空项目，其名称为：

  ```
  codecatalyst-eks-project
  ```

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

  有关更多信息，请参阅 [在 Amazon 中创建一个空项目 CodeCatalyst](projects-create.md#projects-create-empty)。
+ 在你的项目中，你需要一个名为：的空 CodeCatalyst **源代码库**

  ```
  codecatalyst-eks-source-repository
  ```

  有关更多信息，请参阅 [使用源存储库存储代码并协作处理代码 CodeCatalyst使用源存储库存储代码并进行协作](source.md)。
+ 在你的项目中，你需要一个 C CodeCatalyst I/CD **环境**（不是开发环境），名为：

  ```
  codecatalyst-eks-environment
  ```

  按如下方式配置此环境：
  + 选择任何类型，例如**非生产**。
  + 将您的 AWS 账户与之关联。
  + 对于**默认 IAM 角色**，选择任何角色。稍后需要指定另一个角色。

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

## 步骤 1：设置开发机器
<a name="deploy-tut-eks-dev-env-create"></a>

本教程中的第一步是使用将在本教程中使用的几种工具来配置开发机器。这些工具是：
+ `eksctl` 实用工具 – 用于创建集群
+ `kubectl` 实用工具 – `eksctl` 的先决条件
+ 这 AWS CLI 个 — 也是前提条件 `eksctl`

如果有的话，可以在现有的开发计算机上安装这些工具，也可以使用基于云的 CodeCatalyst 开发环境。 CodeCatalyst 开发环境的好处是，它易于启动和关闭，并且与其他 CodeCatalyst 服务集成，因此您可以用更少的步骤完成本教程。

本教程假设你将使用 CodeCatalyst 开发环境。

以下说明描述了启动 CodeCatalyst 开发环境并使用所需工具对其进行配置的快速方法，但如果您需要详细说明，请参阅：
+ 本指南中的[创建开发环境](devenvironment-create.md)。
+ 《Amazon EKS 用户指南》****中的[安装 kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)。
+ 《Amazon EKS 用户指南》****中的[安装或升级 eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html)。
+ 《AWS Command Line Interface User Guide》**中的 [Installing or updating the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)。

**启动开发环境**

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

1. 导航到您的项目 `codecatalyst-eks-project`。

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

1. 选择您的源存储库的名称：`codecatalyst-eks-source-repository`。

1. 在顶部附近，选择**创建开发环境**，然后选择 **AWS Cloud9 (在浏览器中)**。

1. 确保选中**在现有分支中工作**和**主要**，然后选择**创建**。

   您的开发环境将在新的浏览器标签页中启动，并且您的存储库（`codecatalyst-eks-source-repository`）将克隆到其中。

**安装和配置 kubectl**

1. 在开发环境终端中，输入：

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. 输入：

   ```
   chmod +x ./kubectl
   ```

1. 输入：

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. 输入：

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. 输入：

   ```
   kubectl version --short --client
   ```

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

   您现在已安装 `kubectl`。

**安装和配置 eksctl**
**注意**  
`eksctl` 不是硬性要求，因为您可以改用 `kubectl`。不过，`eksctl` 的优势在于能够自动执行大部分集群配置，因此建议在本教程中使用此工具。

1. 在开发环境终端中，输入：

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. 输入：

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. 输入：

   ```
   eksctl version
   ```

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

   您现在已安装 `eksctl`。

**验证 AWS CLI 是否已安装**

1. 在开发环境终端中，输入：

   ```
   aws --version
   ```

1. 检查是否显示了版本以验证 AWS CLI 是否已安装。

   完成其余步骤，为 AWS CLI 其配置必要的访问权限 AWS。

**要配置 AWS CLI**

您必须 AWS CLI 使用访问密钥和会话令牌配置才能使其访问 AWS 服务。以下说明提供了配置密钥和令牌的快速方法，但如果您需要详细说明，请参阅《AWS Command Line Interface User Guide》**中的 [Configuring the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)。

1. 按如下方式创建 IAM Identity Center 用户：

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

      （如果您之前从未登录过 IAM Identity Center，则可能需要选择**启用**。）
**注意**  
请务必使用与您的 CodeCatalyst空间 AWS 账户 相连的登录。您可以通过导航到您的空间并选择 **AWS 账户**选项卡来确认已连接哪个账户。有关更多信息，请参阅 [创建空间](spaces-create.md)。

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

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

      ```
      codecatalyst-eks-user
      ```

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

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

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

      ```
      codecatalyst-eks-user
      ```

   1. 在**姓氏**中，输入：

      ```
      codecatalyst-eks-user
      ```

   1. 在**显示名称**中，保留：

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

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

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

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

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

   1. 选择**复制**，然后将登录信息粘贴到文本文件中。登录信息由 AWS 访问门户 URL、用户名和一次性密码组成。

   1. 选择**关闭**。

1. 按如下所示创建权限集：

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

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

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

   1. 在**权限集名称**中，移除 `AdministratorAccess` 并输入：

      ```
      codecatalyst-eks-permission-set
      ```

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

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

1. 按如下方式将权限集分配给 `codecatalyst-eks-user`：

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

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

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

   1. 选中 `codecatalyst-eks-user` 旁边的复选框。

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

   1. 选中 `codecatalyst-eks-permission-set` 旁边的复选框。

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

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

      现在，你已经`codecatalyst-eks-permission-set`将`codecatalyst-eks-user`和分配给你的 AWS 账户，将它们绑定在一起。

1. 按如下方式获取 `codecatalyst-eks-user` 的访问密钥和会话令牌：

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

   1. 退出 AWS。

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

   1. 使用以下项进行登录：
      + **用户名**：

        ```
        codecatalyst-eks-user
        ```
      + **密码**：

        *one-time-password*

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

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

   1. 选择 **AWS 账户**，然后选择您为其分配了 `codecatalyst-eks-user` 用户和权限集的 AWS 账户 的名称。

   1. 在 `codecatalyst-eks-permission-set` 旁边，选择**命令行访问或以编程方式访问**。

   1. 复制页面中间的命令。其内容与以下内容类似：

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ... 其中*session-token*是一个长随机字符串。

1. 将访问密钥和会话令牌添加到 AWS CLI，如下所示：

   1. 返回您的 CodeCatalyst 开发环境。

   1. 在终端提示符处，粘贴您复制的命令。按 Enter。

      现在，您已经为配置 AWS CLI 了访问密钥和会话令牌。现在，您可以使用 AWS CLI 来完成本教程要求的任务。
**重要**  
在本教程中，如果您在任何时候看到与以下内容类似的消息：  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
或：  
`ExpiredToken: The security token included in the request is expired`  
... 这是因为您的 AWS CLI 会话已过期。在此情况下，请*不要*运行 `aws configure` 命令。相反，请按照本过程的步骤 4（以 `Obtain codecatalyst-eks-user's access key and session token` 开头）中的说明操作来刷新会话。

## 步骤 2：创建 Amazon EKS 集群
<a name="deploy-tut-eks-cluster"></a>

在此部分中，您将在 Amazon EKS 中创建集群。以下说明介绍使用 `eksctl` 创建集群的快速方法，但如果您需要详细说明，请参阅：
+ 《Amazon EKS 用户指南》****中的[开始使用 eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)

  或者
+ 《Amazon EKS 用户指南》****中的[开始使用控制台和 AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html)（本主题提供用于创建集群的 `kubectl` 指令） 

**注意**  
与 Amazon EKS 的 CodeCatalyst 集成不支持@@ [私有集群](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html)。

**开始之前**

确保您已在开发机器上完成以下任务：
+ 已安装 `eksctl` 实用工具。
+ 已安装 `kubectl` 实用工具。
+ 已安装 AWS CLI 并使用访问密钥和会话令牌对其进行配置。

有关如何完成这些任务的信息，请参阅[步骤 1：设置开发机器](#deploy-tut-eks-dev-env-create)。

**创建集群**
**重要**  
请勿使用 Amazon EKS 服务的用户界面来创建集群，因为这将无法正确配置集群。执行以下步骤来使用 `eksctl` 实用工具。

1. 转到您的开发环境。

1. 创建集群和节点：

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   其中：
   + *codecatalyst-eks-cluster*已替换为您要为集群命名的名称。
   + *us-west-2*已替换为您所在的地区。

   10-20 分钟后，将显示与以下内容类似的消息：

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**注意**  
在 AWS 创建集群时，您将看到多条 `waiting for CloudFormation stack` 消息。这是预期行为。

1. 验证是否已成功创建集群：

   ```
   kubectl cluster-info
   ```

   您将看到与以下内容类似的消息，这表示已成功创建集群：

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

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

在此部分中，您将在 Amazon Elastic Container Registry（Amazon ECR）中创建私有映像存储库。此存储库将存储教程的 Docker 映像。

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

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

1. 转到您的开发环境。

1. 在 Amazon ECR 中创建一个空存储库：

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

   *codecatalyst-eks-image-repo*替换为您想要为 Amazon ECR 存储库提供的名称。

   本教程假定您已将存储库命名为 `codecatalyst-eks-image-repo`。

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

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

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

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

## 步骤 4：添加源文件
<a name="deploy-tut-eks-source-files"></a>

在此部分中，您将应用程序源文件添加到源存储库（`codecatalyst-eks-source-repository`）。它们包括：
+ `index.html` 文件 – 在浏览器中显示“Hello, World\$1” 消息。
+ Dockerfile – 描述用于 Docker 映像的基本映像以及应用于该映像的 Docker 命令。
+ `deployment.yaml` 文件 – 定义 Kubernetes 服务和部署的 Kubernetes 清单。

文件夹结构如下所示：

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [部署 .yaml](#deploy-tut-eks-source-files-deployment-yml)

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

`index.html` 文件在浏览器中显示“Hello, World\$1” 消息。

**添加 index.html 文件**

1. 转到您的开发环境。

1. 在 `codecatalyst-eks-source-repository` 中，创建一个名为 `public-html` 的文件夹。

1. 在 `/public-html` 中，创建一个名为 `index.html` 的包含以下内容的文件：

   ```
   <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. 在终端提示符下，输入：

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. 添加、提交和推送：

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

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

### Dockerfile
<a name="deploy-tut-eks-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. 在 `codecatalyst-eks-source-repository` 中，创建一个名为 `Dockerfile` 的包含以下内容的文件：

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

   不要包含文件扩展名。
**重要**  
Dockerfile 必须位于存储库的根目录文件夹中。工作流的 `Docker build` 命令期望它在该位置。

1. 添加、提交和推送：

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

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

### 部署 .yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

在此部分中，您将 `deployment.yaml` 文件添加到存储库。`deployment.yaml` 文件是一个 Kubernetes 清单，它定义两种要运行的 Kubernetes 资源类型或*类别*：“服务”和“部署”。
+ “服务”将负载均衡器部署到 Amazon EC2 中。负载均衡器为您提供面向 Internet 的公有 URL 和标准端口（端口 80），您可以使用它们浏览找到“Hello, World\$1” 应用程序的修订。
+ “部署”部署三个容器组（pod），每个容器组（pod）将包含一个带“Hello, World\$1”的 Docker 容器 应用程序的修订。这三个容器组（pod）将部署到您创建集群时创建的节点上。

本教程中的清单较短；但清单可以包含任意数量的 Kubernetes 资源类型，例如容器组（pod）、作业、入口和网络策略。此外，如果您的部署复杂，则可以使用多个清单文件。

**添加 deployment.yaml 文件**

1. 在 `codecatalyst-eks-source-repository` 中，创建一个名为 `Kubernetes` 的文件夹。

1. 在 `/Kubernetes` 中，创建一个名为 `deployment.yaml` 的包含以下内容的文件：

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. 添加、提交和推送：

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   这会将 `deployment.yaml` 文件添加到存储库中名为 `Kubernetes` 的文件夹中。

现在，您已添加所有源文件。

请花点时间仔细检查您的工作，确保已将所有文件置于正确的文件夹中。文件夹结构如下所示：

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## 步骤 5：创建 AWS 角色
<a name="deploy-tut-eks-roles"></a>

在本节中，您将创建 CodeCatalyst 工作流程运行所需的 AWS IAM 角色。这些角色是：
+ **构建角色**-授予 CodeCatalyst 构建操作（在工作流程中）访问您的 AWS 账户并写入 Amazon ECR 和 Amazon EC2 的权限。
+ **部署角色** — **向 CodeCatalyst 部署到 Kubernetes 集群**操作（在工作流程中）授予访问您的账户 AWS 和 Amazon EKS 的权限。

有关 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` 角色具有非常广泛的权限，这可能会带来安全风险。我们建议您仅在教程和安全要求较低的场景中使用此角色。本教程假定您创建的是前面列出的两个角色。

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

**1. 为两个角色创建信任策略**

1. 转到您的开发环境。

1. 在 `Cloud9-long-string` 目录中，创建一个名为 `codecatalyst-eks-trust-policy.json` 的包含以下内容的文件：

**2. 为构建角色创建构建策略**
+ 在 `Cloud9-long-string` 目录中，创建一个名为 `codecatalyst-eks-build-policy.json` 的包含以下内容的文件：

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

****  

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

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

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

**3. 为部署角色创建部署策略**
+ 在 `Cloud9-long-string` 目录中，创建一个名为 `codecatalyst-eks-deploy-policy.json` 的包含以下内容的文件：

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

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

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

现在，您已将三个策略文档添加到开发环境。现在，您的目录结构应如下所示：

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. 将生成策略添加到 AWS**

1. 在开发环境终端中，输入：

   ```
   cd /projects
   ```

1. 输入：

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

1. 按 **Enter** 键。

1. 在命令输出中，记下 `"arn":` 值，例如 `arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy`。稍后您将需要此 ARN。

**5. 将部署策略添加到 AWS**

1. 输入：

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

1. 按 **Enter** 键。

1. 在命令输出中，记下部署策略的 `"arn":` 值，例如 `arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy`。稍后您将需要此 ARN。

**6. 创建构建角色**

1. 输入：

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

1. 按 **Enter** 键。

1. 输入：

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

   其中*arn:aws:iam::111122223333:policy/codecatalyst-eks-build-policy*，替换为你之前提到的构建策略的 ARN。

1. 按 **Enter** 键。

1. 在终端提示符下，输入：

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

1. 按 **Enter** 键。

1. 请记下角色的 `"Arn":` 值，例如 `arn:aws:iam::111122223333:role/codecatalyst-eks-build-role`。稍后您将需要此 ARN。

**7. 创建部署角色**

1. 输入：

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

1. 按 **Enter** 键。

1. 输入：

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

   其中*arn:aws:iam::111122223333:policy/codecatalyst-eks-deploy-policy*，替换为你之前提到的部署策略的 ARN。

1. 按 **Enter** 键。

1. 输入：

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

1. 按 **Enter** 键。

1. 请记下角色的 `"Arn":` 值，例如 `arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role`。稍后您将需要此 ARN。

现在，您已经创建了生成和部署角色并记下了它们 ARNs。

## 步骤 6：将 AWS 角色添加到 CodeCatalyst
<a name="deploy-tut-eks-import-roles"></a>

在此步骤中，将构建角色 (`codecatalyst-eks-build-role`) 和部署角色 (`codecatalyst-eks-deploy-role`) 添加到连接到空间 AWS 账户 的角色中。这将使这两个角色能够在工作流中使用。

**向您的添加生成和部署角色 AWS 账户**

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

1. 在顶部，选择**设置**。

1. 在导航窗格中，选择 **AWS 账户**。这将显示账户列表。

1. 在 **Amazon CodeCatalyst 显示名称**列中，复制您创建构建和部署角色的显示名称。 AWS 账户 （它可能是一个数字。） 您稍后在创建工作流时将需要此值。

1. 选择该显示名称。

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

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

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

   这将显示一个下拉列表。该列表显示构建角色和部署角色，以及任何其他具有包含 `codecatalyst-runner.amazonaws.com` 和 `codecatalyst.amazonaws.com` 服务主体的信任策略的 IAM 角色。

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

1. 返回 CodeCatalyst 控制台并刷新页面。

   现在，构建角色和部署角色应显示在 **IAM 角色**下。

   这些角色现在可以在工作 CodeCatalyst 流程中使用。

## 步骤 7：更新 ConfigMap
<a name="deploy-tut-eks-configmap"></a>

您必须将您在[步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)中创建的部署角色添加到 Kubernetes `ConfigMap` 文件中，这样**部署到 Kubernetes 集群**操作（在工作流中）才能访问您的集群并与之交互。您可以使用 `eksctl` 或 `kubectl` 来执行此任务。

**使用 eksctl 配置 Kubernetes 文件 ConfigMap**
+ 在开发环境终端中，输入：

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  其中：
  + *codecatalyst-eks-cluster*已替换为 Amazon EKS 集群的集群名称。
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*将替换为您在中创建的部署角色的 ARN。[步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)
  +  *codecatalyst-eks-deploy-role*（旁边的`--username`）将替换为您在中创建的部署角色的名称[步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)。
**注意**  
如果您决定不创建部署角色，请*codecatalyst-eks-deploy-role*替换为该`CodeCatalystWorkflowDevelopmentRole-spaceName`角色的名称。有关该角色的更多信息，请参阅[步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)。
  +  *us-west-2*已替换为您所在的地区。

  有关此命令的详细信息，请参阅 [Manage IAM users and roles](https://eksctl.io/usage/iam-identity-mappings/)。

  这将显示一条与以下内容类似的消息：

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**使用 kubectl 配置 Kubernetes 文件 ConfigMap**

1. 在开发环境终端中，输入：

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

    ConfigMap 文件出现在屏幕上。

1. 添加红色斜体文本：

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   其中：
   +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*将替换为您在中创建的部署角色的 ARN。[步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)
   +  *codecatalyst-eks-deploy-role*（旁边的`username:`）将替换为您在中创建的部署角色的名称[步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)。
**注意**  
如果您决定不创建部署角色，请*codecatalyst-eks-deploy-role*替换为该`CodeCatalystWorkflowDevelopmentRole-spaceName`角色的名称。有关该角色的更多信息，请参阅[步骤 5：创建 AWS 角色](#deploy-tut-eks-roles)。

   有关详细信息，请参阅《Amazon EKS 用户指南》****中的[让 IAM 主体访问您的集群](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html)。

现在，您已向部署角色以及**部署到 Amazon EKS** 操作对您的 Kubernetes 集群的 `system:masters` 权限。

## 步骤 8：创建并运行工作流
<a name="deploy-tut-eks-workflow"></a>

在此步骤中，您将创建一个工作流来提取源文件，将源文件构建到 Docker 映像中，然后将该映像部署到 Amazon EKS 集群中的三个容器组（pod）中。

工作流包含以下按顺序运行的构造块：
+ 触发器 – 当您将更改推送到源存储库时，此触发器会自动启动工作流运行。有关触发器的更多信息，请参阅[使用触发器自动启动工作流运行](workflows-add-trigger.md)。
+ 构建操作（`BuildBackend`）– 此操作在触发后会使用 Dockerfile 构建 Docker 映像并将该映像推送到 Amazon ECR。构建操作还使用正确的值更新 `deployment.yaml` 文件中的 `$REPOSITORY_URI` 和 `$IMAGE_TAG` 变量，然后创建此文件的输出构件并在 `Kubernetes` 文件夹中创建任何其他文件。在本教程中，`Kubernetes` 文件夹仅包含 `deployment.yaml` 文件，但您可以包含更多文件。此构件将用作接下来的部署操作的输入。

  有关构建操作的更多信息，请参阅[使用工作流进行构建](build-workflow-actions.md)。
+ 部署操作（`DeployToEKS`）– 构建操作完成后，部署操作将查找构建操作（`Manifests`）所生成的输出构件，并查找其中包含的 `deployment.yaml` 文件。之后，该操作按照 `deployment.yaml` 文件中的指令运行三个容器组（pod），每个容器组（pod）包含一个“Hello, World\$1” Docker 容器 – 在 Amazon EKS 集群中。

**创建工作流**

1. 转到 CodeCatalyst 控制台。

1. 导航到您的项目（`codecatalyst-eks-project`）。

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

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

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

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

1. 选择**创建**。

1. 删除 YAML 示例代码。

1. 添加以下 YAML 代码以创建新的工作流定义文件：
**注意**  
有关工作流定义文件的更多信息，请参阅[工作流 YAML 定义](workflow-reference.md)。
**注意**  
在接下来的 YAML 代码中，如果需要，可以省略 `Connections:` 部分。如果您省略这些部分，则必须确保您环境的**默认 IAM 角色**字段中指定的角色包含[步骤 6：将 AWS 角色添加到 CodeCatalyst](#deploy-tut-eks-import-roles)中描述的两个角色的权限和信任策略。有关使用默认 IAM 角色设置环境的更多信息，请参阅[创建环境](deploy-environments-creating-environment.md)。

   ```
   Name: codecatalyst-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-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 deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

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

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

1. 选择**提交**。

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

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

      ```
      Add first workflow
      ```

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

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

   1. 选择**提交**。

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

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

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

1. 选择您刚刚创建的工作流：`codecatalyst-eks-workflow`。

1. 选择**BuildBackend**查看构建进度。

1. 选择 **DeployToEKS** 以查看部署进度。

   有关查看运行详细信息的更多信息，请参阅[查看工作流运行状态和详细信息](workflows-view-run.md)。

**验证部署**

1. 打开位于 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 的 Amazon EC2 控制台。

1. 在底部左侧附近，选择**负载均衡器**。

1. 选择已在 Kubernetes 部署过程中创建的负载均衡器。如果您无法确定要选择哪个负载均衡器，请在**标签**选项卡下查找以下标签：
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. 选定正确的负载均衡器后，选择**描述**选项卡。

1. 将 **DNS 名称**值复制并粘贴到浏览器的地址栏中。

   “Hello, World\$1” 网页将显示在浏览器中，这表示您已成功部署应用程序。

## 步骤 9：对源文件进行更改
<a name="deploy-tut-eks-change"></a>

在此部分中，您将对源存储库中的 `index.html` 文件进行更改。此更改会促使工作流构建新的 Docker 映像，使用提交 ID 对它进行标记，将它推送到 Amazon ECR，然后将它部署到 Amazon ECS。

**更改 index.html**

1. 转到您的开发环境。

1. 在终端提示符下，更改为您的源存储库：

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  拉取最新的工作流更改：

   ```
   git pull
   ```

1. 打开 `codecatalyst-eks-source-repository/public-html/index.html`。

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

1. 添加、提交和推送：

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   工作流运行将自动启动。

1. （可选）输入：

   ```
   git show HEAD
   ```

   记下 `index.html` 更改的提交 ID。这将使用此提交 ID 标记将由您刚刚启动的工作流运行部署的 Docker 映像。

1. 查看部署进度：

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

   1. 选择 `codecatalyst-eks-workflow` 以查看最新运行。

   1. 选择 **BuildBackend**，然后选择 **DeployToEKS** 以查看工作流程的运行进度。

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

   1. 打开位于 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 的 Amazon EC2 控制台。

   1. 在底部左侧附近，选择**负载均衡器**。

   1. 选择已在 Kubernetes 部署过程中创建的负载均衡器。

   1. 将 **DNS 名称**值复制并粘贴到浏览器的地址栏中。

      “Tutorial Complete\$1” 网页将显示在浏览器中，这表示您已成功部署新版本的应用程序。

1. （可选）在中 AWS，切换到 Amazon ECR 控制台，确认新 Docker 映像已使用此过程步骤 7 中的提交 ID 进行标记。

## 清理
<a name="deploy-tut-eks-cleanup"></a>

您应清理环境，以免因本教程使用的存储和计算资源而产生不必要的费用。

**清理**

1. 删除集群：

   1. 在开发环境终端中，输入：

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     其中：
     + *us-west-2*已替换为您所在的地区。
     + *codecatalyst-eks-cluster*将替换为您创建的集群的名称。

     5-10 分钟后，集群和相关资源将被删除，包括但不限于 CloudFormation 堆栈、节点组（在 Amazon EC2 中）和负载均衡器。
**重要**  
如果该`eksctl delete cluster`命令不起作用，则可能需要刷新您的 AWS 凭据或`kubectl`凭据。如果您不确定要刷新哪些凭据，请先刷新 AWS 凭据。要刷新您的 AWS 凭证，请参阅[如何修复 “找不到凭证” 和 “ExpiredToken” 错误？](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks)。要刷新您的 `kubectl` 凭证，请参阅[如何修复“无法连接到服务器”错误？](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks)。

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

   1. 在 Amazon ECR 中，删除 `codecatalyst-eks-image-repo`。

   1. 在 IAM Identity Center 中，删除：

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. 在 IAM 中，删除：
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

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

   1. 删除 `codecatalyst-eks-workflow`。

   1. 删除 `codecatalyst-eks-environment`。

   1. 删除 `codecatalyst-eks-source-repository`。

   1. 删除您的开发环境。

   1. 删除 `codecatalyst-eks-project`。

在本教程中，您学习了如何使用 CodeCatalyst 工作流程和部署到 **Kubernetes 集群操作将应用程序部署到 Amazon EK** S 服务。

# 添加“部署到 Kubernetes 集群”操作
<a name="deploy-action-eks-adding"></a>

按照以下说明操作，将**部署到 Kubernetes 集群**操作添加到工作流。

**开始之前**

在将**部署到 Kubernetes 集群**操作添加到工作流之前，您必须做好以下准备：

**提示**  
要快速设置这些先决条件，请按照[教程：将应用程序部署到 Amazon EKS](deploy-tut-eks.md) 中的说明进行操作。
+ Amazon EKS 中的 Kubernetes 集群。有关集群的信息，请参阅《Amazon EKS 用户指南》****中的 [Amazon EKS 集群](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html)。
+ 至少一个 Dockerfile，它描述如何将您的应用程序组装成 Docker 映像。有关 Dockerfile 的更多信息，请参阅 [Dockerfile reference](https://docs.docker.com/engine/reference/builder/)。
+ 至少一个 Kubernetes 清单文件，该文件在 Kubernetes 文档中称作*配置文件*或*配置*。有关更多信息，请参阅 Kubernetes 文档中的[管理资源](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/)。
+ 一个 IAM 角色，它可让**部署到 Kubernetes 集群**操作访问您的 Amazon EKS 集群并与之交互。有关更多信息，请参阅[“部署到 Kubernetes 集群”操作 YAML](deploy-action-ref-eks.md) 中的[Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role)主题。

  创建此角色后，您必须将它添加到：
  + 你的 Kubernetes 文件 ConfigMap 。要了解如何向 ConfigMap 文件添加角色，请参阅 A **mazon EKS 用户指南**中的[启用 IAM 委托人访问您的集群](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html)。
  + CodeCatalyst。 要了解如何向添加 IAM 角色 CodeCatalyst，请参阅[将 IAM 角色添加到账户连接](ipa-connect-account-addroles.md)。
+  CodeCatalyst 空间、项目和环境。空间和环境都必须与要部署应用程序的 AWS 账户相关联。有关更多信息，请参阅 [创建空间](spaces-create.md)、[在 Amazon 中创建一个空项目 CodeCatalyst](projects-create.md#projects-create-empty) 和 [部署到 AWS 账户 和 VPCs](deploy-environments.md)。
+ 支持的源存储库 CodeCatalyst。存储库将存储您的应用程序源文件、Dockerfile 和 Kubernetes 清单。有关更多信息，请参阅 [使用源存储库存储代码并协作处理代码 CodeCatalyst使用源存储库存储代码并进行协作](source.md)。

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

**使用可视化编辑器添加“部署到 Kubernetes 集群”操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

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

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

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

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

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

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

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

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

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

**使用 YAML 编辑器添加“部署到 Kubernetes 集群”操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择 **YAML**。

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

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

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

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

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

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

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

------

# “部署到 Kubernetes 集群”变量
<a name="deploy-action-eks-variables"></a>

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

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


| 键 | 值 | 
| --- | --- | 
|  cluster  |  在工作流运行期间部署到的 Amazon EKS 集群的 Amazon 资源名称（ARN）。 示例：`arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  deployment-platform  |  部署平台的名称。 硬编码为 `AWS:EKS`。  | 
|  元数据  |  预留。与工作流运行期间部署的集群相关的 JSON 格式的元数据。  | 
|  namespace  |  已将集群部署到的 Kubernetes 命名空间。 示例：`default`  | 
|  resources  |  预留。与工作流运行期间部署的资源相关的 JSON 格式的元数据。  | 
|  server  |  API 服务器端点的名称，可使用管理工具（例如 `kubectl`）通过此端点与集群进行通信。 有关更多信息，请参阅《Amazon EKS 用户指南》****中的 [Amazon EKS 集群端点访问控制](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html)。 示例：`https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# “部署到 Kubernetes 集群”操作 YAML
<a name="deploy-action-ref-eks"></a>

下面是**部署到 Kubernetes 集群**操作的 YAML 定义。要了解如何使用此操作，请参阅[使用工作流部署到 Amazon EKS](deploy-action-eks.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.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-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: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.name"></a>

（必需）

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

默认值：`DeployToKubernetesCluster_nn`。

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

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

(*DeployToKubernetesCluster*/**Identifier**)

（必需）

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

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

对应的 UI：工作流图表/DeployToKubernetesCluster\$1nn/**aws/kubernetes-deploy@v1** 标签

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

(*DeployToKubernetesCluster*/**DependsOn**)

（可选）

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

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

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

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

(*DeployToKubernetesCluster*/**Compute**)

（可选）

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

对应的 UI：*无*

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

(*DeployToKubernetesCluster*/Compute/**Type**)

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

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

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

  优化了操作启动速度。

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

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

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

(*DeployToKubernetesCluster*/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.eks.timeout"></a>

(*DeployToKubernetesCluster*/**Timeout**)

（可选）

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

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

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

(*DeployToKubernetesCluster*/**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.eks.environment.name"></a>

(*DeployToKubernetesCluster*/Environment/**Name**)

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

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

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

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

(*DeployToKubernetesCluster*/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.eks.environment.connections.name"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

（可选）

指定账户连接的名称。

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

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

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

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

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

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

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

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

  ```
  "Resource": "*"
  ```
+ 以下自定义信任策略：

确保将此角色添加到：
+ 您的账户连接。要了解有关将 IAM 角色添加到账户连接的更多信息，请参阅[将 IAM 角色添加到账户连接](ipa-connect-account-addroles.md)。
+ 你的 Kubernetes ConfigMap。要了解有关向添加 IAM 角色的更多信息 ConfigMap，请参阅`eksctl`文档中的[管理 IAM 用户和角色](https://eksctl.io/usage/iam-identity-mappings/)。

**提示**  
另请参阅[教程：将应用程序部署到 Amazon EKS](deploy-tut-eks.md)，了解有关向账户连接添加 IAM 角色的说明，以及 ConfigMap。

**注意**  
如果需要，可以在此操作中使用 `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.eks.inputs"></a>

(*DeployToKubernetesCluster*/**Inputs**)

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

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

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

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

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

(*DeployToKubernetesCluster*/Inputs/**Sources**)

（如果您的清单文件存储在源存储库中，则为必需）

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

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

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

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

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

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

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

如果一个或多个 Kubernetes 清单文件包含在上一操作生成的构件中，请在此处指定该构件。如果您的清单文件不包含在构件中，则必须位于源存储库中。

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

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

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

(*DeployToKubernetesCluster*/**Configuration**)

（必需）

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

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

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

（可选）

指定 Kubernetes 应用程序将部署到的 Kubernetes 命名空间。如果未将命名空间与集群结合使用，请使用 `default`。有关命名空间的更多信息，请参阅 Kubernetes 文档中的 [Subdividing your cluster using Kubernetes namespaces](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces)。

如果省略命名空间，则使用值 `default`。

对应的 UI：“配置”选项卡/**命名空间**

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

(*DeployToKubernetesCluster*/Configuration/**Region**)

（必需）

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

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

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

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

（必需）

指定现有 Amazon EKS 集群的名称。**部署到 Kubernetes 集群**操作会将容器化应用程序部署到该集群中。有关 Amazon EKS 集群的更多信息，请参阅《Amazon EKS 用户指南》****中的[集群](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html)。

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

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

（必需）

指定 YAML 格式的 Kubernetes 清单文件的路径，这些文件在 Kubernetes 文档中称作*配置文件*、*config 文件*，或简称为*配置*。

如果您使用了多个清单文件，请将它们置于一个文件夹中并引用该文件夹。Kubernetes 会按字母数字顺序处理清单文件，因此请务必在文件名前添加递增数字或字母，以便控制处理顺序。例如：

`00-namespace.yaml`

`01-deployment.yaml`

如果清单文件位于源存储库中，则该路径相对于源存储库根文件夹。如果该文件位于上一工作流操作生成的构件中，则该路径相对于构件根文件夹。

示例：

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

请勿使用通配符（`*`）。

**注意**  
不支持 [Helm 图表](https://helm.sh/docs/topics/charts/)和 [kustomization 文件](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/)。

有关清单文件的更多信息，请参阅 Kubernetes 文档中的 [Organizing resource configurations](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations)。

对应的 UI：“配置”选项卡/**清单**

# 部署 CloudFormation 堆栈
<a name="deploy-action-cfn"></a>

本节介绍如何使用 CodeCatalyst 工作流程部署 AWS CloudFormation 堆栈。为此，您必须将 “**部署 CloudFormation 堆栈**” 操作添加到您的工作流程中。该操作会 AWS 根据您提供的模板将资源 CloudFormation 堆栈部署到中。模板可以是：
+ CloudFormation 模板-有关更多信息，请参阅[使用 CloudFormation 模板](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html)。
+ AWS SAM 模板-有关更多信息，请参阅 [AWS Serverless Application Model (AWS SAM) 规范](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html)。
**注意**  
要使用 AWS SAM 模板，必须先使用`[sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)`操作打包 AWS SAM 应用程序。有关向您展示如何在 Amazon CodeCatalyst 工作流程中自动进行打包的教程，请参阅[教程：部署无服务器应用程序](deploy-tut-lambda.md)。

如果堆栈已经存在，则该操作将运行 CloudFormation `[CreateChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html)`操作，然后运行该`[ExecuteChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html)`操作。之后，该操作会等待部署完更改，并根据结果自行标记为成功或失败。

如果您已经有包含要**部署的资源的 CloudFormation 或 AWS SAM 模板，或者您计划使用 AWS SAM 和之类的工具在工作流程构建操作中自动生成一个模板，请使用 “部署 CloudFormation 堆栈**[” 操作[AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)](build-add-action.md)。

你可以使用的模板没有任何限制，无论你能在其中创作什么， CloudFormation 或者 AWS SAM 你可以在 De **ploy CloudFormation stack** 操作中使用什么。

**提示**  
有关向您展示如何使用 “部署** CloudFormation 堆栈**” 操作部署无服务器应用程序的教程，请参阅[教程：部署无服务器应用程序](deploy-tut-lambda.md)。

**Topics**
+ [“部署 CloudFormation 堆栈” 操作使用的运行时镜像](#deploy-action-cfn-runtime)
+ [教程：部署无服务器应用程序](deploy-tut-lambda.md)
+ [添加 “部署 CloudFormation 堆栈” 操作](deploy-action-cfn-adding.md)
+ [配置回滚](deploy-consumption-enable-alarms.md)
+ ['部署 CloudFormation 堆栈'变量](deploy-action-cfn-variables.md)
+ ['部署 CloudFormation 堆栈'动作 YAML](deploy-action-ref-cfn.md)

## “部署 CloudFormation 堆栈” 操作使用的运行时镜像
<a name="deploy-action-cfn-runtime"></a>

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

# 教程：部署无服务器应用程序
<a name="deploy-tut-lambda"></a>

在本教程中，您将学习如何使用工作流程构建、测试和部署无服务器应用程序作为 CloudFormation 堆栈。

本教程中的应用程序是一个输出“Hello World”消息的简单 Web 应用程序。它由一个 AWS Lambda 函数和一个 Amazon API Gateway 组成，你可以使用 [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) 来构建它，后者是的扩展[CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)。

**Topics**
+ [先决条件](#deploy-tut-lambda-cfn-prereqs)
+ [步骤 1：创建源存储库](#deploy-tut-lambda-cfn-source)
+ [步骤 2：创建 AWS 角色](#deploy-tut-lambda-cfn-roles)
+ [步骤 3：将 AWS 角色添加到 CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)
+ [步骤 4：创建 Amazon S3 存储桶](#deploy-tut-lambda-cfn-s3)
+ [步骤 5：添加源文件](#deploy-tut-lambda-cfn-files)
+ [步骤 6：创建并运行工作流](#deploy-tut-lambda-cfn-workflow)
+ [步骤 7：进行更改](#deploy-tut-lambda-cfn-change)
+ [清理](#deploy-tut-lambda-cfn-clean-up)

## 先决条件
<a name="deploy-tut-lambda-cfn-prereqs"></a>

开始前的准备工作：
+ 你需要一个带有关联 AWS 账户的 CodeCatalyst **空间**。有关更多信息，请参阅 [创建空间](spaces-create.md)。
+ 在您的空间中，您需要一个空项目，其名称为：

  ```
  codecatalyst-cfn-project
  ```

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

  有关更多信息，请参阅 [在 Amazon 中创建一个空项目 CodeCatalyst](projects-create.md#projects-create-empty)。
+ 在你的项目中，你需要一个 CodeCatalyst **名**为：

  ```
  codecatalyst-cfn-environment
  ```

  按如下方式配置此环境：
  + 选择任何类型，例如**非生产**。
  + 将您的 AWS 账户与之关联。
  + 对于**默认 IAM 角色**，选择任何角色。稍后需要指定另一个角色。

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

## 步骤 1：创建源存储库
<a name="deploy-tut-lambda-cfn-source"></a>

在此步骤中，您将在中创建源存储库 CodeCatalyst。此存储库用于存储教程的源文件，例如 Lambda 函数文件。

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

**创建源存储库**

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

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

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

   ```
   codecatalyst-cfn-source-repository
   ```

1. 选择**创建**。

现在，您已经创建了一个名为 `codecatalyst-cfn-source-repository` 的存储库。

## 步骤 2：创建 AWS 角色
<a name="deploy-tut-lambda-cfn-roles"></a>

在此步骤中，您将创建以下 AWS IAM 角色：
+ **部署角色**-授予 CodeCatalyst **Deploy CloudFormation stack** 操作访问您的 AWS 账户和 CloudFormation 服务的权限，您将在其中部署无服务器应用程序。**部署 CloudFormation 堆栈**操作是您的工作流程的一部分。
+ **构建角色**-授予 CodeCatalyst 构建操作访问您的 AWS 账户并写入存储无服务器应用程序包的 Amazon S3 的权限。构建操作是您的工作流的一部分。
+ **堆栈角色**- CloudFormation 授予读取和修改您稍后将提供的 AWS SAM 模板中指定的资源的权限。还授予权限 CloudWatch。

有关 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` 角色具有非常广泛的权限，这可能会带来安全风险。我们建议您仅在教程和安全要求较低的场景中使用此角色。本教程假定您创建的是前面列出的三个角色。

**注意**  
还需要一个 [Lambda 执行角色](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html)，但您无需立即创建此角色，因为当您在步骤 5 中运行工作流时，`sam-template.yml` 文件会为您创建它。



**创建部署角色**

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

   1. 登录到 AWS。

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

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

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

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

   1. 删除现有代码。

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

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

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

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

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

      ```
      codecatalyst-deploy-policy
      ```

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

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

1. 按如下步骤操作，创建部署角色：

   1. 在导航窗格中，选择**角色**，然后选择**创建角色**。

   1. 选择**自定义信任策略**。

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

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

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

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

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

   1. 对于**角色名称**，输入：

      ```
      codecatalyst-deploy-role
      ```

   1. 对于**角色描述**，输入：

      ```
      CodeCatalyst deploy role
      ```

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

   现在，您已创建一个具有信任策略和权限策略的部署角色。

1. 按如下步骤操作，获取部署角色 ARN：

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

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

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

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

   1. 在顶部，复制 **ARN** 值。

   现在，您已创建具有相应权限的部署角色并已获取其 ARN。

**创建构建角色**

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

   1. 登录到 AWS。

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

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

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

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

   1. 删除现有代码。

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

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

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

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

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

      ```
      codecatalyst-build-policy
      ```

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

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

1. 按如下步骤操作，创建构建角色：

   1. 在导航窗格中，选择**角色**，然后选择**创建角色**。

   1. 选择**自定义信任策略**。

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

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

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

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

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

   1. 对于**角色名称**，输入：

      ```
      codecatalyst-build-role
      ```

   1. 对于**角色描述**，输入：

      ```
      CodeCatalyst build role
      ```

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

   现在，您已创建一个具有信任策略和权限策略的构建角色。

1. 按如下步骤操作，获取构建角色 ARN：

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

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

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

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

   1. 在顶部，复制 **ARN** 值。

   现在，您已创建具有相应权限的构建角色并已获取其 ARN。<a name="deploy-tut-lambda-cfn-roles-stack"></a>

**创建堆栈角色**

1.  AWS 使用要部署堆栈的账户登录。

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

1. 按如下步骤操作，创建堆栈角色：

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

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

   1. 选择 **AWS 服务**。

   1. 在 “**用例**” 部分，**CloudFormation**从下拉列表中进行选择。

   1. 选择 **CloudFormation** 单选按钮。

   1. 选择底部的**下一步**。

   1. 使用搜索框找到以下权限策略，然后选中它们对应的复选框。
**注意**  
如果您搜索一个策略，但该策略未显示，请务必选择**清除筛选条件**，然后重试。
      + **CloudWatchFullAccess**
      + **AWS CloudFormationFullAccess**
      + **IAMFull访问**
      + **AWS Lambda\$1 FullAccess**
      + **亚马逊APIGateway管理员**
      + **亚马逊 3 FullAccess**
      + **AmazonEC2ContainerRegistryFullAccess**

      第一个策略允许访问 CloudWatch 以在警报发生时启用堆栈回滚。

      其余策略 AWS SAM 允许访问堆栈中将在本教程中部署的服务和资源。有关授予权限的更多信息，请参阅 *AWS Serverless Application Model 开发人员指南*的 [ 权限](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-permissions.html)。

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

   1. 对于**角色名称**，输入：

      ```
      codecatalyst-stack-role
      ```

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

1. 按如下步骤操作，获取堆栈角色的 ARN：

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

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

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

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

   现在，您已创建具有相应权限的堆栈角色并已获取其 ARN。

## 步骤 3：将 AWS 角色添加到 CodeCatalyst
<a name="deploy-tut-lambda-cfn-roles-add"></a>

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

**注意**  
您无需将堆栈角色（`codecatalyst-stack-role`）添加到连接。这是因为在部署角色之间 CodeCatalyst 已经建立连接*之后 *CloudFormation**（不是 CodeCatalyst） AWS 使用堆栈角色。由于堆栈角色不用于获取 CodeCatalyst 访问权限 AWS，因此无需将其与账户连接相关联。

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

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

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

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

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

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

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

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

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

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

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

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

## 步骤 4：创建 Amazon S3 存储桶
<a name="deploy-tut-lambda-cfn-s3"></a>

在此步骤中，您将创建可在其中存储无服务器应用程序的部署包 .zip 文件的 Amazon S3 存储桶。

**创建 Amazon S3 存储桶**

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

1. 在主窗格中，选择**创建存储桶**。

1. 对于**存储桶名称**，输入：

   ```
   codecatalyst-cfn-s3-bucket
   ```

1. 对于 **AWS 区域**，选择一个区域。本教程假设您选择了**美国西部（俄勒冈州）us-west-2**。有关 Amazon S3 支持的区域的信息，请参阅《AWS 一般参考》**中的 [Amazon Simple Storage Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/s3.html)。

1. 在页面底部选择**创建存储桶**。

现在，您已经在美国西部（俄勒冈州）us-west-2 区域中创建了一个名为 **codecatalyst-cfn-s3-bucket** 的存储桶。

## 步骤 5：添加源文件
<a name="deploy-tut-lambda-cfn-files"></a>

在此步骤中，您将向源存储库中添加多个应用程序 CodeCatalyst 源文件。`hello-world` 文件夹包含您将部署的应用程序文件。`tests` 文件夹包含单元测试。文件夹结构如下所示：

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

### .npmignore 文件
<a name="deploy-tut-lambda-cfn-files-npmignore"></a>

`.npmignore` 文件指明 npm 应从应用程序包中排除哪些文件和文件夹。在本教程中，npm 将排除 `tests` 文件夹，因为它不是应用程序的一部分。

**添加 .npmignore 文件**

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

1. 选择您的项目 `codecatalyst-cfn-project`。

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

1. 从源存储库列表中，选择您的存储库 `codecatalyst-cfn-source-repository`。

1. 在**文件**中，选择**创建文件**。

1. 对于**文件名**，输入：

   ```
   .npmignore
   ```

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

   ```
   tests/*
   ```

1. 选择**提交**，然后再次选择**提交**。

   现在，您已在存储库的根目录中创建名为 `.npmignore` 的文件。

### package.json 文件
<a name="deploy-tut-lambda-cfn-files-package-json"></a>

`package.json` 文件包含有关您的 Node 项目的重要元数据，例如项目名称、版本号、描述、依赖项以及描述如何运行应用程序并与之交互的其他详细信息。

本教程中的 `package.json` 包括依赖项列表和 `test` 脚本。测试脚本执行以下操作：
+ 通过使用 [mocha](https://mochajs.org/)，测试脚本运行 `hello-world/tests/unit/` 中指定的单元测试，并使用 [xunit]() 报告器将结果写入 `junit.xml` 文件。
+ 通过使用 [Istanbul (nyc)](https://istanbul.js.org/)，测试脚本使用 [clover](https://openclover.org/doc/manual/4.2.0/general--about-openclover.html) 报告器生成代码覆盖率报告（`clover.xml`）。有关更多信息，请参阅 Istanbul 文档中的 [Using alternative reporters](https://istanbul.js.org/docs/advanced/alternative-reporters/#clover)。

**添加 package.json 文件**

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

1. 对于**文件名**，输入：

   ```
   package.json
   ```

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

   ```
   {
     "name": "hello_world",
     "version": "1.0.0",
     "description": "hello world sample for NodeJS",
     "main": "app.js",
     "repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
     "author": "SAM CLI",
     "license": "MIT",
     "dependencies": {
       "axios": "^0.21.1",
       "nyc": "^15.1.0"
     },
     "scripts": {
       "test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
     },
     "devDependencies": {
       "aws-sdk": "^2.815.0",
       "chai": "^4.2.0",
       "mocha": "^8.2.1"
     }
   }
   ```

1. 选择**提交**，然后再次选择**提交**。

   现在，您已将名为 `package.json` 的文件添加到存储库的根目录。

### sam-template.yml 文件
<a name="deploy-tut-lambda-cfn-files-sam-template-yml"></a>

`sam-template.yml` 文件包含有关部署 Lambda 函数和 API Gateway 并将它们一起配置的说明。它遵循[AWS Serverless Application Model 模板规范](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html)，该规范扩展了 CloudFormation 模板规范。

在本教程中，您将使用 AWS SAM 模板而不是常规 CloudFormation 模板，因为 AWS SAM 提供了一种有用的:: [Serverless AWS:: Function 资源](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)类型。这种类型执行许多 behind-the-scenes配置，你通常必须写出这些配置才能使用基本 CloudFormation 语法。例如，`AWS::Serverless::Function` 创建一个 Lambda 函数、Lambda 执行角色和启动该函数的事件源映射。如果你想用 basic 来编写，你必须对所有这些代码进行编码 CloudFormation。

本教程使用的是预先编写的模板，您可以使用构建操作在工作流中生成一个模板。有关更多信息，请参阅 [部署 CloudFormation 堆栈](deploy-action-cfn.md)。

**添加 sam-template.yml 文件**

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

1. 对于**文件名**，输入：

   ```
   sam-template.yml
   ```

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

   ```
   AWSTemplateFormatVersion: '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: >
     serverless-api
   
     Sample SAM Template for serverless-api
     
   # More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
   Globals:
     Function:
       Timeout: 3
   
   Resources:
     HelloWorldFunction:
       Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
       Properties:
         CodeUri: hello-world/
         Handler: app.lambdaHandler
         Runtime: nodejs12.x
         Events:
           HelloWorld:
             Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
             Properties:
               Path: /hello
               Method: get
   
   Outputs:
     # ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
     # Find out about other implicit resources you can reference within AWS SAM at
     # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
     HelloWorldApi:
       Description: "API Gateway endpoint URL for the Hello World function"
       Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
     HelloWorldFunction:
       Description: "Hello World Lambda function ARN"
       Value: !GetAtt HelloWorldFunction.Arn
     HelloWorldFunctionIamRole:
       Description: "Implicit Lambda execution role created for the Hello World function"
       Value: !GetAtt HelloWorldFunctionRole.Arn
   ```

1. 选择**提交**，然后再次选择**提交**。

   现在，您已将名为 `sam-template.yml` 的文件添加到存储库的根文件夹下。

### setup-sam.sh 文件
<a name="deploy-tut-lambda-cfn-files-setup-sam"></a>

该`setup-sam.sh`文件包含下载和安装 AWS SAM CLI 实用程序的说明。工作流使用此实用工具来打包 `hello-world` 源。

**添加 setup-sam.sh 文件**

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

1. 对于**文件名**，输入：

   ```
   setup-sam.sh
   ```

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

   ```
   #!/usr/bin/env bash
   echo "Setting up sam"
   
   yum install unzip -y
   
   curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
   unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory
   
   ./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2
   ```

   在前面的代码中，*us-west-2*替换为您所在 AWS 的地区。

1. 选择**提交**，然后再次选择**提交**。

   现在，您已将名为 `setup-sam.sh` 的文件添加到存储库的根目录。

### app.js 文件
<a name="deploy-tut-lambda-cfn-files-app-js"></a>

`app.js` 包含 Lambda 函数代码。在本教程中，代码返回文本 `hello world`。

**添加 app.js 文件**

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

1. 对于**文件名**，输入：

   ```
   hello-world/app.js
   ```

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

   ```
   // const axios = require('axios')
   // const url = 'http://checkip.amazonaws.com/';
   let response;
   
   /**
    *
    * Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
    * @param {Object} event - API Gateway Lambda Proxy Input Format
    *
    * Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html 
    * @param {Object} context
    *
    * Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
    * @returns {Object} object - API Gateway Lambda Proxy Output Format
    * 
    */
   exports.lambdaHandler = async (event, context) => {
       try {
           // const ret = await axios(url);
           response = {
               'statusCode': 200,
               'body': JSON.stringify({
                   message: 'hello world',
                   // location: ret.data.trim()
               })
           }
       } catch (err) {
           console.log(err);
           return err;
       }
   
       return response
   };
   ```

1. 选择**提交**，然后再次选择**提交**。

   现在，您已创建名为 `hello-world` 的文件夹和名为 `app.js` 的文件。

### test-handler.js 文件
<a name="deploy-tut-lambda-cfn-files-test-handler-js"></a>

`test-handler.js` 文件包含 Lambda 函数的单元测试。

**添加 test-handler.js 文件**

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

1. 对于**文件名**，输入：

   ```
   hello-world/tests/unit/test-handler.js
   ```

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

   ```
   'use strict';
   
   const app = require('../../app.js');
   const chai = require('chai');
   const expect = chai.expect;
   var event, context;
   
   describe('Tests index', function () {
       it('verifies successful response', async () => {
           const result = await app.lambdaHandler(event, context)
   
           expect(result).to.be.an('object');
           expect(result.statusCode).to.equal(200);
           expect(result.body).to.be.an('string');
   
           let response = JSON.parse(result.body);
   
           expect(response).to.be.an('object');
           expect(response.message).to.be.equal("hello world");
           // expect(response.location).to.be.an("string");
       });
   });
   ```

1. 选择**提交**，然后再次选择**提交**。

   现在，您已将名为 `test-handler.js` 的文件添加到 `hello-world/tests/unit` 文件夹下。

现在，您已添加所有源文件。

请花点时间仔细检查您的工作，确保已将所有文件置于正确的文件夹中。文件夹结构如下所示：

```
.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh
```

## 步骤 6：创建并运行工作流
<a name="deploy-tut-lambda-cfn-workflow"></a>

在此步骤中，您将创建一个工作流来打包 Lambda 源代码并对其进行部署。工作流包含以下按顺序运行的构造块：
+ 触发器 – 当您将更改推送到源存储库时，此触发器会自动启动工作流运行。有关触发器的更多信息，请参阅[使用触发器自动启动工作流运行](workflows-add-trigger.md)。
+ 测试操作（`Test`）– 触发时，此操作将安装 [Node package manager (npm)](https://www.npmjs.com/)，然后运行 `npm run test` 命令。此命令告知 npm 运行 `package.json` 文件中定义的 `test` 脚本。`test` 脚本反过来运行单元测试并生成两个报告：测试报告（`junit.xml`）和代码覆盖率报告（`clover.xml`）。有关更多信息，请参阅 [package.json 文件](#deploy-tut-lambda-cfn-files-package-json)。

  接下来，测试操作将 XML 报告转换为 CodeCatalyst 报告，并将其显示在 CodeCatalyst 控制台中，位于测试操作的 “**报告**” 选项卡下。

  有关测试操作的更多信息，请参阅[使用工作流进行测试使用工作流进行测试](test-workflow-actions.md)。
+ 构建操作 (`BuildBackend`)-测试操作完成后，构建操作将下载并安装 AWS SAM CLI，打包`hello-world`源代码，然后将包复制到您的 Amazon S3 存储桶（Lambda 服务期望的位置）。该操作还会输出一个名为的新 AWS SAM 模板文件，`sam-template-packaged.yml`并将其放置在名为的输出构件中`buildArtifact`。

  有关构建操作的更多信息，请参阅[使用工作流进行构建](build-workflow-actions.md)。
+ 部署操作 (`DeployCloudFormationStack`)-生成操作完成后，部署操作将查找生成操作 (`buildArtifact`) 生成的输出对象，在其中找到 AWS SAM 模板，然后运行该模板。该 AWS SAM 模板创建了一个用于部署无服务器应用程序的堆栈。

**创建工作流**

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

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

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

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

1. 选择**创建**。

1. 删除 YAML 示例代码。

1. 添加以下 YAML 代码：
**注意**  
在接下来的 YAML 代码中，如果需要，可以省略 `Connections:` 部分。如果您省略这些部分，则必须确保您环境的**默认 IAM 角色**字段中指定的角色包含[步骤 2：创建 AWS 角色](#deploy-tut-lambda-cfn-roles)中描述的两个角色的权限和信任策略。有关使用默认 IAM 角色设置环境的更多信息，请参阅[创建环境](deploy-environments-creating-environment.md)。

   ```
   Name: codecatalyst-cfn-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main   
   Actions:
     Test:
       Identifier: aws/managed-test@v1
       Inputs:
         Sources:
           - WorkflowSource
       Outputs:
         Reports:
           CoverageReport:
             Format: CLOVERXML
             IncludePaths:
               - "coverage/*"
           TestReport:
             Format: JUNITXML
             IncludePaths:
               - junit.xml
       Configuration:
         Steps:
           - Run: npm install
           - Run: npm run test  
     BuildBackend:
       Identifier: aws/build@v1
       DependsOn:
         - Test
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-build-role
       Inputs:
         Sources:
           - WorkflowSource
       Configuration: 
         Steps:
           - Run: . ./setup-sam.sh
           - Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
       Outputs:
         Artifacts:
           - Name: buildArtifact
             Files:
               - "**/*"
     DeployCloudFormationStack:
       Identifier: aws/cfn-deploy@v1
       DependsOn: 
         - BuildBackend
       Environment:
         Name: codecatalyst-cfn-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-deploy-role
       Inputs:
         Artifacts:
           - buildArtifact
         Sources: []
       Configuration:
         name: codecatalyst-cfn-stack
         region: us-west-2
         role-arn: arn:aws:iam::111122223333:role/StackRole
         template: ./sam-template-packaged.yml
         capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND
   ```

   在上述代码中，进行如下替换：
   + 的两个实例均*codecatalyst-cfn-environment*以您的环境名称命名。
   + 的两个实例都*codecatalyst-account-connection*带有您的账户连接的显示名称。显示名称可能是数字。有关更多信息，请参阅 [步骤 3：将 AWS 角色添加到 CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)。
   + 将 *codecatalyst-build-role* 替换为您在[步骤 2：创建 AWS 角色](#deploy-tut-lambda-cfn-roles)中创建的构建角色的名称。
   + *codecatalyst-cfn-s3-bucket*使用您在中创建的 Amazon S3 存储桶的名称[步骤 4：创建 Amazon S3 存储桶](#deploy-tut-lambda-cfn-s3)。
   + *us-west-2*包含您的 Amazon S3 存储桶所在区域（第一个实例）和堆栈将部署的位置（第二个实例）的两个实例。这两个区域可能不同。本教程假定两个区域都设置为 `us-west-2`。有关 Amazon S3 和支持的区域的详细信息 CloudFormation，请参阅中的[服务终端节点和配额*AWS 一般参考*](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html)。
   + 将 *codecatalyst-deploy-role* 替换为您在[步骤 2：创建 AWS 角色](#deploy-tut-lambda-cfn-roles)中创建的部署角色的名称。
   + *codecatalyst-cfn-environment*使用您在中创建的环境的名称[先决条件](#deploy-tut-lambda-cfn-prereqs)。
   + *arn:aws:iam::111122223333:role/StackRole*使用您在中创建的堆栈角色的 Amazon 资源名称 (ARN)。[步骤 2：创建 AWS 角色](#deploy-tut-lambda-cfn-roles)
**注意**  
如果您决定不创建构建、部署和堆叠角色 *codecatalyst-build-role**codecatalyst-deploy-role*，请使用角色的*arn:aws:iam::111122223333:role/StackRole*名称或 ARN 替换、和。`CodeCatalystWorkflowDevelopmentRole-spaceName`有关该角色的更多信息，请参阅[步骤 2：创建 AWS 角色](#deploy-tut-lambda-cfn-roles)。

   有关前面显示的代码中的属性的信息，请参阅['部署 CloudFormation 堆栈'动作 YAML](deploy-action-ref-cfn.md)。

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

1. 选择**提交**。

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

   1. 对于**工作流文件名**，保留默认值 `codecatalyst-cfn-workflow`。

   1. 对于**提交消息**，输入：

      ```
      add initial workflow file
      ```

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

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

   1. 选择**提交**。

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

**查看正在运行的工作流**

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

1. 选择您刚刚创建的工作流：`codecatalyst-cfn-workflow`。

1. 选择**运行**选项卡。

1. 在**运行 ID** 列中，选择运行 ID。

1. 选择**测试**以查看测试进度。

1. 选择**BuildBackend**查看构建进度。

1. 选择**DeployCloudFormationStack**查看部署进度。

   有关查看运行详细信息的更多信息，请参阅[查看工作流运行状态和详细信息](workflows-view-run.md)。

1. **DeployCloudFormationStack**操作完成后，请执行以下操作：
   + 如果工作流运行成功，请转到下一过程。
   + 如果工作流程在**测试**或**BuildBackend**操作中运行失败，请选择**日志**来解决问题。
   + 如果**DeployCloudFormationStack**操作的工作流程运行失败，请选择部署操作，然后选择**摘要**选项卡。滚动至**CloudFormation 事件**部分以查看详细的错误消息。如果发生了回滚， AWS 请在重新运行工作流程之前通过 CloudFormation 控制台删除`codecatalyst-cfn-stack`堆栈。

**验证部署**

1. 在部署成功后，从顶部附近的水平菜单栏中选择**变量 (7)**。（请勿在右侧窗格中选择**变量**。）

1. 旁边 **HelloWorldApi**，将 `https://` URL 粘贴到浏览器中。

   这将显示来自 Lambda 函数的 **hello world** JSON 消息，表示工作流已成功部署和配置 Lambda 函数以及 API Gateway。
**提示**  
您可以通过一些小配置在工作流程图中 CodeCatalyst 显示此 URL。有关更多信息，请参阅 [在工作流图中显示应用程序 URL](deploy-app-url.md)。

**验证单元测试结果和代码覆盖率**

1. 在工作流图中，选择**测试**，然后选择**报告**。

1. 选择**TestReport**查看单元测试结果，或者选择**CoverageReport**查看正在测试的文件的代码覆盖率详细信息，在本例中为`app.js`和`test-handler.js`。

**验证已部署的资源**

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

1. 观察 AWS SAM 模板创建的 **codecatalyst-cfn-stack**API。API 名称来自工作流定义文件（`codecatalyst-cfn-workflow.yaml`）中的 `Configuration/name` 值。

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

1. 在导航窗格中，选择**函数**。

1. 选择您的 Lambda 函数 `codecatalyst-cfn-stack-HelloWorldFunction-string`。

1. 您可以查看 API Gateway 是如何成为该函数的触发器的。此集成是根据 AWS SAM `AWS::Serverless::Function`资源类型自动配置的。

## 步骤 7：进行更改
<a name="deploy-tut-lambda-cfn-change"></a>

在此步骤中，您对 Lambda 源代码进行更改，然后提交它。此提交将启动新的工作流运行。此运行在蓝绿方案中部署新的 Lambda 函数，该方案使用 Lambda 控制台中指定的默认流量转移配置。

**更改您的 Lambda 源**

1. 在中 CodeCatalyst，导航到您的项目。

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

1. 选择您的源存储库 `codecatalyst-cfn-source-repository`。

1. 更改应用程序文件：

   1. 选择 `hello-world` 文件夹。

   1. 选择 `app.js` 文件。

   1. 选择**编辑**。

   1. 在第 23 行上，将 `hello world` 更改为 **Tutorial complete\$1**。

   1. 选择**提交**，然后再次选择**提交**。

      提交会促使启动工作流运行。此运行将失败，因为您尚未更新单元测试来反映名称更改。

1. 更新单元测试：

   1. 选择 `hello-world\tests\unit\test-handler.js`。

   1. 选择**编辑**。

   1. 在第 19 行上，将 `hello world` 更改为 **Tutorial complete\$1**。

   1. 选择**提交**，然后再次选择**提交**。

      提交会促使启动另一个工作流运行。此运行将成功。

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

1. 选择 `codecatalyst-cfn-workflow`，然后选择**运行**。

1. 选择最新运行的运行 ID。该运行应仍在进行中。

1. 选择 “**测试**” **BuildBackend**、“和” **DeployCloudFormationStack**以查看工作流程的运行进度。

1. 在工作流完成后，选择顶部附近的**变量 (7)**。

1. 旁边 **HelloWorldApi**，将 `https://` URL 粘贴到浏览器中。

   一条 `Tutorial complete!` 消息将显示在浏览器中，这表示您已成功部署新应用程序。

## 清理
<a name="deploy-tut-lambda-cfn-clean-up"></a>

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

**在 CodeCatalyst 控制台中进行清理**

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

1. 删除 `codecatalyst-cfn-workflow`。

1. 删除 `codecatalyst-cfn-environment`。

1. 删除 `codecatalyst-cfn-source-repository`。

1. 删除 `codecatalyst-cfn-project`。

**要在里面清理干净 AWS 管理控制台**

1. 清理一下 CloudFormation，如下所示：

   1. 在 [https://console.aws.amazon.com/cloudformat](https://console.aws.amazon.com/cloudformation/) ion 上打开 CloudFormation 控制台。

   1. 删除 `codecatalyst-cfn-stack`。

      删除堆栈将从 API Gateway 和 Lambda 服务中移除所有教程资源。

1. 在 Amazon S3 中进行清理，如下所示：

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

   1. 选择 `codecatalyst-cfn-s3-bucket`。

   1. 删除存储桶内容。

   1. 删除 存储桶。

1. 在 IAM 中进行清理，如下所示：

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

   1. 删除 `codecatalyst-deploy-policy`。

   1. 删除 `codecatalyst-build-policy`。

   1. 删除 `codecatalyst-stack-policy`。

   1. 删除 `codecatalyst-deploy-role`。

   1. 删除 `codecatalyst-build-role`。

   1. 删除 `codecatalyst-stack-role`。

在本教程中，您学习了如何使用 CodeCatalyst 工作流程和部署 CloudFormation 堆栈操作将无服务器应用程序**部署为 CloudFormation 堆栈**。

# 添加 “部署 CloudFormation 堆栈” 操作
<a name="deploy-action-cfn-adding"></a>

按照以下说明将 “**部署 CloudFormation 堆栈**” 操作添加到您的工作流程中。

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

**使用可视化编辑器添加 “部署 CloudFormation 堆栈” 操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

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

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

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

1. 搜索 “**部署 CloudFormation 堆栈**” 操作，然后执行以下任一操作：
   + 选择加号（**\$1**），将操作添加到工作流图表中并打开其配置窗格。

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

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

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

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

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

**使用 YAML 编辑器添加 “部署 CloudFormation 堆栈” 操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择 **YAML**。

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

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

1. 搜索 “**部署 CloudFormation 堆栈**” 操作，然后执行以下任一操作：
   + 选择加号（**\$1**），将操作添加到工作流图表中并打开其配置窗格。

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

1. 根据需求修改 YAML 代码中的属性。['部署 CloudFormation 堆栈'动作 YAML](deploy-action-ref-cfn.md)中提供了每个可用属性的解释。

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

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

------

# 配置回滚
<a name="deploy-consumption-enable-alarms"></a>

默认情况下，如果 **Deploy CloudFormation 堆栈**操作失败，它将导致堆栈回滚 CloudFormation 到上次已知的稳定状态。您可以更改行为，使回滚不仅在操作失败时发生，而且还会在出现指定的 Amazon CloudWatch 警报时发生。有关 CloudWatch 警报的更多信息，请参阅[亚马逊* CloudWatch 用户指南中的使用亚马逊 CloudWatch *警报](https://docs.aws.amazon.com/)。

您也可以更改默认行为，以便在操作失败时 CloudFormation 不会回滚堆栈。

按照以下说明操作来配置回滚。

**注意**  
您无法手动启动回滚。

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

**开始前的准备工作**

1. 确保您的[工作流程](workflow.md)包含有效的 De **ploy CloudFormation 堆栈**操作。有关更多信息，请参阅 [部署 CloudFormation 堆栈](deploy-action-cfn.md)。

1. 在 “**部署 CloudFormation **堆栈” 操作的 “**堆栈角色-可选**” 字段中指定的角色中，确保包含**CloudWatchFullAccess**权限。有关创建此具有适当权限的角色的信息，请参阅[步骤 2：创建 AWS 角色](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles)。

**为 “部署 CloudFormation 堆栈” 操作配置回滚警报**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

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

1. 选择您的**部署 CloudFormation 堆栈**操作。

1. 在详细信息窗格中，选择**配置**。

1. 在底部，展开**高级**。

1. 在 “**监控警报**” 下 ARNs，选择 “**添加警报**”。

1. 在以下字段中输入信息。
   + **警报 ARN**

     指定要用作回滚触发器的亚马逊 CloudWatch 警报的亚马逊资源名称 (ARN)。例如 `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`。您可以拥有最多 5 个回滚触发器。
**注意**  
如果您指定 CloudWatch 警报 ARN，则还需要配置其他权限才能使操作能够访问。 CloudWatch有关更多信息，请参阅 [配置回滚](#deploy-consumption-enable-alarms)。
   + **监控时间**

     指定 CloudFormation 监视指定警报的时间段，介于 0 到 180 分钟之间。在部署完所有堆栈资源*后*开始监控。如果警报发生在指定的监控时间内，则部署将失败，并回 CloudFormation 滚整个堆栈操作。

     默认值：0。 CloudFormation 仅在部署堆栈资源时监控警报，而不在部署堆栈资源之后监视警报。

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

**为 “部署 CloudFormation 堆栈” 操作配置回滚触发器**

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

1. 选择您的项目。

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

1. 选择包含**部署 CloudFormation 堆栈**操作的工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择 **YAML**。

1. 在 YAML 代码中添加 `monitor-alarm-arns` 和 `monitor-timeout-in-minutes` 属性以添加回滚触发器。有关每个属性的说明，请参阅['部署 CloudFormation 堆栈'动作 YAML](deploy-action-ref-cfn.md)。

1. 在 De **ploy CloudFormation 堆栈**操作的`role-arn`属性中指定的角色中，确保包含**CloudWatchFullAccess**权限。有关创建此具有适当权限的角色的信息，请参阅[步骤 2：创建 AWS 角色](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles)。

------

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

**关闭 “部署 CloudFormation 堆栈” 操作的回滚功能**

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

1. 选择您的项目。

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

1. 选择包含**部署 CloudFormation 堆栈**操作的工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

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

1. 选择您的**部署 CloudFormation 堆栈**操作。

1. 在详细信息窗格中，选择**配置**。

1. 在底部，展开**高级**。

1. 启用**禁用回滚**。

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

**关闭 “部署 CloudFormation 堆栈” 操作的回滚功能**

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

1. 选择您的项目。

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

1. 选择包含**部署 CloudFormation 堆栈**操作的工作流的名称。您可以按定义工作流的源存储库或分支名称筛选，也可以按工作流名称或状态筛选。

1. 选择**编辑**。

1. 选择 **YAML**。

1. 在 YAML 代码中添加 `disable-rollback: 1` 属性以停止回滚。有关每个属性的说明，请参阅['部署 CloudFormation 堆栈'动作 YAML](deploy-action-ref-cfn.md)。

------

# '部署 CloudFormation 堆栈'变量
<a name="deploy-action-cfn-variables"></a>

**部署 CloudFormation 堆栈**操作在运行时生成并设置以下变量。这些变量被称为*预定义变量*。

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


| 键 | 值 | 
| --- | --- | 
|  deployment-platform  |  部署平台的名称。 硬编码为 `AWS:CloudFormation`。  | 
|  region  |  在工作流程运行期间部署到的的区域代码。 AWS 区域  示例：`us-west-2`  | 
|  stack-id  |  部署的堆栈的 Amazon 资源名称（ARN）。 示例：`arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cfn-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 

# '部署 CloudFormation 堆栈'动作 YAML
<a name="deploy-action-ref-cfn"></a>

以下是 “**部署 CloudFormation 堆栈**” 操作的 YAML 定义。要了解如何使用此操作，请参阅[部署 CloudFormation 堆栈](deploy-action-cfn.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.    
  DeployCloudFormationStack:  
    Identifier: aws/cfn-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: DeployRole
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - CloudFormation-artifact
    Configuration:
      name: stack-name
      region: us-west-2
      template: template-path
      role-arn: arn:aws:iam::123456789012:role/StackRole        
      capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
      parameter-overrides: KeyOne=ValueOne,KeyTwo=ValueTwo | path-to-JSON-file
      no-execute-changeset: 1|0
      fail-on-empty-changeset: 1|0
      disable-rollback: 1|0
      termination-protection: 1|0
      timeout-in-minutes: minutes
      notification-arns: arn:aws:sns:us-east-1:123456789012:MyTopic,arn:aws:sns:us-east-1:123456789012:MyOtherTopic
      monitor-alarm-arns: arn:aws:cloudwatch::123456789012:alarm/MyAlarm,arn:aws:cloudwatch::123456789012:alarm/MyOtherAlarm
      monitor-timeout-in-minutes: minutes       
      tags: '[{"Key":"MyKey1","Value":"MyValue1"},{"Key":"MyKey2","Value":"MyValue2"}]'
```

## DeployCloudFormationStack
<a name="deploy.action.cfn.deploycloudformationstack"></a>

（必需）

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

默认值：`DeployCloudFormationStack_nn`。

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

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

(*DeployCloudFormationStack*/**Identifier**)

（必需）

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

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

对应的 UI：工作流图表/DeployCloudFormationStack\$1nn/**aws/cfn-deploy@v1** 标签

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

(*DeployCloudFormationStack*/**DependsOn**)

（可选）

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

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

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

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

(*DeployCloudFormationStack*/**Compute**)

（可选）

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

对应的 UI：*无*

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

(*DeployCloudFormationStack*/Compute/**Type**)

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

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

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

  优化了操作启动速度。

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

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

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

(*DeployCloudFormationStack*/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.cfn.timeout"></a>

(*DeployCloudFormationStack*/**Timeout**)

（可选）

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

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

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

(*DeployCloudFormationStack*/**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.cfn.environment.name"></a>

(*DeployCloudFormationStack*/Environment/**Name**)

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

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

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

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

(*DeployCloudFormationStack*/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.cfn.environment.connections.name"></a>

(*DeployCloudFormationStack*/Environment/Connections/**Name**)

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

指定账户连接的名称。

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

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

(*DeployCloudFormationStack*/Environment/Connections/**Role**)

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

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

如果您未指定 IAM 角色，则该操作将使用 CodeCatalyst 控制台中[环境](deploy-environments.md)中列出的默认 IAM 角色。如果您使用此环境中的默认角色，请确保该角色具有以下策略。
+ 以下权限策略：
**警告**  
将权限限制在以下策略所示的范围内。使用具有更广泛权限的角色可能会带来安全风险。
**注意**  
第一次使用该角色时，请在资源策略语句中使用以下通配符，然后在策略可用后使用资源名称缩小策略范围。  

  ```
  "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.cfn.inputs"></a>

(*DeployCloudFormationStack*/**Inputs**)

（可选）

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

**注意**  
每个 Deplo **y CloudFormation 堆栈**操作最多允许四个输入（一个源和三个工件）。

如果您需要引用驻留在不同输入（例如源和构件）中的文件，则源输入是主输入，构件是辅助输入。辅助输入中对文件的引用采用特殊前缀，以与主输入中的文件区分开来。有关更多信息，请参阅 [示例：引用多个构件中的文件](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file)。

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

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

(*DeployCloudFormationStack*/Inputs/**Sources**)

（如果您的 CloudFormation 或 AWS SAM 模板存储在源存储库中，则为必填项）

如果您的 CloudFormation 或 AWS SAM 模板存储在源存储库中，请指定该源存储库的标签。目前，唯一支持的标签是 `WorkflowSource`。

如果您的 CloudFormation 或 AWS SAM 模板不包含在源存储库中，则它必须位于其他操作生成的项目或 Amazon S3 存储桶中。

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

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

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

(*DeployCloudFormationStack*/Inputs/**Artifacts**)

（如果您的 CloudFormation 或 AWS SAM 模板存储在先前操作的[输出对象](workflows-working-artifacts-output.md)中，则为必填项）

如果要部署的 CloudFormation 或 AWS SAM 模板包含在先前操作生成的对象中，请在此处指定该对象。如果您的 CloudFormation 模板不包含在项目中，则该模板必须位于您的源存储库或 Amazon S3 存储桶中。

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

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

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

(*DeployCloudFormationStack*/**Configuration**)

（必需）

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

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

## name
<a name="deploy.action.cfn.stackname"></a>

(*DeployCloudFormationStack*/Configuration/**name**)

（必需）

为 De **ploy CloudFormation 堆栈操作创建或更新的 CloudFormation 堆栈**指定名称。

对应的 UI：“配置”选项卡/**堆栈名称**

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

(*DeployCloudFormationStack*/Configuration/**region**)

（必需）

指定堆栈将部署 AWS 区域 到哪里。有关区域代码的列表，请参阅[区域端点](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes)。

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

## template
<a name="deploy.action.cfn.templatepath"></a>

(*DeployCloudFormationStack*/Configuration/**template**)

（必需）

指定您的文件 CloudFormation 或 AWS SAM 模板文件的名称和路径。模板可以采用 JSON 或 YAML 格式，并且可以位于源存储库、上一操作生成的构件或 Amazon S3 存储桶中。如果模板文件位于源存储库或构件中，则路径相对于源存储库或构件根目录。如果模板位于 Amazon S3 存储桶中，则路径为模板的**对象 URL** 值。

示例：

`./MyFolder/MyTemplate.json`

`MyFolder/MyTemplate.yml`

`https://MyBucket.s3.us-west-2.amazonaws.com/MyTemplate.yml`

**注意**  
您可能需要在模板的文件路径中添加前缀，以指明要在哪个构件或源中查找它。有关更多信息，请参阅[引用源存储库文件](workflows-sources-reference-files.md)和[在构件中引用文件](workflows-working-artifacts-refer-files.md)。

对应的 UI：“配置”选项卡/**模板**

## role-arn
<a name="deploy.action.cfn.stackrolearn"></a>

(*DeployCloudFormationStack*/Configuration/**role-arn**)

（必需）

指定堆栈角色的亚马逊资源名称 (ARN)。 CloudFormation 使用此角色访问和修改堆栈中的资源。例如：`arn:aws:iam::123456789012:role/StackRole`。

确保堆栈角色包括：
+ 一个或多个权限策略。这些策略取决于您在堆栈中拥有的资源。例如，如果您的堆栈包含一个 AWS Lambda 函数，则需要添加授予对 Lambda 访问权限的权限。如果您按照[教程：部署无服务器应用程序](deploy-tut-lambda.md)中描述的教程进行操作，则其中包含一个名为[创建堆栈角色](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles-stack)的过程，该过程列出堆栈角色在部署典型无服务器应用程序堆栈时所需的权限。
**警告**  
将权限限制为 CloudFormation 服务访问堆栈中资源所需的权限。使用具有更广泛权限的角色可能会带来安全风险。
+ 以下信任策略：

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

****  

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

------

（可选）将此角色与您的账户连接关联。要了解有关将 IAM 角色与账户连接关联的更多信息，请参阅[将 IAM 角色添加到账户连接](ipa-connect-account-addroles.md)。如果您未将堆栈角色与账户连接关联，则堆栈角色将不会出现在可视化编辑器中的**堆栈角色**下拉列表中；但仍可以使用 YAML 编辑器在 `role-arn` 字段中指定角色 ARN。

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

对应的 UI：“配置”选项卡/**堆栈角色 – 可选**

## capabilities
<a name="deploy.action.cfn.capabilities"></a>

(*DeployCloudFormationStack*/Configuration/**capabilities**)

（必需）

指定允许 CloudFormation 创建特定堆栈所需的 IAM 功能列表。在大多数情况下，您可以将 `capabilities` 保留默认值 `CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND`。

如果您在**部署 CloudFormation 堆栈**操作的日志中看到 `##[error] requires capabilities: [capability-name]`，请参阅[如何修复 IAM 功能错误？](troubleshooting-workflows.md#troubleshooting-workflows-capabilities)以获取有关如何修复该问题的信息。

有关 IAM 功能的更多信息，请参阅 [IAM *用户指南中的在 CloudFormation 模板中确认 IAM* 资源](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities)。

对应的 UI：“配置”选项卡/高级/**功能**

## parameter-overrides
<a name="deploy.action.cfn.parameter.overrides"></a>

(*DeployCloudFormationStack*/Configuration/**parameter-overrides**)

（可选）

在您的 CloudFormation 或 AWS SAM 模板中指定没有默认值的参数，或者您要为其指定非默认值的参数。有关参数的更多信息，请参阅《* AWS CloudFormation 用户指南*》中的[参数](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html)。

`parameter-overrides` 属性接受：
+ 包含参数和值的 JSON 文件。
+ 参数和值的逗号分隔列表。

**指定 JSON 文件**

1. 确保 JSON 文件使用下列语法之一：

   ```
   {
     "Parameters": {
       "Param1": "Value1",
       "Param2": "Value2",
       ...
     }
   }
   ```

   或...

   ```
   [
     {
        "ParameterKey": "Param1",
        "ParameterValue": "Value1"
     },
     ...
   ]
   ```

   （还有其他语法，但在撰写本文时尚不支持这些语法。） CodeCatalyst 有关在 JSON 文件中指定 CloudFormation 参数的更多信息，请参阅*AWS CLI 命令参考*中[支持的 JSON 语法](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudformation/deploy/index.html#supported-json-syntax)。

1. 使用下列格式之一指定 JSON 文件的路径：
   + 如果 JSON 文件位于上一操作的输出构件中，请使用：

     `file:///artifacts/current-action-name/output-artifact-name/path-to-json-file`

     有关详细信息，请参阅**示例 1**。
   + 如果 JSON 文件位于源存储库中，请使用：

     `file:///sources/WorkflowSource/path-to-json-file`

     有关详细信息，请参阅**示例 2**。

     **示例 1** – JSON 文件位于输出构件中

     ```
     ##My workflow YAML
     ...
     Actions:
       MyBuildAction:
         Identifier: aws/build@v1
         Outputs:
           Artifacts:
             - Name: ParamArtifact
               Files:
                 - params.json
         Configuration:
         ...
       MyDeployCFNStackAction:
         Identifier: aws/cfn-deploy@v1
         Configuration:
           parameter-overrides: file:///artifacts/MyDeployCFNStackAction/ParamArtifact/params.json
     ```

     **示例 2** – JSON 文件位于源存储库中的名为 `my/folder` 的文件夹中

     ```
     ##My workflow YAML
     ...
     Actions:
       MyDeployCloudFormationStack:
         Identifier: aws/cfn-deploy@v1
         Inputs:
           Sources:
             - WorkflowSource
         Configuration:
           parameter-overrides: file:///sources/WorkflowSource/my/folder/params.json
     ```

**使用参数的逗号分隔列表**
+ 使用以下格式在 `parameter-overrides` 属性中添加参数名称/值对：

  `param-1=value-1,param-2=value-2`

  例如，假设使用以下 CloudFormation 模板：

  ```
  ##My CloudFormation template
  
  Description: My CloudFormation template
  
  Parameters:
    InstanceType:
      Description: Defines the Amazon EC2 compute for the production server.
      Type: String
      Default: t2.micro
      AllowedValues:
        - t2.micro
        - t2.small
        - t3.medium
      
  Resources:
  ...
  ```

  ...您可以设置 `parameter-overrides` 属性，如下所示：

  ```
  ##My workflow YAML
  ...
  Actions:
  ...
    DeployCloudFormationStack:
      Identifier: aws/cfn-deploy@v1
      Configuration:
        parameter-overrides: InstanceType=t3.medium,UseVPC=true
  ```
**注意**  
您可以使用 `undefined` 作为值来指定不带相应值的参数名称。例如：  
`parameter-overrides: MyParameter=undefined`  
 其效果是，在堆栈更新期间， CloudFormation 使用现有参数值作为给定参数名称。

对应的 UI：
+ “配置”选项卡/高级/**参数覆盖**
+ 配置tab/Advanced/Parameter覆盖/ 使用文件**指定覆盖**
+ 配置tab/Advanced/Parameter覆盖/使用值集**指定覆盖**

## no-execute-changeset
<a name="deploy.action.cfn.noexecutechangeset"></a>

(*DeployCloudFormationStack*/Configuration/**no-execute-changeset**)

（可选）

指定是否 CodeCatalyst 要创建 CloudFormation 更改集，然后在运行之前将其停止。这使您有机会在 CloudFormation 控制台中查看更改集。如果您确定更改集看起来不错，请禁用此选项，然后重新运行工作流程，这样 CodeCatalyst 就可以不停地创建和运行变更集。默认设置为不停地创建和运行更改集。有关更多信息，请参阅《*AWS CLI 命令参考*》中的 deplo CloudFormation [y](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) 参数。有关查看更改集的更多信息，请参阅《AWS CloudFormation 用户指南》**中的[查看更改集](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets-view.html)。

对应的 UI：“配置”选项卡/高级/**没有执行更改集**

## fail-on-empty-changeset
<a name="deploy.action.cfn.failonemptychangeset"></a>

(*DeployCloudFormationStack*/Configuration/**fail-on-empty-changeset**)

（可选）

指定如果 CloudFormation 更改集为空，是否 CodeCatalyst 要让 “**部署 CloudFormation 堆栈**” 操作失败。（如果更改集为空，则表示在最新部署期间未对堆栈进行任何更改。） 默认设置为，在更改集为空时允许操作继续执行，并返回一条 `UPDATE_COMPLETE` 消息（即使未更新堆栈）。

有关此设置的更多信息，请参阅《*AWS CLI 命令参考*》中的 dep CloudFormation [loy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) 参数。有关更多信息，请参阅《AWS CloudFormation 用户指南》**中的[使用更改集更新堆栈](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html)。

对应的 UI：“配置”选项卡/高级/**空更改集会失败**

## disable-rollback
<a name="deploy.action.cfn.disablerollback"></a>

(*DeployCloudFormationStack*/Configuration/**disable-rollback**)

（可选）

指定在堆栈部署失败时是否 CodeCatalyst 要回滚堆栈部署。回滚会使堆栈返回到上一个已知的稳定状态。默认设置为启用回滚。有关此设置的更多信息，请参阅《*AWS CLI 命令参考*》中的 dep CloudFormation [loy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) 参数。

有关 Depl **oy CloudFormation 堆栈**操作如何处理回滚的更多信息，请参阅[配置回滚](deploy-consumption-enable-alarms.md)。

有关回滚堆栈的更多信息，请参阅《AWS CloudFormation 用户指南》**中的[堆栈故障选项](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stack-failure-options.html)。

对于的 UI：“配置”选项卡/高级/**禁用回滚**

## termination-protection
<a name="deploy.action.cfn.terminationprotection"></a>

(*DeployCloudFormationStack*/Configuration/**termination-protection**)

（可选）

指定是否希望 **Deploy CloudFormation 堆栈**为其正在部署的堆栈添加终止保护。如果用户尝试删除已启用终止保护的堆栈，则删除操作会失败，并且堆栈及其状态将保持不变。默认设置为禁用终止保护。有关更多信息，请参阅《AWS CloudFormation 用户指南》**中的[保护堆栈不被删除](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html)。

对应的 UI：“配置”选项卡/高级/**终止保护**

## timeout-in-minutes
<a name="deploy.action.cfn.timeoutinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**timeout-in-minutes**)

（可选）

指定在堆栈创建操作超时并将堆栈状态设置为之前 CloudFormation 应分配的时间（以`CREATE_FAILED`分钟为单位）。如果 CloudFormation 无法在分配的时间内创建整个堆栈，它将因超时而导致堆栈创建失败并回滚该堆栈。

默认情况下，堆栈创建从不超时。但是，单个资源可能会根据它们所实施服务的性质而具有自己的超时。例如，如果堆栈中的单个资源发生超时，则堆栈创建也会超时，即使尚未达到您为堆栈创建指定的超时也不例外。

**对应的用户界面：配置选项卡/高级/超CloudFormation时**

## notification-arns
<a name="deploy.action.cfn.notificationarns"></a>

(*DeployCloudFormationStack*/Configuration/**notification-arns**)

（可选）

指定您 CodeCatalyst 要向其发送通知消息的 Amazon SNS 主题的 ARN。例如 `arn:aws:sns:us-east-1:111222333:MyTopic`。当 **Deploy CloudFormation 堆栈**操作运行时，与 CodeCatalyst CloudFormation 协调，为堆栈创建或更新过程中发生的每个 CloudFormation 事件发送一条通知。（事件显示在 CloudFormation 控制台堆栈的 “**事件**” 选项卡中。） 最多可以指定五个主题。有关更多信息，请参阅 [Amazon SNS 是什么？](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)。

**对应的用户界面：“配置” 选项卡/高级/ “通知” ARNs**

## monitor-alarm-arns
<a name="deploy.action.cfn.monitoralarmarns"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-alarm-arns**)

（可选）

指定要用作回滚触发器的亚马逊 CloudWatch 警报的亚马逊资源名称 (ARN)。例如 `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`。您可以拥有最多 5 个回滚触发器。

**注意**  
如果您指定 CloudWatch 警报 ARN，则还需要配置其他权限才能使操作能够访问。 CloudWatch有关更多信息，请参阅 [配置回滚](deploy-consumption-enable-alarms.md)。

**对应的用户界面：“配置” 选项卡/高级/监控警报 ARNs**

## monitor-timeout-in-minutes
<a name="deploy.action.cfn.monitortimeinminutes"></a>

(*DeployCloudFormationStack*/Configuration/**monitor-timeout-in-minutes**)

（可选）

指定 CloudFormation 监视指定警报的时间段，介于 0 到 180 分钟之间。在部署完所有堆栈资源*后*开始监控。如果警报发生在指定的监控时间内，则部署将失败，并回 CloudFormation 滚整个堆栈操作。

默认值：0。 CloudFormation 仅在部署堆栈资源时监控警报，而不在部署堆栈资源之后监视警报。

对应的 UI：“配置”选项卡/高级/**监控时间**

## tags
<a name="deploy.action.cfn.tags"></a>

(*DeployCloudFormationStack*/Configuration/**tags**)

（可选）

指定要附加到 CloudFormation 堆栈的标签。标签是任意键值对，可用于针对成本分配等目的来标识堆栈。有关什么是标签以及如何使用标签的更多信息，请参阅《Amazon EC2 用户指南》中的[标记资源](https://docs.aws.amazon.com/)。有关在中添加标签的更多信息 CloudFormation，请参阅《*AWS CloudFormation 用户指南》*中的[设置 CloudFormation 堆栈选项](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html)。

密钥可包含字母数字字符或空格，最多包含 127 个字符。值可包含字母数字字符或空格，最多包含 255 个字符。

您可以为每个堆栈添加最多 50 个唯一标签。

对应的 UI：“配置”选项卡/高级/**标签**

# 使用工作流程部署 AWS CDK 应用程序
<a name="cdk-dep-action"></a>

本节介绍如何使用工作流程将 AWS Cloud Development Kit (AWS CDK) 应用程序部署到您的 AWS 账户。为此，您必须将 **AWS CDK 部署**操作添加到工作流中。**AWS CDK 部署**操作会合成您的 AWS Cloud Development Kit (AWS CDK) 应用程序并将其部署到。 AWS如果您的应用程序已存在于中 AWS，则操作会在必要时对其进行更新。

有关使用编写应用程序的一般信息 AWS CDK，请参阅[什么是 AWS CDK？](https://docs.aws.amazon.com/cdk/v2/guide/home.html) 在《*AWS Cloud Development Kit (AWS CDK) 开发人员指南》*中。

**Topics**
+ [何时使用 “AWS CDK 部署” 操作](#cdk-dep-action-when-to-use)
+ [“AWS CDK 部署” 操作的工作原理](#cdk-dep-action-how-it-works)
+ [“部AWS CDK 署” 操作使用的 CDK CLI 版本](#cdk-dep-action-cdk-version)
+ [“AWS CDK 部署” 操作使用的运行时镜像](#cdk-dep-action-runtime)
+ [操作可以部署多少个堆栈？](#cdk-dep-action-how-many-stacks)
+ [示例：部署 AWS CDK 应用程序](cdk-dep-action-example-workflow.md)
+ [添加 “AWS CDK 部署” 操作](cdk-dep-action-add.md)
+ [“AWS CDK 部署”变量](cdk-dep-action-variables.md)
+ [“AWS CDK 部署”操作 YAML](cdk-dep-action-ref.md)

## 何时使用 “AWS CDK 部署” 操作
<a name="cdk-dep-action-when-to-use"></a>

如果您使用开发了应用程序 AWS CDK，并且现在想要将其作为自动化持续集成和交付 (CI/CD) 工作流程的一部分自动部署，请使用此操作。例如，当有人合并与您的 AWS CDK 应用程序来源相关的拉取请求时，您可能希望自动部署您的 AWS CDK 应用程序。

## “AWS CDK 部署” 操作的工作原理
<a name="cdk-dep-action-how-it-works"></a>

**AWS CDK 部署**的工作方式如下：

1. [在运行时，如果您指定了 1.0.12 或更早版本的操作，则该操作会将最新的 CDK CLI（也称为 AWS CDK Tookit）下载到 CodeCatalyst 运行时环境映像。](#cdk-dep-action-runtime)

   如果您指定了 1.0.13 或更高版本，则该操作会与[特定版本](#cdk-dep-action-cdk-version)的 CDK CLI 捆绑在一起，因此不会下载。

1. 该操作使用 CDK CLI 来运行 `cdk deploy` 命令。此命令将您的 AWS CDK 应用程序合成并部署到中。 AWS有关更多信息，请参阅《AWS Cloud Development Kit (AWS CDK) Developer Guide》**中的 [AWS CDK Toolkit (cdk command)](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) 主题。

## “部AWS CDK 署” 操作使用的 CDK CLI 版本
<a name="cdk-dep-action-cdk-version"></a>

下表显示了不同版本的 **AWS CDK 部署**操作默认使用哪个版本的 CDK CLI。

**注意**  
您也许能够覆盖默认值。有关更多信息，请参阅[“AWS CDK 部署”操作 YAML](cdk-dep-action-ref.md) 中的 [CdkCliVersion](cdk-dep-action-ref.md#cdk.dep.cdk.cli.version)。


| “AWS CDK 部署”操作版本 | AWS CDK CLI 版本 | 
| --- | --- | 
|  1.0.0 – 1.0.12  |  最新  | 
|  1.0.13 或更高版本  |  2.99.1  | 

## “AWS CDK 部署” 操作使用的运行时镜像
<a name="cdk-dep-action-runtime"></a>

下表显示了 CodeCatalyst 用于运行不同版本的**AWS CDK 部署**操作的运行时环境映像。这些映像包括不同的预安装工具集。有关更多信息，请参阅 [活动映像](build-images.md#build-curated-images)。

**注意**  
我们建议将您的 **AWS CDK 部署**操作升级到 2.x 版，从而利用 2024 年 3 月版映像中提供的最新工具。要升级操作，请在工作流定义文件中将其 `Identifier` 属性设置为 `aws/cdk-deploy@v2`。有关更多信息，请参阅 [“AWS CDK 部署”操作 YAML](cdk-dep-action-ref.md)。


| “AWS CDK 部署”操作版本 | 运行时环境映像 | 
| --- | --- | 
|  1.x  |  2022 年 11 月版映像  | 
|  2.x  |  2024 年 3 月版映像  | 

## 操作可以部署多少个堆栈？
<a name="cdk-dep-action-how-many-stacks"></a>

**AWS CDK 部署**只能部署单个堆栈。如果您的 AWS CDK 应用程序由多个堆栈组成，则必须创建包含嵌套堆栈的父堆栈，然后使用此操作部署父堆栈。

# 示例：部署 AWS CDK 应用程序
<a name="cdk-dep-action-example-workflow"></a>

以下示例工作流包括 **AWS CDK 部署**操作以及 **AWS CDK 引导**操作。工作流包含以下按顺序运行的构造块：
+ **触发器** – 当您将更改推送到源存储库时，此触发器会自动启动工作流运行。此存储库包含您的 AWS CDK 应用程序。有关触发器的更多信息，请参阅[使用触发器自动启动工作流运行](workflows-add-trigger.md)。
+ **AWS CDK 引导**操作 (`CDKBootstrap`)-触发后，该操作会将`CDKToolkit`引导堆栈部署到。 AWS如果环境中已存在 `CDKToolkit` 堆栈，则将在必要时对堆栈进行升级；否则，不会发生任何操作，并且该操作将标记为成功。
+ **AWS CDK 部署**操作 (`AWS CDK Deploy`)-完成**AWS CDK 引导**操作后，**AWS CDK 部署**操作会将您的 AWS CDK 应用程序代码合成到模板中，并将 CloudFormation 模板中定义的堆栈部署到中。 AWS

**注意**  
以下工作流示例仅用于说明目的，如果不执行附加配置，则无法运行。

**注意**  
在接下来的 YAML 代码中，如果需要，可以省略 `Connections:` 部分。如果您省略这些部分，则必须确保在您的环境的**默认 IAM 角色**字段中指定的角色包含 **AWS CDK 引导**和 **AWS CDK 部署**操作所需的权限和信任策略。有关使用默认 IAM 角色设置环境的更多信息，请参阅[创建环境](deploy-environments-creating-environment.md)。有关 **AWS CDK 引导**和 **AWS CDK 部署**操作所需的权限和信任策略的更多信息，请参阅[“AWS CDK 引导”操作 YAML](cdk-boot-action-ref.md) 和[“AWS CDK 部署”操作 YAML](cdk-dep-action-ref.md) 中 `Role` 属性的说明。

```
Name: codecatalyst-cdk-deploy-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  CDKBootstrap:
    Identifier: aws/cdk-bootstrap@v2
    Inputs:
      Sources:
        - WorkflowSource
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-bootstrap-role
    Configuration:
      Region: us-west-2
        
  CDKDeploy:
    Identifier: aws/cdk-deploy@v2
    DependsOn: 
      - CDKBootstrap
    Environment:
      Name: codecatalyst-cdk-deploy-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-cdk-deploy-role
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      StackName: my-app-stack
      Region: us-west-2
```

# 添加 “AWS CDK 部署” 操作
<a name="cdk-dep-action-add"></a>

 按照以下说明，将 **AWS CDK 部署**操作添加到您的工作流中。

**开始之前**

在将 **AWS CDK 部署**操作添加到工作流之前，请先完成以下任务：

1. **准备好 AWS CDK 应用程序**。您可以使用 AWS CDK v1 或 v2，使用支持的任何编程语言编写 AWS CDK 应用程序。 AWS CDK确保您的 AWS CDK 应用程序文件在以下位置可用：
   +  CodeCatalyst [源存储库](source.md)，或 
   + 由另一个工作流程操作生成的 CodeCatalyst [输出对象](workflows-working-artifacts.md)

1. **引导您的 AWS 环境。**要进行引导，您可以：
   + 使用《AWS Cloud Development Kit (AWS CDK) Developer Guide》**中的 [How to bootstrap](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-howto) 介绍的方法之一。
   + 使用 **AWS CDK 引导**操作。您可以在与 **AWS CDK 部署**相同的工作流中添加此操作，也可以在不同的工作流中添加。这是为了确保引导操作在运行 **AWS CDK 部署**操作之前至少运行一次，以便必要的资源准备就位。有关**AWS CDK 引导**操作的更多信息，请参阅[使用工作流程引导 AWS CDK 应用程序](cdk-boot-action.md)。

     有关引导的更多信息，请参阅《AWS Cloud Development Kit (AWS CDK) Developer Guide》**中的 [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)。

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

**使用可视化编辑器添加AWS CDK “部署” 操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

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

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

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

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

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

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

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

1. 选择**提交**，输入提交消息，然后再次选择**提交**。
**注意**  
如果您的 **AWS CDK 部署**操作失败并出现 `npm install` 错误，请参阅[如何修复“npm install”错误？](troubleshooting-workflows.md#troubleshooting-workflows-npm)，了解有关如何修复错误的信息。

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

**使用 YAML 编辑器添加AWS CDK “部署” 操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择 **YAML**。

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

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

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

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

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

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

1. 选择**提交**，输入提交消息，然后再次选择**提交**。
**注意**  
如果您的 **AWS CDK 部署**操作失败并出现 `npm install` 错误，请参阅[如何修复“npm install”错误？](troubleshooting-workflows.md#troubleshooting-workflows-npm)，了解有关如何修复错误的信息。

------

# “AWS CDK 部署”变量
<a name="cdk-dep-action-variables"></a>

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

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


| 键 | 值 | 
| --- | --- | 
|  stack-id  |  在工作流程运行期间部署到的 AWS CDK 应用程序堆栈的 Amazon 资源名称 (ARN)。 示例：`arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-app-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  deployment-platform  |  部署平台的名称。 硬编码为 `AWS:CloudFormation`。  | 
|  region  |  在工作流程运行期间部署到的的区域代码。 AWS 区域  示例：`us-west-2`  | 
|  SKIP-DEPLOYMENT  |  值为`true`表示在工作流程运行期间跳过了 AWS CDK 应用程序堆栈的部署。如果自上次部署以来，堆栈没有发生变化，则将跳过堆栈部署。 只有当该变量的值为 `true` 时，才会生成该变量。 硬编码为 `true`。  | 
|  *CloudFormation variables*  |  除了生成前面列出的变量外，**AWS CDK 部署**操作还将*CloudFormation*输出变量作为*工作流*变量公开，以便在后续的工作流操作中使用。默认情况下，该操作仅公开它找到的前四个（或更少） CloudFormation变量。要确定哪些变量已公开，请运行一次 **AWS CDK 部署**操作，然后在运行详细信息页面的**变量**选项卡中查看。如果**变量**选项卡上列出的变量不是您需要的，则可以使用 `CfnOutputVariables` YAML 属性配置其他变量。有关更多信息，请参阅[“AWS CDK 部署”操作 YAML](cdk-dep-action-ref.md) 中 [CfnOutputVariables](cdk-dep-action-ref.md#cdk.dep.cfn.out) 属性的描述。  | 

# “AWS CDK 部署”操作 YAML
<a name="cdk-dep-action-ref"></a>

下面是 **AWS CDK 部署**操作的 YAML 定义。要了解如何使用此操作，请参阅[使用工作流程部署 AWS CDK 应用程序](cdk-dep-action.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.   
  CDKDeploy\$1nn: 
    Identifier: aws/cdk-deploy@v2
    DependsOn:
      - CDKBootstrap
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_artifact
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      StackName: my-cdk-stack
      Region: us-west-2
      Tags: '{"key1": "value1", "key2": "value2"}'
      Context: '{"key1": "value1", "key2": "value2"}'
      CdkCliVersion: version
      CdkRootPath: directory-containing-cdk.json-file
      CfnOutputVariables: '["CnfOutputKey1","CfnOutputKey2","CfnOutputKey3"]'
      CloudAssemblyRootPath: path-to-cdk.out
```

## CDKDeploy
<a name="cdk.dep.name"></a>

（必需）

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

默认值：`CDKDeploy_nn`。

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

## Identifier
<a name="cdk.dep.identifier"></a>

(*CDKDeploy*/**Identifier**)

（必需）

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

**注意**  
指定 `aws/cdk-deploy@v2` 可以让操作在 [2024 年 3 月版映像](build-images.md#build.default-image)上运行，其中包括较新的工具，例如 Node.js 18。指定 `aws/cdk-deploy@v1` 可以让操作在 [2022 年 11 月版映像](build-images.md#build.previous-image)上运行，其中包括较旧的工具，例如 Node.js 16。

默认值：`aws/cdk-deploy@v2`。

对应的 UI：工作流图表/CDKDeploy\$1nn/**aws/cdk-deploy@v2** 标签

## DependsOn
<a name="cdk.dep.dependson"></a>

(*CDKDeploy*/**DependsOn**)

（可选）

指定必须成功运行才能使 **AWS CDK 部署**操作运行的操作或操作组。我们建议在 `DependsOn` 属性中指定 **AWS CDK 引导**操作，如下所示：

```
CDKDeploy:
  Identifier: aws/cdk-deploy@v2
  DependsOn:
    - CDKBootstrap
```

**注意**  
[引导](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)是部署应用程序的必备先决条件。 AWS CDK 如果您未在工作流中包含 **AWS CDK 引导**操作，则在运行 **AWS CDK 部署**操作之前，必须找到另一种用于部署 AWS CDK 引导堆栈的方法。有关更多信息，请参阅[使用工作流程部署 AWS CDK 应用程序](cdk-dep-action.md)中的[添加 “AWS CDK 部署” 操作](cdk-dep-action-add.md)。

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

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

## Compute
<a name="cdk.dep.computename"></a>

(*CDKDeploy*/**Compute**)

（可选）

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

对应的 UI：*无*

## Type
<a name="cdk.dep.computetype"></a>

(*CDKDeploy*/Compute/**Type**)

（如果包含 [Compute](#cdk.dep.computename)，则为必需）

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

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

  优化了操作启动速度。

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

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

## Fleet
<a name="cdk.dep.computefleet"></a>

(*CDKDeploy*/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="cdk.dep.timeout"></a>

(*CDKDeploy*/**Timeout**)

（必需）

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

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

## Inputs
<a name="cdk.dep.inputs"></a>

(*CDKDeploy*/**Inputs**)

（可选）

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

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

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

## Sources
<a name="cdk.dep.inputs.sources"></a>

(*CDKDeploy*/Inputs/**Sources**)

（如果您要部署的 AWS CDK 应用程序存储在源存储库中，则为必填项）

如果您的 AWS CDK 应用程序存储在源存储库中，请指定该源存储库的标签。在启动部署过程之前，**AWS CDK 部署**操作会合成此存储库中的应用程序。目前，唯一支持的标签是 `WorkflowSource`。

如果您的 AWS CDK 应用程序不包含在源存储库中，则它必须位于另一个操作生成的构件中。

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

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

## Artifacts - input
<a name="cdk.dep.inputs.artifacts"></a>

(*CDKDeploy*/Inputs/**Artifacts**)

（如果您要部署的 AWS CDK 应用程序存储在先前操作的[输出项目](workflows-working-artifacts-output.md)中，则为必填项）

如果您的 AWS CDK 应用程序包含在先前操作生成的构件中，请在此处指定该构件。在开始**AWS CDK 部署过程之前，部署**操作会将指定构件中的应用程序合成到 CloudFormation模板中。如果您的 AWS CDK 应用程序不包含在工件中，则它必须位于您的源存储库中。

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

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

## Outputs
<a name="cdk.dep.outputs"></a>

(*CDKDeploy*/**Outputs**)

（可选）

定义在工作流运行期间操作输出的数据。

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

## Artifacts - output
<a name="cdk.dep.outputs.artifacts"></a>

(*CDKDeploy*/Outputs/**Artifacts**

（可选）

指定操作生成的构件。您可以在其他操作中将这些构件作为输入来引用。

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

对应的 UI：“输出”选项卡/**构件**

## Name
<a name="cdk.dep.outputs.artifacts.name"></a>

(*CDKDeploy*/Outputs/Artifacts/**Name**)

（如果包含 [Artifacts - output](#cdk.dep.outputs.artifacts)，则为必需）

指定将包含在运行时由**AWS CDK 部署**操作合成的 CloudFormation 模板的对象的名称。默认值为 `cdk_artifact`。如果您未指定构件，则该操作会合成模板，但不会将模板保存在构件中。考虑将合成的模板保存在构件中，以便保留其记录，供测试或故障排除之用。

**对应的用户界面：输出tab/Artifacts/Add构件/构建构件名称**

## Files
<a name="cdk.dep.outputs.artifacts.files"></a>

(*CDKDeploy*/Outputs/Artifacts/**Files**)

（如果包含 [Artifacts - output](#cdk.dep.outputs.artifacts)，则为必需）

指定要包含在构件中的文件。您`"cdk.out/**/*"`必须指定包含 AWS CDK 应用程序的合成 CloudFormation 模板。

**注意**  
`cdk.out` 是保存已合成文件的默认目录。如果您指定了输出目录，而不是 `cdk.json` 文件中的 `cdk.out`，请在此处指定该目录，而不是 `cdk.out`。

相应的 UI：输出tab/Artifacts/Add构件/编译生成的**文件**

## Environment
<a name="cdk.dep.environment"></a>

(*CDKDeploy*/**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="cdk.dep.environment.name"></a>

(*CDKDeploy*/Environment/**Name**)

（如果包含 [Environment](#cdk.dep.environment)，则为必需）

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

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

## Connections
<a name="cdk.dep.environment.connections"></a>

(*CDKDeploy*/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="cdk.dep.environment.connections.name"></a>

(*CDKDeploy*/Environment/Connections/**Name**)

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

指定账户连接的名称。

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

## Role
<a name="cdk.dep.environment.connections.role"></a>

(*CDKDeploy*/Environment/Connections/**Role**)

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

指定账户连接的名称。

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

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

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "cloudformation:DescribeStackEvents",
                  "cloudformation:DescribeChangeSet",
                  "cloudformation:DescribeStacks",
                  "cloudformation:ListStackResources"
              ],
              "Resource": "*"
          },
          {
              "Sid": "VisualEditor1",
              "Effect": "Allow",
              "Action": "sts:AssumeRole",
              "Resource": "arn:aws:iam::111122223333:role/cdk-*"
          }
      ]
  }
  ```

------
+ 以下自定义信任策略：

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

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

## Configuration
<a name="cdk.dep.configuration"></a>

(*CDKDeploy*/**Configuration**)

（必需）

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

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

## StackName
<a name="cdk.dep.stack.name"></a>

(*CDKDeploy*/Configuration/**StackName**)

（必需）

 AWS CDK 应用程序堆栈的名称，显示在 AWS CDK 应用程序目录的入口点文件中。`bin`以下示例显示了 TypeScript入口点文件的内容，其中突出显示了堆栈名称。*red italics*如果您的入口点文件使用的是不同语言，该文件看起来会很相似。

```
import * as cdk from 'aws-cdk-lib';
import { CdkWorksopTypescriptStack } from '../lib/cdk_workshop_typescript-stack';

const app = new cdk.App();
new CdkWorkshopTypescriptStack(app, 'CdkWorkshopTypescriptStack');
```

您只能指定一个堆栈。

**提示**  
如果您具有多个堆栈，则可以创建带有嵌套堆栈的父堆栈。然后，您可以在此操作中指定父堆栈，以便部署所有堆栈。

对应的 UI：“配置”选项卡/**堆栈名称**

## Region
<a name="cdk.dep.region"></a>

(*CDKDeploy*/Configuration/**Region**)

（可选）

指定要 AWS 区域 将 AWS CDK 应用程序堆栈部署到哪里。有关区域代码的列表，请参阅[区域端点](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes)。

如果您未指定区域，则**AWS CDK 部署**操作将部署到您的 AWS CDK 代码中指定的区域。有关更多信息，请参阅《AWS Cloud Development Kit (AWS CDK) Developer Guide》**中的 [Environments](https://docs.aws.amazon.com/cdk/v2/guide/environments.html)。

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

## Tags
<a name="cdk.dep.tags"></a>

(*CDKDeploy*/Configuration/**Tags**)

（可选）

指定要应用于 AWS CDK 应用程序堆栈中 AWS 资源的标签。标签应用于堆栈自身以及堆栈中的各个资源。有关标记的更多信息，请参阅《AWS Cloud Development Kit (AWS CDK) Developer Guide》**中的 [Tagging](https://docs.aws.amazon.com/cdk/v2/guide/tagging.html)。

**对应的用户界面：配置 tab/Advanced -可选/标签**

## Context
<a name="cdk.dep.context"></a>

(*CDKDeploy*/Configuration/**Context**)

（可选）

以键值对的形式指定要与 AWS CDK 应用程序堆栈关联的上下文。有关上下文的更多信息，请参阅《AWS Cloud Development Kit (AWS CDK) Developer Guide》**中的 [Runtime contexts](https://docs.aws.amazon.com/cdk/v2/guide/context.html)。

**相应的 UI：配置 tab/Advanced -可选/上下文**

## CdkCliVersion
<a name="cdk.dep.cdk.cli.version"></a>

(*CDKDeploy*/Configuration/**CdkCliVersion**)

（可选）

此属性适用于 **AWS CDK 部署**操作的 1.0.13 或更高版本，以及 **AWS CDK 引导**操作的 1.0.8 或更高版本。

指定下列项之一：
+ 您希望此操作使用的 AWS Cloud Development Kit (AWS CDK) 命令行界面 (CLI)（也称为 AWS CDK 工具包）的完整版本。示例：`2.102.1`。在构建和部署您的应用程序时，请考虑指定完整版本，从而确保一致性和稳定性。

  Or
+ `latest`。请考虑指定 `latest`，从而利用 CDK CLI 的最新功能和修复。

该操作会将指定版本（或最新版本）的 AWS CDK CLI 下载到 CodeCatalyst [构建映像](build-images.md)，然后使用此版本运行部署 CDK 应用程序或引导环境所需的命令。 AWS 

有关可使用的受支持 CDK CLI 版本的列表，请参阅 [AWS CDK 版本](https://docs.aws.amazon.com/cdk/api/versions.html)。

如果省略此属性，则该操作将使用以下主题之一中描述的默认 AWS CDK CLI 版本：
+ [“部AWS CDK 署” 操作使用的 CDK CLI 版本](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [“AWS CDK 引导” 操作使用的 CDK CLI 版本](cdk-boot-action.md#cdk-boot-action-cdk-version)

对应的 UI：“配置” 选项卡/ **AWS CDK CLI 版本**

## CdkRootPath
<a name="cdk.dep.cdk.root.path"></a>

(*CDKDeploy*/Configuration/**CdkRootPath**)

（可选）

包含 AWS CDK 项目`cdk.json`文件的目录的路径。**AWS CDK 部署**操作从该文件夹运行，并且该操作创建的所有输出都将添加到此目录中。如果未指定，则**AWS CDK 部署**操作假定该`cdk.json`文件位于 AWS CDK 项目的根目录中。

对应的 UI：“配置选项卡”/**cdk.json 所在的目录**

## CfnOutputVariables
<a name="cdk.dep.cfn.out"></a>

(*CDKDeploy*/Configuration/**CfnOutputVariables**)

（可选）

指定要在 AWS CDK 应用程序代码中将哪些`CfnOutput`构造显示为工作流程输出变量。然后，您可以在工作流的后续操作中引用工作流输出变量。有关中变量的更多信息 CodeCatalyst，请参阅[在工作流中使用变量](workflows-working-with-variables.md)。

例如，如果您的 AWS CDK 应用程序代码如下所示：

```
import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import * as s3 from 'aws-cdk-lib/aws-s3';
import { Construct } from 'constructs';
import * as cdk from 'aws-cdk-lib';
export class HelloCdkStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);
    const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
      removalPolicy: RemovalPolicy.DESTROY,
    });
    new CfnOutput(this, 'bucketName', {
      value: bucket.bucketName,
      description: 'The name of the s3 bucket',
      exportName: 'amzn-s3-demo-bucket',
    });
    const table = new dynamodb.Table(this, 'todos-table', {
      partitionKey: {name: 'todoId', type: dynamodb.AttributeType.NUMBER},
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
      removalPolicy: RemovalPolicy.DESTROY,
    })
    new CfnOutput(this, 'tableName', {
      value: table.tableName,
      description: 'The name of the dynamodb table',
      exportName: 'myDynamoDbTable',
    });
    ...
  }
}
```

... 并且您的 `CfnOutputVariables` 属性如下：

```
Configuration:
  ...
  CfnOutputVariables: '["bucketName","tableName"]'
```

... 则该操作会生成以下工作流输出变量：


| 键 | 值 | 
| --- | --- | 
|  bucketName  |  `bucket.bucketName`  | 
|  tableName  |  `table.tableName`  | 

然后，您可以在后续操作中引用 `bucketName` 和 `tableName` 变量。要了解如何在后续操作中引用工作流输出变量，请参阅 [引用预定义变量](workflows-working-with-variables-reference-output-vars.md)。

如果您未在`CfnOutputVariables`属性中指定任何`CfnOutput`构造，则该操作会将其找到的前四个（或更少） CloudFormation输出变量显示为工作流输出变量。有关更多信息，请参阅 [“AWS CDK 部署”变量](cdk-dep-action-variables.md)。

**提示**  
要获取操作生成的所有 CloudFormation 输出变量的列表，请运行一次包含**AWS CDK 部署**操作的工作流，然后查看该操作的 “**日志**” 选项卡。日志包含与您的 AWS CDK 应用程序关联的所有 CloudFormation 输出变量的列表。知道所有 CloudFormation 变量是什么之后，就可以使用`CfnOutputVariables`属性指定要将哪些变量转换为工作流程输出变量。

有关 CloudFormation 输出变量的更多信息，请参阅 *AWS Cloud Development Kit (AWS CDK) API 参考*中的`CfnOutput`[类 CfnOutput （构造）](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)中提供的构造文档。

相应的 UI：配置选项卡/ **CloudFormation 输出变量**

## CloudAssemblyRootPath
<a name="cdk.dep.cloud"></a>

(*CDKDeploy*/Configuration/**CloudAssemblyRootPath**)

（可选）

如果您已经将 AWS CDK 应用程序的堆栈合成到云程序集中（使用`cdk synth`操作），请指定云程序集目录的根路径（`cdk.out`）。位于指定云程序集目录中的 CloudFormation 模板将通过**AWS CDK 部署**操作 AWS 账户 使用`cdk deploy --app`命令部署到您的中。当存在 `--app` 选项时，不会发生 `cdk synth` 操作。

如果您未指定云程序集目录，则 **AWS CDK 部署**操作将运行不带 `--app` 选项的 `cdk deploy` 命令。如果没有该`--app`选项，则该`cdk deploy`操作既会合成 (`cdk synth`)，又会将您的 AWS CDK 应用程序部署到您的 AWS 账户。

**当 “AWS CDK 部署” 操作可以在运行时进行合成时，我为什么要指定现有的合成云组件？**

您可能需要将现有的合成云程序集指定为：
+ **确保每次运行 “部署” 操作时AWS CDK 部署完全相同的资源集**

  如果您未指定云程序集，则 **AWS CDK 部署**操作可能会根据运行时间合成和部署不同的文件。例如，**AWS CDK 部署**操作可能会在测试阶段合成具有一组依赖项的云程序集，而在生产阶段使用另一组依赖项（如果这些依赖项在各个阶段之间发生了变化）。为了确保测试的内容和部署的内容之间完全对等，我们建议合成一次，然后使用**云程序集目录路径**字段（可视化编辑器）或 `CloudAssemblyRootPath` 属性（YAML 编辑器），指定已合成的云程序集。
+ **将非标准的软件包管理器和工具与 AWS CDK 应用程序结合使用**

  在 `synth` 操作期间，**AWS CDK 部署**操作会尝试使用 npm 或 pip 等标准工具运行您的应用程序。如果操作未能使用这些工具成功运行您的应用程序，则合成将不会执行，操作将失败。要解决此问题，您可以在应用程序`cdk.json`的文件中指定成功运行应用程序所需的确切命令，然后使用不涉及**AWS CDK 部署**操作的方法合成应用程序。 AWS CDK 生成云程序集后，可以在 **AWS CDK 部署**操作的**云程序集目录路径**字段（可视化编辑器）或 `CloudAssemblyRootPath` 属性（YAML 编辑器）中指定该程序集。

有关配置`cdk.json`文件以包含用于安装和运行 AWS CDK 应用程序的命令的信息，请参阅[指定应用程序命令](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-app-command)。

有关 `cdk deploy` 和 `cdk synth` 命令以及 `--app` 选项的信息，请参阅**《AWS Cloud Development Kit (AWS CDK) Developer Guide》中的 [Deploying stacks](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy)、[Synthesizing stacks](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-synth) 和 [Skipping synthesis](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-nosynth)。

有关云程序集的信息，请参阅**《AWS Cloud Development Kit (AWS CDK) API Reference》中的 [Cloud Assembly](https://docs.aws.amazon.com/cdk/api/v2/docs/cloud-assembly-schema-readme.html)。

对应的 UI：“配置”选项卡/**云程序集目录路径**

# 使用工作流程引导 AWS CDK 应用程序
<a name="cdk-boot-action"></a>

本节介绍如何使用 CodeCatalyst 工作流程引导 AWS CDK 应用程序。为此，您必须将 **AWS CDK 引导**操作添加到工作流中。**AWS CDK 引导**操作使用[现代模板](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-template)，在您的 AWS 环境中预置引导堆栈。如果引导堆栈已存在，则操作会在必要时更新该堆栈。在中存在引导堆栈 AWS 是部署 AWS CDK 应用程序的先决条件。

有关引导的更多信息，请参阅《AWS Cloud Development Kit (AWS CDK) Developer Guide》**中的 [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html)。

**Topics**
+ [何时使用 “AWS CDK bootstrap” 操作](#cdk-boot-action-when-to-use)
+ [“AWS CDK bootstrap” 操作的工作原理](#cdk-boot-action-how-it-works)
+ [“AWS CDK 引导” 操作使用的 CDK CLI 版本](#cdk-boot-action-cdk-version)
+ [“AWS CDK bootstrap” 操作使用的运行时镜像](#cdk-boot-action-runtime)
+ [示例：引导应用程序 AWS CDK](cdk-boot-action-example-workflow.md)
+ [添加 “AWS CDK 引导” 操作](cdk-boot-action-add.md)
+ [“AWS CDK 引导”变量](cdk-boot-action-variables.md)
+ [“AWS CDK 引导”操作 YAML](cdk-boot-action-ref.md)

## 何时使用 “AWS CDK bootstrap” 操作
<a name="cdk-boot-action-when-to-use"></a>

如果您有部署 AWS CDK 应用程序的工作流程，并且想要同时部署（并在需要时更新）引导堆栈，请使用此操作。在这种情况下，您可以将**AWS CDK 引导**操作添加到与部署应用程序的工作流程相同的工作流程中。 AWS CDK 

如果符合以下任一情况，请**不要**使用此操作：
+ 您已使用另一种机制部署了引导堆栈，并且希望保持其原样（不更新）。
+ 您想要使用[自定义引导模板](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-customizing)，但 **AWS CDK 引导**操作不支持该模板。

## “AWS CDK bootstrap” 操作的工作原理
<a name="cdk-boot-action-how-it-works"></a>

**AWS CDK 引导**操作的工作方式如下：

1. [在运行时，如果您指定了 1.0.7 或更早版本的操作，则该操作会将最新的 CDK CLI（也称为 AWS CDK Tookit）下载到构建映像。 CodeCatalyst ](build-images.md)

   如果您指定了 1.0.8 或更高版本，则该操作会与[特定版本](cdk-dep-action.md#cdk-dep-action-cdk-version)的 CDK CLI 捆绑在一起，因此不会下载。

1. 该操作使用 CDK CLI 来运行 `cdk bootstrap` 命令。此命令执行《AWS Cloud Development Kit (AWS CDK) Developer Guide》**的 [Bootstrapping](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html) 主题中介绍的引导任务。

## “AWS CDK 引导” 操作使用的 CDK CLI 版本
<a name="cdk-boot-action-cdk-version"></a>

下表显示了不同版本的 **AWS CDK 引导**操作默认使用哪个版本的 CDK CLI。

**注意**  
您也许能够覆盖默认值。有关更多信息，请参阅[“AWS CDK 引导”操作 YAML](cdk-boot-action-ref.md) 中的 [CdkCliVersion](cdk-boot-action-ref.md#cdk.boot.cdk.cli.version)。


| “AWS CDK 引导”操作版本 | AWS CDK CLI 版本 | 
| --- | --- | 
|  1.0.0 – 1.0.7  |  最新  | 
|  1.0.8 或更高版本  |  2.99.1  | 

## “AWS CDK bootstrap” 操作使用的运行时镜像
<a name="cdk-boot-action-runtime"></a>

下表显示了 CodeCatalyst 用于运行不同版本的**AWS CDK 引导**操作的运行时环境映像。这些映像包括不同的预安装工具集。有关更多信息，请参阅 [活动映像](build-images.md#build-curated-images)。

**注意**  
我们建议您将 **AWS CDK 引导**操作升级到 2.x 版，从而利用 2024 年 3 月版映像中提供的最新工具。要升级操作，请在工作流定义文件中将其 `Identifier` 属性设置为 `aws/cdk-bootstrap@v2`。有关更多信息，请参阅 [“AWS CDK 部署”操作 YAML](cdk-dep-action-ref.md)。


| “AWS CDK 引导”操作版本 | 运行时环境映像 | 
| --- | --- | 
|  1.x  |  2022 年 11 月版映像  | 
|  2.x  |  2024 年 3 月版映像  | 

# 示例：引导应用程序 AWS CDK
<a name="cdk-boot-action-example-workflow"></a>

有关包含 **AWS CDK 引导**操作的工作流，请参阅[使用工作流程部署 AWS CDK 应用程序](cdk-dep-action.md)中的[示例：部署 AWS CDK 应用程序](cdk-dep-action-example-workflow.md)。

# 添加 “AWS CDK 引导” 操作
<a name="cdk-boot-action-add"></a>

 按照以下说明，将 **AWS CDK 引导**操作添加到您的工作流中。

**开始之前**

在使用 **AWS CDK 引导**操作之前，请确保已准备好 AWS CDK 应用程序。引导操作将在引导之前合成 AWS CDK 应用程序。您可以使用 AWS CDK支持的任何编程语言编写应用程序。

确保您的 AWS CDK 应用程序文件在以下位置可用：
+  CodeCatalyst [源存储库](source.md)，或 
+ 由另一个工作流程操作生成的 CodeCatalyst [输出对象](workflows-working-artifacts.md)

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

**使用可视化编辑器添加 “AWS CDK bootstrap” 操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

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

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

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

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

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

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

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

1. 选择**提交**，输入提交消息，然后再次选择**提交**。
**注意**  
如果您的 **AWS CDK 引导**操作失败并出现 `npm install` 错误，请参阅[如何修复“npm install”错误？](troubleshooting-workflows.md#troubleshooting-workflows-npm)，了解有关如何修复错误的信息。

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

**使用 YAML 编辑器添加 “AWS CDK bootstrap” 操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择 **YAML**。

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

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

1. 搜索 **AWS CDK 引导**操作，然后选择 **\$1**，将操作添加到工作流图表中并打开其配置窗格。

1. 根据需求修改 YAML 代码中的属性。[“AWS CDK 引导”操作 YAML](cdk-boot-action-ref.md)中提供了每个可用属性的解释。

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

1. 选择**提交**，输入提交消息，然后再次选择**提交**。
**注意**  
如果您的 **AWS CDK 引导**操作失败并出现 `npm install` 错误，请参阅[如何修复“npm install”错误？](troubleshooting-workflows.md#troubleshooting-workflows-npm)，了解有关如何修复错误的信息。

------

# “AWS CDK 引导”变量
<a name="cdk-boot-action-variables"></a>

**AWS CDK 引导**操作在运行时会生成并设置以下变量。这些变量被称为*预定义变量*。

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


| 键 | 值 | 
| --- | --- | 
|  deployment-platform  |  部署平台的名称。 硬编码为 `AWS:CloudFormation`。  | 
|  region  |  在工作流程运行期间部署 AWS CDK 引导堆栈的区域代码。 AWS 区域  示例：`us-west-2`  | 
|  stack-id  |  已部署的 AWS CDK 引导堆栈的 Amazon 资源名称 (ARN)。 示例：`arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cdk-bootstrap-stack/6aad4380-100a-11ec-a10a-03b8a84d40df`  | 
|  SKIP-DEPLOYMENT  |  值为`true`表示在工作流程运行期间跳过了 AWS CDK 引导堆栈的部署。如果自上次部署以来，堆栈没有发生变化，则将跳过堆栈部署。 只有当该变量的值为 `true` 时，才会生成该变量。 硬编码为 `true`。  | 

# “AWS CDK 引导”操作 YAML
<a name="cdk-boot-action-ref"></a>

下面是 **AWS CDK 引导**操作的 YAML 定义。要了解如何使用此操作，请参阅[使用工作流程引导 AWS CDK 应用程序](cdk-boot-action.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.    
  CDKBootstrapAction\$1nn: 
    Identifier: aws/cdk-bootstrap@v2
    DependsOn:
      - action-name
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
    Outputs:
      Artifacts:
        - Name: cdk_bootstrap_artifacts
          Files: 
            - "cdk.out/**/*"
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      Region: us-west-2
      CdkCliVersion: version
```

## CDKBootstrapAction
<a name="cdk.boot.name"></a>

（必需）

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

默认值：`CDKBootstrapAction_nn`。

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

## Identifier
<a name="cdk.boot.identifier"></a>

(*CDKBootstrapAction*/**Identifier**)

（必需）

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

**注意**  
指定 `aws/cdk-bootstrap@v2` 可以让操作在 [2024 年 3 月版映像](build-images.md#build.default-image)上运行，其中包括较新的工具，例如 Node.js 18。指定 `aws/cdk-bootstrap@v1` 可以让操作在 [2022 年 11 月版映像](build-images.md#build.previous-image)上运行，其中包括较旧的工具，例如 Node.js 16。

默认值：`aws/cdk-bootstrap@v2`。

对应的 UI：工作流图表/CDKBootstrapAction\$1nn/**aws/cdk-bootstrap@v2** 标签

## DependsOn
<a name="cdk.boot.dependson"></a>

(*CDKBootstrapAction*/**DependsOn**)

（可选）

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

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

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

## Compute
<a name="cdk.boot.computename"></a>

(*CDKBootstrapAction*/**Compute**)

（可选）

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

对应的 UI：*无*

## Type
<a name="cdk.boot.computetype"></a>

(*CDKBootstrapAction*/Compute/**Type**)

（如果包含 [Compute](#cdk.boot.computename)，则为必需）

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

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

  优化了操作启动速度。

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

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

## Fleet
<a name="cdk.boot.computefleet"></a>

(*CDKBootstrapAction*/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="cdk.boot.timeout"></a>

(*CDKBootstrapAction*/**Timeout**)

（必需）

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

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

## Inputs
<a name="cdk.boot.inputs"></a>

(*CDKBootstrapAction*/**Inputs**)

（可选）

`Inputs` 部分中定义了工作流运行期间 **AWS CDK 引导**操作所需的数据。

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

**注意**  
每个 **AWS CDK 引导**操作只能有一个输入（可以是源或构件）。

## Sources
<a name="cdk.boot.inputs.sources"></a>

(*CDKBootstrapAction*/Inputs/**Sources**)

（如果您的 AWS CDK 应用程序存储在源存储库中，则为必填项）

如果您的 AWS CDK 应用程序存储在源存储库中，请指定该源存储库的标签。在启动引导过程之前，**AWS CDK 引导**操作会合成此存储库中的应用程序。目前唯一支持的存储库标签是 `WorkflowSource`。

如果您的 AWS CDK 应用程序不包含在源存储库中，则它必须位于另一个操作生成的构件中。

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

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

## Artifacts - input
<a name="cdk.boot.inputs.artifacts"></a>

(*CDKBootstrapAction*/Inputs/**Artifacts**)

（如果您的 AWS CDK 应用程序存储在先前操作的[输出构件](workflows-working-artifacts-output.md)中，则为必填项）

如果您的 AWS CDK 应用程序包含在先前操作生成的构件中，请在此处指定该构件。在**AWS CDK 启动引导**过程之前，bootstrap 操作会将指定工件中的应用程序合成到 CloudFormation 模板中。如果您的 AWS CDK 应用程序不包含在构件中，则必须驻留在您的源存储库中。

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

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

## Outputs
<a name="cdk.boot.outputs"></a>

(*CDKBootstrapAction*/**Outputs**)

（可选）

定义在工作流运行期间操作输出的数据。

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

## Artifacts - output
<a name="cdk.boot.outputs.artifacts"></a>

(*CDKBootstrapAction*/Outputs/**Artifacts**)

（可选）

指定操作生成的构件。您可以在其他操作中将这些构件作为输入来引用。

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

对应的 UI：“输出”选项卡/**构件**

## Name
<a name="cdk.boot.outputs.artifacts.name"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Name**)

（如果包含 [Artifacts - output](#cdk.boot.outputs.artifacts)，则为必需）

指定将包含在运行时由**AWS CDK 引导**操作合成的 CloudFormation 模板的工件的名称。默认值为 `cdk_bootstrap_artifacts`。如果您未指定构件，则该操作会合成模板，但不会将模板保存在构件中。考虑将合成的模板保存在构件中，以便保留其记录，供测试或故障排除之用。

**对应的用户界面：输出tab/Artifacts/Add构件/构建构件名称**

## Files
<a name="cdk.boot.outputs.artifacts.files"></a>

(*CDKBootstrapAction*/Outputs/Artifacts/**Files**)

（如果包含 [Artifacts - output](#cdk.boot.outputs.artifacts)，则为必需）

指定要包含在构件中的文件。您`"cdk.out/**/*"`必须指定包含 AWS CDK 应用程序的合成 CloudFormation 模板。

**注意**  
`cdk.out` 是保存已合成文件的默认目录。如果您指定了输出目录，而不是 `cdk.json` 文件中的 `cdk.out`，请在此处指定该目录，而不是 `cdk.out`。

相应的 UI：输出tab/Artifacts/Add构件/编译生成的**文件**

## Environment
<a name="cdk.boot.environment"></a>

(*CDKBootstrapAction*/**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="cdk.boot.environment.name"></a>

(*CDKBootstrapAction*/Environment/**Name**)

（如果包含 [Environment](#cdk.boot.environment)，则为必需）

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

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

## Connections
<a name="cdk.boot.environment.connections"></a>

(*CDKBootstrapAction*/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="cdk.boot.environment.connections.name"></a>

(*CDKBootstrapAction*/Environment/Connections/**Name**)

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

指定账户连接的名称。

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

## Role
<a name="cdk.boot.environment.connections.role"></a>

(*CDKBootstrapAction*/Environment/Connections/**Role**)

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

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

如果您未指定 IAM 角色，则该操作将使用 CodeCatalyst 控制台中[环境](deploy-environments.md)中列出的默认 IAM 角色。如果您使用此环境中的默认角色，请确保该角色具有合适的策略。

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

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

## Configuration
<a name="cdk.boot.configuration"></a>

(*CDKBootstrapAction*/**Configuration**)

（必需）

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

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

## Region
<a name="cdk.boot.region"></a>

(*CDKBootstrapAction*/Configuration/**Region**)

（必需）

指定要部署 AWS 区域 引导堆栈的。该区域应与您的 AWS CDK 应用程序部署的区域相匹配。有关区域代码的列表，请参阅[区域端点](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes)。

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

## CdkCliVersion
<a name="cdk.boot.cdk.cli.version"></a>

(*CDKBootstrapAction*/Configuration/**CdkCliVersion**)

（可选）

此属性适用于 **AWS CDK 部署**操作的 1.0.13 或更高版本，以及 **AWS CDK 引导**操作的 1.0.8 或更高版本。

指定下列项之一：
+ 您希望此操作使用的 AWS Cloud Development Kit (AWS CDK) 命令行界面 (CLI)（也称为 AWS CDK 工具包）的完整版本。示例：`2.102.1`。在构建和部署您的应用程序时，请考虑指定完整版本，从而确保一致性和稳定性。

  Or
+ `latest`。请考虑指定 `latest`，从而利用 CDK CLI 的最新功能和修复。

该操作会将指定版本（或最新版本）的 AWS CDK CLI 下载到 CodeCatalyst [构建映像](build-images.md)，然后使用此版本运行部署 CDK 应用程序或引导环境所需的命令。 AWS 

有关可使用的受支持 CDK CLI 版本的列表，请参阅 [AWS CDK 版本](https://docs.aws.amazon.com/cdk/api/versions.html)。

如果省略此属性，则该操作将使用以下主题之一中描述的默认 AWS CDK CLI 版本：
+ [“部AWS CDK 署” 操作使用的 CDK CLI 版本](cdk-dep-action.md#cdk-dep-action-cdk-version) 
+ [“AWS CDK 引导” 操作使用的 CDK CLI 版本](cdk-boot-action.md#cdk-boot-action-cdk-version)

对应的 UI：“配置” 选项卡/ **AWS CDK CLI 版本**

# 使用工作流将文件发布到 Amazon S3
<a name="s3-pub-action"></a>

本节介绍如何使用 CodeCatalyst 工作流程将文件发布到 Amazon S3。为此，您必须将 **Amazon S3 发布**操作添加到工作流。**Amazon S3 发布**操作会将源目录中的文件复制到 Amazon S3 存储桶。源目录可以位于：
+ [源存储库](source.md)，或 
+ 由另一个工作流操作生成的[输出构件](workflows-working-artifacts.md)

**Topics**
+ [何时使用“Amazon S3 发布”操作](#s3-pub-action-when-to-use)
+ [“Amazon S3 发布”操作使用的运行时映像](#s3-pub-action-runtime)
+ [示例：将文件发布到 Amazon S3](s3-pub-action-example-workflow.md)
+ [添加“Amazon S3 发布”操作](s3-pub-action-add.md)
+ [“Amazon S3 发布”操作 YAML](s3-pub-action-ref.md)

## 何时使用“Amazon S3 发布”操作
<a name="s3-pub-action-when-to-use"></a>

在以下情况下使用此操作：
+ 您有一个生成要存储在 Amazon S3 中的文件的工作流。

  例如，您可能有一个用于构建要在 Amazon S3 中托管的静态网站的工作流。在这种情况下，您的工作流将包括一个用于构建站点的 HTML 和支持文件的[构建操作](build-add-action.md)，以及一个用于将文件复制到 Amazon S3 的 **Amazon S3 发布**操作。
+ 您有一个包含要存储在 Amazon S3 中的文件的源存储库。

  例如，您可能有一个包含应用程序源文件的源存储库，您每晚都要将这些文件存档到 Amazon S3。

## “Amazon S3 发布”操作使用的运行时映像
<a name="s3-pub-action-runtime"></a>

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

# 示例：将文件发布到 Amazon S3
<a name="s3-pub-action-example-workflow"></a>

以下示例工作流包括 **Amazon S3 发布**操作以及构建操作。该工作流会构建一个静态文档网站，然后将该网站发布到用于托管它的 Amazon S3。工作流包含以下按顺序运行的构造块：
+ **触发器** – 当您将更改推送到源存储库时，此触发器会自动启动工作流运行。有关触发器的更多信息，请参阅[使用触发器自动启动工作流运行](workflows-add-trigger.md)。
+ **构建**操作（`BuildDocs`）– 触发后，该操作会构建一个静态文档网站（`mkdocs build`），并将关联的 HTML 文件和支持元数据添加到名为 `MyDocsSite` 的构件中。有关构建操作的更多信息，请参阅[使用工作流进行构建](build-workflow-actions.md)。
+ **Amazon S3 发布**操作（`PublishToS3`）– 在构建操作完成后，此操作会将 `MyDocsSite` 构件中的站点复制到 Amazon S3 以进行托管。

**注意**  
以下工作流示例仅用于说明目的，如果不执行附加配置，则无法运行。

**注意**  
在接下来的 YAML 代码中，如果需要，可以省略 `Connections:` 部分。如果您省略此部分，则必须确保您环境的**默认 IAM 角色**字段中指定的角色包含 **Amazon S3 发布**操作所需的权限和信任策略。有关使用默认 IAM 角色设置环境的更多信息，请参阅[创建环境](deploy-environments-creating-environment.md)。有关 **Amazon S3 发布**操作所需的权限和信任策略的更多信息，请参阅[“Amazon S3 发布”操作 YAML](s3-pub-action-ref.md) 中的 [Role](s3-pub-action-ref.md#s3.pub.environment.connections.role) 属性的说明。

```
Name: codecatalyst-s3-publish-workflow
SchemaVersion: 1.0

Triggers:
  - Type: PUSH
    Branches:
      - main
Actions:
  BuildDocs:
    Identifier: aws/build@v1
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      Steps:
        - Run: echo BuildDocs started on `date`
        - Run: pip install --upgrade pip
        - Run: pip install mkdocs
        - Run: mkdocs build
        - Run: echo BuildDocs completed on `date`
    Outputs:
      Artifacts:
      - Name: MyDocsSite
        Files:
          - "site/**/*"
        
  PublishToS3:
    Identifier: aws/s3-publish@v1
    Environment:
      Name: codecatalyst-s3-publish-environment
      Connections:
        - Name: codecatalyst-account-connection
          Role: codecatalyst-s3-publish-build-role
    Inputs:
      Sources:
        - WorkflowSource
      Artifacts:
        - MyDocsSite
    Configuration:      
      DestinationBucketName: amzn-s3-demo-bucket
      SourcePath: /artifacts/PublishToS3/MyDocSite/site
      TargetPath: my/docs/site
```

# 添加“Amazon S3 发布”操作
<a name="s3-pub-action-add"></a>

 按照以下说明操作，将 **Amazon S3 发布**操作添加到工作流。

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

**使用可视化编辑器添加“Amazon S3 发布”操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

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

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

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

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

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

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

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

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

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

**使用 YAML 编辑器添加“Amazon S3 发布”操作**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择 **YAML**。

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

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

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

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

1. 根据需求修改 YAML 代码中的属性。[“Amazon S3 发布”操作 YAML](s3-pub-action-ref.md)中提供了每个可用属性的解释。

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

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

------

# “Amazon S3 发布”操作 YAML
<a name="s3-pub-action-ref"></a>

下面是 **Amazon S3 发布**操作的 YAML 定义。要了解如何使用此操作，请参阅[使用工作流将文件发布到 Amazon S3](s3-pub-action.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.    
  S3Publish\$1nn: 
    Identifier: aws/s3-publish@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Inputs:
      Sources:
        - source-name-1
      Artifacts:
        - artifact-name
      Variables:
        - Name: variable-name-1
          Value: variable-value-1
        - Name: variable-name-2
          Value: variable-value-2
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Configuration:
      SourcePath: my/source
      DestinationBucketName: amzn-s3-demo-bucket
      TargetPath: my/target
```

## S3Publish
<a name="s3.pub.name"></a>

（必需）

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

默认值：`S3Publish_nn`。

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

## Identifier
<a name="s3.pub.identifier"></a>

(*S3Publish*/**Identifier**)

（必需）

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

默认值：`aws/s3-publish@v1`。

对应的 UI：工作流图表/S3Publish\$1nn/**aws/s3-publish@v1** 标签

## DependsOn
<a name="s3.pub.dependson"></a>

(*S3Publish*/**DependsOn**)

（可选）

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

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

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

## Compute
<a name="s3.pub.computename"></a>

(*S3Publish*/**Compute**)

（可选）

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

对应的 UI：*无*

## Type
<a name="s3.pub.computetype"></a>

(*S3Publish*/Compute/**Type**)

（如果包含 [Compute](#s3.pub.computename)，则为必需）

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

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

  优化了操作启动速度。

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

对应的 UI：“配置”选项卡/**计算类型**

## Fleet
<a name="s3.pub.computefleet"></a>

(*S3Publish*/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：“配置”选项卡/**计算实例集**

## Timeout
<a name="s3.pub.timeout"></a>

(*S3Publish*/**Timeout**)

（必需）

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

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

## Inputs
<a name="s3.pub.inputs"></a>

(*S3Publish*/**Inputs**)

（可选）

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

**注意**  
每个 **AWS CDK 部署**操作最多有四个输入（一个源和三个构件）。变量不计入此总数。

如果您需要引用驻留在不同输入（例如源和构件）中的文件，则源输入是主输入，构件是辅助输入。辅助输入中对文件的引用采用特殊前缀，以与主输入中的文件区分开来。有关更多信息，请参阅 [示例：引用多个构件中的文件](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file)。

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

## Sources
<a name="s3.pub.inputs.sources"></a>

(*S3Publish*/Inputs/**Sources**)

（如果要发布到 Amazon S3 的文件存储在源存储库中，则为必需）

如果要发布到 Amazon S3 的文件存储在源存储库中，请指定该源存储库的标签。目前，唯一支持的标签是 `WorkflowSource`。

如果要发布到 Amazon S3 的文件不包含在源存储库中，则必须位于另一个操作生成的构件中。

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

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

## Artifacts - input
<a name="s3.pub.inputs.artifacts"></a>

(*S3Publish*/Inputs/**Artifacts**)

（如果要发布到 Amazon S3 的文件存储在先前操作生成的[输出构件](workflows-working-artifacts-output.md)中，则为必需）

如果要发布到 Amazon S3 的文件包含在上一操作生成的构件中，请在此处指定该构件。如果您的文件不包含在构件中，则必须位于源存储库中。

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

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

## Variables - input
<a name="s3.pub.inputs.variables"></a>

(*S3Publish*/Inputs/**Variables**)

（可选）

指定一系列 name/value 对，用于定义要提供给操作的输入变量。变量名称仅限字母数字字符（a-z、A-Z、0-9）、连字符（-）和下划线（\$1）。不允许使用空格。不能使用引号以使变量名能够包含特殊字符和空格。

有关变量的更多信息（包括示例），请参阅[在工作流中使用变量](workflows-working-with-variables.md)。

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

## Environment
<a name="s3.pub.environment"></a>

(*S3Publish*/**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="s3.pub.environment.name"></a>

(*S3Publish*/Environment/**Name**)

（如果包含 [Environment](#s3.pub.environment)，则为必需）

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

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

## Connections
<a name="s3.pub.environment.connections"></a>

(*S3Publish*/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="s3.pub.environment.connections.name"></a>

(*S3Publish*/Environment/Connections/**Name**)

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

指定账户连接的名称。

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

## Role
<a name="s3.pub.environment.connections.role"></a>

(*S3Publish*/Environment/Connections/**Role**)

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

指定 A **mazon S3 发布操作用于访问 AWS 和将文件复制到 Amaz** on S3 的 IAM 角色的名称。请确保您已将[该角色添加到您的 CodeCatalyst 空间](ipa-connect-account-addroles.md)，并且该角色包含以下策略。

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

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "VisualEditor0",
              "Effect": "Allow",
              "Action": [
                  "s3:PutObject",
                  "s3:ListBucket",
                  "s3:DeleteObject"
              ],
              "Resource": [
                  "arn:aws:s3:::bucket-name",
                  "arn:aws:s3:::bucket-name/*"
              ]
          }
      ]
  }
  ```

------
+ 以下自定义信任策略：

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

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

## Configuration
<a name="s3.pub.configuration"></a>

(*S3Publish*/**Configuration**)

（必需）

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

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

## SourcePath
<a name="s3.pub.source.directory"></a>

(*S3Publish*/Configuration/**SourcePath**)

（必需）

指定要发布到 Amazon S3 的目录或文件的名称和路径。目录或文件可以位于源存储库或先前操作的构件中，并且相对于源存储库或构件根目录。

示例：

指定 `./myFolder/` 会将 `/myFolder` 的内容复制到 Amazon S3，并保留底层目录结构。

指定 `./myFolder/myfile.txt` *仅*将 `myfile.txt` 复制到 Amazon S3。（这将移除目录结构。）

您无法使用通配符。

**注意**  
您可能需要在目录或文件路径中添加前缀，以指明要在哪个构件或源中查找它。有关更多信息，请参阅[引用源存储库文件](workflows-sources-reference-files.md)和[在构件中引用文件](workflows-working-artifacts-refer-files.md)。

对应的 UI：“配置”选项卡/**源路径**

## DestinationBucketName
<a name="s3.pub.dest.bucket"></a>

(*S3Publish*/Configuration/**DestinationBucketName**)

（必需）

指定要将文件发布到的 Amazon S3 存储桶的名称。

对应的 UI：“配置”选项卡/**目标存储桶 – 可选**

## TargetPath
<a name="s3.pub.dest.directory"></a>

(*S3Publish*/Configuration/**TargetPath**)

（可选）

指定要将文件发布到的 Amazon S3 中的目录的名称和路径。如果该目录不存在，系统会创建它。该目录路径不得包含存储桶名称。

示例：

`myS3Folder`

`./myS3Folder/myS3Subfolder`

对应的 UI：“配置”选项卡/**目标目录 – 可选**

# 部署到 AWS 账户 和 VPCs
<a name="deploy-environments"></a>

使用[CodeCatalyst 工作流程](workflow.md)，您可以将应用程序和其他资源部署到 AWS 云 VPCs 中的目标和 AWS 账户 Amazon。要启用这些部署，必须设置 CodeCatalyst 环境。

不要将 CodeCatalyst *环境*与[开发环境](https://docs.aws.amazon.com/codecatalyst/latest/userguide/devenvironment.html)混淆，它定义了 CodeCatalyst [工作流程](workflow.md)所连接的目标 AWS 账户 和可选的 Amazon VPC。环境还定义了工作流程访问目标账户中的 AWS 服务和资源所需的 [IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)。

您可以设置多个环境并为它们指定名称，例如开发、测试、暂存和生产。在这些环境中部署时，有关部署的信息会显示在环境中的 CodeCatalyst **部署活动**和**部署目标**选项卡上。

## 如何开始使用环境？
<a name="deploy-environments-get-started"></a>

添加和使用 CodeCatalyst 环境的高级步骤如下：

1. 在您的 CodeCatalyst 空间中，**关联一个或多个 AWS 账户**。在此过程中，添加工作流访问 AWS 账户中的资源所需的 IAM 角色。有关更多信息，请参阅 [允许在已连接的情况下访问 AWS 资源 AWS 账户](ipa-connect-account.md)。

1. 在您的 CodeCatalyst 项目中，**创建一个包含步骤 1 中的 AWS 账户 s 和 IAM 角色之一的环境**。有关更多信息，请参阅 [创建环境](deploy-environments-creating-environment.md)。

1. 在您的 CodeCatalyst 项目中，在工作流程中**，添加指向您在步骤 2 中创建的环境的[操作](workflows-actions.md)**。有关更多信息，请参阅 [添加操作到工作流](workflows-add-action.md)。

   现在，您已配置一个环境。此操作现在可将资源部署到环境中指定的 AWS 账户 中。

**注意**  
您也可以将 Amazon VPC 添加到环境中。有关更多信息，请参阅《*CodeCatalyst 管理指南》*中的[为空间添加 VPC 连接](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html)和[将 VPC 与环境关联](deploy-environments-associate-vpc.md)。

## 单个工作流中是否能有多个环境？
<a name="deploy-environments-multiple"></a>

可以。如果工作流包含多个操作，则可以为每个操作分配一个环境。例如，您的工作流可能包含两个部署操作，为一个部署操作分配了 `my-staging-enviroment` 环境，为另一个部署操作分配了 `my-production-environment` 环境。

## 哪些工作流操作支持环境？
<a name="deploy-environments-supported"></a>

任何将资源部署到 AWS 云端或出于其他原因（例如监控和报告）与 AWS 服务通信的工作流程操作都支持环境。

## 哪些操作支持在中显示其部署信息 CodeCatalyst？
<a name="deploy-environments-supported-targets"></a>

在支持环境的工作流程操作中，只有少数支持将其部署信息显示在 CodeCatalyst 控制台的 “**部署活动**” 和 “**部署目标**” 页面上。

以下工作流操作支持显示其部署信息：
+ **部署 CloudFormation 堆栈**-有关更多信息，请参阅 [部署 CloudFormation 堆栈](deploy-action-cfn.md)
+ **部署到 Amazon ECS** – 有关更多信息，请参阅[使用工作流部署到 Amazon ECS](deploy-action-ecs.md)
+ **部署到 Kubernetes 集群** – 有关更多信息，请参阅[使用工作流部署到 Amazon EKS](deploy-action-eks.md)
+ **AWS CDK 部署**-有关更多信息，请参阅 [使用工作流程部署 AWS CDK 应用程序](cdk-dep-action.md)

## 支持的区域：
<a name="deploy-environments-supported-regions"></a>

**环境**页面可以显示任何 AWS 区域中的资源。

## 环境是强制性的吗？
<a name="deploy-environments-optional-or-mandatory"></a>

如果分配给环境的工作流程操作将资源部署到 AWS 云中，或者出于其他原因（例如监控和报告）与 AWS 服务通信，则该环境是必需的。

例如，如果您的构建操作可以构建应用程序，但不需要与您的 AWS 账户 或 Amazon VPC 通信，则无需为该操作分配环境。但是，如果构建操作将日志发送到您的 Amazon CloudWatch 服务 AWS 账户，则必须为该操作分配环境。

**Topics**
+ [如何开始使用环境？](#deploy-environments-get-started)
+ [单个工作流中是否能有多个环境？](#deploy-environments-multiple)
+ [哪些工作流操作支持环境？](#deploy-environments-supported)
+ [哪些操作支持在中显示其部署信息 CodeCatalyst？](#deploy-environments-supported-targets)
+ [支持的区域：](#deploy-environments-supported-regions)
+ [环境是强制性的吗？](#deploy-environments-optional-or-mandatory)
+ [创建环境](deploy-environments-creating-environment.md)
+ [将环境与操作关联](deploy-environments-add-app-to-environment.md)
+ [将 VPC 与环境关联](deploy-environments-associate-vpc.md)
+ [将 AWS 账户 与环境关联](deploy-environments-associate-account.md)
+ [更改操作的 IAM 角色](deploy-environments-switch-role.md)

# 创建环境
<a name="deploy-environments-creating-environment"></a>

按照以下说明操作来创建稍后能够与工作流操作关联的环境。

**开始前的准备工作**

您需要以下项：
+ 一个 CodeCatalyst 空间。有关更多信息，请参阅 [设置并登录 CodeCatalyst设置并登录 CodeCatalyst](setting-up-topnode.md)。
+ 一个 CodeCatalyst 项目。有关更多信息，请参阅 [使用蓝图创建项目](projects-create.md#projects-create-console-template)。
+ 包含您的工作流程操作需要访问的 IAM 角色的 AWS 账户连接 AWS。有关创建账户连接的信息，请参阅[允许在已连接的情况下访问 AWS 资源 AWS 账户](ipa-connect-account.md)。对于每个环境，最多使用一个账户连接。
**注意**  
您可以在没有账户连接的情况下创建环境；但您稍后需添加该连接。
+ 以下 CodeCatalyst 角色之一：
  + **空间管理员**
  + **项目管理员**
  + **贡献者**
**注意**  
如果您具有**贡献者**角色，则可以创建一个环境，但无法将该环境与 AWS 账户 连接关联。你需要请具有**空间管理员或**项目管理员****角色的人员将环境与 AWS 账户 连接关联。

   有关权限和角色的更多信息，请参阅[向用户授予项目权限](projects-members.md)。

**创建环境**

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

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**环境**。

1. 在**环境名称**中，输入一个名称，例如 **Production** 或 **Staging**。

1. 在**环境类型**中，选择下列选项之一：
   + **非生产** – 在将应用程序投入生产之前，可在其中测试应用程序以确保其按预期运行的环境。
   + **生产** – 一个公开可用的“实时”环境，用于托管您最终的应用程序。

     如果您选择**生产**，则 UI 中与环境关联的所有操作旁边都会显示一个**生产**徽章。该徽章可帮助您快速查看哪些操作正在部署到生产中。除了徽章的外观外，生产环境和非生产环境之间没有区别。

1. （可选）在**描述**中，输入描述，例如 **Production environment for the hello-world app**。

1. 在**AWS 账户 连接中-可选**，选择要与此环境关联的 AWS 账户连接。分配了此环境的工作流操作将能够连接到关联的 AWS 账户。有关在中创建 AWS 账户 连接的更多信息 CodeCatalyst，请参阅[允许在已连接的情况下访问 AWS 资源 AWS 账户](ipa-connect-account.md)。

   如果您要使用的 AWS 账户 连接未列出，则可能是因为您的项目中不允许使用该连接。有关更多信息，请参阅《A *mazon CodeCatalyst 管理员*指南》中的[配置受项目限制的账户连接](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html)。

1. 在**默认 IAM 角色**中，选择要与此环境关联的 IAM 角色。分配给此环境的工作流程操作将继承此 IAM 角色，并能够使用该角色连接到您的中的服务和资源 AWS 账户。

   如果您需要将环境分配给多个操作，并且这些操作需要的 IAM 角色与此处指定的默认角色不同，则可以使用**切换角色**选项在每个操作的**配置**选项卡上指定不同的角色。有关更多信息，请参阅 [更改操作的 IAM 角色](deploy-environments-switch-role.md)。

   如果您要用作默认角色的 IAM 角色未列出，则可能是因为您尚未将其添加到 AWS 账户 连接中。要向账户连接添加 IAM 角色，请参阅[将 IAM 角色添加到账户连接](ipa-connect-account-addroles.md)。

1. （可选）在 **VPC 连接**中，选择要与此环境关联的 VPC 连接。有关创建 VPC 连接的更多信息，请参阅《[亚马逊* CodeCatalyst 管理员指南》中的管理亚马逊*虚拟私有云](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html)。

   如果您要使用的 VPC 连接未列出，则可能是因为它包含了您的项目中不允许的 AWS 账户 连接。有关更多信息，请参阅《A *mazon CodeCatalyst 管理员*指南》中的[配置受项目限制的账户连接](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html)。

1. 选择 “**创建环境**”。 CodeCatalyst 创建一个空环境。

**后续步骤**
+ 现在您已创建一个环境，可以将该环境与工作流操作关联。有关更多信息，请参阅 [将环境与操作关联](deploy-environments-add-app-to-environment.md)。

# 将环境与操作关联
<a name="deploy-environments-add-app-to-environment"></a>

当您将环境与[支持的工作流程操作](deploy-environments.md#deploy-environments-supported)关联时，该环境的 AWS 账户默认 IAM 角色和可选的 Amazon VPC 将分配给该操作。之后，此操作可以使用 IAM 角色连接和部署到 AWS 账户 ，还可以连接到可选 Amazon VPC。

按照以下说明操作来将环境与操作关联。

## 步骤 1：将环境与工作流操作关联
<a name="deploy-environments-add-app-to-environment-assoc"></a>

使用以下过程将环境与工作流操作关联。

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

**使用可视化编辑器将环境与工作流操作关联**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

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

1. 在工作流图中，选择环境支持的操作。有关更多信息，请参阅 [哪些操作支持在中显示其部署信息 CodeCatalyst？](deploy-environments.md#deploy-environments-supported-targets)。

1. 选择**配置**选项卡，然后在**环境**字段中指定信息，如下所示。

   **环境**

   指定要用于操作的 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)。

1. （可选）更改与操作关联的 IAM 角色。如果角色包含操作的一组错误权限，则可能需要更改角色。

    要更改角色，请执行以下操作：

   1. 在 W **hat's in*my-environment*？** 框，然后选择垂直省略号图标 (![\[Ellipsis.\]](http://docs.aws.amazon.com/zh_cn/codecatalyst/latest/userguide/images/flows/elipsis.png))。

   1. 选择下列选项之一：
      +  **切换角色**。选择此选项能且只能更改此操作使用的 IAM 角色。其他操作继续使用其关联环境中指定的默认 IAM 角色。有关更多信息，请参阅 [更改操作的 IAM 角色](deploy-environments-switch-role.md)。
      +  **编辑环境**。选择此选项可更改环境中列出的默认 IAM 角色。选择此选项后，您的操作以及与同一环境关联的任何其他操作都将开始使用新的默认 IAM 角色。
**重要**  
更新默认 IAM 角色时要谨慎。如果角色具备的权限不足，无法执行所有共享环境的操作，则更改角色可能会导致操作失败。

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

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

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

**使用 YAML 编辑器将环境与工作流操作关联**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择 **YAML**。

1. 在要与环境关联的工作流操作中，添加与以下内容类似的代码：

   ```
   action-name:
     Environment:
       Name: environment-name
   ```

   有关更多信息，请参阅[操作类型](workflows-actions.md#workflows-actions-types)主题。本主题包含每个操作的文档链接，包括其 YAML 参考。

1. （可选）如果您希望操作使用与环境中列出的默认 IAM 角色不同的角色，请添加包含您要使用的角色的 `Connections:` 部分。有关更多信息，请参阅 [更改操作的 IAM 角色](deploy-environments-switch-role.md)。

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

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

------

## 步骤 2：填充部署活动页面
<a name="deploy-environments-add-app-to-environment-run"></a>

将环境与工作流操作关联后，可以在 CodeCatalyst 控制台的 “**环境**” 部分的 “**部署” 活动**和 “**部署目标**” 页面中填充部署信息。按照以下说明操作来填充这些页面。

**注意**  
只有少数操作支持在 CodeCatalyst控制台中显示其部署信息。有关更多信息，请参阅 [哪些操作支持在中显示其部署信息 CodeCatalyst？](deploy-environments.md#deploy-environments-supported-targets)。

**将部署信息添加到 CodeCatalyst**

1. 如果您在[步骤 1：将环境与工作流操作关联](#deploy-environments-add-app-to-environment-assoc)中提交更改时工作流运行未自动启动，请执行以下操作来手动启动运行：

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

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

   1. 选择**运行**。

   工作流程运行会启动新的部署，这会导致 CodeCatalyst 向添加部署信息 CodeCatalyst。

1. 确认部署活动已添加到 CodeCatalyst 控制台：

   1. 在导航窗格中，选择 **CI/CD**，然后选择**环境**。

   1. 选择您的环境（例如 `Production`）。

   1. 选择**部署活动**选项卡，并确认部署的**状态**为**成功**。这表示工作流运行已成功部署您的应用程序资源。

   1. 选择**部署目标**选项卡，并确认已显示您的应用程序资源。

# 将 VPC 与环境关联
<a name="deploy-environments-associate-vpc"></a>

在使用具有 VPC 连接的环境配置操作时，该操作将在连接到 VPC 的情况下运行，遵守网络规则并访问关联的 VPC 所指定的资源。一个或多个环境可使用同一 VPC 连接。

按照以下说明操作来将 VPC 连接与环境关联。

**将 VPC 连接与环境关联**

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

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**环境**。

1. 选择您的环境（例如 `Production`）。

1. 选择**环境属性**选项卡。

1. 选择**管理 VPC 连接**，再选择所需的 VPC 连接，然后选择**确认**。这会将选定的 VPC 连接与此环境关联。
**注意**  
如果您要使用的 VPC 连接未列出，则可能是因为该 AWS 账户 连接包含您的项目中不允许的连接。有关更多信息，请参阅《A *mazon CodeCatalyst 管理员*指南》中的[配置受项目限制的账户连接](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html)。

有关更多信息，请参阅《*CodeCatalyst 管理员指南》*中的 “[管理 Amazon 虚拟私有云](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.html)”。

# 将 AWS 账户 与环境关联
<a name="deploy-environments-associate-account"></a>

按照以下说明将 AWS 账户 与环境相关联。当您将 AWS 账户 与环境关联时，分配给该环境的工作流操作将能够连接到该环境 AWS 账户。

有关账户连接的更多信息，请参阅[允许在已连接的情况下访问 AWS 资源 AWS 账户](ipa-connect-account.md)。

**开始前的准备工作**

您需要以下项：
+ 包含您的工作流程操作需要访问的 IAM 角色的 AWS 账户连接 AWS。有关创建账户连接的信息，请参阅[允许在已连接的情况下访问 AWS 资源 AWS 账户](ipa-connect-account.md)。对于每个环境，最多使用一个账户连接。
+ 以下 CodeCatalyst 角色之一：**空间管理员**或**项目管理员**。有关更多信息，请参阅 [向用户授予项目权限](projects-members.md)。

**将 AWS 账户 与环境关联**

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

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**环境**。

1. 选择您的环境（例如 `Production`）。

1. 选择**编辑环境**。

1. 在**环境属性**下的 **AWS 账户 连接 – 可选**下拉列表中，选择所需的 AWS 账户。

   如果您要使用的 AWS 账户 连接未列出，则可能是因为您的项目中不允许使用该连接。有关更多信息，请参阅《A *mazon CodeCatalyst 管理员*指南》中的[配置受项目限制的账户连接](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-accounts-restriction.html)。

1. 在**默认 IAM 角色**中，选择要与此环境关联的 IAM 角色。分配给此环境的工作流程操作将继承此 IAM 角色，并能够使用该角色连接到您的中的服务和资源 AWS 账户。

   如果您要用作默认角色的 IAM 角色未列出，则可能是因为您尚未将其添加到 AWS 账户 连接中。要向账户连接添加 IAM 角色，请参阅[将 IAM 角色添加到账户连接](ipa-connect-account-addroles.md)。

# 更改操作的 IAM 角色
<a name="deploy-environments-switch-role"></a>

默认情况下，在将[环境](deploy-environments.md)与工作流[操作](workflows-actions.md)关联时，该操作将继承环境中指定的默认 IAM 角色。您可以更改此行为，让操作使用其他角色。如果默认 IAM 角色缺少操作在 AWS 云中运行所需的权限，则可能需要让操作使用其他角色。

要向操作分配其他 IAM 角色，您可以使用可视化编辑器中的**切换角色**选项或 YAML 编辑器中的 `Connections:` 属性。新角色将覆盖环境中指定的默认 IAM 角色，可让您将默认 IAM 角色保持原样。如果有其他操作使用默认 IAM 角色，则可能需要将它保持原样。

按照以下说明操作，将操作配置为使用与其环境中指定的 IAM 角色不同的 IAM 角色。

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

**向操作分配其他 IAM 角色（可视化编辑器）**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择代表要更新其 IAM 角色的操作的框。

1. 选择**配置**选项卡。

1. 在 W **hat's in*my-environment*？** 框中，选择垂直省略号图标 (![\[Ellipsis.\]](http://docs.aws.amazon.com/zh_cn/codecatalyst/latest/userguide/images/flows/elipsis.png))。

1. 选择**切换角色**。

1. 在**切换角色**对话框的 **IAM 角色**下拉列表中，选择您希望该操作使用的 IAM 角色。此角色将覆盖环境中指定的默认 IAM 角色。如果要使用的角色不在列表中，请确保已将它添加到空间。有关更多信息，请参阅 [将 IAM 角色添加到账户连接](ipa-connect-account-addroles.md)。

   所选角色现在出现在 W **hat's in*my-environment*？** 框以及 “**在工作流程中定义”** 徽章。此角色还显示在工作流定义文件的 `Connections:` 部分中。

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

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

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

**向操作分配其他 IAM 角色（YAML 编辑器）**

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

1. 选择您的项目。

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

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

1. 选择**编辑**。

1. 选择 **YAML**。

1. 在要在其中使用其他 IAM 角色的工作流操作中，添加一个类似于以下内容的 `Connections:` 部分：

   ```
   action-name:
     Environment:
       Name: environment-name
       Connections: 
         - Name: account-connection-name
           Role: iam-role-name
   ```

   在前面的代码中，*account-connection-name*替换为包含 IAM 角色的[账户连接](ipa-connect-account.md)的名称，并*iam-role-name*替换为您希望操作使用的 IAM 角色的名称。此角色将覆盖环境中指定的默认 IAM 角色。确保您已将此角色添加到空间。有关更多信息，请参阅 [将 IAM 角色添加到账户连接](ipa-connect-account-addroles.md)。

   有关更多信息，请参阅[操作类型](workflows-actions.md#workflows-actions-types)主题。本主题包含每个操作的文档链接，包括其 YAML 参考。

------

# 在工作流图中显示应用程序 URL
<a name="deploy-app-url"></a>

如果您的工作流程部署了应用程序，则可以将 Amazon 配置 CodeCatalyst 为将应用程序的 URL 显示为可点击的链接。此链接出现在 CodeCatalyst 控制台中，位于部署该链接的操作中。以下工作流图显示了位于操作底部的**查看应用程序** URL。

![\[查看应用程序 URL\]](http://docs.aws.amazon.com/zh_cn/codecatalyst/latest/userguide/images/deploy/view-app-url.png)


通过在 CodeCatalyst 控制台中将此 URL 设置为可点击，您可以快速验证您的应用程序部署。

**注意**  
**部署到 Amazon ECS** 操作不支持应用程序 URL。

要启用此功能，请向操作添加名称包含 `appurl` 或 `endpointurl` 的输出变量。您可以使用带有连接符（`-`）、下划线（`_`）或空格（` `）的名称，也可以不使用这些字符。此字符串不区分大小写。将变量的值设置为已部署的应用程序的 `http` 或 `https` URL。

**注意**  
如果要更新现有输出变量以包含 `app url` 或 `endpoint url` 字符串，请更新对该变量的所有引用以使用新的变量名。

有关详细步骤，请参阅下列过程之一：
+ [在 “AWS CDK 部署” 操作中显示应用程序网址](#deploy-app-url-cdk)
+ [在 “部署 CloudFormation 堆栈” 操作中显示应用程序 URL](#deploy-app-url-cfn)
+ [在所有其他操作中显示应用程序 URL](#deploy-app-url-other)

配置完 URL 后，请按照以下说明操作来验证它是否按预期显示：
+ [验证是否已添加应用程序 URL](#deploy-app-url-verify)<a name="deploy-app-url-cdk"></a>

**在 “AWS CDK 部署” 操作中显示应用程序网址**

1. 如果您使用的是**AWS CDK 部署**操作，请在 AWS CDK 应用程序代码中添加一个`CfnOutput`构造（这是键值对）：
   + 键名称必须包含 `appurl` 或 `endpointurl`，可以带有连接符（`-`）、下划线（`_`）或空格（` `），也可以不使用这些字符。此字符串不区分大小写。
   + 值必须是已部署的应用程序的 `http` 或 `https` URL。

   例如，你的 AWS CDK 代码可能如下所示：

   ```
   import { Duration, Stack, StackProps, CfnOutput, RemovalPolicy} from 'aws-cdk-lib';
   import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
   import * as s3 from 'aws-cdk-lib/aws-s3';
   import { Construct } from 'constructs';
   import * as cdk from 'aws-cdk-lib';
   export class HelloCdkStack extends Stack {
     constructor(scope: Construct, id: string, props?: StackProps) {
       super(scope, id, props);
       const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
         removalPolicy: RemovalPolicy.DESTROY,
       });
       new CfnOutput(this, 'APP-URL', {
         value: https://mycompany.myapp.com,
         description: 'The URL of the deployed application',
         exportName: 'myApp',
       });
       ...
     }
   }
   ```

   有关该`CfnOutput`构造的更多信息，请参阅 *AWS Cloud Development Kit (AWS CDK) API 参考 CfnOutputProps*中的[接口](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutputProps.html)。

1. 保存并提交您的代码。

1. 继续执行[验证是否已添加应用程序 URL](#deploy-app-url-verify)。<a name="deploy-app-url-cfn"></a>

**在 “部署 CloudFormation 堆栈” 操作中显示应用程序 URL**

1. 如果您使用的是**部署 CloudFormation 堆栈**操作，请向 CloudFormation 模板或 AWS SAM 模板中的`Outputs`部分添加具有以下特征的输出：
   + 键（也称作逻辑 ID）必须包含 `appurl` 或 `endpointurl`，可以带有连接符（`-`）、下划线（`_`）或空格（` `），也可以不使用这些字符。此字符串不区分大小写。
   + 值必须是已部署的应用程序的 `http` 或 `https` URL。

   例如，您的 CloudFormation 模板可能如下所示：

   ```
   "Outputs" : {
     "APP-URL" : {
       "Description" : "The URL of the deployed app",
       "Value" : "https://mycompany.myapp.com",
       "Export" : {
         "Name" : "My App"
       }
     }
   }
   ```

   有关 CloudFormation 输出的更多信息，请参阅《*AWS CloudFormation 用户指南*》中的[输出](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)。

1. 保存并提交您的代码。

1. 继续执行[验证是否已添加应用程序 URL](#deploy-app-url-verify)。<a name="deploy-app-url-other"></a>

**在所有其他操作中显示应用程序 URL**

如果您使用其他操作来部署应用程序，例如构建**GitHub 操作或操作**，请执行以下操作以显示应用程序网址。

1. 在工作流定义文件中操作的 `Inputs` 或 `Steps` 部分中定义环境变量。此变量必须具有以下特征：
   + `name` 必须包含 `appurl` 或 `endpointurl`，可以带有连接符（`-`）、下划线（`_`）或空格（` `），也可以不使用这些字符。此字符串不区分大小写。
   + 值必须是已部署的应用程序的 `http` 或 `https` URL。

   例如，构建操作可能与以下内容类似：

   ```
   Build-action:
     Identifier: aws/build@v1
     Inputs:
       Variables:
         - Name: APP-URL
           Value: https://mycompany.myapp.com
   ```

   ...或与以下内容类似：

   ```
   Actions:
     Build:
       Identifier: aws/build@v1
       Configuration:    
         Steps:
           - Run: APP-URL=https://mycompany.myapp.com
   ```

   有关定义环境变量的更多信息，请参阅[定义变量](workflows-working-with-variables-define-input.md)。

1. 导出变量。

   例如，您的构建操作可能与以下内容类似：

   ```
   Build-action:
     ...
     Outputs:
       Variables:
         - APP-URL
   ```

   有关导出变量的信息，请参阅[导出变量以便其他操作使用](workflows-working-with-variables-export-input.md)。

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

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

1. 继续执行[验证是否已添加应用程序 URL](#deploy-app-url-verify)。<a name="deploy-app-url-verify"></a>

**验证是否已添加应用程序 URL**
+ 启动工作流运行（如果它未自动启动）。新运行的应用程序 URL 应在其工作流图中显示为可单击链接。有关启动运行的更多信息，请参阅[手动启动工作流运行](workflows-manually-start.md)。

# 移除部署目标
<a name="deploy-remove-target"></a>

您可以从 CodeCatalyst 控制台的部署目标页面中移除**部署目标**，例如 Amazon ECS 集群或 CloudFormation 堆栈。

**重要**  
移除部署目标时，它会从 CodeCatalyst 控制台中删除，但在托管它的 AWS 服务中仍然可用（如果它仍然存在）。

如果部署目标已过时，可以考虑移除该目标。 CodeCatalyst在以下情况下，目标可能会过时：
+ 您删除了已部署到目标的工作流。
+ 您更改了要部署到的堆栈或集群。
+ 您在 AWS 控制台中从或 Amazon ECS 服务中删除了堆栈 CloudFormation 或集群。

**移除部署目标**

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

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**环境**。

1. 选择包含要移除的部署目标的环境的名称。有关环境的信息，请参阅[部署到 AWS 账户 和 VPCs](deploy-environments.md)。

1. 选择**部署目标**选项卡。

1. 选中要移除的部署目标旁边的单选按钮。

1. 选择**移除 **。

   这将从页面中移除目标。

# 通过提交跟踪部署状态
<a name="track-changes"></a>

在开发生命周期的任何时候，了解特定提交（如错误修复、新功能或其它有影响的变更）的部署状态都很重要。考虑以下场景，在这些场景中，部署状态跟踪功能会对开发团队有所帮助：
+ 作为一名开发人员，您已经修复了一个错误，并希望报告其在团队部署环境中的部署状态。
+ 作为发布管理者，您希望查看已部署提交的列表，以跟踪和报告其部署状态。

CodeCatalyst 提供了一个视图，您可以用来一目了然地确定各个提交或更改的部署位置以及部署到哪个环境。此视图包括：
+ 提交列表。
+ 包含提交的部署的状态。
+ 成功部署提交的环境。
+ 根据 CI/CD 工作流程中的提交运行的任何测试的状态。

下面的步骤将详细介绍如何导航到该视图并使用该视图跟踪项目中的更改。

**注意**  
只有[CodeCatalyst 存储库](source.md)才支持通过提交跟踪部署状态。您不能将此功能用于[GitHub 存储库、Bitbucket 存储库或 GitLab 项目存储库](extensions.md)。

**通过提交跟踪部署状态**

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

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**更改跟踪**。

1. 在主窗格顶部的两个下拉列表中，选择包含要查看其发布状态的提交的源存储库和分支。

1. 选择**查看更改**。

   出现提交列表。

   对于每个提交，您可以查看以下内容：
   + 提交信息，如 ID、作者、消息和提交时间。有关更多信息，请参阅 [使用源存储库存储代码并协作处理代码 CodeCatalyst使用源存储库存储代码并进行协作](source.md)。
   + 部署到每个环境的状态。有关更多信息，请参阅 [部署到 AWS 账户 和 VPCs](deploy-environments.md)。
   + 测试和代码覆盖率结果。有关更多信息，请参阅 [使用工作流进行测试使用工作流进行测试](test-workflow-actions.md)。
**注意**  
不显示软件组成分析（SCA）结果。

1. （可选）要查看与特定提交相关的更多更改信息，包括最新部署以及详细的代码覆盖率和单元测试信息，请选择该提交对应的**查看详细信息**。

# 查看部署日志
<a name="deploy-deployment-logs"></a>

您可以查看与特定部署操作相关的日志，以解决 Amazon 中的问题 CodeCatalyst。

您可以从[工作流](workflow.md)或[环境](deploy-environments.md)开始查看日志。

**查看从工作流开始的部署操作的日志**

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

1. 选择您的项目。

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

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

1. 选择**运行**。

1. 选择已部署应用程序的工作流运行。

1. 在工作流图中，选择要查看其日志的操作。

1. 选择**日志**选项卡并展开各个部分以显示日志消息。

1. 要查看更多日志，请选择 “**摘要**” 选项卡，然后选择 “**查看于” CloudFormation（如果可用），在**那里查看更多日志。您可能需要登录 AWS。

**查看从环境开始的部署操作的日志**

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

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**环境**。

1. 选择已将应用程序部署到的环境。

1. 在**部署活动**中，找到**工作流运行 ID** 列，然后选择已部署堆栈的工作流运行。

1. 在工作流图中，选择要查看其日志的操作。

1. 选择**日志**选项卡并展开各个部分以显示日志消息。

1. 要查看更多日志，请选择 “**摘要**” 选项卡，然后选择 “**查看于” CloudFormation（如果可用），在**那里查看更多日志。您可能需要登录 AWS。

# 查看部署信息
<a name="deploy-view-deployment-info"></a>

您可以在 Amazon 中查看有关部署的以下信息 CodeCatalyst：
+ 部署活动，包括部署状态、开始时间、结束时间、历史记录和事件持续时间。
+ 堆栈名称 AWS 区域、上次更新时间和相关工作流程。
+ 提交和拉取请求。
+ 特定于操作的信息，例如 CloudFormation 事件和输出。

您可以从[工作流](workflow.md)、[环境](deploy-environments.md)或工作流[操作](workflows-concepts.md#workflows-concepts-actions)开始查看部署信息。

**从工作流开始查看部署信息**
+ 转到已部署应用程序的工作流运行。有关说明，请参阅[查看工作流运行状态和详细信息](workflows-view-run.md)。

**从环境开始查看部署信息**

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

1. 选择您的项目。

1. 在导航窗格中，选择 **CI/CD**，然后选择**环境**。

1. 选择已在其中部署堆栈的环境，例如 `Production`。

1. 选择**部署活动**可查看堆栈的部署历史记录、部署状态（例如，**成功**或**失败**）以及其他与部署相关的信息。

1. 选择**部署目标**可查看有关已部署到环境中的堆栈、集群或其他目标的信息。您可以查看堆栈名称、区域、提供商和标识符等信息。

**从操作开始查看部署信息**

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

1. 选择您的项目。

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

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

1. 在工作流图中，选择已部署应用程序的工作流操作。例如，你可以选择**DeployCloudFormationStack**。

1. 查看右侧窗格中的内容以了解特定于操作的部署信息。