先决条件第 1 步：设置开发机器步骤 2：创建亚马逊EKS集群步骤 3：创建亚马逊ECR镜像存储库步骤 4：添加源文件步骤 5：创建 AWS 角色步骤 6：将 AWS 角色添加到 CodeCatalyst 步骤 7：更新 ConfigMap 步骤 8：创建并运行工作流程第 9 步：更改源文件清理

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

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

初始部署完成后，本教程将指导您对应用程序源进行更改。此更改会生成一个新的 Docker 镜像，并将其推送到包含新修订信息的 Docker 镜像存储库。然后，Docker 镜像的新修订版部署到亚马逊EKS中。

提示

与其完成本教程的学习，不如使用蓝图为您完成完整的Amazon EKS 设置。你需要使用EKS应用程序部署蓝图。有关更多信息，请参阅使用蓝图创建项目。

先决条件

在开始本教程之前：

您需要一个带有关联 AWS 账户的 Amazon CodeCatalyst 空间。有关更多信息，请参阅创建空间。
在你的空间里，你需要一个名为：
```
codecatalyst-eks-project
```
使用 “从头开始” 选项来创建此项目。

有关更多信息，请参阅在 Amazon 中创建一个空项目 CodeCatalyst。
在你的项目中，你需要一个名为：的空 CodeCatalyst 源代码库
```
codecatalyst-eks-source-repository
```
有关更多信息，请参阅使用源存储库存储代码并协作处理代码 CodeCatalyst。
在你的项目中，你需要一个名为 CodeCatalyst CI/CD 环境（不是开发环境）：
```
codecatalyst-eks-environment
```
按如下方式配置此环境：
- 选择任何类型，例如 “非生产”。
- 将您的 AWS 账户与之关联。
- 对于默认IAM角色，请选择任意角色。稍后您将指定其他角色。
有关更多信息，请参阅部署到 AWS 账户和 VPCs。

第 1 步：设置开发机器

本教程的第一步是使用本教程中要使用的几个工具来配置开发机器。这些工具是：

eksctl实用程序 — 用于创建集群
kubectl实用程序 — 的先决条件 eksctl
这 AWS CLI 个 — 也是前提条件 eksctl

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

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

以下说明描述了启动 CodeCatalyst 开发环境并使用所需工具对其进行配置的快速方法，但如果您需要详细说明，请参阅：

本指南中的创建开发环境。
在亚马逊EKS用户指南中@@ 安装 kubectl。
在《亚马逊EKS用户指南》中@@ 安装或升级 eksctl。
在《AWS Command Line Interface 用户指南》 AWS CLI中安装或更新最新版本的。

启动开发环境

打开 CodeCatalyst 控制台，网址为 https://codecatalyst.aws/。
导航到您的项目，codecatalyst-eks-project。
在导航窗格中，选择代码，然后选择源存储库。
选择源存储库的名称codecatalyst-eks-source-repository。
在顶部附近，选择 “创建开发环境”，然后选择 AWS Cloud9 （在浏览器中）。
确保选中 “在现有分支中工作” 和 “主分支”，然后选择 “创建”。

您的开发环境将在新的浏览器选项卡中启动，您的存储库 (codecatalyst-eks-source-repository) 已克隆到其中。

安装和配置 kubectl

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


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

输入：
```
chmod +x ./kubectl
```

输入：


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

输入：


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

输入：
```
kubectl version --short --client
```
检查是否出现了版本。

你现在已经安装好了kubectl。

安装和配置 eksctl

注意

eksctl不是严格要求的，因为你可以kubectl改用。但是，eksctl它具有自动执行大部分集群配置的好处，因此是本教程推荐的工具。

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


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

输入：
```
sudo cp /tmp/eksctl /usr/bin
```
输入：
```
eksctl version
```
检查是否出现了版本。

你现在已经安装好了eksctl。

验证 AWS CLI 是否已安装

在开发环境终端中，输入：
```
aws --version
```
检查是否显示了版本以验证 AWS CLI 是否已安装。

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

要配置 AWS CLI

