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

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

# 使用工作流部署到 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：“配置”选项卡/**清单**