您必须 AWS CLI 使用访问密钥和会话令牌配置才能使其访问 AWS 服务。以下说明提供了配置密钥和令牌的快速方法，但如果您需要详细说明，请参阅AWS Command Line Interface 用户指南 AWS CLI中的配置。

创建IAM身份中心用户，如下所示：
1. 登录 AWS Management Console 并打开 AWS IAM Identity Center 控制台，网址为https://console.aws.amazon.com/singlesignon/。
  
  （如果您之前从未登录过 Ident IAM ity Center，则可能需要选择 “启用”。）
  
  注意
  请务必使用与您的 CodeCatalyst空间 AWS 账户相连的登录。您可以通过导航到您的空间并选择 “帐户” 选项卡来验证关联了哪AWS个账户。有关更多信息，请参阅创建空间。
2. 在导航窗格中，选择 Users，然后选择 Add user。
3. 在用户名中，输入：
```
codecatalyst-eks-user
```
4. 在 “密码” 下，选择 “生成可与该用户共享的一次性密码”。
5. 在 “电子邮件地址” 和 “确认电子邮件地址” 中，输入 Ident IAM ity Center 中尚不存在的电子邮件地址。
6. 在 “名字” 中，输入：
```
codecatalyst-eks-user
```
7. 在姓氏中，输入：
```
codecatalyst-eks-user
```
8. 在 “显示名称” 中，保留：
```
codecatalyst-eks-user codecatalyst-eks-user
```
9. 选择下一步。
10. 在 “将用户添加到群组” 页面上，选择 “下一步”。
11. 在查看并添加用户页面上，查看信息并选择添加用户。
  
  将出现 “一次性密码” 对话框。
12. 选择 “复制”，然后将登录信息粘贴到文本文件中。登录信息由 AWS 访问门户URL、用户名和一次性密码组成。
13. 选择关闭。
按如下方式创建权限集：
1. 在导航窗格中，选择权限集，然后选择创建权限集。
2. 选择 “预定义权限集”，然后选择AdministratorAccess。此策略向所有人提供完全权限 AWS 服务。
3. 选择下一步。
4. 在权限集名称中，删除AdministratorAccess并输入：
```
codecatalyst-eks-permission-set
```
5. 选择下一步。
6. 在查看和创建页面上，检查相应信息，然后选择创建。
按如下方式将权限集分配给：codecatalyst-eks-user
1. 在导航窗格中 AWS 账户，选择，然后选中您当前登录 AWS 账户的旁边的复选框。
2. 选择分配用户或组。
3. 选择用户选项卡。
4. 选中 codecatalyst-eks-user 旁边的复选框。
5. 选择下一步。
6. 选中 codecatalyst-eks-permission-set 旁边的复选框。
7. 选择下一步。
8. 检查相应信息，然后选择提交。
  
  现在，你已经codecatalyst-eks-permission-set将codecatalyst-eks-user和分配给你的 AWS 账户，将它们绑定在一起。
获取codecatalyst-eks-user的访问密钥和会话令牌，如下所示：
1. 确保您拥有 AWS 访问门户URL以及的用户名和一次性密码codecatalyst-eks-user。您应该早点将此信息复制到文本编辑器中。
  
  注意
  如果您没有此信息，请前往 Ident IAM ity Center 的codecatalyst-eks-user详细信息页面，选择重置密码，生成一次性密码 [...] ，然后再次重置密码以在屏幕上显示信息。
2. 退出 AWS。
3. 将 AWS 访问门户粘贴URL到浏览器的地址栏中。
4. 使用以下方式登录：
  - 用户名:
```
codecatalyst-eks-user
```
  - 密码:
    
    one-time-password
5. 在设置新密码中，输入新密码并选择设置新密码。
  
  屏幕上会出现一个 AWS 账户框。
6. 选择 AWS 账户，然后选择 AWS 账户向其分配codecatalyst-eks-user用户和权限集的名称。
7. 在旁边codecatalyst-eks-permission-set，选择命令行或编程访问。
8. 复制页面中间的命令。它们看起来类似于以下内容：
```
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
export AWS_SESSION_TOKEN="session-token"
```
  ... 哪里 session-token 是一个长随机字符串。
将访问密钥和会话令牌添加到 AWS CLI，如下所示：
1. 返回您的 CodeCatalyst 开发环境。
2. 在终端提示符处，粘贴您复制的命令。按 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：创建亚马逊EKS集群

在本节中，您将在 Amazon 中创建一个集群EKS。以下说明描述了使用创建集群的快速方法eksctl，但如果您需要详细说明，请参阅：

亚马逊EKS用户指南中的 eksctl 入门

或者
控制台入门和 AWS CLI Amazon EKS 用户指南（本主题提供创建集群的kubectl说明）

注意

与 Amazon 的 CodeCatalyst 集成不支持@@ 私有集群EKS。

开始之前

确保您已在开发计算机上完成以下任务：

已安装该eksctl实用程序。
已安装该kubectl实用程序。
已安装 AWS CLI 并使用访问密钥和会话令牌对其进行配置。

有关如何完成这些任务的信息，请参阅第 1 步：设置开发机器。

创建集群

重要

请勿使用 Amazon EKS 服务的用户界面创建集群，因为集群配置不正确。使用该eksctl实用程序，如以下步骤所述。

转到您的开发环境。
创建集群和节点：
```
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条消息。这是预期行为。

验证您的集群是否已成功创建：


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：创建亚马逊ECR镜像存储库

在本节中，您将在 Amazon 弹性容器注册表 (AmazonECR) 中创建私有镜像存储库。此存储库存储本教程的 Docker 镜像。

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

在 Amazon 中创建镜像存储库 ECR

转到您的开发环境。
在 Amazon 中创建一个空仓库ECR：
```
aws ecr create-repository --repository-name codecatalyst-eks-image-repo
```
Replace（替换） codecatalyst-eks-image-repo 用你想给亚马逊ECR存储库起的名字。

本教程假设您命名了存储库codecatalyst-eks-image-repo。

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


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

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

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

步骤 4：添加源文件

在本节中，您将向源存储库中添加应用程序源文件 (codecatalyst-eks-source-repository)。它们包括：

index.html文件 — 显示 “你好，世界！” 浏览器中的消息。
Dockerfile — 描述用于你的 Docker 镜像的基础镜像以及应用于它的 Docker 命令。
deployment.yaml文件 — 定义 Kubernetes 服务和部署的 Kubernetes 清单。

文件夹结构如下：


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

主题

index.html
Dockerfile
部署 .yaml

index.html

index.html文件显示 “你好，世界！” 浏览器中的消息。

添加 index.html 文件

转到您的开发环境。
在中codecatalyst-eks-source-repository，创建一个名为的文件夹public-html。

在中/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>

在终端提示符下，输入：


cd /projects/codecatalyst-eks-source-repository

添加、提交和推送：
```
git add .
git commit -m "add public-html/index.html"
git push
```
将index.html以public-html文件夹的形式添加到存储库中。

Dockerfile

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

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

添加 Dockerfile

在中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命令希望它在那里。
添加、提交和推送：
```
git add .
git commit -m "add Dockerfile"
git push
```
Dockerfile 已添加到您的存储库中。

部署 .yaml

在本节中，您将向存储库中添加deployment.yaml文件。该deployment.yaml文件是一个 Kubernetes 清单，它定义了两种要运行的 Kubernetes 资源类型或类型：“服务” 和 “部署”。

“服务” 将负载均衡器部署到 Amazon EC2。负载均衡器为您提供面向 Internet 的公用URL和标准端口（端口 80），您可以使用该端口浏览到 “Hello，World！” 应用程序的修订。
“部署” 部署了三个 pod，每个 pod 将包含一个带有 “Hello，World！” 的 Docker 容器应用程序的修订。这三个 Pod 将部署到您创建集群时创建的节点上。

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

添加部署.yaml 文件

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

在中/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

添加、提交和推送：
```
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 角色

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

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

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

注意

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

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

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

转到您的开发环境。

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


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

2. 为生成角色创建生成策略

在Cloud9-long-string目录中，创建一个名为的文件codecatalyst-eks-build-policy.json，其中包含以下内容：
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*",
                "ec2:*"
            ],
            "Resource": "*"
        }
    ]
}
```
注意
首次使用该角色运行工作流程操作时，请在资源策略语句中使用通配符，然后在策略可用后使用资源名称缩小策略范围。
```
"Resource": "*"
```

3. 为部署角色创建部署策略

在Cloud9-long-string目录中，创建一个名为的文件codecatalyst-eks-deploy-policy.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

在开发环境终端中，输入：
```
cd /projects
```

输入：


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

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

5. 将部署策略添加到 AWS

输入：


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

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

6. 创建生成角色

输入：


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

按 Enter 键。

输入：


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

按 Enter 键。

在终端提示符下，输入：


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

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

7. 创建部署角色

输入：


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

按 Enter 键。

输入：


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

按 Enter 键。

输入：


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

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

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

步骤 6：将 AWS 角色添加到 CodeCatalyst

在此步骤中，将构建角色 (codecatalyst-eks-build-role) 和部署角色 (codecatalyst-eks-deploy-role) 添加到连接到空间 AWS 账户的角色中。这样，这些角色就可以在您的工作流程中使用。

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

在 CodeCatalyst 控制台中，导航到您的空间。
在顶部，选择设置。
在导航窗格中，选择AWS 账户。此时会出现账户列表。
在 Amazon CodeCatalyst 显示名称列中，复制您创建构建和部署角色的显示名称。 AWS 账户（可能是一个数字。）稍后，在创建工作流程时，您将需要此值。
选择显示名称。
从管理控制台中选择 “ AWS 管理角色”。

将出现 “向 Amazon CodeCatalyst 空间添加IAM角色” 页面。您可能需要登录才能访问该页面。
选择添加您在中创建的现有角色IAM。

将出现一个下拉列表。该列表显示生成和部署角色，以及具有包括codecatalyst-runner.amazonaws.com和codecatalyst.amazonaws.com服务委托人的信任策略的任何其他IAM角色。
从下拉列表中添加：
- codecatalyst-eks-build-role
- codecatalyst-eks-deploy-role
注意
如果你看见The security token included in the request is invalid，可能是因为你没有正确的权限。要解决此问题，请使用您在创建 CodeCatalyst空间时使用的 AWS 账号退出并重新登录。 AWS
返回 CodeCatalyst 控制台并刷新页面。

现在，生成和部署角色应显示在IAM角色下。

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

步骤 7：更新 ConfigMap

您必须将您在中创建的部署角色添加到 Kubernetes ConfigMap 文件中步骤 5：创建 AWS 角色，才能让 “部署到 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 角色。
- codecatalyst-eks-deploy-role （旁边--username）将替换为您在中创建的部署角色的名称步骤 5：创建 AWS 角色。
  
  注意
  如果您决定不创建部署角色，请替换 codecatalyst-eks-deploy-role 用CodeCatalystWorkflowDevelopmentRole-spaceName角色的名字。有关该角色的更多信息，请参阅步骤 5：创建 AWS 角色。
- us-west-2 已替换为您所在的地区。
有关此命令的详细信息，请参阅管理IAM用户和角色。

将显示一条类似于以下内容的消息：
```
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

在开发环境终端中，输入：
```
kubectl edit configmap -n kube-system aws-auth
```
ConfigMap 文件出现在屏幕上。

用红色斜体添加文本：

# 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 角色。
codecatalyst-eks-deploy-role （旁边username:）将替换为您在中创建的部署角色的名称步骤 5：创建 AWS 角色。

注意
如果您决定不创建部署角色，请替换 codecatalyst-eks-deploy-role 用CodeCatalystWorkflowDevelopmentRole-spaceName角色的名字。有关该角色的更多信息，请参阅步骤 5：创建 AWS 角色。

有关详细信息，请参阅 Amazon EKS 用户指南中的启用对集群的IAM委托人访问权限。

现在，您已经授予了部署角色以及部署到亚马逊EKS操作对您的 Kubernetes 集群的system:masters权限。

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

在此步骤中，您将创建一个工作流程，该工作流程用于获取源文件，将其构建为 Docker 映像，然后将该映像部署到 Ama EKS zon 集群中的树容器中。

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

触发器-当您将更改推送到源存储库时，此触发器会自动启动工作流程运行。有关触发器的更多信息，请参阅启动工作流程使用触发器自动运行。
构建操作 (BuildBackend) — 触发后，该操作使用 Dockerfile 构建 Docker 镜像并将镜像推送到亚马逊。ECR生成操作还会使用正确的值更新deployment.yaml文件中的$REPOSITORY_URI和$IMAGE_TAG变量，然后创建该文件和该Kubernetes文件夹中任何其他文件的输出对象。在本教程中，Kubernetes文件夹中唯一的文件是，deployment.yaml但您可以包含更多文件。该构件用作部署操作的输入，接下来是部署操作。

有关生成操作的更多信息，请参阅使用工作流程进行构建。
部署操作 (DeployToEKS)-生成操作完成后，部署操作将查找生成操作 (Manifests) 生成的输出对象，并在其中找到deployment.yaml文件。然后，该操作按照deployment.yaml文件中的说明运行三个 pod，每个吊舱都包含一个 “Hello，World！” Docker 容器 — 位于您的亚马逊集群中。EKS

创建工作流

转到 CodeCatalyst 控制台。
导航到您的项目 (codecatalyst-eks-project)。
在导航窗格中，选择 C I/CD，然后选择工作流程。
选择 “创建工作流程”。
对于源存储库，选择codecatalyst-eks-source-repository。
对于 “分支”，选择main。
选择创建。
删除YAML示例代码。

添加以下YAML代码以创建新的工作流程定义文件：

注意

有关工作流程定义文件的更多信息，请参阅工作流程YAML定义。

注意

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


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 使用您在中创建的环境的名称先决条件。
的两个实例 codecatalyst-account-connection 显示您的账户连接的显示名称。显示名称可能是一个数字。有关更多信息，请参阅步骤 6：将 AWS 角色添加到 CodeCatalyst。
codecatalyst-eks-build-role 使用您在中创建的构建角色的名称步骤 5：创建 AWS 角色。
111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo （在Value:属性中）使用您在中创建URI的 Amazon ECR 存储库的步骤 3：创建亚马逊ECR镜像存储库。
111122223333.dkr.ecr.us-west-2.amazonaws.com （在Run: aws ecr命令中）使用不带图像后缀 (/codecatalyst-eks-image-repo) 的 Amazon ECR 存储库。URI
codecatalyst-eks-deploy-role 使用您在中创建的部署角色的名称步骤 5：创建 AWS 角色。
的两个实例 us-west-2 使用您的 AWS 地区代码。有关区域代码的列表，请参阅中的区域终端节点AWS 一般参考。

注意

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

（可选）选择 “验证”，确保YAML代码在提交之前有效。
选择 Commit (提交)。
在 “提交工作流程” 对话框中，输入以下内容：
1. 对于 “提交消息”，删除文本并输入：
```
Add first workflow
```
2. 对于 “存储库”，选择codecatalyst-eks-source-repository。
3. 对于分支名称，选择主分支。
4. 选择 Commit (提交)。
现在，您已经创建了一个工作流程。由于在工作流程顶部定义了触发器，因此工作流程运行会自动启动。具体而言，当您将workflow.yaml文件提交（并推送）到源存储库时，触发器会启动工作流程运行。

查看工作流程运行进度

在 CodeCatalyst 控制台的导航窗格中，选择 C I/CD，然后选择工作流程。
选择您刚刚创建的工作流程codecatalyst-eks-workflow。
选择BuildBackend查看构建进度。
选择DeployToEKS查看部署进度。

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

验证部署

打开亚马逊EC2控制台，网址为https://console.aws.amazon.com/ec2/。
在左侧的底部附近，选择负载均衡器。
选择在 Kubernetes 部署过程中创建的负载均衡器。如果您不确定要选择哪个负载均衡器，请在标签选项卡下查找以下标签：
- kubernetes.io/service-name
- kubernetes.io/cluster/ekstutorialcluster
选择正确的负载均衡器后，选择描述选项卡。
将DNS名称值复制并粘贴到浏览器的地址栏中。

'你好，世界！' 网页出现在您的浏览器中，表示您已成功部署应用程序。

第 9 步：更改源文件

在本节中，您将对源存储库中的index.html文件进行更改。此更改会导致工作流程生成新的 Docker 映像，使用提交 ID 对其进行标记，将其推送到亚马逊ECR，然后将其部署到亚马逊ECS。

要更改 index.html

转到您的开发环境。
在终端提示符下，切换到您的源存储库：
```
cd /projects/codecatalyst-eks-source-repository
```
获取最新的工作流程更改：
```
git pull
```
打开 codecatalyst-eks-source-repository/public-html/index.html。
在第 14 行，将Hello, World!文本更改为Tutorial complete!。
添加、提交和推送：
```
git add .
git commit -m "update index.html title"
git push
```
工作流程运行会自动启动。
（可选）输入：
```
git show HEAD
```
记下index.html变更的提交 ID。此提交 ID 将被标记为 Docker 镜像，该镜像将由您刚开始的工作流程运行部署。
观看部署进度：
1. 在 CodeCatalyst 控制台的导航窗格中，选择 C I/CD，然后选择工作流程。
2. 选择codecatalyst-eks-workflow查看最新运行情况。
3. 选择BuildBackend、和DeployToEKS以查看工作流程的运行进度。
验证您的应用程序是否已更新，如下所示：
1. 打开亚马逊EC2控制台，网址为https://console.aws.amazon.com/ec2/。
2. 在左侧的底部附近，选择负载均衡器。
3. 选择在 Kubernetes 部署过程中创建的负载均衡器。
4. 将DNS名称值复制并粘贴到浏览器的地址栏中。
  
  '教程完成了！' 网页出现在您的浏览器中，表示您成功部署了应用程序的新修订版。
（可选）在中 AWS，切换到 Amazon ECR 控制台，确认新 Docker 镜像已使用此过程步骤 7 中的提交 ID 进行标记。

清理

您应该清理环境，这样您就不会因为本教程使用的存储和计算资源而产生不必要的费用。

清理

删除您的集群：
1. 在开发环境终端中，输入：
```
eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
```
  其中：
  - us-west-2 已替换为您所在的地区。
  - codecatalyst-eks-cluster 将替换为您创建的集群的名称。
  5-10 分钟后，集群和相关资源将被删除，包括但不限于 AWS CloudFormation 堆栈、节点组（在 Amazon 中EC2）和负载均衡器。
重要
如果该eksctl delete cluster命令不起作用，则可能需要刷新您的 AWS 凭据或kubectl凭据。如果您不确定要刷新哪些凭据，请先刷新 AWS 凭据。要刷新您的 AWS 凭证，请参阅如何修复 “找不到凭证” 和 “ExpiredToken” 错误？。要刷新您的kubectl凭证，请参阅如何修复 “无法连接到服务器” 错误？。
在 AWS 控制台中，按如下方式进行清理：
1. 在亚马逊中ECR，删除codecatalyst-eks-image-repo。
2. 在 “IAM身份中心” 中，删除：
  1. codecatalyst-eks-user
  2. codecatalyst-eks-permission-set
3. 在中IAM，删除：
  - codecatalyst-eks-build-role
  - codecatalyst-eks-deploy-role
  - codecatalyst-eks-build-policy
  - codecatalyst-eks-deploy-policy
在 CodeCatalyst 控制台中，按如下方式进行清理：
1. 删除codecatalyst-eks-workflow。
2. 删除codecatalyst-eks-environment。
3. 删除codecatalyst-eks-source-repository。
4. 删除您的开发环境。
5. 删除codecatalyst-eks-project。

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

Javascript 在您的浏览器中被禁用或不可用。

要使用 Amazon Web Services 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

文档惯例

部署到亚马逊 EKS

添加 “部署到 Kubernetes 集群” 操作