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

# CodePipeline 教程
<a name="tutorials"></a>

完成中的步骤后[入门 CodePipeline](getting-started-codepipeline.md)，您可以尝试本用户指南中的其中一个 AWS CodePipeline 教程。

**Topics**
+ [教程：使用以下命令部署到 Amazon EC2 实例 CodePipeline](tutorials-ec2-deploy.md)
+ [教程：使用 CodePipeline （V2 类型）构建 Docker 镜像并将其推送到亚马逊 ECR](tutorials-ecr-build-publish.md)
+ [教程：使用以下方法部署到 Amazon EKS CodePipeline](tutorials-eks-deploy.md)
+ [教程：创建使用计算运行命令的管道（V2 类型）](tutorials-commands.md)
+ [教程：使用 Git 标签启动管道](tutorials-github-tags.md)
+ [教程：根据分支名称筛选拉取请求以启动管道（V2 类型）](tutorials-github-featurebranches.md)
+ [教程：使用管道级变量](tutorials-pipeline-variables.md)
+ [教程：创建一个简单的管道（S3 存储桶）](tutorials-simple-s3.md)
+ [教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)
+ [教程：创建一个四阶段管道](tutorials-four-stage-pipeline.md)
+ [教程：设置 CloudWatch 事件规则以接收有关管道状态更改的电子邮件通知](tutorials-cloudwatch-sns-notifications.md)
+ [教程：创建用于构建和测试您的 Android 应用程序的管道 AWS Device Farm](tutorials-codebuild-devicefarm.md)
+ [教程：创建用于测试你的 iOS 应用的管道 AWS Device Farm](tutorials-codebuild-devicefarm-S3.md)
+ [教程：创建部署到 Service Catalog 的管道](tutorials-S3-servicecatalog.md)
+ [教程：使用创建管道 AWS CloudFormation](tutorials-cloudformation.md)
+ [教程：创建使用 AWS CloudFormation 部署操作中的变量的管道](tutorials-cloudformation-action.md)
+ [教程：使用 Amazon ECS 标准部署 CodePipeline](ecs-cd-pipeline.md)
+ [教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道](tutorials-ecs-ecr-codedeploy.md)
+ [教程：创建部署 Amazon Alexa 技能的管道](tutorials-alexa-skills-kit.md)
+ [教程：创建以 Amazon S3 作为部署提供程序的管道](tutorials-s3deploy.md)
+ [教程：创建将您的无服务器应用程序发布到的管道 AWS Serverless Application Repository](tutorials-serverlessrepo-auto-publish.md)
+ [教程：使用 Lambda 函数部署 CodePipeline](tutorials-lambda-deploy.md)
+ [教程：将变量与 Lambda 调用操作一起使用](tutorials-lambda-variables.md)
+ [教程：在管道中使用 AWS Step Functions 调用操作](tutorials-step-functions.md)
+ [教程：创建 AWS AppConfig 用作部署提供者的管道](tutorials-AppConfig.md)
+ [教程：使用带有 GitHub 管道源的完整克隆](tutorials-github-gitclone.md)
+ [教程：使用带有 CodeCommit 管道源的完整克隆](tutorials-codecommit-gitclone.md)
+ [教程：使用 AWS CloudFormation StackSets 部署操作创建管道](tutorials-stackset-deployment.md)
+ [教程：为管道创建变量检查规则作为“入口”条件](tutorials-varcheckrule.md)

# 教程：使用以下命令部署到 Amazon EC2 实例 CodePipeline
<a name="tutorials-ec2-deploy"></a>

本教程可帮助您创建部署操作 CodePipeline ，将您的代码部署到您在 Amazon EC2 中配置的实例。

**注意**  
作为在控制台中创建管道的一部分，S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
`EC2` 部署操作仅适用于 V2 类型管道。

## 先决条件
<a name="tutorials-ec2-deploy-prereqs"></a>

您必须先部署一些资源，然后才能使用本教程创建您的 CD 管道。以下是您在开始操作之前需要的资源：

**注意**  
所有这些资源都应在同一个 AWS 区域内创建。
+ 源代码控制存储库（本教程使用 GitHub），您将在其中添加示例`script.sh`文件。
+ 您必须使用已更新为具有此操作权限的现有 CodePipeline 服务角色。要更新您的服务角色，请参阅[EC2 部署操作的服务角色策略权限](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action)。

在满足这些先决条件后，您可以继续完成本教程并创建您的 CD 管道。

## 步骤 1：创建 Amazon EC2 Linux 实例
<a name="tutorials-ec2-deploy-instances"></a>

在此步骤中，您将创建要在其中部署示例应用程序的 Amazon EC2 实例。作为此过程的一部分，如果您尚未在要创建资源的区域中创建实例角色，请在 IAM 中创建一个。

**创建实例角色**

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

1. 在控制台控制面板中，选择**角色**。

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

1. 在**选择受信任实体的类型**下，选择 **AWS 服务**。在**选择使用案例**下，选择 **EC2**。在**选择您的使用案例**下，选择 **EC2**。选择**下一步**。

1. 搜索名为 **`AmazonSSMManagedEC2InstanceDefaultPolicy`** 的策略并将其选中。

1. 搜索名为 **`AmazonSSMManagedInstanceCore`** 的策略并将其选中。选择**下一步：标签**。

1. 选择**下一步：审核**。输入角色的名称（例如 **EC2InstanceRole**）。
**注意**  
记下您的角色名称以便在下一步中使用。在创建实例时选择此角色。
**注意**  
您将向该角色添加权限，以便在创建管道后允许其访问管道的 S3 构件存储桶。

   选择**创建角色**。

**启动实例**

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

1. 在侧面导航栏中，选择**实例**，然后从页面顶部选择**启动实例**。

1. 在**名称**中，输入 **MyInstances**。这会为实例分配标签**键** **Name** 和标签值 ****MyInstances****。

1. 在 “**应用程序和操作系统映像（亚马逊系统映像）**” 下，找到带有 AWS 徽标的 **Amazon Linux** AMI 选项，并确保将其选中。（此 AMI 称为 Amazon Linux 2 AMI (HVM)，并标记为“符合免费套餐条件”。）

1. 在**实例类型**下，选择符合免费套餐条件的 `t2.micro` 类型作为实例的硬件配置。

1. 在**密钥对(登录)** 下，选择或创建密钥对。

1. 在**网络设置**下，确保状态为**启用**。

1. 展开**高级详细信息**。在 **IAM 实例配置文件**中，选择您在上一过程中创建的 IAM 角色（例如 **EC2InstanceRole**）。
**注意**  
不要将实例角色留空，因为这会导致系统创建默认角色并且不会选择您创建的角色。

1. 在**摘要**下的**实例数**下，输入 `2`。

1. 选择**启动实例**。

1. 您可以在**实例**页面上查看启动的状态。启动实例时，其初始状态为 `pending`。实例启动后，其状态变为 `running`，并且会收到一个公有 DNS 名称。（如果**公有 DNS** 列不显示，请选择**显示/隐藏**图标，然后选择**公有 DNS**。）

## 步骤 2：向 EC2 实例角色添加构件存储桶权限
<a name="tutorials-ec2-deploy-role-s3"></a>

您必须更新为实例创建的 EC2 实例角色，允许其访问管道的构件存储桶。

**注意**  
创建实例时，会创建角色或使用现有的 EC2 实例角色。为避免`Access Denied`错误，您必须向实例角色添加 S3 存储桶权限，以授予实例对 CodePipeline 项目存储桶的权限。创建默认角色或更新现有角色，将 `s3:GetObject` 权限范围缩小到管道所在区域的构件存储桶。

1. 在 CodePipeline 控制台中导航到您的管道。选择**设置**。查看现有管道的构件存储的名称和位置。记下构件存储桶 Amazon 资源名称（ARN）并复制。

1. 导航到 IAM 控制台，然后选择 **Roles (角色)**。选择您在本教程步骤 1 中创建的实例角色。

1. 在**权限**选项卡上，选择**添加内联策略**。

1. 将以下 JSON 添加到策略文档中，将 `Resource` 字段中的值替换为存储桶 ARN。

   ```
   {
       "Effect": "Allow",
       "Principal": "*",
       "Action": "s3:GetObject",
       "Resource": "arn:aws:s3:::BucketName"
   }
   ```

1. 选择**更新**。

## 步骤 3：向您的存储库添加脚本文件
<a name="tutorials-ec2-deploy-file"></a>

粘贴此示例文本，为部署中的后脚本步骤创建 `script.sh` 文件。

```
echo "Hello World!" 
```

**将 `script.sh` 文件添加至您的源存储库**

1. 打开文本编辑器，然后将上述文件复制并粘贴到新文件中。

1. 提交您的 `script.sh` 文件并将其推送至源存储库。

   1. 添加文件。

      ```
      git add .
      ```

   1. 提交更改。

      ```
      git commit -m "Adding script.sh."
      ```

   1. 推送提交。

      ```
      git push
      ```

   记下存储库中的路径。

   ```
   /MyDemoRepo/test/script.sh
   ```

## 步骤 4：创建管道
<a name="tutorials-ec2-deploy-pipeline"></a>

使用向 CodePipeline 导创建工作流阶段并连接源存储库。

**创建管道**

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

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**使用现有服务角色**，然后选择已更新为具有此操作所需权限的 CodePipeline 服务角色。要为此操作配置您的 CodePipeline服务角色，请参阅[EC2 部署操作的服务角色策略权限](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action)。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**来源提供商**中，选择 **GitHub （通过 GitHub 应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub源操作的连接，请参阅[GitHub 连接](connections-github.md)。

   1. 在 **Repository name (存储库名称)** 中，选择 GitHub 存储库的名称。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**页面上，选择**跳过**。

1. 在**步骤 5：添加部署阶段**页面上，选择 **EC2**。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ec2deploy-action.png)

   1. 在**目标目录**中，输入要部署到的实例上的目录，例如 `/home/ec2-user/testhelloworld`。
**注意**  
指定您希望操作对实例使用的部署目录。作为部署的一部分，该操作将在实例上自动创建指定目录。

   1. 对于 **PostScript**，请输入脚本的路径和文件名，例如`test/script.sh`。

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

1. 在 **Step 6: Review** 页面上，审查您的管道配置，然后选择 **Create pipeline** 以创建管道。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ec2deploy-pipeline.png)

1. 管道成功运行后，选择**查看详细信息**即可查看操作日志，查看托管计算操作输出。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ec2deploy-logs.png)  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ec2deploy-logs2.png)

## 第 5 步：测试您的管道
<a name="tutorials-ec2-deploy-test"></a>

您的管道应该具备运行 end-to-end原生 AWS 持续部署所需的一切。现在，通过将代码更改推送至您的源存储库来测试管道的功能。

**测试您的管道**

1. 对您的已配置源存储库进行代码更改，然后提交并推送更改。

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

1. 从列表中选择您的管道。

1. 监视管道经历不同阶段的进度。您的管道应已完成，您的操作将在您的实例上部署脚本。

1. 有关问故障排除的更多信息，请参阅[EC2 部署操作失败并显示错误消息“`No such file`”](troubleshooting.md#troubleshooting-ec2-deploy)。

# 教程：使用 CodePipeline （V2 类型）构建 Docker 镜像并将其推送到亚马逊 ECR
<a name="tutorials-ecr-build-publish"></a>

本教程可帮助您在中创建一个生成操作 CodePipeline ，在更改源代码后运行您的 Docker 映像并将其推送到 Amazon ECR。本教程还向您展示了如何添加 Amazon ECS 部署操作来部署您推送的映像。

**重要**  
作为在控制台中创建管道的一部分，S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
本教程适用于包含 GitHub 源存储库的 CodePipeline 管道的 ECRBuildAndPublish 构建操作以及用于部署到 Amazon ECS 集群的 Amazon ECS 标准操作。有关使用带有 ECR 镜像存储库的管道作为 Amazon ECS 的 CodeDeploy 蓝/绿部署操作源的教程，请参阅。 CodePipeline [教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道](tutorials-ecs-ecr-codedeploy.md)

**重要**  
此操作使用 CodePipeline 托管 CodeBuild 计算在构建环境中运行命令。运行 Commands 操作将在 AWS CodeBuild中产生单独的费用。

## 先决条件
<a name="tutorials-ecr-build-publish-prereqs"></a>

您必须先部署一些资源，然后才能使用本教程创建您的 CD 管道。以下是您在开始操作之前需要的资源：

**注意**  
所有这些资源都应在同一个 AWS 区域内创建。
+ 源代码控制存储库（本教程使用 GitHub），您将在其中为本教程添加以下内容：
  + 在步骤 1 中，您将向源存储库中添加一个示例 Dockerfile 作为中 ECRBuildAndPublish 构建操作的输入项目。 CodePipeline
  + 在步骤 2 中，您将向源存储库中添加一个示例 imagedefinitions.json 文件，以此作为中亚马逊 ECS 标准部署操作的要求。 CodePipeline
+ 一个 Amazon ECR 映像存储库，其中包含您基于 Dockerfile 构建的映像。有关更多信息，请参阅 *Amazon Elastic Container Registry 用户指南* 中的[创建存储库](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html)和[推送映像](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html)。
+ 在与映像存储库相同的区域中创建的 Amazon ECS 集群和服务。有关更多信息，请参阅 *Amazon Elastic Container Service 开发者指南* 中的[创建集群](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html)和[创建服务](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service.html)。

在满足这些先决条件后，您可以继续完成本教程并创建您的 CD 管道。

## 步骤 1：向源存储库添加 Dockerfile
<a name="tutorials-ecr-build-publish-file"></a>

本教程使用该 ECRBuildAndPublish 操作来构建 Docker 镜像并将镜像推送到 Amazon ECR。中的托管计算操作 CodePipeline CodeBuild 用于运行 ECR 登录和映像推送的命令。您无需向源代码存储库中添加`buildspec.yml`文件即可说明 CodeBuild如何执行此操作。在本示例中，您只需在存储库中提供 Dockerfile，如下所示。

粘贴此示例文本以创建您的 `Dockerfile` 文件。此示例 Dockerfile 与先决条件中 ECR 镜像说明中使用的示例相同。

```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest

# Install dependencies
RUN yum update -y && \
 yum install -y httpd

# Install apache and write hello world message
RUN echo 'Hello World!' > /var/www/html/index.html

# Configure apache
RUN echo 'mkdir -p /var/run/httpd' >> /root/run_apache.sh && \
 echo 'mkdir -p /var/lock/httpd' >> /root/run_apache.sh && \
 echo '/usr/sbin/httpd -D FOREGROUND' >> /root/run_apache.sh && \
 chmod 755 /root/run_apache.sh

EXPOSE 80

CMD /root/run_apache.sh
```

**将 `Dockerfile` 文件添加至您的源存储库**

1. 打开文本编辑器，然后将上述 Dockerfile 复制并粘贴到新文件中。

1. 提交您的 `Dockerfile` 文件并将其推送至源存储库。

   1. 添加文件。

      ```
      git add .
      ```

   1. 提交更改。

      ```
      git commit -m "Adding Dockerfile."
      ```

   1. 推送提交。

      ```
      git push
      ```

   确保文件位于存储库的根级别。

   ```
   / Dockerfile
   ```

## 步骤 2：向源存储库添加 imagedefinitions.json 文件
<a name="w2aac13b9c15"></a>

本教程使用中的 Amazon ECS 标准部署操作将您的容器部署 CodePipeline 到您的 Amazon ECS 集群。Amazon ECS 标准部署操作需要一个包含您的映像名称和 URI 的 imagedefinitions.json 文件。有关 imagedefinitions.json 文件的更多信息，请参阅[适用于 Amazon ECS 标准部署操作的 imagedefinitions.json 文件](file-reference.md#pipelines-create-image-definitions)。

粘贴此示例文本以创建您的 `imagedefinitions.json` 文件。使用 Dockerfile 中的名称，例如 `hello-world`，并使用存储映像的 Amazon ECR 存储库中的 URI。

```
[
  {
    "name": "hello-world",
    "imageUri": "ACCOUNT-ID.dkr.ecr.us-east-1.amazonaws.com/actions/image-repo"
  }
]
```

**将 `imagedefinitions.json` 文件添加至您的源存储库**

1. 打开文本编辑器，然后将上述示例复制并粘贴到新文件中。

1. 提交您的 `imagedefinitions.json` 文件并将其推送至源存储库。

   1. 添加文件。

      ```
      git add .
      ```

   1. 提交更改。

      ```
      git commit -m "Adding imagedefinitions.json."
      ```

   1. 推送提交。

      ```
      git push
      ```

   确保文件位于存储库的根级别。

   ```
   / imagedefinitions.json
   ```

## 步骤 3：创建管道
<a name="tutorials-ecr-build-publish-pipeline"></a>

使用向 CodePipeline 导创建工作流阶段并连接源存储库。

**创建管道**

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

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**来源提供商**中，选择 **GitHub （通过 GitHub 应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub源操作的连接，请参阅[GitHub 连接](connections-github.md)。

   1. 在 **Repository name (存储库名称)** 中，选择 GitHub 存储库的名称。

   1. 在**默认分支**中，选择在管道手动启动或使用非 Git 标签的源事件时要指定的分支。如果更改的来源不是触发器，或者管道执行是手动启动的，则使用的更改将是来自默认分支的 HEAD 提交。

   选择**下一步**。

1. 在 “**步骤 4：添加构建阶段**” 页面上，选择 “**其他构建提供者**选择” **ECRBuildAndPublish**。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ecrbuild-wizard.png)

   1. 在 **ECR 存储库名称**中，选择您的映像存储库。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**页面上，选择**跳过部署阶段**。您将在以下步骤中添加 ECS 操作。

1. 在 “**步骤 7：审阅**” 页面上，查看您的工作流配置，然后选择**创建管道**来创建管道。

1. 编辑您的管道以将 Amazon ECS 部署操作添加到您的管道中：

   1. 在右上角，选择**编辑**。

   1. 在示意图底部，选择 **\$1 添加阶段**。在**阶段名称**中，输入名称，例如 **Deploy**。

   1. 选择 **\$1 添加操作组**。

   1. 在**操作名称**中输入名称。

   1. 在**操作提供程序**中，选择 Amazon ECS。允许**区域**默认为管道区域。

   1. 在**输入构件**中，从源阶段选择输入构件，例如 `SourceArtifact`。

   1. 对于**集群名称**，请选择在其中运行您的服务的 Amazon ECS 集群。

   1. 对于**服务名称**，选择要更新的服务。

   1. 选择**保存**。

   1. 在所编辑的阶段上，选择**完成**。在 AWS CodePipeline 窗格中，选择**保存**，然后选择警告消息上的**保存**。

   1. 要提交所做的更改并开始管道构建，请选择**发布更改**，然后选择**发布**。

1. 管道运行后，查看管道结构和状态。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ecrbuild-ecsaction.png)

1. 管道成功运行后，选择**查看详细信息**即可查看操作日志，查看托管计算操作输出。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ecrbuild-logs.png)

1. 对任何失败的操作进行故障排除。例如，如果 imagedefinitions.json 文件不在源存储库中，ECS 部署操作可能会失败。下面是 imagedefinitions.json 文件丢失时显示的错误消息的示例。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ecrbuild-ecsdebug.png)

## 步骤 4：测试您的管道
<a name="tutorials-ecr-build-publish-test"></a>

您的管道应该具备运行 end-to-end原生 AWS 持续部署所需的一切。现在，通过将代码更改推送至您的源存储库来测试管道的功能。

**测试您的管道**

1. 对您的已配置源存储库进行代码更改，然后提交并推送更改。

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

1. 从列表中选择您的管道。

1. 监视管道经历不同阶段的进度。您的管道应完成且您的操作会将通过您的代码更改创建的 Docker 映像推送到 ECR。

# 教程：使用以下方法部署到 Amazon EKS CodePipeline
<a name="tutorials-eks-deploy"></a>

本教程可帮助您在中创建部署操作 CodePipeline ，将您的代码部署到您在 Amazon EKS 中配置的集群。

EKS 操作支持公共和私有 EKS 集群。私有集群是 EKS 推荐的类型；但是，两种类型都支持。

**注意**  
作为在控制台中创建管道的一部分，S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
此操作使用 CodePipeline 托管 CodeBuild 计算在构建环境中运行命令。运行 Commands 操作将在 AWS CodeBuild中产生单独的费用。

**注意**  
`EKS` 部署操作仅适用于 V2 类型管道。

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

您必须先部署一些资源，然后才能使用本教程创建您的 CD 管道。以下是您在开始操作之前需要的资源：

**注意**  
所有这些资源都应在同一个 AWS 区域内创建。
+ 源代码控制存储库（本教程使用 GitHub），您将在其中添加示例`deployment.yaml`文件。
+ 您必须使用现有的 CodePipeline 服务角色，该角色将使用[步骤 3：在 IAM 中更新 CodePipeline 服务角色策略](#tutorials-eks-deploy-role)以下方法更新为该操作的权限。所需的权限取决于您创建的集群的类型。有关更多信息，请参阅 [服务角色策略权限](action-reference-EKS.md#action-reference-EKS-service-role)。
+ 您已推送到 ECR 或您的映像存储库的工作映像和存储库标签。

在满足这些先决条件后，您可以继续完成本教程并创建您的 CD 管道。

## 步骤 1：（可选）在 Amazon EKS 中创建集群
<a name="tutorials-eks-deploy-cluster"></a>

您可以选择使用公有或私有端点创建 EKS 集群。

在以下步骤中，您将在 EKS 中创建公有集群或私有集群。如果已创建集群，则此步骤为可选步骤。

### 在 Amazon EKS 中创建公有集群。
<a name="tutorials-eks-deploy-cluster-public"></a>

在本步骤中，您将在 EKS 中创建集群。

**创建公有集群**

1. 打开 EKS 控制台，然后选择**创建集群**。

1. 在**名称**中，为您的集群命名。选择**下一步**。

1. 选择**创建**。

### 在 Amazon EKS 中创建私有集群。
<a name="tutorials-eks-deploy-cluster-private"></a>

如果您选择使用私有端点创建集群，请确保仅连接私有子网，并确保它们具有互联网连接。

请按照以下五个子步骤操作，使用私有端点创建集群。

**在控制台中创建 VPC。**

1. 打开 VPC 控制台，然后选择**创建 VPC**。

1. 在 **VPC 设置**页面上，选择 **VPC 等**。

1. 选择创建 1 个公有子网和 4 个私有子网。选择**创建 VPC**。

1. 在子网页面上，选择**私有**。

**确定 VPC 中的私有子网**

1. 导航到您的 VPC，然后选择 VPC ID 以打开 VPC 详细信息页面。

1. 在 VPC 详细信息页面，选择**资源图**选项卡。

1. 查看图表并记下您的私有子网。子网显示有指示公有或私有状态的标签，并且每个子网都映射到路由表。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/eks-deploy-subnets.png)

   请注意，私有集群将拥有所有私有子网。

1. 创建一个公有子网以托管 NAT 网关。您一次只能将一个互联网网关连接到 VPC。

**在公有子网中创建 NAT 网关**

1. 在公有子网中创建 NAT 网关。导航到 VPC 控制台，然后选择**互联网网关**。选择**创建互联网网关**。

1. 对于“名称”，为互联网网关输入名称。选择**创建互联网网关**。

更新私有子网的路由表，以将流量引至 NAT 网关。

**将 NAT 网关添加到私有子网的路由表中**

1. 导航到 VPC 控制台，然后选择**子网**。

1. 对于每个私有子网，选择它，然后在详细信息页面上选择该子网的路由表，选择**编辑路由表**。

1. 更新私有子网的路由表，以将互联网流量引至 NAT 网关。选择 **Add route**（添加路由）。从选项中选择要添加的 **NAT 网关**。选择您创建的互联网网关。

1. 对于公有子网，创建一个自定义路由表。验证您的公有子网的网络访问控制列表（ACL）是否允许来自私有子网的入站流量。

1. 选择**保存更改**。

在本步骤中，您将在 EKS 中创建集群。

**创建私有集群**

1. 打开 EKS 控制台，然后选择**创建集群**。

1. 在**名称**中，为您的集群命名。选择**下一步**。

1. 指定您的 VPC 和其他配置信息。选择**创建**。

您的 EKS 集群可以是公有集群，也可以是私有集群。此步骤适用于只有私有端点的集群。确保您的集群是私有的。

## 步骤 2：在 Amazon EKS 中配置您的私有集群
<a name="tutorials-eks-deploy-cluster-private-configure"></a>

仅当您创建了私有集群时，此步骤才适用。此步骤适用于只有私有端点的集群。

**配置集群**

1. 在**联网**选项卡下，仅在 EKS 集群中附加私有子网。附加[步骤 1：（可选）在 Amazon EKS 中创建集群](#tutorials-eks-deploy-cluster)下**确定 VPC 中的私有子网**部分捕获的私有子网。

1. 确保私有子网可以访问 Internet，因为可以 CodePipeline存储和检索管道的 S3 工件存储桶中的项目。

## 步骤 3：在 IAM 中更新 CodePipeline 服务角色策略
<a name="tutorials-eks-deploy-role"></a>

在此步骤中，您将使用连接集群所需的权限 CodePipeline 来更新现有 CodePipeline 服务角色（例如）。`cp-service-role`如果您还没有角色，请创建新角色。

通过以下步骤更新您的 CodePipeline 服务角色。

**更新您的 CodePipeline 服务角色政策**

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

1. 在控制台控制面板中，选择**角色**。

1. 查找您的 CodePipeline 服务角色，例如`cp-service-role`。

1. 添加新的内联策略。

1. 在**策略编辑器**中，输入以下内容。
   + 对于公有集群，添加以下权限。

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             }
         ]
     }
     ```

------
   + 对于私有集群，添加以下权限。私有集群需要您的 VPC 的额外权限（如果适用）。

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
     
         "Statement": [
             {
                 "Sid": "EksClusterPolicy",
                 "Effect": "Allow",
                 "Action": "eks:DescribeCluster",
                 "Resource": "arn:aws:eks:us-east-1:111122223333:cluster/my-cluster"
             },
             {
                 "Sid": "EksVpcClusterPolicy",
                 "Effect": "Allow",
                 "Action": [
                     "ec2:DescribeDhcpOptions",
                     "ec2:DescribeNetworkInterfaces",
                     "ec2:DescribeRouteTables",
                     "ec2:DescribeSubnets",
                     "ec2:DescribeSecurityGroups",
                     "ec2:DescribeVpcs"
                 ],
                 "Resource": [
                     "*"
                 ]
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:CreateNetworkInterfacePermission",
                 "Resource": "*",
                 "Condition": {
                     "ArnEquals": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:111122223333:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             },
             {
                 "Effect": "Allow",
                 "Action": "ec2:DeleteNetworkInterface",
                 "Resource": "*",
                 "Condition": {
                     "StringEqualsIfExists": {
                         "ec2:Subnet": [
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-03ebd65daeEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0e377f6036EXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE",
                             "arn:aws:ec2:us-east-1:ACCOUNT-ID:subnet/subnet-0db658ba1cEXAMPLE"
                         ]
                     }
                 }
             }
         ]
     }
     ```

------

1. 选择**更新策略**。

## 步骤 4：为 CodePipeline 服务角色创建访问条目
<a name="tutorials-eks-deploy-access-entry"></a>

在此步骤中，您将在集群上创建一个访问条目，该条目将添加您在步骤 3 中更新的 CodePipeline 服务角色以及托管访问策略。

1. 打开 EKS 控制台并导航至您的集群。

1. 选择**访问**选项卡。

1. 在 **IAM 访问条目**下，选择**创建访问条目**。

1. 在 **IAM 主体 ARN** 中，输入您刚刚为操作更新的角色，例如 `cp-service-role`。选择**下一步**。

1. 在**步骤 2：添加访问策略**页面的**策略名称**中，选择用于访问的托管策略，例如 `AmazonEKSClusterAdminPolicy`。选择**添加策略**。选择**下一步**。
**注意**  
这是该 CodePipeline 操作用来与 Kubernetes 对话的策略。最佳做法是，附加自定义策略，将策略中的权限范围缩小到最低权限，而非使用管理员策略。

1. 在查看页面上，选择**创建**。

## 步骤 5：创建源存储库并添加 `helm chart` 配置文件
<a name="tutorials-eks-deploy-source"></a>

在此步骤中，您将创建一个适合您的操作的配置文件（Kubernetes 清单文件或 Helm 图表），并将配置文件存储在源存储库中。使用适合您的配置的文件。欲了解更多信息，请参阅 [https://kubernetes。 ](https://kubernetes.io/docs/reference/kubectl/quick-reference/)io/docs/reference/kubectl/quick[-reference/ 或 https://helm。 sh/docs/topics/charts](https://helm.sh/docs/topics/charts/)/。
+ 对于 Kubernetes，请使用清单文件。
+ 对于 Helm，请使用 Helm 图表。

1. 创建或使用现有 GitHub 存储库。

1. 在存储库中为 Helm 图表文件创建一个新结构，如下例所示。

   ```
   mychart
   |-- Chart.yaml
   |-- charts
   |-- templates
   |   |-- NOTES.txt
   |   |-- _helpers.tpl
   |   |-- deployment.yaml
   |   |-- ingress.yaml
   |   `-- service.yaml
   `-- values.yaml
   ```

1. 将文件添加到存储库的根级别。

## 步骤 6：创建管道
<a name="tutorials-eks-deploy-pipeline"></a>

使用向 CodePipeline 导创建工作流阶段并连接源存储库。

**创建管道**

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

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyEKSPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择您在步骤 3 中更新的服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在 “**步骤 3：添加源阶段**” 页面上，对于**源提供商****，选择创建与存储 GitHub 库的连接**。

1. 在**步骤 4：添加构建阶段**页面上，选择**跳过**。

1. 在**步骤 5：添加部署阶段**页面上，选择 **Amazon EKS**。  
![\[Deploy configuration form with Helm selected, showing fields for release name and chart location.\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/eks-action-example.png)

   1. 在**部署配置类型**下，选择 **Helm**。

   1. 在 **Helm 图表位置**中，输入版本名称，例如 `my-release`。对于 **Helm 图表位置**，请输入 Helm 图表的路径，例如 `mychart`。

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

1. 在 **Step 6: Review** 页面上，审查您的管道配置，然后选择 **Create pipeline** 以创建管道。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/eks-deploy-pipeline.png)

1. 管道成功运行后，选择**查看详细信息**即可查看操作日志，查看操作输出。

# 教程：创建使用计算运行命令的管道（V2 类型）
<a name="tutorials-commands"></a>

在本教程中，您将配置一个管道，该管道使用构建阶段中的 Commands 操作持续运行所提供的构建命令。有关 Commands 操作的更多信息，请参阅 [Commands 操作参考](action-reference-Commands.md)。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

## 先决条件
<a name="tutorials-commands-prereq"></a>

您必须已经具备以下各项：
+ 存储 GitHub 库。您可以使用您在中创建的 GitHub 存储库[教程：使用带有 GitHub 管道源的完整克隆](tutorials-github-gitclone.md)。

## 第 1 步：创建源文件并推送到您的 GitHub 存储库
<a name="tutorials-commands-push"></a>

在本节中，您将创建示例源文件并将其推送到管道用于源阶段的存储库。在此示例中，您将生成并推送以下内容：
+ 一个 `README.txt` 文件。

**创建源文件**

1. 创建一个包含以下文本的文件：

   ```
   Sample readme file
   ```

1. 将该文件保存为 `README.txt`。

**将文件推送到您的 GitHub 存储库**

1. 将文件推送或上传至您的 存储库。这些文件是由**创建管道**向导针对您在 AWS CodePipeline中的部署操作创建的源项目。您的文件在本地目录中应如下所示：

   ```
   README.txt
   ```

1. 在本地计算机上从克隆的存储库使用 Git 命令行：

   1. 运行以下命令以立即暂存您的所有文件：

      ```
      git add -A
      ```

   1. 运行以下命令以提交带有提交消息的文件。

      ```
      git commit -m "Added source files"
      ```

   1. 运行以下命令以将文件从您的本地存储库推送到您的 存储库：

      ```
      git push
      ```

## 步骤 2：创建管道
<a name="tutorials-commands-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个源阶段，对存储源文件的存储库进行 GitHub （通过 GitHub App）操作。
+ 包含 Commands 操作的构建阶段。

**使用向导创建管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyCommandsPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。
**注意**  
如果您使用的是现有的服务角色，要使用 Commands 操作，需要为服务角色添加以下权限。在服务角色策略声明中使用基于资源的权限，将权限范围缩小到管道资源级别。有关更多信息，请参阅[服务角色策略权限](action-reference-Commands.md#action-reference-Commands-policy)中的策略示例。  
日志：CreateLogGroup
日志：CreateLogStream
日志：PutLogEvents

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**来源提供商**中，选择 **GitHub （通过 GitHub 应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub源操作的连接，请参阅[GitHub 连接](connections-github.md)。

   1. 在**存储库名称**中，选择您的 GitHub .com存储库的名称。

   1. 在**默认分支**中，选择在管道手动启动或使用非 Git 标签的源事件时要指定的分支。如果更改的来源不是触发器，或者管道执行是手动启动的，则使用的更改将是来自默认分支的 HEAD 提交。您还可以选择性地指定附带筛选功能的 Webhook（触发器）。有关更多信息，请参阅 [使用触发器和筛选功能自动启动管道](pipelines-triggers.md)。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择 **Commands**。
**注意**  
运行 Commands 操作将在 AWS CodeBuild中产生单独的费用。

   输入以下命令：

   ```
   ls
   echo hello world
   cat README.txt
   echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}
   ```

   选择**下一步**。  
![\[使用 Commands 操作的新管道的步骤 4：添加构建阶段页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/commands-wizard-screen.png)

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**页面上，选择**跳过部署阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

1. 创建操作的最后一步是在操作中添加一个环境变量，该变量将产生操作的输出变量。在 Commands 操作上，选择**编辑**。在**编辑**屏幕上，通过在**变量命名空间**字段中输入 `compute`，为您的操作指定变量命名空间。

   添加 CodeBuild 输出变量`AWS_Default_Region`，然后选择**添加变量**。  
![\[Commands 操作的“编辑”页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/commands-output-edit-var.png)

## 步骤 3：运行管道并验证构建命令
<a name="tutorials-commands-update"></a>

发布更改以运行管道。通过查看执行历史记录、构建日志和输出变量，验证构建命令是否运行。

**查看操作日志和输出变量**

1. 管道成功运行后，您可以查看该操作的日志和输出。

1. 要查看操作的输出变量，请选择**历史记录**，然后选择**时间线**。

   查看添加到操作中的输出变量。Commands 操作的输出显示解析为操作区域的输出变量。  
![\[显示解析为操作区域的输出变量的 Commands 操作输出。\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/commands-output-variable.png)

1. 要查看操作的日志，请选择成功 Commands 操作上的**查看详细信息**。查看 Commands 操作的日志。  
![\[Commands 操作的日志示例\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/commands-output-logs.png)

# 教程：使用 Git 标签启动管道
<a name="tutorials-github-tags"></a>

在本教程中，您将创建一个连接到 GitHub 存储库的管道，其中为 Git 标签触发器类型配置了源操作。在提交时创建 Git 标签后，您的管道就会启动。此示例说明如何创建允许根据标签名称语法筛选标签的管道。有关使用 glob 模式筛选的更多信息，请参阅[使用语法中的 glob 模式](syntax-glob.md)。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

本教程 GitHub 通过`CodeStarSourceConnection`操作类型连接到。

**注意**  
此功能在亚太地区（香港）、非洲（开普敦）、中东（巴林）或欧洲（苏黎世）区域不可用。要参考其他可用操作，请参阅 [产品和服务与 CodePipeline](integrations.md)。有关在欧洲地区（米兰）区域使用此操作的注意事项，请参阅[CodeStarSourceConnection 适用于 Bitbucket Cloud GitHub、、 GitHub 企业服务器、 GitLab .com 和 GitLab 自我管理操作](action-reference-CodestarConnectionSource.md)中的说明。

**Topics**
+ [先决条件](#tutorials-github-tags-prereq)
+ [第 1 步：打开 CloudShell 并克隆您的存储库](#w2aac13c16c15)
+ [步骤 2：创建在 Git 标签上触发的管道](#tutorials-github-tags-pipeline)
+ [第 3 步：标记要发布的提交](#w2aac13c16c19)
+ [步骤 4：发布更改并查看日志](#tutorials-github-tags-view)

## 先决条件
<a name="tutorials-github-tags-prereq"></a>

在开始之前，您必须执行以下操作：
+ 使用您的 GitHub 账户创建 GitHub 存储库。
+ 准备好您的 GitHub 凭证。当你使用 AWS 管理控制台 来建立连接时，系统会要求你使用自己的 GitHub 凭据登录。

## 第 1 步：打开 CloudShell 并克隆您的存储库
<a name="w2aac13c16c15"></a>

您可以使用命令行界面来克隆存储库、执行提交和添加标签。本教程启动命令行界面的 CloudShell 实例。

1. 登录到 AWS 管理控制台。

1. 在顶部导航栏中，选择图 AWS 标。此时显示 AWS 管理控制台 主页。

1. 在顶部导航栏中，选择图 AWS CloudShell 标。 CloudShell 打开。等待 CloudShell 环境创建完成。
**注意**  
如果您没有看到该 CloudShell 图标，请确保您[所在的区域由支持 CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available)。本教程假设您位于美国西部（俄勒冈州）区域。

1. 在中 GitHub，导航到您的存储库。选择**代码**，然后选择 **HTTPS**。复制路径。用于克隆 Git 存储库的地址复制到您的剪贴板。

1. 运行以下命令以克隆存储库。

   ```
   git clone https://github.com/<account>/MyGitHubRepo.git
   ```

1. 在出现提示`Password`时输入您的 GitHub 帐户`Username`。对于 `Password` 条目，您必须使用用户创建的令牌，而不是您的账户密码。

## 步骤 2：创建在 Git 标签上触发的管道
<a name="tutorials-github-tags-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个与您的 GitHub 仓库连接和操作的源阶段。
+ 带有生成操作的 AWS CodeBuild 生成阶段。

**使用向导创建管道**

1. 登录 CodePipeline 控制台，网址为[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyGitHubTagsPipeline**。

1. 在**管道类型**中，保留默认选择 **V2**。管道类型有不同的特点和价格。有关更多信息，请参阅 [管道类型](pipeline-types.md)。

1. 在**服务角色**中，选择**新建服务角色**。
**注意**  
如果您选择使用现有的 CodePipeline 服务角色，请确保已`codestar-connections:UseConnection`将 IAM 权限添加到您的服务角色策略中。有关 CodePipeline 服务角色的说明，请参阅[为 CodePipeline 服务角色添加权限](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**高级设置**下，保留原定设置值。在**构件存储**中，选择**默认位置**以将默认构件存储（如指定为默认值的 Amazon S3 项目存储桶）用于为管道选择的区域中的管道。
**注意**  
这不是源代码的源存储桶。这是管道的项目存储。每个管道都需要一个单独的构件存储，例如 S3 存储桶。

   选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**来源提供商**中，选择 **GitHub （通过 GitHub应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub 源操作的连接，请参阅[GitHub 连接](connections-github.md)。

   1. 在 **Repository name (存储库名称)** 中，选择 GitHub 存储库的名称。

   1. 在**默认分支**中，选择在管道手动启动或使用非 Git 标签的源事件时要指定的分支。如果更改的来源不是触发器，或者管道执行是手动启动的，则使用的更改将是来自默认分支的 HEAD 提交。

   1. 在 **Webhook 事件**下的**筛选条件类型**中，选择**标签**。

      在**标签或模式**字段中输入 `release*`。
**重要**  
使用 Git 标签触发器类型启动的管道配置为使用 WebhookV2 事件，而不会使用 Webhook 事件（对所有推送事件进行更改检测）来启动管道。

   选择**下一步**。

1. 在**添加构建阶段**，添加一个构建阶段：

   1. 在**构建提供程序**中，选择 **AWS CodeBuild**。允许**区域**默认为管道区域。

   1. 选择**创建项目**。

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境映像**中，选择**托管映像**。对于**操作系统**，选择 **Ubuntu**。

   1. 对于**运行时**，选择**标准**。**对于 “**图像**”，选择:5.0 aws/codebuild/standard。**

   1. 对于**服务角色**，选择**新建服务角色**。
**注意**  
记下您的 CodeBuild 服务角色的名称。在本教程的最后一步，您会用到此角色名称。

   1. 在**构建规范**下，为**构建规范**选择**插入构建命令**。选择**切换到编辑器**，然后将以下内容粘贴到**构建命令**。

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. 选择 “**继续” CodePipeline**。这将返回到 CodePipeline控制台并创建一个使用您的构建命令进行配置的 CodeBuild 项目。构建项目使用服务角色来管理 AWS 服务 权限。此步骤可能需要几分钟时间。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。

## 第 3 步：标记要发布的提交
<a name="w2aac13c16c19"></a>

创建管道并指定 Git 标签后，可以在 GitHub仓库中标记提交。在这些步骤中，您将使用 `release-1` 标签标记提交。Git 存储库中的每个提交都必须有唯一的 Git 标签。当您选择提交并对其进行标记时，可将来自不同分支的更改合并到您的管道部署中。请注意，标签名称版本不适用于中版本的概念 GitHub。

1. 引用 IDs 要标记的已复制提交。要查看每个分支中的提交，请在 CloudShell 终端中输入以下命令以捕获 IDs 要标记的提交：

   ```
   git log
   ```

1. 在 CloudShell 终端中，输入命令来标记你的提交并将其推送到 Origin。标记提交后，您可以使用 git push 命令将标签推送到源。在以下示例中，输入以下命令将 `release-1` 标签用于 ID 为 `49366bd` 的第二次提交。此标签将按管道 `release*` 标签筛选条件筛选并启动管道。

   ```
   git tag release-1 49366bd
   ```

   ```
   git push origin release-1
   ```  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/git-tags-pipeline.png)

## 步骤 4：发布更改并查看日志
<a name="tutorials-github-tags-view"></a>

1. 管道成功运行后，在成功构建阶段，选择**查看日志**。

   在 “**日志**” 下，查看 CodeBuild 生成输出。这些命令将输出所输入变量的值。

1. 在**历史记录**页面中，查看**触发器**列。查看触发器类型 **GitTag ：release-1。**

# 教程：根据分支名称筛选拉取请求以启动管道（V2 类型）
<a name="tutorials-github-featurebranches"></a>

在本教程中，您将创建一个连接到 GitHub .com存储库的管道，在该存储库中，源操作配置为使用筛选拉取请求的触发器配置启动管道。当指定分支发生指定的拉取请求事件时，管道就会启动。此示例向您演示如何创建一个可筛选分支名称的管道。有关使用触发器的更多信息，请参阅[为推送和拉取请求事件类型添加筛选条件（CLI）](pipelines-filter.md#pipelines-filter-cli)。有关使用 glob 格式的正则表达式模式筛选的更多信息，请参阅[使用语法中的 glob 模式](syntax-glob.md)。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

本教程通过`CodeStarSourceConnection`操作类型连接到 GitHub .com。

**Topics**
+ [先决条件](#tutorials-github-featurebranches-prereq)
+ [步骤 1：创建一个管道，该管道在指定分支有拉取请求时启动](#tutorials-github-featurebranches-pipeline)
+ [第 2 步：在 GitHub .com 中创建并合并拉取请求以开始执行管道](#tutorials-github-featurebranches-pullrequest)

## 先决条件
<a name="tutorials-github-featurebranches-prereq"></a>

在开始之前，您必须执行以下操作：
+ 使用您的 GitHub .com 账户创建 GitHub .com 存储库。
+ 准备好您的 GitHub 凭证。当你使用 AWS 管理控制台 来建立连接时，系统会要求你使用自己的 GitHub 凭据登录。

## 步骤 1：创建一个管道，该管道在指定分支有拉取请求时启动
<a name="tutorials-github-featurebranches-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 与您的 GitHub .com存储库的连接和操作的源阶段。
+ 带有生成操作的 AWS CodeBuild 生成阶段。

**使用向导创建管道**

1. 登录 CodePipeline 控制台，网址为[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyFilterBranchesPipeline**。

1. 在**管道类型**中，保留默认选择 **V2**。管道类型有不同的特点和价格。有关更多信息，请参阅 [管道类型](pipeline-types.md)。

1. 在**服务角色**中，选择**新建服务角色**。
**注意**  
如果您选择使用现有的 CodePipeline 服务角色，请确保已`codeconnections:UseConnection`将 IAM 权限添加到您的服务角色策略中。有关 CodePipeline 服务角色的说明，请参阅[为 CodePipeline 服务角色添加权限](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**高级设置**下，保留原定设置值。在**构件存储**中，选择**默认位置**以将默认构件存储（如指定为默认值的 Amazon S3 项目存储桶）用于为管道选择的区域中的管道。
**注意**  
这不是源代码的源存储桶。这是管道的项目存储。每个管道都需要一个单独的构件存储，例如 S3 存储桶。

   选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**来源提供商**中，选择 **GitHub （通过 GitHub应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub 源操作的连接，请参阅[GitHub 连接](connections-github.md)。

   1. 在**存储库名称**中，选择您的 GitHub .com存储库的名称。

   1. 在**触发器类型**下，选择**指定筛选条件**。

      在**事件类型**下，选择**拉取请求**。选择拉取请求下的所有事件，以便事件发生在创建、更新或关闭的拉取请求中。

      在**分支**下的**包含**字段中，输入 `main*`。  
![\[该图显示了在事件类型为“拉取请求”的触发器中选择了“包含”分支选项，其值为 main*\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/pullreq-example-triggers-edit.png)
**重要**  
使用此触发器类型启动的管道配置为使用 WebhookV2 事件，而不会使用 Webhook 事件（对所有推送事件进行更改检测）来启动管道。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**的**构建提供程序**中，选择 **AWS CodeBuild**。允许**区域**默认为管道区域。按照[教程：使用 Git 标签启动管道](tutorials-github-tags.md)中的说明选择或创建构建项目。此操作仅在本教程中用作创建管道所需的第二阶段。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。

## 第 2 步：在 GitHub .com 中创建并合并拉取请求以开始执行管道
<a name="tutorials-github-featurebranches-pullrequest"></a>

在本节中，您将创建并合并一个拉取请求。这将启动您的管道，针对打开的拉取请求执行一次，针对关闭的拉取请求执行一次。

**创建拉取请求并启动管道**

1. 在 GitHub .com 中，通过更改功能分支上的 README.md 并向该分支提出拉取请求来创建拉取请求。`main`提交更改，并带类似 `Update README.md for PR` 的消息。

1. 管道从源修订开始，将拉取请求的**源**消息显示为 **Update README.md for PR**。  
![\[该图显示了拉取请求的源消息，其中包含以下文本：Update README.md for PR\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/pullreq-example.png)

1. 选择 **History (历史记录)**。在管道执行历史记录中，查看启动管道执行的 CREATED 和 MERGED 拉取请求状态事件。  
![\[该图显示了管道执行历史记录，其中显示了启动管道执行的 CREATED 和 MERGED 拉取请求状态事件\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/pullreq-example-history.png)

# 教程：使用管道级变量
<a name="tutorials-pipeline-variables"></a>

在本教程中，您将创建一个管道，在管道级别添加变量，然后运行输出变量值的 CodeBuild 生成操作。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**Topics**
+ [先决条件](#tutorials-pipeline-variables-prereq)
+ [步骤 1：创建管道并构建项目](#tutorials-pipeline-variables-pipeline)
+ [步骤 2：发布更改并查看日志](#tutorials-pipeline-variables-view)

## 先决条件
<a name="tutorials-pipeline-variables-prereq"></a>

在开始之前，您必须执行以下操作：
+ 创建 CodeCommit 存储库。
+ 向存储库添加 .txt 文件。

## 步骤 1：创建管道并构建项目
<a name="tutorials-pipeline-variables-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 与您的 CodeCommit 存储库建立连接的源阶段。
+ 带有生成操作的 AWS CodeBuild 生成阶段。

**使用向导创建管道**

1. 登录 CodePipeline 控制台，网址为[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyVariablesPipeline**。

1. 在**管道类型**中，保留默认选择 **V2**。管道类型有不同的特点和价格。有关更多信息，请参阅 [管道类型](pipeline-types.md)。

1. 在**服务角色**中，选择**新建服务角色**。
**注意**  
如果您选择使用现有的 CodePipeline 服务角色，请确保已`codeconnections:UseConnection`将 IAM 权限添加到您的服务角色策略中。有关 CodePipeline 服务角色的说明，请参阅[为 CodePipeline 服务角色添加权限](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**变量**下，选择**添加变量**。在**名称**中，输入 `timeout`。在**默认值**中，输入 1000。在“描述”中，输入以下描述：**Timeout**。

   这将创建一个变量，当管道执行开始时，您可以在其中声明变量值。变量名必须匹配 `[A-Za-z0-9@\-_]+`，可以是除空字符串之外的任何名称。

1. 在**高级设置**下，保留原定设置值。在**构件存储**中，选择**默认位置**以将默认构件存储（如指定为默认值的 Amazon S3 项目存储桶）用于为管道选择的区域中的管道。
**注意**  
这不是源代码的源存储桶。这是管道的项目存储。每个管道都需要一个单独的构件存储，例如 S3 存储桶。

   选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**源提供程序**中，选择 **AWS CodeCommit**。

   1. 在**存储库名称**和**分支名称**中，选择您的存储库和分支。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，添加一个构建阶段：

   1. 在**构建提供程序**中，选择 **AWS CodeBuild**。允许**区域**默认为管道区域。

   1. 选择**创建项目**。

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境映像**中，选择**托管映像**。对于**操作系统**，选择 **Ubuntu**。

   1. 对于**运行时**，选择**标准**。**对于 “**图像**”，选择:5.0 aws/codebuild/standard。**

   1. 对于**服务角色**，选择**新建服务角色**。
**注意**  
记下您的 CodeBuild 服务角色的名称。在本教程的最后一步，您会用到此角色名称。

   1. 在**构建规范**下，为**构建规范**选择**插入构建命令**。选择**切换到编辑器**，然后将以下内容粘贴到**构建命令**。在 buildspec 中，客户变量 `$CUSTOM_VAR1` 将用于在构建日志中输出管道变量。您将在下一步骤中创建 `$CUSTOM_VAR1` 输出变量作为环境变量。

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - echo $CUSTOM_VAR1
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. 选择 “**继续” CodePipeline**。这将返回到 CodePipeline控制台并创建一个使用您的构建命令进行配置的 CodeBuild 项目。构建项目使用服务角色来管理 AWS 服务 权限。此步骤可能需要几分钟时间。

   1. 在**环境变量* - 可选***下，要创建环境变量作为将由管道级变量解析的构件操作的输入变量，请选择**添加环境变量**。这将创建在 buildspec 中指定为 `$CUSTOM_VAR1` 的变量。在**名称**中，输入 `CUSTOM_VAR1`。在**值**中，输入 `#{variables.timeout}`。在**类型**中，选择 `Plaintext`。

      环境变量的`#{variables.timeout}`值基于管道级变量命名空间`variables`和步骤 7 中为管道`timeout`创建的管道级变量。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。

## 步骤 2：发布更改并查看日志
<a name="tutorials-pipeline-variables-view"></a>

1. 管道成功运行后，在成功的构建阶段上，选择**查看详细信息**。

   在详细信息页面上，选择**日志**选项卡。查看编 CodeBuild 译输出。这些命令将输出所输入变量的值。

1. 在左侧导航窗格中，选择**历史记录**。

   选择最近执行，然后选择**变量**选项卡。查看管道变量的解析值。

# 教程：创建一个简单的管道（S3 存储桶）
<a name="tutorials-simple-s3"></a>

创建管道的最简单方法是在 AWS CodePipeline 控制台中使用**创建管道**向导。

在本教程中，您将创建一个两阶段管道，该管道使用受版本控制的 S3 源存储桶 CodeDeploy 并发布示例应用程序。

**注意**  
当 Amazon S3 是您的管道的源提供程序时，您可以将一个或多个源文件压缩到单个 .zip 文件中，然后将 .zip 文件上传到源桶。您也可以上传单个解压缩的文件；但是，需要 .zip 文件的下游操作将失败。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

创建此简单管道后，您将另外添加一个阶段，禁用然后再启用阶段之间的过渡。

**重要**  
在此过程中，您在管道中添加的许多操作都涉及在创建管道之前需要创建的 AWS 资源。 AWS 源操作的资源必须始终在您创建管道的同一 AWS 区域创建。例如，如果您在美国东部（俄亥俄州）地区创建管道，则您的 CodeCommit 存储库必须位于美国东部（俄亥俄州）区域。  
您可以在创建管道时添加跨区域操作。 AWS 跨区域操作的资源必须位于您计划执行操作的同一 AWS 区域。有关更多信息，请参阅 [在中添加跨区域操作 CodePipeline](actions-create-cross-region.md)。

在开始之前，您应完成[入门 CodePipeline](getting-started-codepipeline.md)中的先决条件。

**Topics**
+ [步骤 1：为您的应用程序创建一个 S3 源存储桶](#s3-create-s3-bucket)
+ [第 2 步：创建 Amazon EC2 Windows 实例并安装 CodeDeploy 代理](#S3-create-instances)
+ [步骤 3：在中创建应用程序 CodeDeploy](#S3-create-deployment)
+ [第 4 步：在中创建您的第一个管道 CodePipeline](#s3-create-pipeline)
+ [（可选）步骤 5：在管道中添加另一个阶段](#s3-add-stage)
+ [（可选）步骤 6：禁用和启用阶段之间的过渡 CodePipeline](#s3-configure-transitions)
+ [步骤 7：清理资源](#s3-clean-up)

## 步骤 1：为您的应用程序创建一个 S3 源存储桶
<a name="s3-create-s3-bucket"></a>

您可以将源文件或应用程序存储在任何受版本控制的位置。在本教程中，您将为示例应用程序文件创建一个 S3 桶，并对该桶启用版本控制。启用版本控制后，您可将示例应用程序复制到该存储桶。

**创建 S3 存储桶**

1. 登录控制台，网址为 AWS 管理控制台。打开 S3 控制台。

1. 请选择**创建存储桶**。

1. 对于**存储桶名称**，输入您的存储桶的名称（例如 **awscodepipeline-demobucket-example-date**）。
**注意**  
由于 Amazon S3 中的所有桶名称必须是唯一的，因此请使用您自己的名称，而不是示例中显示的名称。您可以通过添加日期来更改示例名称。请记下该名称，因为您需要在本教程的其余部分中使用该名称。

   在**区域**中，选择您要在其中创建管道的区域（例如**美国西部(俄勒冈州)**），然后选择**创建桶**。

1. 创建存储桶后，系统会显示成功横幅。选择**转到存储桶详细信息**。

1. 在**属性**选项卡上，选择**版本控制**。选择**启用版本控制**，然后选择**保存**。

   启用版本控制后，Amazon S3 会在桶中存储每个对象的每个版本。

1. 在**权限**选项卡上，保留默认设置。有关 S3 存储桶和对象权限的更多信息，请参阅[在策略中指定权限](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html)。

1. 接下来，下载一个示例，并将该示例保存到本地计算机上的文件夹或目录中。

   1. 选择下列选项之一。如果要对 Windows Server 实例执行本教程中的步骤，请选择 `SampleApp_Windows.zip`。
      + 如果您想使用部署到亚马逊 Linux 实例 CodeDeploy，请在此处下载示例应用程序：[SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)。
      + 如果你想使用部署到 Windows 服务器实例 CodeDeploy，请在此处下载示例应用程序：[SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip)。

      示例应用程序包含以下用于部署的文件 CodeDeploy：
      + `appspec.yml`— 应用程序规范文件（AppSpec文件）是一个 [YAML](http://www.yaml.org) 格式的文件， CodeDeploy 用于管理部署。有关该 AppSpec 文件的更多信息，请参阅*AWS CodeDeploy 用户指南*中的[CodeDeploy AppSpec 文件参考](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。
      + `index.html` - 索引文件包含已部署的示例应用程序的主页。
      + `LICENSE.txt` - 许可证文件包含示例应用程序的许可证信息。
      + 脚本文件 - 示例应用程序使用脚本将文本文件写入实例上的某个位置。为多个 CodeDeploy 部署生命周期事件分别写入一个文件，如下所示：
        + （仅限 Linux 示例）`scripts` 文件夹 - 该文件夹包含以下 shell 脚本，用于安装依赖项以及启动和停止自动部署的示例应用程序：`install_dependencies`、`start_server` 和 `stop_server`。
        + （仅限 Windows 示例）`before-install.bat` - 此批处理脚本用于 `BeforeInstall` 部署生命周期事件，它将运行以删除此示例在先前部署中写入的旧文件，并在您的实例上创建一个位置用于写入新文件。

   1. 下载压缩（zipped）文件。不要解压缩该文件。

1. 在 Amazon S3 控制台中，为您的桶上传文件：

   1. 选择**上传**。

   1. 拖放文件或选择**添加文件**并通过浏览找到该文件。

   1. 选择**上传**。

## 第 2 步：创建 Amazon EC2 Windows 实例并安装 CodeDeploy 代理
<a name="S3-create-instances"></a>

**注意**  
本教程提供了创建 Amazon EC2 Windows 实例的示例步骤。有关创建 Amazon EC2 Linux 实例的示例步骤，请参阅[步骤 3：创建 Amazon EC2 Linux 实例并安装 CodeDeploy 代理](tutorials-simple-codecommit.md#codecommit-create-deployment)。当系统提示您输入要创建的实例数时，请指定 **2** 个实例。

在此步骤中，您将创建 Windows Server Amazon EC2 实例 以向其部署示例应用程序。作为此过程的一部分，您将创建一个实例角色，其策略允许在实例上安装和管理 CodeDeploy 代理。 CodeDeploy 代理是一个软件包，允许在 CodeDeploy 部署中使用实例。您还可以附加策略，允许实例获取 CodeDeploy 代理用于部署您的应用程序的文件，并允许该实例由 SSM 管理。

**创建实例角色**

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

1. 在控制台控制面板中，选择**角色**。

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

1. 在**选择受信任实体的类型**下，选择 **AWS 服务**。在**选择使用案例**下，选择 **EC2**，然后选择**下一步: 权限**。

1. 搜索名为 **`AmazonEC2RoleforAWSCodeDeploy`** 的策略并将其选中。

1. 搜索名为 **`AmazonSSMManagedInstanceCore`** 的策略并将其选中。选择**下一步：标签**。

1. 选择**下一步：审核**。输入角色的名称（例如 **EC2InstanceRole**）。
**注意**  
记下您的角色名称以便在下一步中使用。在创建实例时选择此角色。

   选择**创建角色**。

**启动实例**

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

1. 在侧面导航栏中，选择**实例**，然后从页面顶部选择**启动实例**。

1. 在**名称和标签**下，对于**名称**，输入 **MyCodePipelineDemo**。这会为实例分配标签**键** **Name** 和标签值 ****MyCodePipelineDemo****。稍后，您将创建一个将示例 CodeDeploy 应用程序部署到实例的应用程序。 CodeDeploy根据标签选择要部署的实例。

1. 在**应用程序和操作系统映像(Amazon 机器映像)** 下，选择 **Windows** 选项。（此 AMI 称为 **Microsoft Windows Server 2019 Base**，标记为“符合免费套餐条件”，可以在**快速入门**下找到。）

1. 在**实例类型**下，选择符合免费套餐条件的 `t2.micro` 类型作为实例的硬件配置。

1. 在**密钥对(登录)** 下，选择或创建密钥对。

   也可以选择**继续操作但不提供密钥对**。
**注意**  
在本教程中，您可以继续操作而不提供密钥对。要使用 SSH 连接到实例，请创建或使用密钥对。

1. 在**网络设置**下，执行以下操作：

   在**自动分配公有 IP** 中，确保状态为**启用**。
   + 在**分配安全组**旁边，选择**创建新安全组**。
   + 在 **SSH** 对应的行中，在**源**下选择**我的 IP**。
   + 选择**添加安全组**，选择 **HTTP**，然后在**源类型**下选择**我的 IP**。

1. 展开**高级详细信息**。在 **IAM 实例配置文件**中，选择您在上一过程中创建的 IAM 角色（例如 **EC2InstanceRole**）。

1. 在**摘要**下的**实例数**下，输入 `2`。

1. 选择**启动实例**。

1. 选择**查看所有实例**以关闭确认页面并返回控制台。

1. 您可以在**实例**页面上查看启动的状态。启动实例时，其初始状态为 `pending`。实例启动后，其状态变为 `running`，并且会收到一个公有 DNS 名称。（如果**公有 DNS** 列不显示，请选择**显示/隐藏**图标，然后选择**公有 DNS**。）

1. 可能需要花几分钟时间，实例才能准备好让您连接到它。检查您的实例是否通过了状态检查。您可以在**状态检查**列中查看此信息。

## 步骤 3：在中创建应用程序 CodeDeploy
<a name="S3-create-deployment"></a>

在中 CodeDeploy，*应用程序*是以名称形式表示要部署的代码的标识符。 CodeDeploy 使用此名称来确保在部署期间引用修订版、部署配置和部署组的正确组合。在本教程稍后创建管道时，您可以选择在此步骤中创建的 CodeDeploy 应用程序的名称。

您首先要创建一个 CodeDeploy 要使用的服务角色。如果已创建服务角色，则无需创建其他服务角色。

**创建 CodeDeploy 服务角色**

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

1. 在控制台控制面板中，选择**角色**。

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

1. 在**选择受信任实体**下，选择 **AWS 服务**。在 **Use case**（使用案例）下，选择 **CodeDeploy**。**CodeDeploy**从列出的选项中进行选择。选择**下一步**。`AWSCodeDeployRole` 托管策略已附加到角色。

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

1. 输入角色的名称（例如 **CodeDeployRole**），然后选择**创建角色**。

**要在中创建应用程序 CodeDeploy**

1. 在 [https://console.aws.amazon.com/codede](https://console.aws.amazon.com/codedeploy) ploy 上打开 CodeDeploy 控制台。

1. 如果未出现 “**应用程序**” 页面，请在 AWS CodeDeploy 菜单上选择 “**应用程序**”。

1. 选择**创建应用程序**。

1. 在**应用程序名称**中，输入 `MyDemoApplication`。

1. 在 **Compute Platform（计算平台）**中，选择 **EC2/On-premises（EC2/本地）**。

1. 选择**创建应用程序**。

**要在中创建部署组 CodeDeploy**

1. 在显示应用程序的页面上，选择**创建部署组**。

1. 在 **Deployment group name（部署组名称）**中，输入 **MyDemoDeploymentGroup**。

1. 在**服务角色**中，选择您之前创建的服务角色。您使用的服务角色必须至少 AWS CodeDeploy 具有[创建服务角色](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-create-service-role.html)中所述的信任和权限 CodeDeploy。要获得服务角色 ARN，请参阅[获得服务角色 ARN（控制台）](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#getting-started-get-service-role-console)。

1. 在**部署类型**下，选择**就地**。

1. 在**环境配置**下，选择 **Amazon EC2 实例**。在**键**字段中选择**名称**，然后在**值**字段中输入 **MyCodePipelineDemo**。
**重要**  
在这里，您必须为**名称**键选择您在创建 EC2 实例时为该实例分配的值。如果您使用 **MyCodePipelineDemo** 以外的内容标记实例，则在此处，请务必使用该内容。

1. 在 “使用 S ** AWS ystems Manager 配置代理**” 下，选择 “**立即并安排更新**”。这将在实例上安装代理。Windows 实例已经配置了 SSM 代理，现在将使用该 CodeDeploy 代理进行更新。

1. 在**部署设置**下，选择 `CodeDeployDefault.OneAtaTime`。

1. 在**负载均衡器**下，确保未选中**启用负载均衡**框。您无需为此示例设置负载均衡器或选择目标组。取消选中此复选框后，不会显示负载均衡器选项。

1. 在**高级**部分中，保留默认值。

1. 选择 **Create deployment group（创建部署组）**。

## 第 4 步：在中创建您的第一个管道 CodePipeline
<a name="s3-create-pipeline"></a>

在这部分的教程中，您将创建管道。示例将自动通过管道运行。

**创建 CodePipeline 自动发布流程**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyFirstPipeline**。
**注意**  
如果您为管道选择另一个名称，请确保在本教程的剩下部分使用该名称替代 **MyFirstPipeline**。创建管道后，便无法再更改其名称。管道名称受一些限制的约束。有关更多信息，请参阅 [AWS CodePipeline 中的限额](limits.md)。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，执行下列操作之一：
   + 选择 “**新建服务角色**” CodePipeline 以允许在 IAM 中创建新的服务角色。
   + 选择**现有服务角色**以使用已在 IAM 中创建的服务角色。在**角色名称**中，从列表中选择您的服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **Amazon S3**。在**存储桶**中，输入您在[步骤 1：为您的应用程序创建一个 S3 源存储桶](#s3-create-s3-bucket)中创建的 S3 存储桶的名称。在**S3 对象键**中，输入带或不带文件路径的对象键。请记住加上文件的扩展名。例如，对于 `SampleApp_Windows.zip`，输入示例文件名，如以下示例所示：

   ```
   SampleApp_Windows.zip
   ```

   选择**下一步**。

   在**更改检测选项**下面，保留默认值。这 CodePipeline 允许使用 Amazon E CloudWatch vents 来检测源存储桶中的更改。

    选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中，在**部署提供程序**中，选择**CodeDeploy **。“**区域**” 字段默认为与您的管道 AWS 区域 相同。在**应用程序名称**中，输入 `MyDemoApplication`，或选择**刷新**按钮，然后从列表中选择应用程序名称。在**部署组**中，输入 **MyDemoDeploymentGroup** 或者从列表中选择它，然后选择**下一步**。
**注意**  
名称“Deploy”是在**步骤 4：添加部署阶段**步骤中创建的阶段的默认名称，就像“Source”是管道第一阶段的默认名称一样。

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

1. 管道开始运行。当 CodePipeline 示例向部署中的每个 Amazon EC2 实例部署网页时，您可以查看进度以及成功和失败消息。 CodeDeploy

恭喜您！您刚刚在中创建了一个简单的管道 CodePipeline。管道具有两个阶段：
+ 一个名为 **Source** 的源阶段，此阶段会检测存储在 S3 存储桶中的受版本控制的示例应用程序中的更改，并将这些更改提取到管道中。
+ 一个 **Deploy** 阶段，该阶段使用 CodeDeploy 将这些更改部署到 EC2 实例。

现在，验证结果。

**验证您的管道是否已成功运行**

1. 查看管道的初始进度。每个阶段的状态将从**还没有任何执行**变为**正在进行**，然后变为 **成功**或**失败**。管道将在几分钟内完成首次运行。

1. 操作状态显示**成功**之后，在**部署**阶段的状态区域中，选择**详细信息**。这将打开 CodeDeploy 控制台。

1. 在**部署组**选项卡的**部署生命周期事件**下，选择一个实例 ID。此操作将打开 EC2 控制台。

1. 在**描述**选项卡上的**公有 DNS**中，复制地址，然后将其粘贴到 Web 浏览器的地址栏中。查看上传到 S3 存储桶的示例应用程序的索引页面。

   此网页为您上传到 S3 桶的示例应用程序显示。

有关阶段和操作以及管道如何工作的更多信息，请参阅[CodePipeline 概念 ](concepts.md)。

## （可选）步骤 5：在管道中添加另一个阶段
<a name="s3-add-stage"></a>

现在，使用 CodeDeploy 在管道中添加另一个阶段，以便从暂存服务器部署到生产服务器。首先，在中创建另一个部署组 CodeDeploy。 CodePipelineDemoApplication 然后，您添加一个包含使用此部署组的操作的阶段。要添加另一个阶段，您可以使用 CodePipeline 控制台或在 AWS CLI JSON 文件中检索和手动编辑管道的结构，然后运行**update-pipeline**命令使用您的更改更新管道。

**Topics**
+ [在中创建第二个部署组 CodeDeploy](#s3-add-stage-part-1)
+ [将部署组作为另一个阶段添加到管道中](#s3-add-stage-part-2)

### 在中创建第二个部署组 CodeDeploy
<a name="s3-add-stage-part-1"></a>

**注意**  
在这部分教程中，您将创建第二个部署组，但要将其部署到与之前相同的 Amazon EC2 实例。这仅用于演示目的。它被故意设计为无法向您显示错误是如何显示的。 CodePipeline

**要在中创建第二个部署组 CodeDeploy**

1. 在 [https://console.aws.amazon.com/codede](https://console.aws.amazon.com/codedeploy) ploy 上打开 CodeDeploy 控制台。

1. 选择**应用程序**，然后在应用程序列表中选择 `MyDemoApplication`。

1. 选择**部署组**选项卡，然后选择**创建部署组**。

1. 在**创建部署组**页面的**部署组名称**中，输入第二个部署组的名称（例如 **CodePipelineProductionFleet**）。

1. 在**服务角色**中，选择与初始部署相同的 CodeDeploy 服务角色（不是 CodePipeline 服务角色）。

1. 在**部署类型**下，选择**就地**。

1. 在**环境配置**下，选择 **Amazon EC2 实例**。在**键**框中选择**名称**，然后在**值**框中从列表中选择 `MyCodePipelineDemo`。保留**部署设置**的默认配置。

1. 在**部署配置**中，选择 `CodeDeployDefault.OneAtaTime`。

1. 在**负载均衡器**中，取消选择**启用负载均衡**。

1.  选择 **Create deployment group（创建部署组）**。

### 将部署组作为另一个阶段添加到管道中
<a name="s3-add-stage-part-2"></a>

有了另一个部署组后，就可以添加一个使用此部署组的阶段来部署到之前所使用的相同 EC2 实例。您可以使用 CodePipeline控制台或 AWS CLI 添加此阶段。

**Topics**
+ [创建第三个阶段（控制台）](#s3-add-stage-part-2-console)
+ [创建第三个阶段（CLI）](#s3-add-stage-part-2-cli)

#### 创建第三个阶段（控制台）
<a name="s3-add-stage-part-2-console"></a>

您可以使用 CodePipeline 控制台添加使用新部署组的新阶段。由于此部署组将部署到您已经使用的 EC2 实例，因此该阶段的部署操作会失败。

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Name (名称)** 中，选择您创建的管道名称 MyFirstPipeline。

1. 在管道详细信息页中，选择**编辑**。

1. 在**编辑**页面上，选择 **\$1 添加阶段**以紧随 Deploy 阶段之后添加一个阶段。  
![\[该图显示编辑屏幕上的 + 添加阶段按钮\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/edit-pipeline-console-pol.png)

1. 在**添加阶段**的**阶段名称**中，输入 **Production**。选择**添加阶段**。

1. 在新阶段中，选择 **\$1 添加操作组**。

1. 在**编辑操作**的**操作名称**中，输入 **Deploy-Second-Deployment**。在 **“操作提供者”** 中的 “**部署**” 下，选择**CodeDeploy**。

1. 在该 CodeDeploy 部分的**应用程序名称**中，`MyDemoApplication`从下拉列表中进行选择，就像创建管道时一样。在**部署组**中，选择您刚刚创建的部署组 **CodePipelineProductionFleet**。在**输入构件**中，从源操作中选择输入构件。选择**保存**。

1. 在**编辑**页面上，选择**保存**。在**保存管道更改**中，选择**保存**。

1. 虽然新阶段已添加到您的管道中，但该阶段显示为 **No executions yet** 状态，因为没有发生触发管道再次运行的更改。您必须手动重新运行最新修订，以了解编辑后的管道的运行情况。在管道详细信息页面中，选择**发布更改**，然后在系统提示时选择**发布**。这会通过管道运行在源操作中指定的每个源位置中提供的最新修订。

   或者，要使用重新运行管道，请从本地 Linux、macOS 或 Unix 计算机上的终端或本地 Windows 计算机上的命令提示符处运行**start-pipeline-execution**该命令，指定管道的名称。 AWS CLI 这将第二次通过管道运行您的源存储桶中的应用程序。

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   该命令返回 `pipelineExecutionId` 对象。

1. 返回 CodePipeline 控制台，在管道列表中 **MyFirstPipeline**，选择打开视图页面。

   管道显示三个阶段以及项目经历这三个阶段时的状态。管道经历所有阶段可能需要 5 分钟的时间。您将看到前两个阶段的部署取得成功，正如之前一样，但 **Production** 阶段显示 **Deploy-Second-Deployment** 操作失败。

1. 在 **Deploy-Second-Deployment** 操作中，选择 **Details**。您将被重定向到 CodeDeploy 部署的页面。在这种情况下，操作失败是因为第一个实例组部署到所有 EC2 实例，导致第二个部署组没有实例可用。
**注意**  
此故障是特意设计的，是为了演示某个管道阶段出现故障会怎么样。

#### 创建第三个阶段（CLI）
<a name="s3-add-stage-part-2-cli"></a>

尽管使用 AWS CLI 向管道添加阶段比使用控制台更为复杂，但它可以更清楚地了解管道的结构。

**为管道创建第三个阶段**

1. 在本地 Linux、macOS 或 Unix 计算机上打开终端会话，或者在本地 Windows 计算机上打开命令提示符，运行 **get-pipeline** 命令，以显示您刚创建的管道的结构。对于 **MyFirstPipeline**，您可以键入以下命令：

   ```
   aws codepipeline get-pipeline --name "MyFirstPipeline"
   ```

   此命令返回的结构 MyFirstPipeline。输出的第一部分应类似于以下内容：

   ```
   {
       "pipeline": {
           "roleArn": "arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service",
           "stages": [
       ...
   ```

   输出的最后部分包括管道元数据，应类似于以下内容：

   ```
       ...
           ],
           "artifactStore": {
               "type": "S3"
               "location": "amzn-s3-demo-bucket",
           },
           "name": "MyFirstPipeline",
           "version": 4
       },
       "metadata": {
           "pipelineArn": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline",
           "updated": 1501626591.112,
           "created": 1501626591.112
       }
   }
   ```

1. 将此结构复制并粘贴到纯文本编辑器中，并将文件保存为 **pipeline.json**。为了方便起见，请将此文件保存在运行 **aws codepipeline** 命令的相同目录中。
**注意**  
您可以使用 **get-pipeline** 命令将 JSON 直接添加到文件中，如下所示：  

   ```
   aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
   ```

1. 将**部署**阶段部分复制并粘贴在前两个阶段之后。由于它是一个部署阶段，就像**部署**阶段一样，您可以将其用作第三个阶段的模板。

1. 更改阶段的名称和部署组详细信息。

   以下示例显示将在**部署**阶段结束后添加到 pipeline.json 文件的 JSON。使用新值编辑突出显示的元素。请记住，使用逗号分隔**部署**和**生产**阶段定义。

   ```
   ,
   {
       "name": "Production",
        "actions": [
           {
            "inputArtifacts": [
                {
                 "name": "MyApp"
                }
              ],
             "name": "Deploy-Second-Deployment",
             "actionTypeId": {
                 "category": "Deploy",
                 "owner": "AWS",
                 "version": "1",
                 "provider": "CodeDeploy"
                 },
            "outputArtifacts": [],
            "configuration": {
                 "ApplicationName": "CodePipelineDemoApplication",
                 "DeploymentGroupName": "CodePipelineProductionFleet"
                  },
            "runOrder": 1
           }
       ]
   }
   ```

1. 如果您要使用通过 **get-pipeline** 命令检索到的管道结构，则必须删除 JSON 文件中的 `metadata` 行。否则，**update-pipeline** 命令无法使用它。删除 `"metadata": { }` 行以及 `"created"`、`"pipelineARN"` 和 `"updated"` 字段。

   例如，从结构中删除以下各行：

   ```
   "metadata": {  
     "pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name",
     "created": "date",
     "updated": "date"
     }
   ```

   保存该文件。

1. 运行 **update-pipeline** 命令并指定管道 JSON 文件，类似于以下内容：

   ```
   aws codepipeline update-pipeline --cli-input-json file://pipeline.json
   ```

   该命令会返回更新后管道的整个结构。
**重要**  
务必在文件名前包含 `file://`。此命令中需要该项。

1.  运行 **start-pipeline-execution** 命令，并且指定管道的名称。这将第二次通过管道运行您的源存储桶中的应用程序。

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   该命令返回 `pipelineExecutionId` 对象。

1. 打开 CodePipeline 控制台并**MyFirstPipeline**从管道列表中进行选择。

   管道显示三个阶段以及项目经历这三个阶段时的状态。管道经历所有阶段可能需要 5 分钟的时间。虽然前两个阶段的部署取得成功，正如之前一样，但 **Production** 阶段显示 **Deploy-Second-Deployment** 操作失败。

1. 在 **Deploy-Second-Deployment** 操作中，选择 **Details** 以查看故障详细信息。您将被重定向到 CodeDeploy 部署的详细信息页面。在这种情况下，操作失败是因为第一个实例组部署到所有 EC2 实例，导致第二个部署组没有实例可用。
**注意**  
此故障是特意设计的，是为了演示某个管道阶段出现故障会怎么样。

## （可选）步骤 6：禁用和启用阶段之间的过渡 CodePipeline
<a name="s3-configure-transitions"></a>

您可以启用或禁用管道中阶段之间的过渡。禁用阶段之间的过渡允许您手动控制一个阶段和另一个阶段之间的过渡。例如，您可能希望运行管道的前两个阶段，但是禁用向第三阶段的过渡，直到您准备好部署到生产环境，或者您要排查该阶段的问题或故障。

**禁用和启用 CodePipeline 管道中各个阶段之间的过渡**

1. 打开 CodePipeline 控制台并**MyFirstPipeline**从管道列表中进行选择。

1. 在管道详细信息页面中，选择第二个阶段（**部署**）与您在上一部分中添加的第三个阶段（**生产**）之间的**禁用过渡**按钮。

1. 在**禁用过渡**中，键入禁用阶段过渡的原因，然后选择**禁用**。

   各个阶段之间的箭头显示一个图标和颜色变化，以及**启用过渡**按钮。  
![\[该图显示输入的禁用过渡的原因为“在我进行故障排除时禁用过渡”\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/codepipeline-disabled-transition-pol.png)

1. 再次将示例应用程序上传到 S3 存储桶。由于存储桶启用了版本控制，因此这一更改将启动管道。

1. 返回管道详细信息页面，查看各个阶段的状态。管道视图会随之发生变化，以显示前两个阶段的进度和成功消息，但第三个阶段不会发生任何变化。此过程可能需要几分钟时间。

1. 通过选择两个阶段之间的**启用过渡**按钮，即可启用过渡。在 **Enable transition** 对话框中，选择 **Enable**。这一阶段将在几分钟内开始运行，并尝试处理已经历管道的前两个阶段的项目。
**注意**  
如果您希望第三阶段成功，请在启用过渡之前编辑 CodePipelineProductionFleet 部署组，并指定部署应用程序的另一组 EC2 实例。有关如何执行此操作的更多信息，请参阅[更改部署组设置](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-change-deployment-group-settings.html)。如果您创建更多的 EC2 实例，可能会产生额外成本。

## 步骤 7：清理资源
<a name="s3-clean-up"></a>

您可以将在本教程中创建的一些资源用于[教程：创建一个四阶段管道](tutorials-four-stage-pipeline.md)。例如，您可以重复使用 CodeDeploy 应用程序和部署。您可以使用提供者（例如）配置生成操作 CodeBuild，这是云中完全托管的生成服务。您还可以配置一个将提供方与生成服务器或系统结合使用的生成操作，例如 Jenkins。

但是，在完成本教程和任何其他教程之后，您应该删除管道及其使用的资源，以避免为继续使用这些资源付费。首先，删除管道，然后删除 CodeDeploy 应用程序及其关联的 Amazon EC2 实例，最后删除 S3 存储桶。

**清理本教程中使用的资源**

1. 要清理您的 CodePipeline 资源，请按照中[删除管道中的](pipelines-delete.md)说明进行操作 AWS CodePipeline。

1. 要清理 CodeDeploy 资源，请按照[清理资源（控制台）](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console)中的说明进行操作。

1. 要删除 S3 存储桶，请按照[删除或清空存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html)中的说明操作。如果您不打算创建更多管道，请删除为存储管道构件而创建的 S3 存储桶。有关此存储桶的更多信息，请参阅[CodePipeline 概念 ](concepts.md)。

# 教程：创建简单的管道（CodeCommit 存储库）
<a name="tutorials-simple-codecommit"></a>

在本教程中，您将使用 CodePipeline 将 CodeCommit 存储库中维护的代码部署到单个 Amazon EC2 实例。当您将更改推送到 CodeCommit 存储库时，您的管道就会被触发。该管道使用 CodeDeploy 部署服务将您的更改部署到 Amazon EC2 实例。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

管道具有两个阶段：
+ 源操作的**源**阶段（ CodeCommit 来源）。
+ 您的部署操作的**部署**阶段（ CodeDeploy 部署）。

最简单的入门方法 AWS CodePipeline 是在 CodePipeline 控制台中使用**创建管道**向导。

**注意**  
在开始之前，请确保已设置好要使用的 Git 客户端 CodeCommit。有关说明，请参阅 [ CodeCommit 设置](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html)。

## 步骤 1：创建 CodeCommit 存储库
<a name="codecommit-create-repository"></a>

首先，在中创建存储库 CodeCommit。您的管道在运行时将从该存储库获取源代码。您还可以创建一个本地存储库，在将代码推送到存储 CodeCommit 库之前，在其中维护和更新代码。

**创建存储 CodeCommit 库**



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

1. 在区域选择器中，选择要创建存储库和管道 AWS 区域 的位置。有关更多信息，请参阅[AWS 区域 和端点](https://docs.aws.amazon.com/general/latest/gr/rande.html)。

1. 在**存储库**页面上，选择**创建存储库**。

1. 在**创建存储库**页面上的**存储库名称**中，输入存储库的名称（例如，**MyDemoRepo**）。

1. 选择**创建**。

**注意**  
本教程的其余步骤将使用**MyDemoRepo**存储 CodeCommit 库的名称。如果您选择其他名称，请确保在本教程中通篇使用它。

**设置本地存储库**

在此步骤中，设置一个本地存储库，连接到您的远程 CodeCommit 存储库。
**注意**  
您无需设置本地存储库。还可以使用此控制台上传文件（如[第 2 步：向 CodeCommit 存储库中添加示例代码](#codecommit-add-code)所述）。

1. 在控制台中打开您的新存储库，选择页面右上角的**克隆 URL**，然后选择**克隆 SSH**。用于克隆 Git 存储库的地址复制到您的剪贴板。

1. 在您的终端窗口或命令行中，导航到您要用来存储本地存储库的本地目录。在本教程中，我们使用 `/tmp`。

1. 运行以下命令以克隆存储库，使用您在上一步中复制的地址替换 SSH 地址。此命令创建一个名为 `MyDemoRepo` 的目录。您将示例应用程序复制到此目录。

   ```
   git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo
   ```

## 第 2 步：向 CodeCommit 存储库中添加示例代码
<a name="codecommit-add-code"></a>

在此步骤中，您将下载为示例演练创建的 CodeDeploy示例应用程序的代码，并将其添加到 CodeCommit 存储库中。



1. 接下来，下载一个示例，并将该示例保存到本地计算机上的文件夹或目录中。

   1. 选择下列选项之一。如果要对 Linux 实例执行本教程中的步骤，请选择 `SampleApp_Linux.zip`。
      + 如果您想使用部署到亚马逊 Linux 实例 CodeDeploy，请在此处下载示例应用程序：[SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)。
      + 如果你想使用部署到 Windows 服务器实例 CodeDeploy，请在此处下载示例应用程序：[SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip)。

      示例应用程序包含以下用于部署的文件 CodeDeploy：
      + `appspec.yml`— 应用程序规范文件（AppSpec文件）是一个 [YAML](http://www.yaml.org) 格式的文件， CodeDeploy 用于管理部署。有关该 AppSpec 文件的更多信息，请参阅*AWS CodeDeploy 用户指南*中的[CodeDeploy AppSpec 文件参考](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。
      + `index.html` - 索引文件包含已部署的示例应用程序的主页。
      + `LICENSE.txt` - 许可证文件包含示例应用程序的许可证信息。
      + 脚本文件 - 示例应用程序使用脚本将文本文件写入实例上的某个位置。为多个 CodeDeploy 部署生命周期事件分别写入一个文件，如下所示：
        + （仅限 Linux 示例）`scripts` 文件夹 - 该文件夹包含以下 shell 脚本，用于安装依赖项以及启动和停止自动部署的示例应用程序：`install_dependencies`、`start_server` 和 `stop_server`。
        + （仅限 Windows 示例）`before-install.bat` - 此批处理脚本用于 `BeforeInstall` 部署生命周期事件，它将运行以删除此示例在先前部署中写入的旧文件，并在您的实例上创建一个位置用于写入新文件。

   1. 下载压缩（zipped）文件。

1. 将文件从 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 解压缩到之前创建的本地目录（例如，`/tmp/MyDemoRepo`或`c:\temp\MyDemoRepo`）。

   务必将文件直接放到本地存储库中。不要包括 `SampleApp_Linux` 文件夹。例如，在您的本地 Linux、macOS 或 Unix 计算机上，您的目录和文件层次结构应如下所示：

   ```
   /tmp
      └-- MyDemoRepo
          │-- appspec.yml
          │-- index.html
          │-- LICENSE.txt
          └-- scripts
              │-- install_dependencies
              │-- start_server
              └-- stop_server
   ```

1. 要将文件上传到您的存储库，请使用以下方法之一。

   1. 要使用 CodeCommit 控制台上传文件，请执行以下操作：

      1. 打开 CodeCommit 控制台，然后从 “存储库” 列表中选择您的**存储库**。

      1. 选择**添加文件**，然后选择**上传文件**。

      1. 选择**选择文件**，然后浏览找到您的文件。要在文件夹下添加文件，请选择**创建文件**，然后输入带有文件名的文件夹名称，例如 `scripts/install_dependencies`。将文件内容粘贴到新文件中。

         通过输入您的用户名和电子邮件地址来提交更改。

         选择**提交更改**。

      1. 对每个文件重复此步骤。

         您的存储库内容应如下所示：

         ```
                │-- appspec.yml
                │-- index.html
                │-- LICENSE.txt
                └-- scripts
                    │-- install_dependencies
                    │-- start_server
                    └-- stop_server
         ```

   1. 使用 git 命令上传文件：

      1. 将目录更改为本地存储库：

         ```
         (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
         (For Windows) cd c:\temp\MyDemoRepo
         ```

      1. 运行以下命令以立即暂存您的所有文件：

         ```
         git add -A
         ```

      1. 运行以下命令以提交带有提交消息的文件：

         ```
         git commit -m "Add sample application files"
         ```

      1. 运行以下命令以将文件从您的本地存储库推送到您的 CodeCommit 存储库：

         ```
         git push
         ```

1. 您下载并添加到本地存储库中的文件现已添加到 CodeCommit `MyDemoRepo`存储库的`main`分支中，可以包含在管道中。

## 步骤 3：创建 Amazon EC2 Linux 实例并安装 CodeDeploy 代理
<a name="codecommit-create-deployment"></a>

在此步骤中，您将创建要在其中部署示例应用程序的 Amazon EC2 实例。作为此过程的一部分，创建一个允许在实例上安装和管理 CodeDeploy 代理的实例角色。 CodeDeploy 代理是一个软件包，允许在 CodeDeploy 部署中使用实例。您还可以附加策略，允许实例获取 CodeDeploy 代理用于部署您的应用程序的文件，并允许该实例由 SSM 管理。

**创建实例角色**

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

1. 在控制台控制面板中，选择**角色**。

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

1. 在**选择受信任实体的类型**下，选择 **AWS 服务**。在**选择使用案例**下，选择 **EC2**。在**选择您的使用案例**下，选择 **EC2**。选择**下一步：权限**。

1. 搜索名为 **`AmazonEC2RoleforAWSCodeDeploy`** 的策略并将其选中。

1. 搜索名为 **`AmazonSSMManagedInstanceCore`** 的策略并将其选中。选择**下一步：标签**。

1. 选择**下一步：审核**。输入角色的名称（例如 **EC2InstanceRole**）。
**注意**  
记下您的角色名称以便在下一步中使用。在创建实例时选择此角色。

   选择**创建角色**。

**启动实例**

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

1. 在侧面导航栏中，选择**实例**，然后从页面顶部选择**启动实例**。

1. 在**名称**中，输入 **MyCodePipelineDemo**。这会为实例分配标签**键** **Name** 和标签值 ****MyCodePipelineDemo****。稍后，您将创建一个将示例 CodeDeploy 应用程序部署到此实例的应用程序。 CodeDeploy根据标签选择要部署的实例。

1. 在 “**应用程序和操作系统映像（亚马逊系统映像）**” 下，找到带有 AWS 徽标的 **Amazon Linux** AMI 选项，并确保将其选中。（此 AMI 称为 Amazon Linux 2 AMI (HVM)，并标记为“符合免费套餐条件”。）

1. 在**实例类型**下，选择符合免费套餐条件的 `t2.micro` 类型作为实例的硬件配置。

1. 在**密钥对(登录)** 下，选择或创建密钥对。

   也可以选择**继续操作但不提供密钥对**。
**注意**  
在本教程中，您可以继续操作而不提供密钥对。要使用 SSH 连接到实例，请创建或使用密钥对。

1. 在**网络设置**下，执行以下操作：

   在**自动分配公有 IP** 中，确保状态为**启用**。

   对于创建的安全组，选择 **HTTP**，然后在**源类型**下选择**我的 IP**。

1. 展开**高级详细信息**。在 **IAM 实例配置文件**中，选择您在上一过程中创建的 IAM 角色（例如 **EC2InstanceRole**）。

1. 在**摘要**下的**实例数**下，输入 `1`。

1. 选择**启动实例**。

1. 您可以在**实例**页面上查看启动的状态。启动实例时，其初始状态为 `pending`。实例启动后，其状态变为 `running`，并且会收到一个公有 DNS 名称。（如果**公有 DNS** 列不显示，请选择**显示/隐藏**图标，然后选择**公有 DNS**。）

## 步骤 4：在中创建应用程序 CodeDeploy
<a name="codecommit-create-codedeploy-app"></a>

在中 CodeDeploy，[https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html)是一种包含要部署的软件应用程序的资源。稍后，您将此应用程序与配合使用 CodePipeline ，自动将示例应用程序部署到您的 Amazon EC2 实例。

首先，创建一个允许执行部署 CodeDeploy 的角色。然后，您将创建一个 CodeDeploy 应用程序。

**创建 CodeDeploy 服务角色**

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

1. 在控制台控制面板中，选择**角色**。

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

1. 在**选择受信任实体**下，选择 **AWS 服务**。在 **Use case**（使用案例）下，选择 **CodeDeploy**。**CodeDeploy**从列出的选项中进行选择。选择**下一步**。`AWSCodeDeployRole` 托管策略已附加到角色。

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

1. 输入角色的名称（例如 **CodeDeployRole**），然后选择**创建角色**。

**要在中创建应用程序 CodeDeploy**

1. 在 [https://console.aws.amazon.com/codede](https://console.aws.amazon.com/codedeploy) ploy 上打开 CodeDeploy 控制台。

1. 如果未显示**应用程序**页面，请在菜单上选择**应用程序**。

1. 选择**创建应用程序**。

1. 在**应用程序名称**中，输入 **MyDemoApplication**。

1. 在 **Compute Platform（计算平台）**中，选择 **EC2/On-premises（EC2/本地）**。

1. 选择**创建应用程序**。

**要在中创建部署组 CodeDeploy**

[https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html)是定义了部署相关设置（例如，要部署到哪些实例以及部署它们的速度有多快）的资源。

1. 在显示应用程序的页面上，选择**创建部署组**。

1. 在 **Deployment group name（部署组名称）**中，输入 **MyDemoDeploymentGroup**。

1. 在**服务角色**中，选择您之前创建的服务角色的 ARN（例如，**`arn:aws:iam::account_ID:role/CodeDeployRole`**）。

1. 在**部署类型**下，选择**就地**。

1. 在**环境配置**下，选择 **Amazon EC2 实例**。在**键**字段中，输入 **Name**。在**值**字段中，输入您用于标记实例的名称（例如，**MyCodePipelineDemo**）。

1. 在 “使用 S ** AWS ystems Manager 配置代理**” 下，选择 “**立即并安排更新**”。这将在实例上安装代理。Linux 实例已经配置了 SSM 代理，现在将使用 CodeDeploy 代理进行更新。

1. 在**部署配置**中，选择 `CodeDeployDefault.OneAtaTime`。

1. 在**负载均衡器**下，确保未选中**启用负载均衡**。您无需为此示例设置负载均衡器或选择目标组。

1. 选择 **Create deployment group（创建部署组）**。

## 第 5 步：在中创建您的第一个管道 CodePipeline
<a name="codecommit-create-pipeline"></a>

现在您已经可以创建并运行您的第一个管道。在此步骤中，您将创建一个在代码推送到 CodeCommit 存储库时自动运行的管道。

**创建 CodePipeline 管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

   打开 CodePipeline 控制台，网址为[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyFirstPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **CodeCommit**。在**存储库名称**中，选择您在中创建的 CodeCommit 存储库的名称[步骤 1：创建 CodeCommit 存储库](#codecommit-create-repository)。在**分支名称**中，选择 `main`，然后选择**下一步**。

   选择存储库名称和分支后，将显示一条消息，显示要为此管道创建的 Amazon Ev CloudWatch ents 规则。

   在**更改检测选项**下面，保留默认值。这 CodePipeline 允许使用 Amazon E CloudWatch vents 来检测源存储库中的更改。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。选择**下一步**。
**注意**  
在本教程中，您将部署不需要生成服务的代码，因此您可以跳过此步骤。但是，如果您的源代码需要在部署到实例之前构建，则可以在此步骤中配置 [CodeBuild](https://aws.amazon.com/codebuild/)。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中，在**部署提供程序**中，选择**CodeDeploy**。在**应用程序名称**中，选择 **MyDemoApplication**。在**部署组**中，选择 **MyDemoDeploymentGroup**，然后选择**下一步**。

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

1. 创建管道后它会开始运行。它会从您的 CodeCommit存储库下载代码并创建到您的 EC2 实例的 CodeDeploy 部署。当 CodePipeline 示例将网页部署到部署中的 Amazon EC2 实例时，您可以查看进度以及成功和失败消息。 CodeDeploy   
![\[CodePipeline 控制台中开始运行的管道视图。\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/codepipeline-firstpipeline-codecommit-pol.png)

恭喜您！您刚刚在中创建了一个简单的管道 CodePipeline。

接下来，您将验证结果。

**验证您的管道是否成功运行**

1. 查看管道的初始进度。每个阶段的状态将从**还没有任何执行**变为**正在进行**，然后变为 **成功**或**失败**。管道将在几分钟内完成首次运行。

1. 在管道状态显示**成功**后，在 “部**署**” 阶段的状态区域中选择**CodeDeploy**。这将打开 CodeDeploy 控制台。如果未显示**成功**，请参阅 [故障排除 CodePipeline](troubleshooting.md)。

1.  在**部署**选项卡上，选择部署 ID。在部署页面上的**部署生命周期事件**下，选择实例 ID。此操作将打开 EC2 控制台。

1. 在**描述**选项卡上的**公有 DNS** 中，复制地址（例如，`ec2-192-0-2-1.us-west-2.compute.amazonaws.com`），然后将其粘贴到 Web 浏览器的地址栏中。

   将显示您下载并推送到 CodeCommit 存储库的示例应用程序的网页。

有关阶段和操作以及管道如何工作的更多信息，请参阅[CodePipeline 概念 ](concepts.md)。

## 第 6 步：修改 CodeCommit 仓库中的代码
<a name="codecommit-push-code"></a>

您的管道配置为每次对 CodeCommit 存储库中的代码进行更改时运行。在此步骤中，您将对作为 CodeCommit 存储库中示例 CodeDeploy应用程序一部分的 HTML 文件进行更改。当您推送这些更改时，您的管道会再次运行，并且您作出的更改将在您之前访问的网址中显示。

1. 将目录更改为本地存储库：

   ```
   (For Linux, macOS, or Unix) cd /tmp/MyDemoRepo
   (For Windows) cd c:\temp\MyDemoRepo
   ```

1. 使用文本编辑器修改 `index.html` 文件：

   ```
   (For Linux or Unix)gedit index.html
   (For OS X)open –e index.html
   (For Windows)notepad index.html
   ```

1. 修订 `index.html` 文件的内容，以更改网页的背景颜色和一些文本，然后保存该文件。

   ```
   <!DOCTYPE html>
   <html>
   <head>
     <title>Updated Sample Deployment</title>
     <style>
       body {
         color: #000000;
         background-color: #CCFFCC;
         font-family: Arial, sans-serif;  
         font-size:14px;
       }
           
       h1 {
         font-size: 250%;
         font-weight: normal;
         margin-bottom: 0;
       }
       
       h2 {
         font-size: 175%;
         font-weight: normal;
         margin-bottom: 0;
       }
     </style>
   </head>
   <body>
     <div align="center"><h1>Updated Sample Deployment</h1></div>
     <div align="center"><h2>This application was updated using CodePipeline, CodeCommit, and CodeDeploy.</h2></div>
     <div align="center">
       <p>Learn more:</p> 
       <p><a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/">CodePipeline User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codecommit/latest/userguide/">CodeCommit User Guide</a></p>
       <p><a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/">CodeDeploy User Guide</a></p>
     </div>
   </body>
   </html>
   ```

1. 通过运行以下命令逐一提交更改并将其推送到 CodeCommit 存储库：

   ```
   git commit -am "Updated sample application files"
   ```

   ```
   git push
   ```

**验证您的管道是否已成功运行**

1. 查看管道的初始进度。每个阶段的状态将从**还没有任何执行**变为**正在进行**，然后变为 **成功**或**失败**。管道应在几分钟内完成运行。

1. 操作状态显示**成功**之后，请刷新您之前在浏览器中访问的演示页面。

   此时将显示更新后的网页。

## 步骤 7：清理资源
<a name="codecommit-clean-up"></a>

您可以将在本教程中创建的一些资源用于本指南中的其他教程。例如，您可以重复使用 CodeDeploy 应用程序和部署。但是，在完成本教程和任何其他教程之后，您应该删除管道及其使用的资源，以避免为继续使用这些资源付费。首先，删除管道，然后删除 CodeDeploy 应用程序及其关联的 Amazon EC2 实例，最后删除 CodeCommit存储库。

**清理本教程中使用的资源**

1. 要清理您的 CodePipeline 资源，请按照中[删除管道中的](pipelines-delete.md)说明进行操作 AWS CodePipeline。

1. 要清理 CodeDeploy 资源，请按照[清理部署演练资源中的说明进行](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up)操作。

1. 要删除 CodeCommit 存储库，请按照[删除存储 CodeCommit库](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html)中的说明进行操作。

## 步骤 8：延伸阅读
<a name="codecommit-optional-tasks"></a>

详细了解 CodePipeline 工作原理：
+ 有关阶段和操作以及管道如何工作的更多信息，请参阅[CodePipeline 概念 ](concepts.md)。
+ 有关您可以使用执行的操作的信息 CodePipeline，请参阅[与动 CodePipeline 作类型的集成](integrations-action-type.md)。
+ 试用这个更高级的教程：[教程：创建一个四阶段管道](tutorials-four-stage-pipeline.md)。它创建一个多阶段管道，包括一个在部署之前构建代码的步骤。

# 教程：创建一个四阶段管道
<a name="tutorials-four-stage-pipeline"></a>

在[教程：创建一个简单的管道（S3 存储桶）](tutorials-simple-s3.md)或[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)中创建了第一个管道后，接下来就可以开始创建更复杂的管道。本教程将引导你创建四阶段管道，该管道使用 GitHub存储库作为源代码，使用 Jenkins 生成服务器来生成项目，使用 CodeDeploy 应用程序将生成的代码部署到暂存服务器。下图显示最初的三阶段管道。

![\[该图显示包含源操作的源阶段、包含 Jenkins 操作的构建阶段和包含部署操作的部署阶段。\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/flow-codepipeline-codecommit-jenkins.png)


创建管道后，您将编辑它以添加包含测试操作的阶段来测试代码，同样使用 Jenkins。

创建此管道之前，必须先配置所需的资源。例如，如果要为源代码使用 GitHub 存储库，则必须先创建存储库，然后才能将其添加到管道中。作为设置的一部分，本教程将指导您在 EC2 实例上设置 Jenkins 以进行演示。

**重要**  
在此过程中，您在管道中添加的许多操作都涉及在创建管道之前需要创建的 AWS 资源。 AWS 源操作的资源必须始终在您创建管道的同一 AWS 区域创建。例如，如果您在美国东部（俄亥俄州）地区创建管道，则您的 CodeCommit 存储库必须位于美国东部（俄亥俄州）区域。  
您可以在创建管道时添加跨区域操作。 AWS 跨区域操作的资源必须位于您计划执行操作的同一 AWS 区域。有关更多信息，请参阅 [在中添加跨区域操作 CodePipeline](actions-create-cross-region.md)。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

在开始学习本教程之前，您应该已经完成[入门 CodePipeline](getting-started-codepipeline.md)中的一般先决条件。

**Topics**
+ [步骤 1：满足先决条件](#tutorials-four-stage-pipeline-prerequisites)
+ [步骤 2：在中创建管道 CodePipeline](#tutorials-four-stage-pipeline-pipeline-create)
+ [步骤 3：向管道中添加另一个阶段](#tutorials-four-stage-pipeline-add-stage)
+ [步骤 4：清理资源](#tutorials-four-stage-pipeline-clean-up)

## 步骤 1：满足先决条件
<a name="tutorials-four-stage-pipeline-prerequisites"></a>

要与 Jenkins 集成， AWS CodePipeline 需要您在要使用的任何 Jenkins 实例上安装适用于 Jenkins 的 CodePipeline 插件。 CodePipeline您还应配置一个专用 IAM 用户或角色，用于在 Jenkins 项目和 CodePipeline之间获得权限。集成 Jenkins 的最简单方法 CodePipeline 是在使用你为 Jenkins 集成创建的 IAM 实例角色的 EC2 实例上安装 Jenkins。为了使管道中 Jenkins 操作的链接能够成功连接，您必须在服务器或 EC2 实例上配置代理和防火墙设置，以允许与 Jenkins 项目使用的端口进行入站连接。在允许连接这些端口（例如，如果您已保护 Jenkins 以仅使用 HTTPS 连接，端口为 443 和 8443；如果您允许 HTTP 连接，端口为 80 和 8080）之前，请确保已将 Jenkins 配置为对用户进行身份验证并强制执行访问控制。有关更多信息，请参阅[保护 Jenkins](https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins)。

**注意**  
本教程使用一个代码示例并配置将该示例从 Haml 转换为 HTML 的生成步骤。您可以按照中的步骤从 GitHub 存储库下载开源示例代码[将示例复制或克隆到 GitHub 存储库中](#tutorials-four-stage-pipeline-prerequisites-github)。您将需要 GitHub 存储库中的整个示例，而不仅仅是.zip 文件。  
本指南还假定：  
您熟悉安装和管理 Jenkins 以及创建 Jenkins 项目的过程。
您已将适用于 Ruby 的 Rake 和 Haml Gem 安装在托管 Jenkins 项目的同一计算机或实例上。
您已设置所需的系统环境变量，以便可以从终端或命令行运行 Rake 命令（例如，在 Windows 系统上，修改 PATH 变量以包括安装 Rake 的目录）。

**Topics**
+ [将示例复制或克隆到 GitHub 存储库中](#tutorials-four-stage-pipeline-prerequisites-github)
+ [创建 IAM 角色以用于 Jenkins 集成](#tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role)
+ [安装和配置 Jenkins 和适用于 Jenkins 的 CodePipeline 插件](#tutorials-four-stage-pipeline-prerequisites-jenkins-configure)

### 将示例复制或克隆到 GitHub 存储库中
<a name="tutorials-four-stage-pipeline-prerequisites-github"></a>

**克隆示例并推送到 GitHub 存储库**

1. 从 GitHub 存储库下载示例代码，或将存储库克隆到本地计算机。有两个示例包：
   + [如果您要将示例部署到亚马逊 Linux、RHEL 或 Ubuntu 服务器实例，请选择 \$1linux.zip。codepipeline-jenkins-aws-codedeploy](https://github.com/awslabs/aws-codepipeline-jenkins-aws-codedeploy_linux)
   + 如果您要将示例部署到 Windows 服务器实例，请选择 [CodePipeline-Jenkins-.zi](https://github.com/awslabs/AWSCodePipeline-Jenkins-AWSCodeDeploy_windows) p。AWSCodeDeploy\$1Windows

1. 在存储库中，选择 **Fork**，将示例存储库克隆到您的 Github 账户的存储库中。有关详情，请参阅 [GitHub 文档](https://help.github.com/articles/create-a-repo/)。

### 创建 IAM 角色以用于 Jenkins 集成
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role"></a>

作为最佳实践，可以考虑启动 EC2 实例来托管您的 Jenkins 服务器，并使用 IAM 角色向该实例授予与 CodePipeline之交互所需的权限。

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

1. 在 IAM 控制台的导航窗格中，选择**角色**，然后选择**创建角色**。

1. 在**选择受信任实体的类型**下，选择 **AWS 服务**。在**选择将使用此角色的服务**下，选择 **EC2**。在**选择您的使用案例**下，选择 **EC2**。

1. 选择**下一步：权限**。在**附加权限策略**页面上，选择 `AWSCodePipelineCustomActionAccess` 托管策略，然后选择**下一步: 标签**。选择**下一步：审核**。

1. 在 **Review (审核)** 页面上的 **Role name (角色名称)** 中，输入专为 Jenkins 集成创建的角色的名称（例如 *JenkinsAccess*），然后选择 **Create role (创建角色)**。

当您创建要在其中安装 Jenkins 的 EC2 实例时，请确保在 **Step 3: Configure Instance Details (步骤 3：配置实例详细信息)** 中选择该实例角色（例如 *JenkinsAccess*）。

有关实例角色和 Amazon EC2 的更多信息，请参阅[适用于 Amazon EC2 的 IAM 角色](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)、[使用 IAM 角色为 Amazon EC2 实例上运行的应用程序授权](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html)和[创建向 AWS 服务委托权限的角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html)。

### 安装和配置 Jenkins 和适用于 Jenkins 的 CodePipeline 插件
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-configure"></a>

**安装 Jenkins 和适用于 Jenkins 的 CodePipeline 插件**

1. 创建要在其中安装 Jenkins 的 EC2 实例，在 **Step 3: Configure Instance Details (步骤 3：配置实例详细信息)** 中，确保选择您所创建的实例角色（例如 *JenkinsAccess*）。有关创建 EC2 实例的更多信息，请参阅 *Amazon EC2 用户指南* 中的[启动 Amazon EC2 实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html)。
**注意**  
如果您已经拥有您想要使用的 Jenkins 资源，您可以执行此操作，但是您必须创建一个专用的 IAM 用户，为该用户应用 `AWSCodePipelineCustomActionAccess` 托管策略，然后在您的 Jenkins 资源上配置和使用该用户的访问凭证。如果您想使用 Jenkins UI 来提供凭证，请将 Jenkins 配置为仅允许 HTTPS。有关更多信息，请参阅 [故障排除 CodePipeline](troubleshooting.md)。

1. 在 EC2 实例上安装 Jenkins。有关更多信息，请参阅针对[安装 Jenkins](https://www.jenkins.io/doc/book/installing/linux/) 和[启动并访问 Jenkins](https://wiki.jenkins.io/JENKINS/Starting-and-Accessing-Jenkins.html) 的 Jenkins 文档以及 [产品和服务与 CodePipeline](integrations.md)中的[details of integration with Jenkins](integrations-action-type.md#JenkinsInt_2)。

1. 启动 Jenkins，然后在主页上，选择**管理 Jenkins**。

1. 在**管理 Jenkins** 页中，选择**管理插件**。

1. 选择**可用**选项卡，然后在**筛选条件**搜索框中，输入 **AWS CodePipeline**。从列表中选择 **Jenkins 的CodePipeline 插件**，然后选择**立即下载并在重启后安装**。

1. 在**正在安装插件/更新**页中，选择**当安装结束且无作业正在运行时重启 Jenkins**。

1. 选择**返回控制面板**。

1. 在主页中，选择**新项目**。

1. 在**项目名称**中，输入 Jenkins 项目的名称（例如，*MyDemoProject*）。选择**自由式项目**，然后选择**确定**。
**注意**  
确保项目的名称符合 CodePipeline 要求。有关更多信息，请参阅 [AWS CodePipeline 中的限额](limits.md)。

1. 在项目的配置页中，选择**如有必要，执行并发构建**复选框。在**源代码管理**中，选择 **AWS CodePipeline**。如果您已在 EC2 实例上安装了 Jenkins，并使用您为 AWS CLI 与 Jenkins 之间的 CodePipeline 集成而创建的 IAM 用户的配置文件配置了，请将所有其他字段留空。

1. **选择 “**高级**”，然后在 “提供者” 中输入操作提供者的名称 CodePipeline （例如，*MyJenkinsProviderName*）。**确保此名称是唯一的且容易记住。在此教程的后面部分，当您向管道添加生成操作时，会用到这个名称，并且在添加测试操作时，会再次用到它。
**注意**  
此操作名称必须符合 CodePipeline 中的操作的命名要求。有关更多信息，请参阅 [AWS CodePipeline 中的限额](limits.md)。

1. 在**构建触发器**中，清除所有复选框，然后选择**轮询 SCM**。在**计划**中，输入五个星号并用空格隔开，如下所示：

   ```
   * * * * *
   ```

    CodePipeline 每分钟进行一次民意调查。

1. 在**构建**中，选择**添加构建步骤**。选择**执行 Shell**（Amazon Linux、RHEL 或 Ubuntu Server）**执行批处理命令** (Windows Server)，然后输入以下内容：

   ```
   rake
   ```
**注意**  
确保您的环境配置有运行 rake 所需的变量和设置，否则，生成会失败。

1. 选择 “**添加生成后期操作”**，然后选择 “**AWS CodePipeline 发布者**”。选择**添加**，然后在**构建输出位置**中，将位置留空。此配置是默认的，会在生成过程结束时创建一个压缩文件。

1. 选择**保存**以保存您的 Jenkins 项目。

## 步骤 2：在中创建管道 CodePipeline
<a name="tutorials-four-stage-pipeline-pipeline-create"></a>

在这部分教程中，您将使用**创建管道**向导来创建管道。

**创建 CodePipeline 自动发布流程**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 如有必要，请使用区域选择器将区域更改为您的管道资源所在的区域。例如，如果您在 `us-east-2` 中为上一教程创建了资源，请确保将区域选择器设置为“美国东部（俄亥俄州）”。

   有关可用区域和终端节点的更多信息 CodePipeline，请参阅终[AWS CodePipeline 端节点和配额](https://docs.aws.amazon.com/general/latest/gr/codepipeline.html)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**页面上，在**管道名称**中，输入管道的名称。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在 “**步骤 3：添加源舞台**” 页面上，在**源提供程序**中，选择**GitHub**。

1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub 源操作的连接，请参阅[GitHub 连接](connections-github.md)。

1. 在**步骤 4：添加构建阶段**中，选择**添加 Jenkins**。在**提供者名称**中，输入您在 Jenkins CodePipeline 插件中提供的操作的名称（例如*MyJenkinsProviderName*）。此名称必须与 Jenkins CodePipeline 插件中的名称完全匹配。在**服务器 URL** 中，输入在其中安装 Jenkins 的 EC2 实例的 URL。在**项目名称**中，输入您在 Jenkins 中创建的项目的名称，例如*MyDemoProject*，然后选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中，重复使用您在中创建的 CodeDeploy 应用程序和部署组[教程：创建一个简单的管道（S3 存储桶）](tutorials-simple-s3.md)。在**部署提供商**中，选择**CodeDeploy**。在**应用程序名称**中，输入 **CodePipelineDemoApplication**，或选择刷新按钮，然后从列表中选择应用程序名称。在**部署组**中，输入 **CodePipelineDemoFleet** 或者从列表中选择它，然后选择**下一步**。
**注意**  
您可以使用自己的 CodeDeploy 资源或创建新的资源，但可能会产生额外费用。

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

1. 管道会自动启动示例并通过管道运行示例。当管道将 Haml 示例构建为 HTML 并将其部署到部署中的每个 Amazon EC2 实例时，您可以查看进度以及成功和失败消息。 CodeDeploy

## 步骤 3：向管道中添加另一个阶段
<a name="tutorials-four-stage-pipeline-add-stage"></a>

现在，您将添加一个测试阶段，然后向该阶段添加测试操作，该操作使用示例中包含的 Jenkins 测试来确定网页是否具有任何内容。该测试仅用于演示目的。

**注意**  
如果您不想向管道中添加另一个阶段，则可以向管道的 Staging 阶段添加一个测试操作，该操作可以在部署操作之前或之后。

### 向管道中添加测试阶段
<a name="tutorials-four-stage-pipeline-add-stage-console"></a>

**Topics**
+ [查找实例的 IP 地址](#tutorials-four-stage-pipeline-instance-ip-lookup)
+ [创建一个 Jenkins 项目用于测试部署](#tutorials-four-stage-pipeline-create-jenkins-project)
+ [创建第四个阶段](#tutorials-four-stage-pipeline-create-fourth-stage)

#### 查找实例的 IP 地址
<a name="tutorials-four-stage-pipeline-instance-ip-lookup"></a>

**验证您将代码部署到的实例的 IP 地址**

1. 当管道状态显示为**成功**后，在 Staging 阶段的状态区域中，选择**详细信息**。

1. 在**部署详细信息**部分，在**实例 ID** 中，选择成功部署的一个实例的实例 ID。

1. 复制实例的 IP 地址（例如*192.168.0.4*）。您将在 Jenkins 测试中用到此 IP 地址。

#### 创建一个 Jenkins 项目用于测试部署
<a name="tutorials-four-stage-pipeline-create-jenkins-project"></a>

**创建 Jenkins 项目**

1. 在您将 Jenkins 安装到的实例中，打开 Jenkins，然后从主页中选择**新项目**。

1.  在**项目名称**中，输入 Jenkins 项目的名称（例如，*MyTestProject*）。选择**自由式项目**，然后选择**确定**。
**注意**  
确保您的项目名称符合 CodePipeline 要求。有关更多信息，请参阅 [AWS CodePipeline 中的限额](limits.md)。

1. 在项目的配置页中，选择**如有必要，执行并发构建**复选框。在**源代码管理**中，选择 **AWS CodePipeline**。如果您已在 EC2 实例上安装了 Jenkins，并使用您为 AWS CLI 与 Jenkins 之间的 CodePipeline 集成而创建的 IAM 用户的配置文件配置了，请将所有其他字段留空。
**重要**  
如果您正在配置 Jenkins 项目，但该项目未安装在 Amazon EC2 实例上，或者该项目安装在运行 Windows 操作系统的 EC2 实例上，请根据您的代理主机和端口设置填写所需的字段，并提供您为在 Jenkins 和之间集成而配置的 IAM 用户或角色的证书。 CodePipeline

1. 选择**高级**，然后在**目录**中，选择**测试**。

1. 在 Prov **id** er 中，输入与生成项目相同的名称（例如，*MyJenkinsProviderName*）。在本教程的稍后部分，您在向您的管道添加测试操作时将用到此名称。
**注意**  
此名称必须符合操作的 CodePipeline 命名要求。有关更多信息，请参阅 [AWS CodePipeline 中的限额](limits.md)。

1. 在**构建触发器**中，清除所有复选框，然后选择**轮询 SCM**。在**计划**中，输入五个星号并用空格隔开，如下所示：

   ```
   * * * * *
   ```

    CodePipeline 每分钟进行一次民意调查。

1. 在**构建**中，选择**添加构建步骤**。如果要部署到 Amazon Linux、RHEL 或 Ubuntu Server 实例，请选择**执行 Shell**。然后输入以下内容，其中 IP 地址是您之前复制的 EC2 实例的地址：

   ```
   TEST_IP_ADDRESS=192.168.0.4 rake test
   ```

   如果您要部署到 Windows Server 实例，请选择**执行批处理命令**，然后输入以下内容，其中 IP 地址是指您前面复制的 EC2 实例的地址：

   ```
   set TEST_IP_ADDRESS=192.168.0.4 rake test
   ```
**注意**  
测试假定为默认端口 80。如果您要指定一个不同的端口，请添加一个测试端口语句，如下所示：  

   ```
   TEST_IP_ADDRESS=192.168.0.4 TEST_PORT=8000 rake test
   ```

1. 选择 “**添加生成后期操作”**，然后选择 “**AWS CodePipeline 发布者**”。不要选择**添加**。

1. 选择**保存**以保存您的 Jenkins 项目。

#### 创建第四个阶段
<a name="tutorials-four-stage-pipeline-create-fourth-stage"></a>

**向您的管道添加一个包括 Jenkins 测试操作的阶段**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Name (名称)** 中，选择您创建的管道名称 MySecondPipeline。

1. 在管道详细信息页中，选择**编辑**。

1. 在**编辑**页面上，选择 **\$1 阶段**，紧随构建阶段之后添加一个阶段。

1. 在新阶段的名称字段中，输入名称（例如 **Testing**），然后选择 **\$1 添加操作组**。

1. 在**操作名称**中，输入*MyJenkinsTest-Action*。在**测试提供者**中，选择您在 Jenkins 中指定的提供者名称（例如，*MyJenkinsProviderName*）。在**项目名称**中，输入您在 Jenkins 中创建的项目的名称（例如，*MyTestProject*）。在 “**输入工件**” 中，从 Jenkins 版本中选择默认名称为的工件*BuildArtifact*，然后选择 “**完成**”。
**注意**  
由于 Jenkins 测试操作对 Jenkins 构建步骤中构建的应用程序起作用，请为输入构件使用构建构件来执行测试操作。

   有关输入和输出构件以及管道结构的更多信息，请参阅 [CodePipeline 管道结构参考](reference-pipeline-structure.md)。

1. 在**编辑**页中，选择**保存管道更改**。在**保存管道更改**对话框中，选择**保存并继续**。

1. 虽然新阶段已添加到您的管道中，但该阶段会显示为 **No executions yet** 状态，因为更改并不会触发管道的另一次运行。要通过修订后的管道运行示例，在管道详细信息页中，选择**发布更改**。

   管道视图会显示管道中的阶段和操作以及经历这四个阶段的修订的状态。管道完成所有阶段需要的时间将取决于项目的大小、生成和测试操作的复杂程度以及其他因素。

## 步骤 4：清理资源
<a name="tutorials-four-stage-pipeline-clean-up"></a>

完成本教程之后，您应该删除管道及其使用的资源，以避免为继续使用这些资源付费。如果您不打算继续使用 CodePipeline，请删除管道，然后删除 CodeDeploy 应用程序及其关联的 Amazon EC2 实例，最后删除用于存储项目的 Amazon S3 存储桶。如果您不打算继续使用其他资源，例如 GitHub 存储库，则还应考虑是否删除它们。

**清理本教程中使用的资源**

1. 在您本地的 Linux、macOS 或 Unix 计算机上打开终端会话或在您本地的 Windows 计算机上打开命令提示符，并运行 **delete-pipeline** 命令，删除您创建的管道。对于 **MySecondPipeline**，您可以输入以下命令：

   ```
   aws codepipeline delete-pipeline --name "MySecondPipeline"
   ```

   该命令不返回任何内容。

1. 要清理 CodeDeploy 资源，请按照[清理](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-walkthrough.html#getting-started-walkthrough-clean-up)中的说明进行操作。

1. 要清理实例资源，请删除您在其中安装 Jenkins 的 EC2 实例。有关更多信息，请参阅[清除您的实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-clean-up-your-instance.html)。

1. 如果您不打算创建更多管道或 CodePipeline 再次使用，请删除用于存储管道项目的 Amazon S3 存储桶。要删除存储桶，请按照[删除存储桶](https://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html)中的说明进行操作。

1. 如果您不打算将其他资源再次用于该管道，请考虑根据该特定资源的指导删除这些资源。例如，如果要删除 GitHub 存储库，请按照在 GitHub 网站上[删除存储库](https://help.github.com/articles/deleting-a-repository/)中的说明进行操作。

# 教程：设置 CloudWatch 事件规则以接收有关管道状态更改的电子邮件通知
<a name="tutorials-cloudwatch-sns-notifications"></a>

在中设置管道后 AWS CodePipeline，您可以设置 CloudWatch 事件规则，以便在管道的执行状态或管道中的阶段或操作发生变化时发送通知。有关使用 CloudWatch 事件设置管道状态更改通知的更多信息，请参阅[监控 CodePipeline 事件](detect-state-changes-cloudwatch-events.md)。

在本教程中，您配置一个通知以在管道状态变为 FAILED 时发送电子邮件。本教程在创建 CloudWatch 事件规则时使用输入转换器方法。它转换消息架构详细信息以在用户可读的文本中传送消息。

**注意**  
在为本教程创建资源（例如 Amazon SNS 通知和 CloudWatch 事件规则）时，请确保在与您的管道相同的 AWS 区域创建这些资源。

**Topics**
+ [步骤 1：使用 Amazon SNS 设置电子邮件通知](#create-filter-for-target)
+ [步骤 2：创建规则并将 SNS 主题添加为目标](#create-notification-rule)
+ [步骤 3：清理资源](#notifications-clean-up-resources)

## 步骤 1：使用 Amazon SNS 设置电子邮件通知
<a name="create-filter-for-target"></a>

Amazon SNS 协调使用的主题以将消息传送到订阅端点或客户端。可以使用 Amazon SNS 创建一个通知主题，然后使用您的电子邮件地址订阅该主题。Amazon SNS 主题将作为目标添加到您的 CloudWatch 事件规则中。有关更多信息，请参阅《Amazon Simple Notification Service 开发人员指南》[https://docs.aws.amazon.com/sns/latest/dg/](https://docs.aws.amazon.com/sns/latest/dg/)。

在 Amazon SNS 中创建或标识主题。 CodePipeline 将使用 CloudWatch 活动通过 Amazon SNS 向该主题发送通知。要创建主题，请执行以下操作:

1. [在 /sns 上打开亚马逊 SNS 控制台。https://console.aws.amazon.com](https://console.aws.amazon.com/sns)

1. 选择**创建主题**。

1. 在 **Create new topic (创建新主题)** 对话框中，为 **Topic name (主题名称)** 键入主题名（例如 **PipelineNotificationTopic**）。  
![\[使用 Amazon SNS 创建通知主题。\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/tutorial-SNS-topic.png)

1. 选择**创建主题**。

   有关更多信息，请参阅 *Amazon SNS 开发者指南* 中的[创建主题](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html)。

为一个或多个收件人订阅主题以接收电子邮件通知。为收件人订阅主题：

1. 在 Amazon SNS 控制台中，从**主题**列表中，选中新主题旁边的复选框。选择**操作**，然后选择“订阅主题”。

1. 在**创建订阅**对话框中，确认在**主题 ARN** 中显示一个 ARN。

1. 对于**协议**，选择**电子邮件**。

1. 对于**终端节点**，请键入收件人的完整电子邮件地址。

1. 选择**创建订阅**。

1. Amazon SNS 向收件人发送订阅确认电子邮件。要接收电子邮件通知，收件人必须在该电子邮件中选择**确认订阅**链接。在收件人单击该链接后，如果成功订阅，Amazon SNS 将在收件人的 Web 浏览器中显示一条确认消息。

   有关更多信息，请参阅 *Amazon SNS 开发者指南* 中的[订阅主题](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html)。

## 步骤 2：创建规则并将 SNS 主题添加为目标
<a name="create-notification-rule"></a>

创建以 CodePipeline 作为 CloudWatch 事件源的事件通知规则。

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

1. 在导航窗格中，选择 **Events（事件）**。

1. 选择 **Create rule**（创建规则）。在**事件源**下面，选择 **AWS CodePipeline**。对于**事件类型**，请选择**管道执行状态更改**。

1. 选择**特定状态**，然后选择 **FAILED**。

1. 对于**事件模式预览**窗格，请选择**编辑**以打开 JSON 编辑器。添加 **pipeline** 参数以及管道名称，如以下示例中名为“myPipeline”的管道所示。

   您可以复制此处的事件模式并将其粘贴到控制台中：

   ```
   {
     "source": [
       "aws.codepipeline"
     ],
     "detail-type": [
       "CodePipeline Pipeline Execution State Change"
     ],
     "detail": {
       "state": [
         "FAILED"
       ],
       "pipeline": [
         "myPipeline"
       ]
     }
   }
   ```

1. 对于**目标**，选择**添加目标**。

1. 在目标列表中，选择 **SNS 主题**。对于**主题**，请输入刚创建的主题。

1. 展开**配置输入**，然后选择**输入转换器**。

1. 在**输入路径**框中，键入以下键值对。

   ```
   { "pipeline" : "$.detail.pipeline" }
   ```

   在**输入模板**框中，键入以下内容：

   ```
   "The Pipeline <pipeline> has failed."
   ```

1. 选择 **Configure details（配置详细信息）**。

1. 在**配置规则详细信息**页中，键入一个名称和可选的描述。对于**状态**，请将**已启用**框保持选中状态。

1. 选择 **Create rule**（创建规则）。

1. 确认现在 CodePipeline 正在发送构建通知。例如，检查您的收件箱中现在是否有构建通知电子邮件。

1. 要更改规则的行为，请在 CloudWatch 控制台中选择规则，然后选择**操作**、**编辑**。编辑该规则，选择**配置详细信息**，然后选择**更新规则**。

   要停止使用规则发送生成通知，请在 CloudWatch 控制台中选择规则，然后选择**操作**，**禁用**。

   要删除规则，请在 CloudWatch 控制台中选择规则，然后选择**操作**，**删除**。

## 步骤 3：清理资源
<a name="notifications-clean-up-resources"></a>

完成本教程之后，您应该删除管道及其使用的资源，以避免为继续使用这些资源付费。

[有关如何清理 SNS 通知和删除亚马逊 CloudWatch 事件规则的信息，请参阅[清理（取消订阅亚马逊 SNS 主题）和《亚马逊](https://docs.aws.amazon.com/sns/latest/dg/CleanUp.html)活动 API 参考》`DeleteRule`中的参考资料。 CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/)

# 教程：创建用于构建和测试您的 Android 应用程序的管道 AWS Device Farm
<a name="tutorials-codebuild-devicefarm"></a>

您可以使用 AWS CodePipeline 来配置持续集成流程，每次推送提交时，都将在该流程中构建和测试您的应用程序。本教程介绍如何使用 GitHub 存储库中的源代码创建和配置管道，以构建和测试您的 Android 应用程序。管道会检测到新 GitHub 提交的[CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)到来，然后使用构建应用程序，并使用Device [Far](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) m对其进行测试。

**重要**  
作为在控制台中创建管道的一部分，S3 工件存储桶将 CodePipeline用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**重要**  
在此过程中，您在管道中添加的许多操作都涉及在创建管道之前需要创建的 AWS 资源。 AWS 源操作的资源必须始终在您创建管道的同一 AWS 区域创建。例如，如果您在美国东部（俄亥俄州）地区创建管道，则您的 CodeCommit 存储库必须位于美国东部（俄亥俄州）区域。  
您可以在创建管道时添加跨区域操作。 AWS 跨区域操作的资源必须位于您计划执行操作的同一 AWS 区域。有关更多信息，请参阅 [在中添加跨区域操作 CodePipeline](actions-create-cross-region.md)。

您可以使用现有的 Android 应用程序和测试定义或使用 [Device Farm 提供的示例应用程序和测试定义](https://github.com/aws-samples/aws-device-farm-sample-app-for-android)进行此尝试。

**开始之前**

1. 登录 AWS Device Farm 控制台并选择**创建新项目**。

1. 选择您的项目。在浏览器中，复制新项目的 URL。URL 包含项目 ID。

1. 复制并保留此项目 ID。在 CodePipeline 中创建管道时要使用它。

   以下是项目的示例 URL。要提取项目 ID，请复制 `projects/` 之后的值。在此示例中，项目 ID 为 `eec4905f-98f8-40aa-9afc-4c1cfexample`。

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## 配置 CodePipeline 为使用您的 Device Farm 测试
<a name="codepipeline-configure-tests"></a>

1. 

   在应用程序代码的根目录[https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)中添加并提交一个名为的文件，然后将其推送到存储库。 CodeBuild 使用此文件执行构建应用程序所需的命令和访问构件。

   ```
   version: 0.2
   
   phases:
     build:
       commands:
         - chmod +x ./gradlew
         - ./gradlew assembleDebug
   artifacts:
     files:
        - './android/app/build/outputs/**/*.apk'
     discard-paths: yes
   ```

1. （可选）如果[使用 Calabash 或 Appium 测试应用程序](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-intro.html)，请将测试定义文件添加到存储库。在后续步骤中，可将 Device Farm 配置为使用定义来执行测试套件。

   如果使用 Device Farm 内置测试，可跳过此步骤。

1. 要创建管道并添加一个源阶段，请执行以下操作：

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

   1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

   1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

   1. 在**步骤 2：选择管道设置**页面上，在**管道名称**中，输入管道的名称。

   1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

   1. 在**服务角色**中，将**新建服务角色**保持选中状态，并将**角色名称**保持不变。您还可以选择使用现有服务角色（如果已有）。
**注意**  
如果您使用在 2018 年 7 月之前创建的 CodePipeline 服务角色，则需要为 Device Farm 添加权限。要执行此操作，请打开 IAM 控制台，找到该角色，然后向该角色的策略添加以下权限。有关更多信息，请参阅 [为 CodePipeline 服务角色添加权限](how-to-custom-role.md#how-to-update-role-new-services)。  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

   1. 在 “**步骤 3：添加源舞台**” 页面上，在**源提供程序**中，选择 **GitHub （通过 GitHub 应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub 源操作的连接，请参阅[GitHub 连接](connections-github.md)。

   1. 在**存储库**中选择源存储库。

   1. 在**分支**中选择要使用的分支。

   1. 保留源操作的其余默认值。选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，添加一个构建阶段：

   1. 在**构建提供程序**中，选择**其他构建提供程序**，然后选择 **AWS CodeBuild**。允许**区域**默认为管道区域。

   1. 选择**创建项目**。

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境映像**中，选择**托管映像**。对于**操作系统**，选择 **Ubuntu**。

   1. 对于**运行时**，选择**标准**。**对于 “**图像**”，选择:5.0 aws/codebuild/standard。**

      CodeBuild 使用此安装了 Android Studio 的操作系统映像来构建您的应用程序。

   1. 对于**服务角色**，请选择您现有的 CodeBuild 服务角色或创建一个新的服务角色。

   1. 对于**构建规范**，选择**使用 buildspec 文件**。

   1. 选择 “**继续” CodePipeline**。这将返回到 CodePipeline控制台并创建一个使用存储库`buildspec.yml`中的进行配置的 CodeBuild 项目。该构建项目使用服务角色来管理 AWS 服务 权限。此步骤可能需要几分钟时间。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。您应看到一个显示源和构建阶段的示意图。

1. 将 Device Farm 测试操作添加到管道：

   1. 在右上角，选择**编辑**。

   1. 在示意图底部，选择 **\$1 添加阶段**。在**阶段名称**中，输入名称，例如 **Test**。

   1. 选择 **\$1 添加操作组**。

   1. 在**操作名称**中输入名称。

   1. 在**操作提供程序**中，选择 **AWS Device Farm**。允许**区域**默认为管道区域。

   1. 在**输入构件**中，选择与测试阶段之前的那个阶段的输出构件相匹配的输入构件，例如 `BuildArtifact`。

      在 AWS CodePipeline 控制台中，将鼠标悬停在管道图中的信息图标上，可以找到每个阶段的输出工件的名称。如果您的管道直接从 S **ourc** e 阶段测试您的应用程序，请选择**SourceArtifact**。如果管道包含 “构**建**” 阶段，请选择**BuildArtifact**。

   1. 在中 **ProjectId**，输入您的 Device Farm 项目 ID。使用本教程开头的步骤来检索您的项目 ID。

   1. 在中 **DevicePoolArn**，输入设备池的 ARN。要获取项目的可用设备池 ARNs ，包括热门设备的 ARN，请使用 CL AWS I 输入以下命令：

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. 在中 **AppType**，输入**安卓**。

      以下是 **AppType** 的有效值列表：
      + **iOS**
      + **Android**
      + **Web**

   1. 在 **App** 中，输入已编译的应用程序包的路径。该路径相对于测试阶段的输入构件的根。通常，此路径类似于 `app-release.apk`。

   1. 在中 **TestType**，输入您的测试类型，然后在**测试**中输入测试定义文件的路径。路径相对于测试的输入项目的根。

      以下是 **TestType** 的有效值列表：
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**注意**  
不支持自定义环境节点。

   1. 在其余字段中，提供适合测试和应用程序类型的配置。

   1. （可选）在**高级**中，为测试运行提供配置信息。

   1. 选择**保存**。

   1. 在所编辑的阶段上，选择**完成**。在 AWS CodePipeline 窗格中，选择**保存**，然后选择警告消息上的**保存**。

   1. 要提交所做的更改并开始管道构建，请选择**发布更改**，然后选择**发布**。

# 教程：创建用于测试你的 iOS 应用的管道 AWS Device Farm
<a name="tutorials-codebuild-devicefarm-S3"></a>

 您可以使用 AWS CodePipeline 来轻松配置持续集成流程，每次源存储桶更改时，都会在该流程中测试您的应用程序。本教程介绍如何创建和配置管道以测试从 S3 存储桶中构建的 iOS 应用程序。该管道通过 Amazon CloudWatch Events 检测已保存更改的到来，然后使用 De [vice Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) 来测试构建的应用程序。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**重要**  
在此过程中，您在管道中添加的许多操作都涉及在创建管道之前需要创建的 AWS 资源。 AWS 源操作的资源必须始终在您创建管道的同一 AWS 区域创建。例如，如果您在美国东部（俄亥俄州）地区创建管道，则您的 CodeCommit 存储库必须位于美国东部（俄亥俄州）区域。  
您可以在创建管道时添加跨区域操作。 AWS 跨区域操作的资源必须位于您计划执行操作的同一 AWS 区域。有关更多信息，请参阅 [在中添加跨区域操作 CodePipeline](actions-create-cross-region.md)。

您可以使用现有的 iOS 应用程序或使用[示例 iOS 应用程序](samples/s3-ios-test-1.zip)进行此测试。

**开始之前**

1. 登录 AWS Device Farm 控制台并选择 “**创建新项目**”。

1. 选择您的项目。在浏览器中，复制新项目的 URL。URL 包含项目 ID。

1. 复制并保留此项目 ID。在 CodePipeline 中创建管道时要使用它。

   以下是项目的示例 URL。要提取项目 ID，请复制 `projects/` 之后的值。在此示例中，项目 ID 为 `eec4905f-98f8-40aa-9afc-4c1cfexample`。

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## 配置 CodePipeline 为使用您的 Device Farm 测试（Amazon S3 示例）
<a name="codepipeline-configure-tests-S3"></a>

1. 创建或使用已启用版本控制的 S3 存储桶。按照[步骤 1：为您的应用程序创建一个 S3 源存储桶](tutorials-simple-s3.md#s3-create-s3-bucket)中的说明创建 S3 存储桶。

1. 在桶的 Amazon S3 控制台中，选择**上传**，然后按照说明上传 .zip 文件。

   您的示例应用程序必须打包在 .zip 文件中。

1. 要创建管道并添加一个源阶段，请执行以下操作：

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

   1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

   1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

   1. 在**步骤 2：选择管道设置**页面上，在**管道名称**中，输入管道的名称。

   1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

   1. 在**服务角色**中，将**新建服务角色**保持选中状态，并将**角色名称**保持不变。您还可以选择使用现有服务角色（如果已有）。
**注意**  
如果您使用在 2018 年 7 月之前创建的 CodePipeline 服务角色，则必须为 Device Farm 添加权限。要执行此操作，请打开 IAM 控制台，找到该角色，然后向该角色的策略添加以下权限。有关更多信息，请参阅 [为 CodePipeline 服务角色添加权限](how-to-custom-role.md#how-to-update-role-new-services)。  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

   1. 在**步骤 3：添加源阶段**页面上，在**源提供程序**中，选择 **Amazon S3**。

   1. 在 **Amazon S3 位置**中，输入 .zip 文件的桶（例如 `my-storage-bucket`）和对象键（例如 `s3-ios-test-1.zip`）。

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

1. 在**步骤 4：添加构建阶段**中，为管道创建一个占位符构建阶段。这样，可以在向导中创建管道。在使用向导创建两阶段管道后，将不再需要此占位符生成阶段。完成该管道后，将在步骤 5 中删除第二个阶段并添加新的测试阶段。

   

   1. 在**构建提供程序**中，选择**添加 Jenkins**。此生成选择是一个占位符。不会使用。

   1. 在**提供商名称**中输入名称。该名称是一个占位符。不会使用。

   1. 在**服务器 URL** 中输入文本。该文本是一个占位符。不会使用。

   1. 在**项目名称**中输入名称。该名称是一个占位符。不会使用。

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

   1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

      选择**下一步**。

   1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。

   1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。您应看到一个显示源和构建阶段的示意图。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/codepipeline-view-pipeline-S3.png)

1. 将 Device Farm 测试操作添加到管道，如下所述：

   1. 在右上角，选择**编辑**。

   1. 选择**编辑阶段**。选择**删除**。此操作将删除不再需要用于管道创建的占位符阶段。

   1. 在示意图底部，选择 **\$1 添加阶段**。

   1. 在“阶段名称”中，输入阶段名称，例如“测试”，然后选择**添加阶段**。

   1. 选择 **\$1 添加操作组**。

   1. 在**操作名称**中，输入一个名称，例如 DeviceFarmTest。

   1. 在**操作提供程序**中，选择 **AWS Device Farm**。允许**区域**默认为管道区域。

   1. 在**输入构件**中，选择与测试阶段之前的那个阶段的输出构件相匹配的输入构件，例如 `SourceArtifact`。

      在 AWS CodePipeline 控制台中，将鼠标悬停在管道图中的信息图标上，可以找到每个阶段的输出工件的名称。如果您的管道直接从 S **ourc** e 阶段测试您的应用程序，请选择**SourceArtifact**。如果管道包含 “构**建**” 阶段，请选择**BuildArtifact**。

   1. 在中 **ProjectId**，选择您的 Device Farm 项目 ID。使用本教程开头的步骤来检索您的项目 ID。

   1. 在中 **DevicePoolArn**，输入设备池的 ARN。要获取项目的可用设备池 ARNs ，包括热门设备的 ARN，请使用 CL AWS I 输入以下命令：

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. 在中 **AppType**，输入 **iOS**。

      以下是 **AppType** 的有效值列表：
      + **iOS**
      + **Android**
      + **Web**

   1. 在 **App** 中，输入已编译的应用程序包的路径。该路径相对于测试阶段的输入构件的根。通常，此路径类似于 `ios-test.ipa`。

   1. 在中 **TestType**，输入您的测试类型，然后在**测试**中输入测试定义文件的路径。路径相对于测试的输入项目的根。

      如果您正在使用其中一个 Device Farm 内置测试，请输入 Device Farm 项目中配置的测试类型，例如 BUILTIN\$1FUZZ。在中 **FuzzEventCount**，输入以毫秒为单位的时间，例如 6000。在中 **FuzzEventThrottle**，输入以毫秒为单位的时间，例如 50。

      如果没有使用其中一个 Device Farm 内置测试，请选择测试类型，然后在**测试**中输入测试定义文件的路径。路径相对于测试的输入项目的根。

      以下是 **TestType** 的有效值列表：
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**注意**  
不支持自定义环境节点。

   1. 在其余字段中，提供适合测试和应用程序类型的配置。

   1. （可选）在**高级**中，为测试运行提供配置信息。

   1. 选择**保存**。

   1. 在所编辑的阶段上，选择**完成**。在 AWS CodePipeline 窗格中，选择**保存**，然后选择警告消息上的**保存**。

   1. 要提交所做的更改并开始管道执行，请选择**发布更改**，然后选择**发布**。

# 教程：创建部署到 Service Catalog 的管道
<a name="tutorials-S3-servicecatalog"></a>

Service Catalog 使您能够基于 AWS CloudFormation 模板创建和配置产品。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

本教程向您展示如何创建和配置管道，以便将您的产品模板部署到 Service Catalog，并交付您在源存储库（已在 GitHub CodeCommit、或 Amazon S3 中创建）中所做的更改。

**注意**  
当 Amazon S3 是管道的源提供程序时，您必须将所有源文件打包为单个 .zip 文件上传到桶。否则，源操作将失败。

首先，您在 Service Catalog 中创建一个产品，然后在 AWS CodePipeline中创建管道。本教程提供两个设置部署配置的选项：
+ 在 Service Catalog 中创建产品并将模板文件上传到您的源存储库。在 CodePipeline 控制台中提供产品版本和部署配置（无需单独的配置文件）。请参阅[选项 1：在不使用配置文件的情况下部署到 Service Catalog](#tutorials-S3-servicecatalog-ex1-configure)。
**注意**  
可以按 YAML 或 JSON 格式创建模板文件。
+ 在 Service Catalog 中创建产品并将模板文件上传到您的源存储库。在单独的配置文件中提供产品版本和部署配置。请参阅[选项 2：使用配置文件部署到 Service Catalog](#tutorials-S3-servicecatalog-ex2-configure)。

## 选项 1：在不使用配置文件的情况下部署到 Service Catalog
<a name="tutorials-S3-servicecatalog-ex1-configure"></a>

在此示例中，您上传了 S3 存储桶的示例 AWS CloudFormation 模板文件，然后在 Service Catalog 中创建您的产品。接下来，创建管道并在 CodePipeline 控制台中指定部署配置。

### 步骤 1：将示例模板文件上传到源存储库
<a name="tutorials-S3-servicecatalog-configure"></a>

1. 打开文本编辑器。通过将以下内容粘贴到文件中创建一个示例模板。将该文件保存为 `S3_template.json`。

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   此模板 AWS CloudFormation 允许创建可由 Service Catalog 使用的 S3 存储桶。

1. 将 `S3_template.json`文件上传到 AWS CodeCommit 存储库中。

### 步骤 2：在 Service Catalog 中创建产品
<a name="tutorials-S3-servicecatalog-product"></a>

1. 以 IT 管理员身份登录到 Service Catalog 控制台，转到**产品**页面，然后选择**上传新产品**。

1. 在**上传新产品**页面上，完成以下操作：

   1. 在**产品名称**中，输入您要用于新产品的名称。

   1. 在**描述**中，输入产品目录描述。此说明显示在产品列表中，可帮助用户选择正确的产品。

   1. 在**提供者**中，输入 IT 部门或管理员的名称。

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

1. （可选）在**输入支持详细信息**中，输入产品支持联系人信息，然后选择**下一步**。

1. 在**版本详细信息**中，完成以下内容：

   1. 选择**上传模板文件**。浏览您的 `S3_template.json` 文件并将其上传。

   1. 在**版本标题**中，输入产品版本名称（例如 **devops S3 v2**）。

   1. 在**描述**中，输入区分此版本与其他版本的详细信息。

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

1. 在**审核**页面上，确认信息正确，然后选择**创建**。

1. 在**产品**页面上，在浏览器中复制新产品的 URL。这包含产品 ID。复制并保留此产品 ID。在 CodePipeline 中创建管道时要使用它。

   以下是名为 `my-product` 的产品的 URL。要提取产品 ID，请复制等号（`=`）和符号（`&`）之间的值。在此示例中，产品 ID 为 `prod-example123456`。

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**注意**  
复制您的产品的 URL，然后再离开该页面。离开此页面后，必须使用 CLI 获取产品 ID。

   几秒钟后，您的产品会显示在**产品**页面上。您可能需要刷新浏览器才能在列表中看到此产品。

### 步骤 3：创建管道
<a name="tutorials-S3-servicecatalog-pipeline"></a>

1. 要命名您的管道并选择用于管道的参数，请执行以下操作：

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

   1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

   1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

   1. 在**步骤 2：选择管道设置**的**管道名称**中，输入管道的名称。

   1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

   1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

   1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 要在**步骤 3：添加源阶段**页面上添加源阶段，请执行以下操作：

   1. 在**源提供程序**中，选择 **AWS CodeCommit**。

   1. 在**存储库名称**和**分支名称**中，输入您要用于自己的源操作的存储库和分支。

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

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中，完成以下操作：

   1. 在**部署提供商**中，选择**AWS Service Catalog**。

   1. 对于部署配置，请选择**输入部署配置**。

   1. 在**产品 ID** 中，粘贴您从 Service Catalog 控制台复制的产品 ID。

   1. 在**模板文件路径**中，输入存储模板文件的位置的相对路径。

   1. 在**产品类型**中，选择 **CloudFormation 模板**。

   1. 在**产品版本名称**中，输入您在 Service Catalog 中指定的产品版本的名称。如果您想将模板更改部署到新的产品版本，请输入尚未用于同一产品中任何先前产品版本的产品版本名称。

   1. 对于**输入项目**，选择源输入项目。

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

1. 在**步骤 7：审核**中，审核您的管道设置，然后选择**创建**。

1. 管道成功运行后，在部署阶段上选择**详细信息**。这会在 Service Catalog 中打开您的产品。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. 在您的产品信息中，选择您的版本名称以打开产品模板。查看模板部署。

### 步骤 4：在 Service Catalog 中推送更改并验证产品
<a name="tutorials-S3-servicecatalog-change"></a>

1. 在 CodePipeline 控制台中查看您的管道，然后在源代码舞台上选择 Deta **ils**。您的源 AWS CodeCommit 存储库将在控制台中打开。选择**编辑**，然后在文件中进行更改（例如，更改描述）。

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. 提交并推送您的更改。推送更改后，您的管道启动。当管道运行完成时，在部署阶段上选择**详细信息**以在 Service Catalog 中打开您的产品。

1. 在您的产品信息中，选择新的版本名称以打开产品模板。查看部署的模板更改。

## 选项 2：使用配置文件部署到 Service Catalog
<a name="tutorials-S3-servicecatalog-ex2-configure"></a>

在此示例中，您上传了 S3 存储桶的示例 AWS CloudFormation 模板文件，然后在 Service Catalog 中创建您的产品。您还可以上传指定您的部署配置的单独配置文件。接下来，您可以创建您的管道，并指定部署文件的位置。

### 步骤 1：将示例模板文件上传到源存储库
<a name="tutorials-S3-servicecatalog-upload2"></a>

1. 打开文本编辑器。通过将以下内容粘贴到文件中创建一个示例模板。将该文件保存为 `S3_template.json`。

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   此模板 AWS CloudFormation 允许创建可由 Service Catalog 使用的 S3 存储桶。

1. 将 `S3_template.json`文件上传到 AWS CodeCommit 存储库中。

### 步骤 2：创建产品部署配置文件
<a name="tutorials-S3-servicecatalog-configure2"></a>

1. 打开文本编辑器。为您的产品创建配置文件。配置文件用于定义 Service Catalog 部署参数/首选项。创建管道时要使用此文件。

   此示例提供了“devops S3 v2”的 `ProductVersionName` 和 `MyProductVersionDescription` 的 `ProductVersionDescription`。如果您想将模板更改部署到新的产品版本，只需输入尚未用于同一产品中任何先前产品版本的产品版本名称。

    将该文件保存为 `sample_config.json`。

   ```
   {
       "SchemaVersion": "1.0",
       "ProductVersionName": "devops S3 v2",
       "ProductVersionDescription": "MyProductVersionDescription",
       "ProductType": "CLOUD_FORMATION_TEMPLATE",
       "Properties": {
           "TemplateFilePath": "/S3_template.json"
       }
   }
   ```

   此文件将在您的管道每次运行时为您创建产品版本信息。

1. 将 `sample_config.json`文件上传到 AWS CodeCommit 存储库中。确保您将此文件上载到您的源存储库。

### 步骤 3：在 Service Catalog 中创建产品
<a name="tutorials-S3-servicecatalog-product2"></a>

1. 以 IT 管理员身份登录到 Service Catalog 控制台，转到**产品**页面，然后选择**上传新产品**。

1. 在**上传新产品**页面上，完成以下操作：

   1. 在**产品名称**中，输入您要用于新产品的名称。

   1. 在**描述**中，输入产品目录描述。此说明出现在产品列表中，可帮助用户选择正确的产品。

   1. 在**提供者**中，输入 IT 部门或管理员的名称。

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

1. （可选）在**输入支持详细信息**中，输入产品支持联系人信息，然后选择**下一步**。

1. 在**版本详细信息**中，完成以下内容：

   1. 选择**上传模板文件**。浏览您的 `S3_template.json` 文件并将其上传。

   1. 在**版本标题**中，输入产品版本的名称（例如，“devops S3 v2”）。

   1. 在**描述**中，输入区分此版本与其他版本的详细信息。

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

1. 在**审核**页面上，确认信息正确，然后选择**确认并上传**。

1. 在**产品**页面上，在浏览器中复制新产品的 URL。这包含产品 ID。复制并保留此产品 ID。在 CodePipeline 中创建管道时要使用它。

   以下是名为 `my-product` 的产品的 URL。要提取产品 ID，请复制等号（`=`）和符号（`&`）之间的值。在此示例中，产品 ID 为 `prod-example123456`。

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**注意**  
复制您的产品的 URL，然后再离开该页面。离开此页面后，必须使用 CLI 获取产品 ID。

   几秒钟后，您的产品会显示在**产品**页面上。您可能需要刷新浏览器才能在列表中看到此产品。

### 步骤 4：创建管道
<a name="tutorials-S3-servicecatalog-pipeline2"></a>

1. 要命名您的管道并选择用于管道的参数，请执行以下操作：

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

   1. 选择**开始使用**。选择**创建管道**，然后输入管道名称。

   1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

   1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 要添加源阶段，请执行以下操作：

   1. 在**源提供程序**中，选择 **AWS CodeCommit**。

   1. 在**存储库名称**和**分支名称**中，输入您要用于自己的源操作的存储库和分支。

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

1. 在**添加构建阶段**中，选择**跳过构建阶段**，然后再次选择**跳过**以接受警告消息。

1. 在**添加部署阶段**中，完成以下操作：

   1. 在**部署提供商**中，选择**AWS Service Catalog**。

   1. 选择**使用配置文件**。

   1. 在**产品 ID** 中，粘贴您从 Service Catalog 控制台复制的产品 ID。

   1. 在**配置文件路径**中，输入存储库中配置文件的文件路径。

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

1. 在**审核**中，审核您的管道设置，然后选择**创建**。

1. 管道成功运行后，在部署阶段上选择**详细信息**，以便在 Service Catalog 中打开您的产品。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. 在您的产品信息中，选择您的版本名称以打开产品模板。查看模板部署。

### 步骤 5：在Service Catalog 中推送更改并验证产品
<a name="tutorials-S3-servicecatalog-change2"></a>

1. 在 CodePipeline 控制台中查看您的管道，然后在源代码舞台上选择 Deta **ils**。您的源 AWS CodeCommit 存储库将在控制台中打开。选择**编辑**，然后在文件中进行更改（例如，更改描述）。

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. 提交并推送您的更改。推送更改后，您的管道启动。当管道运行完成时，在部署阶段上选择**详细信息**以在 Service Catalog 中打开您的产品。

1. 在您的产品信息中，选择新的版本名称以打开产品模板。查看部署的模板更改。

# 教程：使用创建管道 AWS CloudFormation
<a name="tutorials-cloudformation"></a>

这些示例提供了示例模板，允许您使用这些模板 AWS CloudFormation 来创建管道，该管道在每次源代码更改时都会将您的应用程序部署到您的实例。示例模板创建了一个可以在 AWS CodePipeline中查看的管道。该渠道通过 Amazon CloudWatch Events 检测已保存的更改是否到达。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**Topics**
+ [示例 1：使用创建 AWS CodeCommit 管道 AWS CloudFormation](tutorials-cloudformation-codecommit.md)
+ [示例 2：使用以下命令创建 Amazon S3 管道 AWS CloudFormation](tutorials-cloudformation-s3.md)

# 示例 1：使用创建 AWS CodeCommit 管道 AWS CloudFormation
<a name="tutorials-cloudformation-codecommit"></a>

本演练向您展示如何使用 AWS CloudFormation 控制台创建基础架构，其中包括连接到 CodeCommit 源存储库的管道。在本教程中，您将使用提供的示例模板文件创建资源堆栈，其中包括您的项目存储、管道和更改检测资源，例如您的 Amazon Ev CloudWatch ents 规则。在中创建资源堆栈后 AWS CloudFormation，您可以在 AWS CodePipeline 控制台中查看您的管道。该管道是一个分为两个阶段的管道，包括 CodeCommit 源阶段和 CodeDeploy 部署阶段。

**先决条件：**

您必须已创建以下资源才能与 AWS CloudFormation 示例模板一起使用：
+ 您必须已创建一个源存储库。您可以使用您在中创建的 AWS CodeCommit 存储库[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 您必须已创建 CodeDeploy 应用程序和部署组。您可以使用在[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)中创建的 CodeDeploy 资源。
+ [选择以下链接之一下载用于创建管道的示例 AWS CloudFormation 模板文件：[YAML](samples/codepipeline-codecommit-events-yaml.zip) \$1 JSON](samples/codepipeline-codecommit-events-json.zip)

  解压缩该文件并将其放在您的本地计算机上。
+ 下载 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 示例应用程序文件。



**在中创建您的管道 AWS CloudFormation**

1. 从 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 解压文件，然后将文件上传到您的 AWS CodeCommit 存储库。您必须将解压缩的文件上传到存储库的根目录。您可以按照[第 2 步：向 CodeCommit 存储库中添加示例代码](tutorials-simple-codecommit.md#codecommit-add-code)中的说明将文件推送到您的存储库。

1. 打开 AWS CloudFormation 控制台并选择 “**创建堆栈**”。选择**使用新资源（标准）**。

1. 在**指定模板**下，选择**上传模板**。选中**选择文件**，然后从您的本地计算机选择模板文件。选择**下一步**。

1. 在**堆栈名称**中，输入管道的名称。将显示由示例模板指定的参数。输入以下参数：

   1. 在中 **ApplicationName**，输入您的 CodeDeploy应用程序的名称。

   1. 在中 **BetaFleet**，输入您的 CodeDeploy 部署组的名称。

   1. 在中 **BranchName**，输入要使用的存储库分支。

   1. 在中 **RepositoryName**，输入您的 CodeCommit 源存储库的名称。

1. 选择**下一步**。在接下来的页面上接受默认值，然后选择**下一步**。

1. 在 “**能力**” 中，选择 “**我确认 AWS CloudFormation 可能会创建 IAM 资源**”，然后选择 “**创建堆栈**”。

1. 在堆栈创建完成后，查看事件列表以检查是否存在任何错误。

   **故障排查**

   在中创建管道的 IAM 用户 AWS CloudFormation 可能需要额外的权限才能为管道创建资源。策略中需要以下权限才能 AWS CloudFormation 为 CodeCommit管道创建所需的 Amazon E CloudWatch vents 资源：

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

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

   在**管道**下，选择您的管道并选择**查看**。该图显示了您的管道源和部署阶段。
**注意**  
要查看已创建的管道，请在 CloudFormation中找到堆栈的**资源**选项卡下的**逻辑 ID** 列。记下管道的**物理 ID** 列中的名称。在中 CodePipeline，您可以在创建堆栈的区域中查看具有相同物理 ID（管道名称）的管道。

1. 在您的源存储库中，提交并推送更改。您的更改检测资源会拾取更改，并且您的管道启动。

# 示例 2：使用以下命令创建 Amazon S3 管道 AWS CloudFormation
<a name="tutorials-cloudformation-s3"></a>

本演练向您展示如何使用 AWS CloudFormation 控制台创建基础设施，其中包括连接到 Amazon S3 源存储桶的管道。在本教程中，您将使用提供的示例模板文件创建资源堆栈，其中包括您的源存储桶、项目存储、管道和更改检测资源，例如您的 Amazon Ev CloudWatch ents 规则和 CloudTrail跟踪。在中创建资源堆栈后 AWS CloudFormation，您可以在 AWS CodePipeline 控制台中查看您的管道。该管道是一个分为两个阶段的管道，包括一个 Amazon S3 源阶段和一个 CodeDeploy部署阶段。

**先决条件：**

您必须拥有以下资源才能与 AWS CloudFormation 示例模板一起使用：
+ 您必须已创建 Amazon EC2 实例，并在实例上安装了 CodeDeploy 代理。您必须已创建 CodeDeploy 应用程序和部署组。使用您在中创建的 Amazon EC2 和 CodeDeploy 资源[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 选择以下链接下载用于使用 Amazon S3 源创建管道的示例 AWS CloudFormation 模板文件：
  + 为您的管道下载示例模板：[YAML](samples/codepipeline-s3-events-yaml.zip) \$1 [JSON](samples/codepipeline-s3-events-json.zip)
  + [下载 CloudTrail 存储桶和跟踪的示例模板：[YAML](samples/codepipeline-s3-cloudtrail-yaml.zip) \$1 JSON](samples/codepipeline-s3-cloudtrail-json.zip)
  + 解压缩文件并将其放在您的本地计算机上。
+ 从 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 下载示例应用程序。

  将 .zip 文件保存在本地计算机上。创建堆栈后，您将上传 .zip 文件。

**在中创建您的管道 AWS CloudFormation**

1. 打开 AWS CloudFormation 控制台，然后选择 “**创建堆栈**”。选择**使用新资源（标准）**。

1. 在**选择一个模板**中，选择**上传模板**。选中**选择文件**，然后从您的本地计算机选择模板文件。选择**下一步**。

1. 在**堆栈名称**中，输入管道的名称。将显示由示例模板指定的参数。输入以下参数：

   1. 在中 **ApplicationName**，输入您的 CodeDeploy 应用程序的名称。您可以替换 `DemoApplication` 默认名称。

   1. 在中 **BetaFleet**，输入您的 CodeDeploy 部署组的名称。您可以替换 `DemoFleet` 默认名称。

   1. 在 **SourceObjectKey** 中输入 `SampleApp_Linux.zip`。在模板创建存储桶和管道后，将此文件上传到存储桶。

1. 选择**下一步**。在接下来的页面上接受默认值，然后选择**下一步**。

1. 在 “**能力**” 中，选择 “**我确认 AWS CloudFormation 可能会创建 IAM 资源**”，然后选择 “**创建堆栈**”。

1. 在堆栈创建完成后，查看事件列表以检查是否存在任何错误。

   **故障排查**

   在中创建管道的 IAM 用户 AWS CloudFormation 可能需要额外的权限才能为管道创建资源。策略中需要以下权限 AWS CloudFormation 才能允许为 Amazon S3 管道创建所需的 Amazon Ev CloudWatch ents 资源：

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. 在 CloudFormation堆栈的 “**资源**” 选项卡中，查看为您的堆栈创建的资源。
**注意**  
要查看已创建的管道，请在 CloudFormation中找到堆栈的**资源**选项卡下的**逻辑 ID** 列。记下管道的**物理 ID** 列中的名称。在中 CodePipeline，您可以在创建堆栈的区域中查看具有相同物理 ID（管道名称）的管道。

   选择名称中包含 `sourcebucket` 标签的 S3 存储桶，例如 `s3-cfn-codepipeline-sourcebucket-y04EXAMPLE.`。不要选择管道构件存储桶。

   源存储桶为空，因为资源是由 CloudFormation新创建的。打开 Amazon S3 控制台，并找到您的 `sourcebucket` 桶。选择 **Upload (上传)**，然后按照说明上传 `SampleApp_Linux.zip` .zip 文件。
**注意**  
当 Amazon S3 是管道的源提供程序时，您必须将所有源文件打包为单个 .zip 文件上传到桶。否则，源操作将失败。

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

   在**管道**下，选择您的管道，然后选择**查看**。该图显示了您的管道源和部署阶段。

1. 完成以下过程中的步骤来创建您的 AWS CloudTrail 资源。

**在中创建您的 AWS CloudTrail 资源 AWS CloudFormation**

1. 打开 AWS CloudFormation 控制台，然后选择 “**创建堆栈**”。

1. 在**选择一个模板**中，选择**将模板上传到 Amazon S3**。选择 “**浏览**”，然后从本地计算机上为 AWS CloudTrail 资源选择模板文件。选择**下一步**。

1. 在**堆栈名称**中，输入资源堆栈的名称。将显示由示例模板指定的参数。输入以下参数：

   1. 在中 **SourceObjectKey**，接受示例应用程序的 zip 文件的默认值。

1. 选择**下一步**。在接下来的页面上接受默认值，然后选择**下一步**。

1. 在 “**能力**” 中，选择 “**我确认 AWS CloudFormation 可能会创建 IAM 资源**”，然后选择 “**创建**”。

1. 在堆栈创建完成后，查看事件列表以检查是否存在任何错误。

   策略中需要以下权限 AWS CloudFormation 才能创建 Amazon S3 管道所需的 CloudTrail 资源：

   ```
   {
        "Effect": "Allow",
        "Action": [
           "cloudtrail:CreateTrail",
           "cloudtrail:DeleteTrail",
           "cloudtrail:StartLogging",
           "cloudtrail:StopLogging",
           "cloudtrail:PutEventSelectors"
        ],
        "Resource": "resource_ARN"
   }
   ```

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

   在**管道**下，选择您的管道，然后选择**查看**。该图显示了您的管道源和部署阶段。

1. 在您的源存储桶中，提交并推送更改。您的更改检测资源会拾取更改，并且您的管道启动。

# 教程：创建使用 AWS CloudFormation 部署操作中的变量的管道
<a name="tutorials-cloudformation-action"></a>

在本教程中，您将使用 AWS CodePipeline 控制台创建带有部署操作的管道。管道运行时，模板会创建一个堆栈，另外还创建一个 `outputs` 文件。堆栈模板生成的输出是中 AWS CloudFormation 操作生成的变量 CodePipeline。

在从模板创建堆栈的操作中，您可以指定一个变量命名空间。然后，后续操作可以使用由 `outputs` 文件生成的变量。在此示例中，您将根据 AWS CloudFormation 操作生成的`StackName`变量创建更改集。手动批准后，执行更改集，然后创建删除堆栈操作，此操作根据 `StackName` 变量删除堆栈。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**Topics**
+ [先决条件：创建 AWS CloudFormation 服务角色和 CodeCommit 存储库](#tutorials-cloudformation-action-prereq)
+ [步骤 1：下载、编辑和上传示例 AWS CloudFormation 模板](#tutorials-cloudformation-action-upload)
+ [步骤 2：创建管道](#tutorials-cloudformation-action-pipeline)
+ [步骤 3：添加 CloudFormation 部署操作以创建更改集](#tutorials-cloudformation-action-changeset)
+ [步骤 4：添加手动审批操作](#tutorials-cloudformation-action-approval)
+ [步骤 5：添加 CloudFormation 部署操作以执行更改集](#tutorials-cloudformation-action-deployment)
+ [步骤 6：添加 CloudFormation 部署操作以删除堆栈](#tutorials-cloudformation-action-delete)

## 先决条件：创建 AWS CloudFormation 服务角色和 CodeCommit 存储库
<a name="tutorials-cloudformation-action-prereq"></a>

您必须已经具备以下各项：
+ 存储 CodeCommit 库。您可以使用您在中创建的 AWS CodeCommit 存储库[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 此示例从模板创建 Amazon DocumentDB 堆栈。您必须使用 AWS Identity and Access Management (IAM) 为亚马逊文档数据库创建具有以下权限的 AWS CloudFormation 服务角色。

  ```
  "rds:DescribeDBClusters",
  "rds:CreateDBCluster",
  "rds:DeleteDBCluster",
  "rds:CreateDBInstance"
  ```

## 步骤 1：下载、编辑和上传示例 AWS CloudFormation 模板
<a name="tutorials-cloudformation-action-upload"></a>

下载示例 AWS CloudFormation 模板文件并将其上传到您的 CodeCommit 存储库。

1. 导航到您所在区域的示例模板。例如，使用表格（[https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack](https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack)）选择区域并下载模板。下载 Amazon DocumentDB 集群的模板。文件名为 `documentdb_full_stack.yaml`。

1. 解压缩 `documentdb_full_stack.yaml` 文件，然后在文本编辑器中打开它。进行以下更改。

   1. 对于此示例，将以下 `Purpose:` 参数添加到模板中的 `Parameters` 部分。

      ```
        Purpose:
          Type: String
          Default: testing
          AllowedValues:
            - testing
            - production
          Description: The purpose of this instance.
      ```

   1. 对于此示例，将以下 `StackName` 输出添加到模板中的 `Outputs:` 部分。

      ```
        StackName:
          Value: !Ref AWS::StackName
      ```

1. 将模板文件上传到您的 AWS CodeCommit 存储库。您必须将解压缩和编辑的模板文件上传到存储库的根目录。

   要使用 CodeCommit 控制台上传文件，请执行以下操作：

   1. 打开 CodeCommit 控制台，然后从 “存储库” 列表中选择您的**存储库**。

   1. 选择**添加文件**，然后选择**上传文件**。

   1. 选择**选择文件**，然后浏览找到您的文件。通过输入您的用户名和电子邮件地址来提交更改。选择**提交更改**。

   文件在存储库的根级别看起来应该像这样：

   ```
   documentdb_full_stack.yaml
   ```

## 步骤 2：创建管道
<a name="tutorials-cloudformation-action-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个源阶段，其 CodeCommit 操作中的源构件就是您的模板文件。
+ 包含部署操作的 CloudFormation 部署阶段。

分别向由向导创建的源和部署阶段中的每个操作分配一个变量命名空间 `SourceVariables` 和 `DeployVariables`。由于已向操作分配命名空间，因此在此示例中配置的变量可用于下游操作。有关更多信息，请参阅 [变量参考](reference-variables.md)。

**使用向导创建管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyCFNDeployPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，执行下列操作之一：
   + 选择 “**新建服务角色**” CodePipeline 以允许在 IAM 中创建服务角色。
   + 选择**现有服务角色**。在**角色名称**中，从列表中选择您的服务角色。

1. 在**构件存储**中：

   1. 选择**默认位置**以将默认构件存储（如指定为默认值的 Amazon S3 构件桶）用于为管道选择的区域中的管道。

   1. 如果您在管道所在的区域中已有构件存储（例如，Amazon S3 构件桶），请选择**自定义位置**。
**注意**  
这不是源代码的源存储桶。这是管道的项目存储。每个管道都需要一个单独的构件存储，例如 S3 存储桶。创建或编辑管道时，管道区域中必须有一个工件存储桶，并且每个运行操作的 AWS 区域都必须有一个工件存储桶。  
有关更多信息，请参阅[输入和输出构件](welcome-introducing-artifacts.md)和[CodePipeline 管道结构参考](reference-pipeline-structure.md)。

   选择**下一步**。

1. 在**步骤 3：添加源阶段**中：

   1. 在**源提供程序**中，选择 **AWS CodeCommit**。

   1. 在**存储库名称**中，选择您在中创建的 CodeCommit 存储库的名称[步骤 1：创建 CodeCommit 存储库](tutorials-simple-codecommit.md#codecommit-create-repository)。

   1. 在**分支名称**中，选择包含最新的代码更新的分支的名称。

   选择存储库名称和分支后，将显示要为此管道创建的 Amazon CloudWatch Events 规则。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中：

   1. 在**操作名称**中，选择**部署**。在**部署提供商**中，选择**CloudFormation**。

   1. 在**操作模式**中，选择**创建或更新堆栈**。

   1. 在**堆栈名称**中，为堆栈输入名称。这是模板将创建的堆栈的名称。

   1. 在**输出文件名**中，输入输出文件的名称，如 **outputs**。这是创建堆栈后由操作创建的文件的名称。

   1. 展开**高级**。在**参数覆盖**下，作为键值对输入模板覆盖。例如，此模板需要以下覆盖。

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "testing"}
      ```

      如果不输入覆盖，则模板会创建一个具有默认值的堆栈。

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

   1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。您应该可以看到一个显示管道阶段的示意图。允许您的管道运行。您的两阶段管道已完成并准备好添加其他阶段。

## 步骤 3：添加 CloudFormation 部署操作以创建更改集
<a name="tutorials-cloudformation-action-changeset"></a>

在管道中创建下一个操作， CloudFormation 允许在手动批准操作之前创建变更集。



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

   在**管道**下，选择您的管道并选择**查看**。该图显示了您的管道源和部署阶段。

1. 选择以编辑管道，或继续在**编辑**模式下显示管道。

1. 选择以编辑**部署**阶段。

1. 添加一个部署操作，该操作将为在上一个操作中创建的堆栈创建更改集。您可以在阶段中的现有操作之后添加此操作。

   1. 在**操作名称**中，输入 **Change\$1Set**。对于**操作提供程序**，选择 **AWS CloudFormation **。

   1. 在**输入构件**中，选择**SourceArtifact**。

   1. 在**操作模式**中，选择**创建或替换更改集**。

   1. 在**堆栈名称**中，如下所示输入变量语法。这是为其创建更改集的堆栈的名称，其中，向操作分配默认命名空间 `DeployVariables`。

      ```
      #{DeployVariables.StackName}
      ```

   1. 在**更改集名称**中，输入更改集的名称。

      ```
      my-changeset
      ```

   1. 在**参数覆盖**中，将 `Purpose` 参数从 `testing` 更改为 `production`。

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "production"}
      ```

   1. 选择**完成**以保存操作。

## 步骤 4：添加手动审批操作
<a name="tutorials-cloudformation-action-approval"></a>

在管道中创建手动审批操作。



1. 选择以编辑管道，或继续在**编辑**模式下显示管道。

1. 选择以编辑**部署**阶段。

1. 在创建更改集的部署操作之后添加手动审批操作。此操作允许您在管道执行更改集 CloudFormation 之前验证中已创建的资源变更集。

## 步骤 5：添加 CloudFormation 部署操作以执行更改集
<a name="tutorials-cloudformation-action-deployment"></a>

在管道中创建下一个操作， CloudFormation 允许在手动批准操作之后执行变更集。



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

   在**管道**下，选择您的管道并选择**查看**。该图显示了您的管道源和部署阶段。

1. 选择以编辑管道，或继续在**编辑**模式下显示管道。

1. 选择以编辑**部署**阶段。

1. 添加将执行在上一个手动操作中审批的更改集的部署操作：

   1. 在**操作名称**中，输入 **Execute\$1Change\$1Set**。对于**操作提供程序**，选择 **AWS CloudFormation**。

   1. 在**输入构件**中，选择**SourceArtifact**。

   1. 在**操作模式**中，选择**执行更改集**。

   1. 在**堆栈名称**中，如下所示输入变量语法。这是为其创建更改集的堆栈的名称。

      ```
      #{DeployVariables.StackName}
      ```

   1. 在**更改集名称**中，输入您在上一个操作中创建的更改集的名称。

      ```
      my-changeset
      ```

   1. 选择**完成**以保存操作。

   1. 继续管道运行。

## 步骤 6：添加 CloudFormation 部署操作以删除堆栈
<a name="tutorials-cloudformation-action-delete"></a>

在管道中创建最后一个操作， CloudFormation 允许从输出文件中的变量中获取堆栈名称并删除堆栈。



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

   在**管道**下，选择您的管道并选择**查看**。该图显示了您的管道源和部署阶段。

1. 选择以编辑管道。

1. 选择以编辑**部署**阶段。

1. 添加将删除堆栈的部署操作：

   1. 在**操作名称**中，选择**DeleteStack**。在**部署提供商**中，选择**CloudFormation**。

   1. 在**操作模式**下，选 **删除堆栈**。

   1. 在**堆栈名称**中，如下所示输入变量语法。这是操作将删除的堆栈的名称。

   1. 选择**完成**以保存操作。

   1. 选择**保存**以保存管道。

   管道在保存时运行。

# 教程：使用 Amazon ECS 标准部署 CodePipeline
<a name="ecs-cd-pipeline"></a>

本教程可帮助您使用 Amazon ECS 创建完整的 end-to-end持续部署 (CD) 管道 CodePipeline。

**重要**  
作为在控制台中创建管道的一部分，S3 工件存储桶将 CodePipeline用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
本教程适用于 Amazon ECS 的标准部署操作 CodePipeline。有关中使用 Amazon ECS 进行 CodeDeploy 蓝/绿部署操作的教程 CodePipeline，请参阅。[教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道](tutorials-ecs-ecr-codedeploy.md)

**注意**  
本教程适用于 CodePipeline 带有源操作的 Amazon ECS 标准部署操作。有关使用 Amazon ECSstandard 部署操作和 ECRBuildAndPublish 构建操作 CodePipeline 来推送映像的教程，请参阅[教程：使用 CodePipeline （V2 类型）构建 Docker 镜像并将其推送到亚马逊 ECR](tutorials-ecr-build-publish.md)。

## 先决条件
<a name="ecs-cd-prereqs"></a>

您必须先部署一些资源，然后才能使用本教程创建您的 CD 管道。以下是您在开始操作之前需要的资源：

**注意**  
所有这些资源都应在同一个 AWS 区域内创建。
+ 包含您的 Dockerfile 和应用程序源的源代码控制存储库（本教程使用 CodeCommit）。有关更多信息，请参阅《*AWS CodeCommit 用户指南》*中的 “[创建 CodeCommit存储库](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html)”。
+ 一个 Docker 映像存储库（本教程使用 Amazon ECR），其中包含您从 Dockerfile 和应用程序源构建的映像。有关更多信息，请参阅 *Amazon Elastic Container Registry 用户指南* 中的[创建存储库](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html)和[推送映像](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html)。
+ 一个 Amazon ECS 任务定义，该定义会引用在您的映像存储库中托管的 Docker 映像。有关更多信息，请参阅 *Amazon Elastic Container Service 开发者指南* 中的[创建任务定义](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html)。
**重要**  
Amazon ECS 的标准部署操作会根据 Amazon ECS 服务使用的修订版 CodePipeline 创建自己的任务定义修订版。如果您在不更新 Amazon ECS 服务的情况下为任务定义创建新的修订，则部署操作将忽略这些修订。

  以下是本教程中使用的一个任务定义示例。您对 `name` 和 `family` 使用的值将在下一步中用于构建规范文件。

  ```
  {
    "ipcMode": null,
    "executionRoleArn": "role_ARN",
    "containerDefinitions": [
      {
        "dnsSearchDomains": null,
        "environmentFiles": null,
        "logConfiguration": {
          "logDriver": "awslogs",
          "secretOptions": null,
          "options": {
            "awslogs-group": "/ecs/hello-world",
            "awslogs-region": "us-west-2",
            "awslogs-stream-prefix": "ecs"
          }
        },
        "entryPoint": null,
        "portMappings": [
          {
            "hostPort": 80,
            "protocol": "tcp",
            "containerPort": 80
          }
        ],
        "command": null,
        "linuxParameters": null,
        "cpu": 0,
        "environment": [],
        "resourceRequirements": null,
        "ulimits": null,
        "dnsServers": null,
        "mountPoints": [],
        "workingDirectory": null,
        "secrets": null,
        "dockerSecurityOptions": null,
        "memory": null,
        "memoryReservation": 128,
        "volumesFrom": [],
        "stopTimeout": null,
        "image": "image_name",
        "startTimeout": null,
        "firelensConfiguration": null,
        "dependsOn": null,
        "disableNetworking": null,
        "interactive": null,
        "healthCheck": null,
        "essential": true,
        "links": null,
        "hostname": null,
        "extraHosts": null,
        "pseudoTerminal": null,
        "user": null,
        "readonlyRootFilesystem": null,
        "dockerLabels": null,
        "systemControls": null,
        "privileged": null,
        "name": "hello-world"
      }
    ],
    "placementConstraints": [],
    "memory": "2048",
    "taskRoleArn": null,
    "compatibilities": [
      "EC2",
      "FARGATE"
    ],
    "taskDefinitionArn": "ARN",
    "family": "hello-world",
    "requiresAttributes": [],
    "pidMode": null,
    "requiresCompatibilities": [
      "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "1024",
    "revision": 1,
    "status": "ACTIVE",
    "inferenceAccelerators": null,
    "proxyConfiguration": null,
    "volumes": []
  }
  ```
+ 一个 Amazon ECS 集群，该集群运行着一项使用前述任务定义的服务。有关更多信息，请参阅 *Amazon Elastic Container Service 开发者指南* 中的[创建集群](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html)和[创建服务](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html)。

在满足这些先决条件后，您可以继续完成本教程并创建您的 CD 管道。

## 步骤 1：将构建规范文件添加至您的源存储库
<a name="cd-buildspec"></a>

本教程用于 CodeBuild 构建 Docker 镜像并将镜像推送到 Amazon ECR。将 `buildspec.yml` 文件添加至您的源代码存储库以指示 CodeBuild 如何执行此操作。下面的示例构建规范将执行以下操作：
+ 构建前阶段：
  + 登录 Amazon ECR。
  + 将存储库 URI 设置为您的 ECR 映像并添加包含源的 Git 提交 ID 的前七个字符的映像标签。
+ 构建阶段：
  + 构建 Docker 映像并使用 Git 提交 ID 将该映像标记为 `latest`。
+ 构建后阶段：
  + 使用两个标签将该映像推送至 ECR 存储库。
  + 在根目录中编写一个称为 `imagedefinitions.json` 文件，其中包含您的 Amazon ECS 服务的容器名称以及映像和标签。您的 CD 管道的部署阶段将使用此信息来创建您的服务的任务定义的新修订，然后它会将该服务更新为使用此新任务定义。ECS 作业辅助角色需要 `imagedefinitions.json` 文件。

粘贴此示例文本以创建您的 `buildspec.yml` 文件，然后替换映像和任务定义的值。此文本使用示例账户 ID 111122223333。

```
version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json
```

构建规范为[先决条件](#ecs-cd-prereqs)中提供的示例任务定义而编写，本教程中的 Amazon ECS 服务使用了该定义。`REPOSITORY_URI` 值对应于 `image` 存储库 (没有任何映像标签)，此文件末尾附近的 `hello-world` 值对应于该服务的任务定义中的容器名称。

**将 `buildspec.yml` 文件添加至您的源存储库**

1. 打开文本编辑器，然后将上述构建规范复制并粘贴到新文件中。

1. 将 `REPOSITORY_URI` 值 (`012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world`) 替换为您的 Docker 映像的 Amazon ECR 存储库 URI（无任何映像标签）。将 `hello-world` 替换为引用您的 Docker 映像的服务的任务定义中的容器名称。

1. 提交您的 `buildspec.yml` 文件并将其推送至源存储库。

   1. 添加文件。

      ```
      git add .
      ```

   1. 提交更改。

      ```
      git commit -m "Adding build specification."
      ```

   1. 推送提交。

      ```
      git push
      ```

## 步骤 2：创建持续部署管道
<a name="pipeline-wizard"></a>

使用向 CodePipeline 导创建管道阶段并将源存储库连接到 ECS 服务。

**创建管道**

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

1. 在 **Welcome** 页面上，选择 **Create pipeline**。

   如果这是您第一次使用 CodePipeline，则会显示介绍性页面，而不是 “**欢迎**”。选择 **Get Started Now (立即开始)**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入管道的名称。在本教程中，管道名称为 **hello-world**。

1. 在**管道类型**中，保留默认选择 **V2**。管道类型有不同的特点和价格。有关更多信息，请参阅 [管道类型](pipeline-types.md)。选择**下一步**。

1. 在 “**步骤 3：添加源舞台**” 页面上，对于**源提供者**，选择** AWS CodeCommit**。

   1. 对于**存储库名称**，选择要用作您的管道的源位置的 CodeCommit 存储库的名称。

   1. 对于 **Branch name (分支名称)**，选择要使用的分支，然后选择 **Next (下一步)**。

1. 在 “**步骤 4：添加构建阶段**” 页面上，选择 “**生成提供者**” **AWS CodeBuild**，然后选择 “**创建项目**”。

   1. 对于 **Project name**，为您的构建项目选择唯一名称。在本教程中，项目名称为 **hello-world**。

   1. 对于**环境映像**，选择**托管映像**。

   1. 对于**操作系统**，选择 **Amazon Linux 2**。

   1. 对于**运行时**，选择**标准**。

   1. 对于**映像**，请选择 **`aws/codebuild/amazonlinux2-x86_64-standard:3.0`**。

   1. 对于 **Image version (映像版本)** 和 **Environment type (环境类型)**，请使用默认值。

   1. 选择**如果要构建 Docker 映像或希望您的构建获得提升的特权，请启用此标志**。

   1. 取消选择**CloudWatch 日志**。您可能需要展开**高级**。

   1. 选择 “**继续” CodePipeline**。

   1. 选择**下一步**。
**注意**  
该向导会为您的生成项目创建一个名为 **codebuild-service *build-project-name*-role** 的 CodeBuild 服务角色。记下此角色名称，因为稍后您要向该角色添加 Amazon ECR 权限。

1. 在 “**步骤 5：添加部署阶段**” 页面上，对于**部署提供商**，选择 **Amazon ECS**。

   1. 对于**集群名称**，请选择在其中运行您的服务的 Amazon ECS 集群。在本教程中，该集群为 **default**。

   1. 对于 **Service name (服务名称)**，选择要更新的服务，然后选择 **Next (下一步)**。在本教程中，服务名称为 **hello-world**。

1. 在 **Step 6: Review** 页面上，审查您的管道配置，然后选择 **Create pipeline** 以创建管道。
**注意**  
既然管道已创建好，它将尝试经历不同的管道阶段。但是，向导创建的默认 CodeBuild 角色没有权限执行`buildspec.yml`文件中包含的所有命令，因此生成阶段将失败。下一部分将为构建阶段添加权限。

## 步骤 3：为角色添加 Amazon ECR 权限 CodeBuild
<a name="code-build-perms"></a>

该 CodePipeline 向导为 CodeBuild 构建项目创建了一个名为 **codebuild-service *build-project-name*-** role 的 IAM 角色。在本教程中，名称为 **codebuild-hello-world-service-role。**由于 `buildspec.yml` 文件会调用 Amazon ECR API 操作，因此该角色必须具有授权进行这些 Amazon ECR 调用的策略。以下过程帮助您将适当权限附加到该角色。

**向角色添加 Amazon ECR 权限 CodeBuild**

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

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

1. 在搜索框中，键入 **codebuild-**，然后选择 CodePipeline 向导创建的角色。在本教程中，角色名称为 **codebuild-hello-world-service-role**。

1. 在 **Summary (摘要)** 页面上，选择 **Attach policies (附加策略)**。

1. 选中 **Amazon EC2 ContainerRegistryPowerUser** 政策左侧的复选框，然后选择**附加政策**。

## 步骤 4：测试您的管道
<a name="commit-change"></a>

您的管道应该具备运行 end-to-end原生 AWS 持续部署所需的一切。现在，通过将代码更改推送至您的源存储库来测试管道的功能。

**测试您的管道**

1. 对您的已配置源存储库进行代码更改，然后提交并推送更改。

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

1. 从列表中选择您的管道。

1. 监视管道经历不同阶段的进度。您的管道应完成且您的 Amazon ECS 服务运行通过您的代码更改创建的 Docker 映像。

# 教程：使用 Amazon ECR 源和 ECS-to-CodeDeploy部署创建管道
<a name="tutorials-ecs-ecr-codedeploy"></a>

在本教程中，您将配置一个管道， AWS CodePipeline 该管道使用支持 Docker 映像的 blue/green 部署部署来部署容器应用程序。在蓝/绿部署中，您可以在运行旧版本应用程序的同时启动新版本应用程序，并在重新路由流量之前测试新版本。您还可以监控部署流程并且在存在问题的情况下迅速回滚。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
本教程适用于 Amazon ECS 的 CodeDeploy 蓝/绿部署操作。 CodePipeline有关使用中的 Amazon ECS 标准部署操作的教程 CodePipeline，请参阅[教程：使用 Amazon ECS 标准部署 CodePipeline](ecs-cd-pipeline.md)。

已完成的管道会检测您的映像的更改，该图像存储在映像存储库（例如 Amazon ECR）中，并用于 CodeDeploy 将流量路由和部署到 Amazon ECS 集群和负载均衡器。 CodeDeploy 使用侦听器将流量重新路由到 AppSpec 文件中指定的已更新容器的端口。有关如何在 blue/green 部署中使用负载均衡器、生产侦听器、目标组和您的 Amazon ECS 应用程序的信息，请参阅[教程：部署 Amazon ECS 服务](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html)。

管道还配置为使用存储您的 Amazon ECS 任务定义的源位置，例如。 CodeCommit在本教程中，您将配置这些 AWS 资源中的每一个，然后创建包含每种资源操作的阶段的管道。

在源代码发生更改时或者新基本映像上传到 Amazon ECR 时，您的持续交付管道将自动构建和部署容器映像。

此流程使用以下项目：
+ 一个 Docker 映像文件，该文件指定容器名称和 Amazon ECR 映像存储库的存储库 URI。
+ 一个 Amazon ECS 任务定义，该定义列出您的 Docker 映像名称、容器名称、Amazon ECS 服务名称和负载均衡器配置。
+ 一个 CodeDeploy AppSpec 文件，它指定 Amazon ECS 任务定义文件的名称、更新的应用程序容器的名称以及 CodeDeploy重新路由生产流量的容器端口。它还可以指定可选的网络配置以及您在部署生命周期事件挂钩期间可运行的 Lambda 函数。

**注意**  
当您把更改提交到 Amazon ECR 映像存储库时，管道源操作会为该提交创建 `imageDetail.json` 文件。有关 `imageDetail.json` 文件的信息，请参阅[用于亚马逊 ECS 部署操作的 imageDetail.json 文件 blue/green](file-reference.md#file-reference-ecs-bluegreen)。

在创建或编辑管道和更新或指定部署阶段更新或指定源项目时，请确保指向要使用的带最新名称和版本的源项目。在设置管道后，在对映像或任务定义进行更改时，您可能需要更新存储库中的源项目文件，然后在管道中编辑部署阶段。

**Topics**
+ [先决条件](#tutorials-ecs-ecr-codedeploy-prereq)
+ [步骤 1：创建映像并推送至 Amazon ECR 存储库](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [第 2 步：创建任务定义和 AppSpec 源文件并推送到 CodeCommit 存储库](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [步骤 3：创建您的应用程序负载均衡器和目标组](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [步骤 4：创建您的 Amazon ECS 集群和服务](#tutorials-ecs-ecr-codedeploy-cluster)
+ [步骤 5：创建您的 CodeDeploy 应用程序和部署组（ECS 计算平台）](#tutorials-ecs-ecr-codedeploy-deployment)
+ [步骤 6：创建管道](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [步骤 7：对您的管道进行更改并验证部署](#tutorials-ecs-ecr-codedeploy-update)

## 先决条件
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

您必须已创建以下资源：
+ 存储 CodeCommit 库。您可以使用您在中创建的 AWS CodeCommit 存储库[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 启动 Amazon EC2 Linux 实例并安装 Docker 以创建映像，如本教程中所示。如果您已有要使用的映像，则可以跳过此先决条件。

## 步骤 1：创建映像并推送至 Amazon ECR 存储库
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

在本节中，您将使用 Docker 创建映像，然后使用创建 Amazon ECR 存储库并将该映像推送到存储库。 AWS CLI 

**注意**  
如果您已有要使用的映像，则可以跳过此步骤。

**创建镜像**

1. 登录到已安装 Docker 的 Linux 实例。

   下拉 `nginx` 的映像。此命令提供 `nginx:latest` 映像：

   ```
   docker pull nginx
   ```

1. 运行 **docker images**。您将在列表中看到该映像。

   ```
   docker images
   ```

**创建 Amazon ECR 存储库并推送映像**

1. 创建用于存储您的 映像的 Amazon ECR 存储库。记下输出中的 `repositoryUri`。

   ```
   aws ecr create-repository --repository-name nginx
   ```

   输出：

   ```
   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }
   ```

1. 使用上一步中的 `repositoryUri` 值标记映像。

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. 运行 **aws ecr get-login-password** 命令，如 `us-west-2` 区域和 111122223333 账户 ID 的此示例中所示。

   ```
   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx
   ```

1. 使用上一步中的 `repositoryUri` 将映像推送至 Amazon ECR。

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

## 第 2 步：创建任务定义和 AppSpec 源文件并推送到 CodeCommit 存储库
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

在此部分中，您将创建一个任务定义 JSON 文件并将该文件注册到 Amazon ECS。然后，您可以为创建 AppSpec 文件 CodeDeploy 并使用 Git 客户端将这些文件推送到您的 CodeCommit 存储库。

**为您的映像创建任务定义**

1. 使用以下内容创建名为 `taskdef.json` 的文件。对于 `image`，输入您的映像名称，如 nginx。此值会在管道运行时进行更新。
**注意**  
请确保在任务定义中指定的执行角色包含 `AmazonECSTaskExecutionRolePolicy`。有关更多信息，请参阅 *Amazon ECS 开发者指南* 中的 [Amazon ECS 任务执行 IAM 角色](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)。

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

1. 使用 `taskdef.json` 文件注册任务定义。

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

1. 注册任务定义后，编辑您的文件以删除映像名称并将 `<IMAGE1_NAME>` 占位符文本包含在映像字段中。

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

**创建 AppSpec 文件**
+ 该 AppSpec 文件用于 CodeDeploy 部署。该文件（包含可选字段）使用以下格式：

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"
  ```

  有关该 AppSpec 文件的更多信息（包括示例），请参阅[CodeDeploy AppSpec 文件引用](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。

  使用以下内容创建名为 `appspec.yaml` 的文件。对于 `TaskDefinition`，请勿更改 `<TASK_DEFINITION>` 占位符文本。此值会在管道运行时进行更新。

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80
  ```

**将文件推送到您的 CodeCommit 存储库**

1. 将文件推送或上传到您的 CodeCommit 存储库。这些文件是由**创建管道**向导针对您在 CodePipeline 中的部署操作创建的源构件。您的文件在本地目录中应如下所示：

   ```
   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json
   ```

1. 选择要用于上传文件的方法：

   1. 在本地计算机上从克隆的存储库使用 Git 命令行：

      1. 将目录更改为本地存储库：

         ```
         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo
         ```

      1. 运行以下命令以立即暂存您的所有文件：

         ```
         git add -A
         ```

      1. 运行以下命令以提交带有提交消息的文件：

         ```
         git commit -m "Added task definition files"
         ```

      1. 运行以下命令将本地存储库中的文件推送到存储 CodeCommit 库：

         ```
         git push
         ```

   1. 要使用 CodeCommit 控制台上传文件，请执行以下操作：

      1. 打开 CodeCommit 控制台，然后从 “存储库” 列表中选择您的**存储库**。

      1. 选择**添加文件**，然后选择**上传文件**。

      1. 选择**选择文件**，然后浏览以找到您的文件。通过输入您的用户名和电子邮件地址来提交更改。选择**提交更改**。

      1. 对要上传的每个文件重复此步骤。

## 步骤 3：创建您的应用程序负载均衡器和目标组
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

在此部分中，您将创建一个 Amazon EC2 应用程序负载均衡器。在创建 Amazon ECS 服务时，您可以使用稍后将通过负载均衡器创建的子网名称和目标组值。您可以创建应用程序负载均衡器或网络负载均衡器。负载均衡器必须使用在不同的可用区中具有两个公有子网的 VPC。在这些步骤中，您将确认您的默认 VPC，创建负载均衡器，然后为负载均衡器创建两个目标组。有关更多信息，请参阅[您的网络负载均衡器的目标组](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html)。

**验证您的默认 VPC 和公有子网**

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

1. 验证要使用的默认 VPC。在导航窗格中，选择**您的 VPCs**。请注意哪个 VPC 在**默认 VPC** 列中显示为**是**。这是默认 VPC。它包含可供您选择的默认子网。

1. 选择**子网**。选择两个在**默认子网**列中显示**是**的子网。
**注意**  
记下您的子网 IDs。本教程后面将会用到这些 ID。

1. 选择子网，然后选择**描述**选项卡。验证要使用的子网是否位于不同的可用区中。

1. 选择子网，然后选择**路由表**选项卡。为了验证要使用的每个子网是否为公有子网，请确认网关行包含在路由表中。

**创建 Amazon EC2 应用程序负载均衡器**

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

1. 在导航窗格中，选择**负载均衡器**。

1. 选择 **Create Load Balancer（创建负载均衡器）**。

1. 选择 **Application Load Balancer（应用程序负载均衡器）**，然后选择 **Create（创建）**。

1. 在 **Name（名称）**中，输入负载均衡器的名称。

1. 在 **Scheme（模式）**中，选择 **internet-facing（面向 internet）**。

1. 在 **IP 地址类型**中，选择 **ipv4**。

1. 为您的负载均衡器配置两个侦听器端口：

   1. 在**负载均衡器协议**下，选择 **HTTP**。在**负载均衡器端口**下，输入 **80**。

   1. 选择**添加侦听器**。

   1. 在第二个侦听器的**负载均衡器协议**下，选择 **HTTP**。在 **Load Balancer Port（负载均衡器端口）**下，输入 **8080**。

1. 在**可用区**下，在 **VPC** 中，选择默认 VPC。接下来，选择要使用的两个默认子网。

1. 选择**下一步：配置安全设置**。

1. 选择**下一步：配置安全组**。

1. 选择**选择现有安全组**，然后记下安全组 ID。

1. 选择**下一步：配置路由**。

1. 在**目标组**中，选择**新建目标组**并配置您的第一个目标组：

   1. 在**名称**中，输入目标组名称（例如，**target-group-1**）。

   1. 在 **Target type（目标类型）**中，选择 **IP**。

   1. 在 **Protocol（协议）**中，选择 **HTTP**。在 **Port（端口）**中，输入 **80**。

   1. 选择**下一步：注册目标**。

1. 选择 **Next: Review（下一步：审核）**，然后选择 **Create（创建）**。

**为您的负载均衡器创建第二个目标组**

1. 在预配置您的负载均衡器后，打开 Amazon EC2 控制台。在导航窗格中，选择**目标组**。

1. 选择**创建目标组**。

1. 在 **Name（名称）**中，输入目标组名称（例如，**target-group-2**）。

1. 在 **Target type（目标类型）**中，选择 **IP**。

1. 在 **Protocol（协议）**中，选择 **HTTP**。在 **Port（端口）**中，输入 **8080**。

1. 在 **VPC** 中，选择默认 VPC。

1. 选择**创建**。
**注意**  
要使部署运行，您必须为您的负载均衡器创建了两个目标组。您只需记下第一个目标组的 ARN。在下一步中，此 ARN 将用于 `create-service` JSON 文件。

**更新您的负载均衡器以包含第二个目标组**

1. 打开 Amazon EC2 控制台。在导航窗格中，选择**负载均衡器**。

1. 选择您的负载均衡器，然后选择**侦听器**选项卡。选择具有端口 8080 的侦听器，然后选择**编辑**。

1. 选择**转发至**旁的铅笔图标。选择您的第二个目标组，然后选择复选标记。选择**更新**以保存更新。

## 步骤 4：创建您的 Amazon ECS 集群和服务
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

在本节中，您将创建一个 Amazon ECS 集群和服务，用于在部署期间 CodeDeploy 路由流量（到 Amazon ECS 集群而不是 EC2 实例）。要创建 Amazon ECS 服务，您必须使用通过负载均衡器创建的子网名称、安全组和目标组值来创建服务。

**注意**  
使用这些步骤创建 Amazon ECS 集群时，您将使用**仅限联网**的集群模板，该模板预配置 AWS Fargate 容器。 AWS Fargate 是一项为您管理容器实例基础设施的技术。您不需要为 Amazon ECS 集群选择或手动创建 Amazon EC2 实例。

**要创建 Amazon ECS 集群**

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

1. 在导航窗格中，选择**集群**。

1. 选择**创建集群**。

1. 选择使用 AWS Fargate 的**仅限联网**集群模板，然后选择**下一步**。

1. 在**配置集群**页面上，输入集群名称。您可以为资源添加可选标签。选择**创建**。

**创建 Amazon ECS 服务**

使用在 AWS CLI Amazon ECS 中创建您的服务。

1. 创建一个 JSON 文件并将其命名为 `create-service.json`。将以下内容粘贴到 JSON 文件中。

   对于 `taskDefinition` 字段，当您在 Amazon ECS 中注册任务定义时，请提供一个系列。这类似于使用修订号指定的任务定义的多个版本的名称。在此示例中，对文件中的系列和修订号使用“`ecs-demo:1`”。使用您在[步骤 3：创建您的应用程序负载均衡器和目标组](#tutorials-ecs-ecr-codedeploy-loadbal)中随负载均衡器创建的子网名称、安全组和目标组值。
**注意**  
您需要在此文件中包含您的目标组 ARN。打开 Amazon EC2 控制台，然后在导航窗格中的**负载均衡**下，选择**目标组**。选择您的第一个目标组。从**描述**选项卡复制您的 ARN。

   ```
   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }
   ```

1. 运行 **create-service** 命令，并指定 JSON 文件：
**重要**  
务必在文件名前包含 `file://`。此命令中需要该项。

   此示例创建一个名为 `my-service` 的服务。
**注意**  
此示例命令创建一个名为 my-service 服务。如果您已有一个具有该名称的服务，则命令会返回错误。

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   输出将返回您的服务的描述字段。

1. 运行 **describe-services** 命令以验证是否已创建您的服务。

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## 步骤 5：创建您的 CodeDeploy 应用程序和部署组（ECS 计算平台）
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

当您为 Amazon ECS 计算平台创建 CodeDeploy 应用程序和部署组时，将在部署期间使用该应用程序来引用正确的部署组、目标组、侦听器和流量重新路由行为。

**创建 CodeDeploy 应用程序**

1. 打开 CodeDeploy 控制台并选择**创建应用程序**。

1. 在**应用程序名称**中，输入要使用的名称。

1. 在**计算平台**中，选择 **Amazon ECS**。

1. 选择**创建应用程序**。

**创建 CodeDeploy 部署组**

1. 在应用程序页面的**部署组**选项卡上，选择**创建部署组**。

1. 在**部署组名称**中，输入一个描述部署组的名称。

1. 在**服务角色**中，选择一个授予 CodeDeploy对 Amazon ECS 访问权限的服务角色。若要创建新的服务角色，请按照以下步骤操作：

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

   1. 在控制台控制面板中，选择**角色**。

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

   1. 在**选择受信任实体的类型**下，选择 **AWS 服务**。在 **“选择用例**” 下，选择**CodeDeploy**。在 **“选择您的用例**” 下，选择 **CodeDeploy -ECS**。选择**下一步: 权限**。`AWSCodeDeployRoleForECS` 托管策略已附加到角色。

   1. 选择**下一步：标签**，然后选择**下一步：审核**。

   1. 输入角色的名称（例如 **CodeDeployECSRole**），然后选择**创建角色**。

1. 在**环境配置**中，选择 Amazon ECS 集群名称和服务名称。

1. 从**负载均衡器**中，选择将流量提供给 Amazon ECS 服务的负载均衡器的名称。

1. 在**生产侦听器端口**中，选择将生产流量路由至您的 Amazon ECS 服务的侦听器的端口和协议。在**测试侦听器端口**中，选择测试侦听器的端口和协议。

1. 从**目标组 1 名称**和**目标组 2 名称**中，选择用于在部署期间路由流量的目标组。请确保它们是您为负载均衡器创建的目标组。

1. 选择**立即重新路由流量**以确定成功部署后将流量重新路由到更新后的 Amazon ECS 任务的时长。

1. 选择 **Create deployment group（创建部署组）**。

## 步骤 6：创建管道
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一种 CodeCommit 操作，其中源对象是任务定义和 AppSpec 文件。
+ 一个带 Amazon ECR 源操作的源阶段，其中源构件是映像文件。
+ 具有 Amazon ECS 部署操作的部署阶段，其中部署与 CodeDeploy 应用程序和部署组一起运行。

**使用向导创建两阶段管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyImagePipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **AWS CodeCommit**。在 **Repository name (存储库名称)** 中，选择您在[步骤 1：创建 CodeCommit 存储库](tutorials-simple-codecommit.md#codecommit-create-repository)中创建的 CodeCommit 存储库的名称。在**分支名称**中，选择包含最新的代码更新的分支的名称。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中：

   1. 在**部署提供商**中，选择 **Amazon ECS（蓝/绿）**。在**应用程序名称**中，输入应用程序名称或从列表中选择应用程序名称，例如 `codedeployapp`。在**部署组**中，输入部署组名称或从列表中选择部署组名称，例如 `codedeploydeplgroup`。

       
**注意**  
名称“Deploy”是在 **步骤 4：部署**步骤中创建的阶段的默认名称，正如“Source”是管道第一阶段的名称一样。

   1. 在 **Amazon ECS 任务定义**下，选择**SourceArtifact**。在字段中，输入 **taskdef.json**。

   1. 在 “**AWS CodeDeploy AppSpec 文件**” 下，选择**SourceArtifact**。在字段中，输入 **appspec.yaml**。
**注意**  
此时，请不要在**动态更新任务定义映像**下填写任何信息。

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

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

**向管道添加 Amazon ECR 源操作**

查看您的管道并向其添加 Amazon ECR 源操作。

1. 选择您的管道。在左上方，选择**编辑**。

1. 在源阶段中，选择**编辑阶段**。

1. 选择 CodeCommit 源操作旁边的 **\$1 添加动作**，即可添加并行动作。

1. 在**操作名称**中，输入名称（例如 **Image**）。

1. 在**操作提供程序**中，选择 **Amazon ECR**。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/ECR-source-action.png)

1. 在**存储库名称**中，选择 Amazon ECR 存储库的名称。

1. 在**映像标签**中，指定映像名称和版本（如果与最新版本不同）。

1. 在**输出构件**中，选择默认输出构件（例如 `MyImage`），其中包含您希望下一阶段使用的映像名称和存储库 URI 信息。

1. 在操作屏幕上选择**保存**。在阶段屏幕上选择**完成**。在管道上选择**保存**。一条消息显示了要为 Amazon CloudWatch ECR 源操作创建的 Amazon Events 规则。

**将您的源构件连接到部署操作**

1. 在部署阶段上选择**编辑**，然后选择图标以编辑 **Amazon ECS（蓝色/绿色）**操作。

1. 滚动到窗格底部。在**输入项目**中，选择**添加**。从您的新 Amazon ECR 存储库（例如，`MyImage`）添加源构件。

1. 在 “**任务定义**” 中 **SourceArtifact**，选择，然后输入验证**taskdef.json**。

1. 在**AWS CodeDeploy AppSpec 文件**中 **SourceArtifact**，选择，然后输入验证**appspec.yaml**信息。

1. 在**动态更新任务定义图像**中，在**带图像 URI 的 Input Ar** tifact 中 **MyImage**，选择，然后输入`taskdef.json`文件中使用的占位符文本：** IMAGE1\$1NAME**。选择**保存**。

1. 在 AWS CodePipeline 窗格中，选择 “**保存管道更改**”，然后选择 “**保存更改**”。查看已更新的管道。

   创建此示例管道后，控制台条目的操作配置按如下所示在管道结构中显示：

   ```
   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   ```

1. 要提交所做的更改并开始管道构建，请选择**发布更改**，然后选择**发布**。

1. 选择要查看的部署操作 CodeDeploy 并查看流量转移的进度。
**注意**  
您可能会看到一个部署步骤，显示可选的等待时间。默认情况下，在成功部署后 CodeDeploy 等待一小时才终止原始任务集。您可以利用此时间回滚或终止任务，但在任务集终止时，您的部署也会完成。

## 步骤 7：对您的管道进行更改并验证部署
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

对您的映像进行更改，然后将更改推送至您的 Amazon ECR 存储库。这将触发您的管道运行。验证是否已部署您的映像源更改。

# 教程：创建部署 Amazon Alexa 技能的管道
<a name="tutorials-alexa-skills-kit"></a>

在本教程中，您将使用 Alexa Skills Kit 作为部署阶段中的部署提供程序来配置一个连续提供 Alexa 技能的管道。当您对源存储库中的源文件进行更改时，已完成的管道会检测对您的技能所做的更改。然后，管道使用 Alexa Skills Kit 部署到 Alexa 技能开发阶段。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
此功能在亚太地区（香港）或欧洲地区（米兰）区域不可用。要使用该区域可用的其他部署操作，请参阅[部署操作集成](integrations-action-type.md#integrations-deploy)。

要将您的自定义技能创建为 Lambda 函数，请参阅将[自定义技能作为 Lambda AWS 函数托管](https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html)。您还可以创建一个使用 Lambda 源文件的管道和一个用于为您的技能部署对 Lambda 的更改的 CodeBuild 项目。

## 先决条件
<a name="tutorials-alexa-skills-kit-prereq"></a>

您必须已经具备以下各项：
+ 存储 CodeCommit 库。您可以使用您在中创建的 AWS CodeCommit 存储库[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 一个 Amazon 开发人员账户。此账户拥有您的 Alexa 技能。您可以在 [Alexa Skills Kit](https://developer.amazon.com/alexa-skills-kit) 免费创建一个账户。
+ 一个 Alexa 技能。您可以使用[获取自定义技能示例代码](https://developer.amazon.com/docs/custom-skills/use-the-alexa-skills-kit-samples.html)教程创建示例技能。
+ 安装 ASK CLI，并将 `ask init` 与您的 AWS 凭证结合使用来配置它。请参阅[安装和初始化 ASK CLI](https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize)。

## 步骤 1：创建 Alexa 开发人员服务 LWA 安全配置文件
<a name="tutorials-alexa-skills-kit-profile"></a>

在本节中，您将创建一个要与 Login with Amazon（LWA）一起使用的安全配置文件。如果您已有配置文件，可跳过本步骤。
+ 使用[generate-lwa-tokens](https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens)中的步骤来创建安全配置文件。
+ 在您创建配置文件后，请记下**客户端 ID** 和**客户端密钥**。
+ 请务必按照说明中的规定输入 “**允许退货 URLs**”。 URLs 允许 ASK CLI 命令重定向刷新令牌请求。

## 第 2 步：创建 Alexa 技能源文件并推送到你的 CodeCommit 存储库
<a name="tutorials-alexa-skills-kit-push"></a>

在本节中，您将创建 Alexa 技能源文件并将其推送到管道用于源阶段的存储库。对于您在 Amazon 开发人员控制台中创建的技能，您可以生成并推送以下内容：
+ 一个 `skill.json` 文件。
+ 一个 `interactionModel/custom` 文件夹。
**注意**  
此目录结构符合 Alexa Skills Kit 技能包格式要求，如[技能包格式](https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format)中所述。如果您的目录结构未使用正确的技能包格式，则更改不会成功部署到 Alexa Skills Kit 控制台。

**为您的技能创建源文件**

1. 从 Alexa Skills Kit 开发人员控制台中检索您的技能 ID。使用此命令：

   ```
   ask api list-skills
   ```

   按名称查找您的技能，然后在 `skillId` 字段中复制关联的 ID。

1. 生成一个 `skill.json` 文件，其中包含您的技能详细信息。使用此命令：

   ```
   ask api get-skill -s skill-ID > skill.json
   ```

1. （可选）创建一个 `interactionModel/custom` 文件夹。

   使用此命令可在文件夹中生成交互模型文件。对于区域设置，本教程使用 en-US 作为文件名中的区域设置。

   ```
   ask api get-model --skill-id skill-ID --locale locale >
       ./interactionModel/custom/locale.json
   ```

**将文件推送到您的 CodeCommit 存储库**

1. 将文件推送或上传到您的 CodeCommit 存储库。这些文件是由**创建管道**向导针对您在 AWS CodePipeline中的部署操作创建的源项目。您的文件在本地目录中应如下所示：

   ```
   skill.json
   /interactionModel
     /custom
       |en-US.json
   ```

1. 选择要用于上传文件的方法：

   1. 在本地计算机上从克隆的存储库使用 Git 命令行：

      1. 运行以下命令以立即暂存您的所有文件：

         ```
         git add -A
         ```

      1. 运行以下命令以提交带有提交消息的文件：

         ```
         git commit -m "Added Alexa skill files"
         ```

      1. 运行以下命令将本地存储库中的文件推送到存储 CodeCommit 库：

         ```
         git push
         ```

   1. 要使用 CodeCommit 控制台上传文件，请执行以下操作：

      1. 打开 CodeCommit 控制台，然后从 “存储库” 列表中选择您的**存储库**。

      1. 选择**添加文件**，然后选择**上传文件**。

      1. 选择**选择文件**，然后浏览以找到您的文件。通过输入您的用户名和电子邮件地址来提交更改。选择**提交更改**。

      1. 对要上传的每个文件重复此步骤。

## 步骤 3：使用 ASK CLI 命令来创建刷新令牌
<a name="tutorials-alexa-skills-kit-token"></a>

CodePipeline 根据您的亚马逊开发者账户中的客户端 ID 和密钥使用刷新令牌来授权其代表您执行的操作。在本节中，您将使用 ASK CLI 来创建令牌。您将在使用**创建管道**向导时使用这些凭证。

**使用您的 Amazon 开发人员账户凭据创建刷新令牌**

1. 使用以下命令：

   ```
   ask util generate-lwa-tokens
   ```

1. 在系统提示时，输入您的客户端 ID 和密钥，如下例所示：

   ```
   ? Please type in the client ID: 
   amzn1.application-client.example112233445566
   ? Please type in the client secret:
   example112233445566
   ```

1. 将显示登录浏览器页面。使用 Amazon 开发人员账户凭证进行登录。

1. 返回到命令行屏幕。会在输出中生成访问令牌和刷新令牌。复制在输出中返回的刷新令牌。

## 步骤 4：创建管道
<a name="tutorials-alexa-skills-kit-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个源舞台，其 CodeCommit 动作源工件是支持你技能的 Alexa 技能文件。
+ 具有 Alexa Skills Kit 部署操作的部署阶段。

**使用向导创建管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 选择要在其中创建项目及其资源的 AWS 区域。Alexa 技能运行时仅在以下区域可用：
   + 亚太地区（东京）
   + 欧洲地区（爱尔兰）
   + 美国东部（弗吉尼亚州北部）
   + 美国西部（俄勒冈州）

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyAlexaPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **AWS CodeCommit**。在**存储库名称**中，选择您在中创建的 CodeCommit 存储库的名称[步骤 1：创建 CodeCommit 存储库](tutorials-simple-codecommit.md#codecommit-create-repository)。在**分支名称**中，选择包含最新的代码更新的分支的名称。

   选择存储库名称和分支后，将显示一条消息，显示要为此管道创建的 Amazon Ev CloudWatch ents 规则。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中：

   1. 在**部署提供程序**中，选择 **Alexa Skills Kit**。

   1. 在 **Alexa skill ID** 中，输入在 Alexa Skills Kit 开发人员控制台中分配给您的技能的技能 ID。

   1. 在**客户端 ID** 中，输入您注册的应用程序的 ID。

   1. 在**客户端密钥**中，输入您在注册时选择的密钥。

   1. 在**刷新令牌**中，输入您在步骤 3 中生成的令牌。  
![\[步骤 6：Alexa 技能套件操作的部署页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/alexa-deploy.png)

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

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

## 步骤 5：对任何源文件进行更改并验证部署
<a name="tutorials-alexa-skills-kit-update"></a>

对您的技能进行更改，然后将更改推送至您的存储库。这将触发您的管道运行。验证您的技能已在 [Alexa Skills Kit 开发人员控制台](https://developer.amazon.com/alexa/console/ask)中更新。

# 教程：创建以 Amazon S3 作为部署提供程序的管道
<a name="tutorials-s3deploy"></a>

在本教程中，您将使用 Amazon S3 作为部署阶段中的部署操作提供程序来配置连续交付文件的管道。完成的管道会在您对源存储库中的源文件进行更改时检测更改。然后，管道使用 Amazon S3 将文件部署到您的桶。每次在源位置修改或添加网站文件时，部署都会使用最新文件创建网站。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
即使您从源存储库中删除文件，S3 部署操作也不会删除与已删除文件对应的 S3 对象。

本教程提供了两个选项：
+ 创建一个管道，用于将静态网站部署到您的 S3 公有存储桶。此示例创建了一个包含 AWS CodeCommit 源操作和 Amazon S3 部署操作的管道。请参阅[选项 1：将静态网站文件部署到 Amazon S3](#tutorials-s3deploy-acc)。
+ 创建一个管道，该管道将示例 TypeScript 代码编译到您的 S3 存储桶中， JavaScript 并将 CodeBuild 输出项目部署到您的 S3 存储桶中进行存档。此示例创建了一个包含 Amazon S3 源操作、 CodeBuild 构建操作和 Amazon S3 部署操作的管道。请参阅[选项 2：将构建的存档文件从 S3 源桶部署到 Amazon S3。](#tutorials-s3deploy-s3source)。

**重要**  
在此过程中，您在管道中添加的许多操作都涉及在创建管道之前需要创建的 AWS 资源。 AWS 源操作的资源必须始终在您创建管道的同一 AWS 区域创建。例如，如果您在美国东部（俄亥俄州）地区创建管道，则您的 CodeCommit 存储库必须位于美国东部（俄亥俄州）区域。  
您可以在创建管道时添加跨区域操作。 AWS 跨区域操作的资源必须位于您计划执行操作的同一 AWS 区域。有关更多信息，请参阅 [在中添加跨区域操作 CodePipeline](actions-create-cross-region.md)。

## 选项 1：将静态网站文件部署到 Amazon S3
<a name="tutorials-s3deploy-acc"></a>

在此示例中，您将下载示例静态网站模板文件，将文件上传到 AWS CodeCommit 存储库，创建存储桶，然后将其配置为托管。接下来，您可以使用 AWS CodePipeline 控制台创建管道并指定 Amazon S3 部署配置。

### 先决条件
<a name="tutorials-s3deploy-acc-prereq"></a>

您必须已经具备以下各项：
+ 存储 CodeCommit 库。您可以使用您在中创建的 AWS CodeCommit 存储库[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 您的静态网站的源文件。使用此链接下载[示例静态网站](samples/sample-website.zip)。该 sample-website.zip 下载生成以下文件：
  + 一个 `index.html` 文件
  + 一个 `main.css` 文件
  + 一个 `graphic.jpg` 文件
+ 一个为网站托管配置的 S3 存储桶。请参阅[在 Amazon S3 上托管静态网站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)。确保您在与管道相同的区域中创建存储桶。
**注意**  
若要托管网站，您的桶必须具有公共读取访问权限，以为每个人提供读取访问权限。您应该保留阻止对 S3 存储桶的公共访问的默认访问设置，但网站托管除外。

### 第 1 步：将源文件推送到您的 CodeCommit 存储库
<a name="tutorials-s3deploy-acc-push"></a>

在本节中，将源文件推送到管道用于源阶段的存储库。

**将文件推送到您的 CodeCommit 存储库**

1. 提取下载的示例文件。不要将 ZIP 文件上传到您的存储库。

1. 将文件推送或上传到您的 CodeCommit 存储库。这些文件是由**创建管道**向导针对您在 CodePipeline 中的部署操作创建的源项目。您的文件在本地目录中应如下所示：

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. 你可以使用 Git 或 CodeCommit 控制台上传文件：

   1. 在本地计算机上从克隆的存储库使用 Git 命令行：

      1. 运行以下命令以立即暂存您的所有文件：

         ```
         git add -A
         ```

      1. 运行以下命令以提交带有提交消息的文件：

         ```
         git commit -m "Added static website files"
         ```

      1. 运行以下命令将本地存储库中的文件推送到存储 CodeCommit 库：

         ```
         git push
         ```

   1. 要使用 CodeCommit 控制台上传您的文件，请执行以下操作：

      1. 打开 CodeCommit 控制台，然后从 “存储库” 列表中选择您的**存储库**。

      1. 选择**添加文件**，然后选择**上传文件**。

      1. 选择**选择文件**，然后浏览找到您的文件。通过输入您的用户名和电子邮件地址来提交更改。选择**提交更改**。

      1. 对要上传的每个文件重复此步骤。

### 步骤 2：创建管道
<a name="tutorials-s3deploy-acc-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个源代码阶段，其 CodeCommit 操作中的源构件是您网站的文件。
+ 一个具有 Amazon S3 部署操作的部署阶段。

**使用向导创建管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyS3DeployPipeline**。

1. 在**管道类型**中，选择 **V2**。有关更多信息，请参阅 [管道类型](pipeline-types.md)。选择**下一步**。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **AWS CodeCommit**。在 **Repository name (存储库名称)** 中，选择您在[步骤 1：创建 CodeCommit 存储库](tutorials-simple-codecommit.md#codecommit-create-repository)中创建的 CodeCommit 存储库的名称。在**分支名称**中，选择包含最新的代码更新的分支的名称。除非您自行创建了其他分支，否则仅 `main` 可用。

   选择存储库名称和分支后，将显示要为此管道创建的 Amazon CloudWatch Events 规则。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中：

   1. 在**部署提供程序**中，选择 **Amazon S3**。

   1. 在**存储桶**中，输入您的公有存储桶的名称。

   1. 选择**在部署前提取文件**。
**注意**  
如果不选择**部署前提取文件**，部署将会失败。这是因为管道中的 AWS CodeCommit 操作会压缩源工件，而您的文件是一个 ZIP 文件。

      当**在部署前提取文件**已选择时，将会显示**部署路径**。输入您要使用的路径的名称。这将在 Amazon S3 中创建一个文件夹结构，文件将提取到该文件夹结构中。对于此教程，将此字段保留为空。  
![\[步骤 6：为包含 AWS CodeCommit 源的 S3 部署操作添加部署阶段页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-codecommit.png)

   1. （可选）在**标准 ACL** 中，您可以将一组预定义的授权（称作[标准 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl)）应用于上传的构件。

   1. （可选）在**缓存控制**中，输入缓存参数。您可以设置它以控制请求/响应的缓存行为。有关有效值，请参阅 HTTP 操作的 [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) 标头字段 。

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

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

1. 在管道成功运行后，打开 Amazon S3 控制台并验证您的文件是否显示在公有桶中，如下所示：

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. 访问您的终端节点以测试网站。您的终端节点遵循以下格式： `http://bucket-name.s3-website-region.amazonaws.com/`。

   示例终端节点：`http://my-bucket.s3-website-us-west-2.amazonaws.com/`。

   此时会显示示例网页。

### 步骤 3：对任何源文件进行更改并验证部署
<a name="tutorials-s3deploy-acc-update"></a>

对您的源文件进行更改，然后将更改推送到存储库。这将触发您的管道运行。验证您的网站是否已更新。

## 选项 2：将构建的存档文件从 S3 源桶部署到 Amazon S3。
<a name="tutorials-s3deploy-s3source"></a>

在此选项中，构建阶段的构建命令将 TypeScript 代码编译成 JavaScript 代码，并将输出部署到带有时间戳的单独文件夹下的 S3 目标存储桶。首先，创建 TypeScript 代码和一个 buildspec.yml 文件。将源文件合并到 ZIP 文件中后，将源 ZIP 文件上传到 S3 源存储桶，然后使用 CodeBuild 阶段将构建的应用程序 ZIP 文件部署到您的 S3 目标存储桶。编译后的代码将作为存档保留在目标存储桶中。

### 先决条件
<a name="tutorials-s3deploy-s3source-prereq"></a>

您必须已经具备以下各项：
+ S3 源存储桶。您可以使用在[教程：创建一个简单的管道（S3 存储桶）](tutorials-simple-s3.md)中创建的桶。
+ S3 目标存储桶。请参阅[在 Amazon S3 上托管静态网站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)。请务必使用与要创建的管道 AWS 区域 相同的方式创建存储桶。
**注意**  
此示例演示如何将文件部署到私有存储桶。请勿为网站托管启用目标桶，也不要附加任何将桶设为公共桶的策略。

### 步骤 1：创建源文件并将其上传到您的 S3 源存储桶
<a name="tutorials-s3deploy-s3source-upload"></a>

在本部分中，您将创建源文件，并将其上传到管道用于源阶段的桶。本节提供有关创建以下源文件的说明：
+ 一个`buildspec.yml`文件，用于 CodeBuild 生成项目。
+ 一个 `index.ts` 文件。

**创建 buildspec.yml 文件**
+ 使用以下内容创建名为 `buildspec.yml` 的文件。这些编译命令安装 TypeScript 并使用 TypeScript编译器将代码重写`index.ts`为 JavaScript代码。

  ```
  version: 0.2
  
  phases:
    install:
      commands:
        - npm install -g typescript
    build:
      commands:
        - tsc index.ts
  artifacts:
    files:
      - index.js
  ```

**创建 index.ts 文件**
+ 使用以下内容创建名为 `index.ts` 的文件。

  ```
  interface Greeting {
      message: string;
  }
  
  class HelloGreeting implements Greeting {
      message = "Hello!";
  }
  
  function greet(greeting: Greeting) {
      console.log(greeting.message);
  }
  
  let greeting = new HelloGreeting();
  
  greet(greeting);
  ```

**将文件上传到 S3 源存储桶**

1. 您的文件在本地目录中应如下所示：

   ```
   buildspec.yml
   index.ts
   ```

   压缩这些文件，并将文件命名为 `source.zip`。

1. 在 Amazon S3 控制台中，对于您的源桶，选择**上传**。选择**添加文件**，然后浏览找到您之前创建的 ZIP 文件。

1.  选择**上传**。这些文件是由**创建管道**向导针对您在 CodePipeline 中的部署操作创建的源项目。您的文件应该在您的文件夹中如下所示：

   ```
   source.zip
   ```

### 步骤 2：创建管道
<a name="tutorials-s3deploy-s3source-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个具有 Amazon S3 操作的源阶段，其中源构件是用于可下载应用程序的文件。
+ 一个具有 Amazon S3 部署操作的部署阶段。

**使用向导创建管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyS3DeployPipeline**。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **Amazon S3**。在**存储桶**中，选择您的源存储桶的名称。在 **S3 对象键**中，输入您的源 ZIP 文件。请确保包含 .zip 文件扩展名。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中：

   1. 在**构建提供程序**中，选择 **CodeBuild**。

   1. 选择 **Create build project（创建构建项目）**。在**创建项目**页面上：

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境**中，选择**托管映像**。对于**操作系统**，选择 **Ubuntu**。

   1. 对于**运行时**，选择**标准**。**对于**运行时版本**，请选择aws/codebuild/standard:1.0。**

   1. 在**映像版本**中，选择**始终对此运行时版本使用最新映像**。

   1. 对于**服务角色**，请选择您的 CodeBuild 服务角色或创建一个服务角色。

   1. 对于**构建规范**，选择**使用 buildspec 文件**。

   1. 选择 “**继续” CodePipeline**。如果项目已成功创建，则会显示一条消息。

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

1. 在**步骤 5：添加部署阶段**中：

   1. 在**部署提供程序**中，选择 **Amazon S3**。

   1. 在**存储桶**中，输入您的 S3 目标存储桶的名称。

   1. 确保已清除**部署前提取文件**。

      当**在部署前提取文件**已清除时，将会显示 **S3 对象键**。输入您要使用的路径的名称：`js-application/{datetime}.zip`。

      这将在 Amazon S3 中创建一个 `js-application` 文件夹，文件将提取到该文件夹中。在此文件夹中，`{datetime}` 变量在您的管道运行时会在每个输出文件上创建一个时间戳。  
![\[使用 Amazon S3 源的 Amazon S3 部署操作的步骤 5：部署页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-s3source.png)

   1. （可选）在**标准 ACL** 中，您可以将一组预定义的授权（称作[标准 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl)）应用于上传的构件。

   1. （可选）在**缓存控制**中，输入缓存参数。您可以设置它以控制请求/响应的缓存行为。有关有效值，请参阅 HTTP 操作的 [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) 标头字段 。

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

1. 在 **Step 6: Review** 中，查看信息，然后选择 **Create pipeline**。

1. 管道成功运行后，在 Amazon S3 控制台中查看您的桶。验证已部署的 ZIP 文件是否显示在 `js-application` 文件夹下的目标存储桶中。ZIP JavaScript 文件中包含的文件应为`index.js`。`index.js` 文件包含以下输出：

   ```
   var HelloGreeting = /** @class */ (function () {
       function HelloGreeting() {
           this.message = "Hello!";
       }
       return HelloGreeting;
   }());
   function greet(greeting) {
       console.log(greeting.message);
   }
   var greeting = new HelloGreeting();
   greet(greeting);
   ```

### 步骤 3：对任何源文件进行更改并验证部署
<a name="tutorials-s3deploy-s3source-update"></a>

对源文件进行更改，然后将其上传到源存储桶。这将触发您的管道运行。查看目标存储桶并验证部署的输出文件是否在 `js-application` 文件夹中可用，如下所示：

![\[示例 ZIP 下载\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/tutorial-s3deploy-pipeline-appzip.png)


# 教程：创建将您的无服务器应用程序发布到的管道 AWS Serverless Application Repository
<a name="tutorials-serverlessrepo-auto-publish"></a>

您可以使用 AWS CodePipeline 将您的 AWS SAM 无服务器应用程序持续交付给。 AWS Serverless Application Repository

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

本教程介绍如何创建和配置管道来构建托管的无服务器应用程序并将其 AWS Serverless Application Repository 自动发布到。 GitHub 管道 GitHub 用作源提供者和 CodeBuild 生成提供者。要将您的无服务器应用程序发布到 AWS Serverless Application Repository，您需要部署一个[应用程序（来自 AWS Serverless Application Repository），并将该应用程序](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish )创建的 Lambda 函数关联为管道中的 Invoke 操作提供者。然后，您无需编写任何代码即可持续向 AWS Serverless Application Repository提供应用程序更新。

**重要**  
在此过程中，您在管道中添加的许多操作都涉及在创建管道之前需要创建的 AWS 资源。 AWS 源操作的资源必须始终在您创建管道的同一 AWS 区域创建。例如，如果您在美国东部（俄亥俄州）地区创建管道，则您的 CodeCommit 存储库必须位于美国东部（俄亥俄州）区域。  
您可以在创建管道时添加跨区域操作。 AWS 跨区域操作的资源必须位于您计划执行操作的同一 AWS 区域。有关更多信息，请参阅 [在中添加跨区域操作 CodePipeline](actions-create-cross-region.md)。

## 开始前的准备工作
<a name="tutorials-serverlessrepo-auto-publish-prereq"></a>

在本教程中，我们假设您满足以下条件：
+ 您熟悉[AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/) 和 [AWS Serverless Application Repository](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/)。
+ 您在中托管了一个无服务器应用程序 GitHub ，并已 AWS Serverless Application Repository 使用 AWS SAM CLI 将其发布到。要向发布示例应用程序 AWS Serverless Application Repository，请参阅《*AWS Serverless Application Repository 开发人员指南》*中的 “[快速入门：发布应用程序](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-quick-start.html)”。要将自己的应用程序[发布到 AWS Serverless Application Repository，请参阅《*AWS Serverless Application Model 开发者指南》*中的 “使用 AWS SAM CLI 发布应用程序](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html)”。

## 步骤 1：创建 buildspec.yml 文件
<a name="serverlessrepo-auto-publish-create-buildspec"></a>

创建包含以下内容的`buildspec.yml`文件，并将其添加到无服务器应用程序的 GitHub 存储库中。*template.yml*替换为应用程序的 AWS SAM 模板和*bucketname*存储打包应用程序的 S3 存储桶。

```
version: 0.2
phases:
  install:
    runtime-versions:
        python: 3.8
  build:
    commands:
      - sam package --template-file template.yml --s3-bucket bucketname --output-template-file packaged-template.yml
artifacts:
  files:
    - packaged-template.yml
```

## 步骤 2：创建并配置您的管道
<a name="serverlessrepo-auto-publish-create-pipeline"></a>

按照以下步骤在要发布无服务器应用程序的 AWS 区域 位置创建管道。

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

1. 如有必要，请切换到要发布无服务器应用程序 AWS 区域 的位置。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 选择 **Create pipeline（创建管道）**。在**步骤 2：选择管道设置**页面上，在**管道名称**中，输入管道的名称。

1. 在**管道类型**中，选择 **V2**。有关更多信息，请参阅 [管道类型](pipeline-types.md)。选择**下一步**。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在 “**步骤 3：添加源舞台**” 页面上，在**源提供程序**中，选择**GitHub**。

1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub 源操作的连接，请参阅[GitHub 连接](connections-github.md)。

1. 在**存储库**中，选择您的 GitHub 源存储库。

1. 在 **Branch** 中，选择您的 GitHub 分支。

1. 保留源操作的其余默认值。选择**下一步**。

1. 在**步骤 4：添加构建阶**页面上，添加一个构建阶段：

   1. 在**构建提供程序**中，选择 **AWS CodeBuild**。对于 **Region (区域)**，请使用管道区域。

   1. 选择**创建项目**。

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境映像**中，选择**托管映像**。对于**操作系统**，请选择 **Ubuntu**。

   1. 对于 **Runtime (运行时)** 和 **Runtime version (运行时版本)**，选择无服务器应用程序所需的运行时和版本。

   1. 对于**服务角色**，选择**新建服务角色**。

   1. 对于**构建规范**，选择**使用 buildspec 文件**。

   1. 选择 “**继续” CodePipeline**。这将打开 CodePipeline 控制台并创建一个使用存储库`buildspec.yml`中的进行配置的 CodeBuild 项目。该构建项目使用服务角色来管理 AWS 服务 权限。此步骤可能需要几分钟时间。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。您应该可以看到一个显示阶段的示意图。

1. 向 CodeBuild 服务角色授予访问存储打包应用程序的 S3 存储桶的权限。

   1. 在新管道的 **Build (构建)** 阶段，选择 **CodeBuild**。

   1. 选择 **Build details (构建详细信息)** 选项卡。

   1. 在**环境**中，选择 CodeBuild 服务角色以打开 IAM 控制台。

   1. 展开 `CodeBuildBasePolicy` 选项，然后选择 **Edit policy (编辑策略)**。

   1. 选择 **JSON**。

   1. 添加包含以下内容的新策略声明。该语句 CodeBuild 允许将对象放入存储已打包应用程序的 S3 存储桶中。*bucketname*替换为您的 S3 存储桶的名称。

      ```
              {
                  "Effect": "Allow",
                  "Resource": [
                      "arn:aws:s3:::bucketname/*"
                  ],
                  "Action": [
                      "s3:PutObject"
                  ]
              }
      ```

   1. 选择**查看策略**。

   1. 选择**保存更改**。

## 步骤 3：部署发布应用程序
<a name="serverlessrepo-auto-publish-deploy-app"></a>

按照以下步骤部署包含 Lambda 函数的应用程序，该函数执行到 AWS Serverless Application Repository的发布操作。此应用程序是 **aws-serverless-codepipeline-serverlessrepo-pub** lish。

**注意**  
您必须将应用程序部署到与您的管道 AWS 区域 相同的位置。

1. 转到[应用程序](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish )页面，然后选择 **Deploy (部署)**。

1. 选择 **I acknowledge that this app creates custom IAM roles (我确认此应用程序创建自定义 IAM 角色)**。

1. 选择**部署**。

1. 选择 “**查看 CloudFormation 堆栈**” 以打开 CloudFormation 控制台。

1. 展开**资源**部分。你看 **ServerlessRepoPublish**，属于这种类型**AWS::Lambda::Function**。记下此资源的物理 ID 以供下一步使用。您在 CodePipeline 中创建新的发布操作时将会用到此物理 ID。

## 步骤 4：创建发布操作
<a name="serverlessrepo-auto-publish-create-action"></a>

请按照以下步骤在管道中创建发布操作。

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

1. 在左侧导航部分中，选择要编辑的管道。

1. 选择**编辑**。

1. 在当前管道的最后一个阶段之后，选择 **\$1 Add stage (\$1 添加阶段)**。在 **Stage name (阶段名称)** 中，输入名称，例如 **Publish**，然后选择 **Add stage (添加阶段)**。

1. 在新阶段中，选择 **\$1 添加操作组**。

1. 输入操作名称。从 **Action provider (操作提供程序)** 的 **Invoke (调用)** 中，选择 **AWS Lambda**。

1. 从**输入构件**中选择**BuildArtifact**。

1. 从**函数名称**中，选择您在上一步中记下的 Lambda 函数的物理 ID。

1. 对操作选择 **Save (保存)**。

1. 对阶段选择 **Done (完成)**。

1. 在右上角，选择 **Save (保存)**。

1. 要验证您的管道，请在中更改您的应用程序 GitHub。例如，更改 AWS SAM 模板文件`Metadata`部分中应用程序的描述。提交更改并将其推送到您的 GitHub 分支。这将触发您的管道运行。管道完成后，检查您的应用程序是否已根据 [AWS Serverless Application Repository](https://console.aws.amazon.com/serverlessrepo/home) 中的更改进行了更新。

# 教程：使用 Lambda 函数部署 CodePipeline
<a name="tutorials-lambda-deploy"></a>

本教程可帮助您创建部署操作， CodePipeline 该操作可将您的代码部署到您在 Lambda 中配置的函数中。您将创建示例 Lambda 函数，您将在其中创建别名和版本，将压缩后的 Lambda 函数添加到源位置，然后在管道中运行 Lambda 操作。

**注意**  
作为在控制台中创建管道的一部分，S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**注意**  
`Lambda` 部署操作仅适用于 V2 类型管道。

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

您必须先部署一些资源，然后才能使用本教程创建您的 CD 管道。以下是您在开始操作之前需要的资源：

**注意**  
所有这些资源都应在同一个 AWS 区域内创建。
+ 源代码控制存储库（例如 GitHub）或源 S3 存储桶（本教程使用 S3），您将在其中存储为 Lambda 函数创建的`.zip`文件。
+ 您必须使用已更新为具有此操作权限的现有 CodePipeline 服务角色。要更新您的服务角色，请参阅[Lambda 部署操作的服务角色策略权限](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action)。

在满足这些先决条件后，您可以继续完成本教程并创建您的 CD 管道。

## 步骤 1：创建示例 Lambda 函数
<a name="tutorials-lambda-deploy-instances"></a>

在此步骤中，您将创建要部署到的 Lambda 函数。

**创建 Lambda 函数**

1. 访问 Lambda 控制台并按照以下教程中的步骤创建示例 Lambda 函数：链接。

1. 从顶部导航栏中选择**创建**，然后从页面顶部选择**从头开始**。

1. 在**名称**中，输入 **MyLambdaFunction**。

1. 发布新版本。这将是别名将指向的版本。

   1. 选择您的函数。

   1. 选择**操作**下拉菜单。

   1. 选择 **새 버전 발행**。

   1. (可选)在**描述**中键入描述。

   1. 选择**发布**。

1. 为您的函数创建别名，例如 `aliasV1`。

1. 确保别名指向您刚刚创建的版本（例如 1）。
**注意**  
如果您选择 \$1LATEST，则无法使用流量转移功能，因为 Lambda 不支持指向多个版本的别名使用 \$1LATEST。

## 步骤 2：将函数文件上传到存储库。
<a name="tutorials-lambda-deploy-file"></a>

下载函数并将其另存为 zip 文件。使用以下步骤将压缩文件上传到 S3 存储桶。

**将 `.zip` 文件添加至您的源存储库**

1. 打开您的 S3 存储桶。

1. 选择**上传**。

1. 将包含您的 `sample_lambda_source.zip` 文件的 zip 文件上传到您的源存储桶。

   记下路径。

   ```
   object key
   ```

## 步骤 3：创建管道
<a name="tutorials-lambda-deploy-pipeline"></a>

使用向 CodePipeline 导创建工作流阶段并连接源存储库。

**创建管道**

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

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**使用现有服务角色**，然后选择已更新为具有此操作所需权限的 CodePipeline 服务角色。要为此操作配置您的 CodePipeline服务角色，请参阅[Lambda 部署操作的服务角色策略权限](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action)。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**源提供商**中，选择 **Amazon S3**。

   1. 在**对象密钥**中，添加.zip 文件的名称，包括文件扩展名，例如`sample_lambda_source.zip`。

      

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**页面上，选择**跳过**。

1. 在**步骤 5：添加测试阶段**页面上，选择**跳过**。

1. 在**步骤 6：添加部署阶段**页面上，选择 **Lambda**。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)

   1. 添加您的函数名称和别名。

   1. 选择您的部署策略。

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

1. 在 “**步骤 7：审阅**” 页面上，查看您的工作流配置，然后选择**创建管道**来创建管道。  
![\[\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/lambdadeploy-pipeline-screen.png)

## 步骤 4：测试您的管道
<a name="tutorials-lambda-deploy-test"></a>

您的管道应该具备运行 end-to-end原生 AWS 持续部署所需的一切。现在，通过将代码更改推送至您的源存储库来测试管道的功能。

**测试您的管道**

1. 对您的已配置源存储库进行代码更改，然后提交并推送更改。

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

1. 从列表中选择您的管道。

1. 监视管道经历不同阶段的进度。您的管道应已完成，您的操作将部署到 Lambda 函数。

## 了解详情
<a name="tutorials-lambda-deploy-learn"></a>

Lambda 部署操作允许使用两种部署方法。一种方法是单独进行流量转移，不使用源操作的输入构件。另一种方法是使用源操作中的输入构件更新函数代码，然后根据更新的代码发布新版本。对于第二种方法，如果提供了别名，也 CodePipeline 将进行流量切换。此 Lambda 部署操作教程演示了使用源构件更新函数。

要了解有关该操作的更多信息，请参阅 [AWS Lambda 部署操作参考](action-reference-LambdaDeploy.md)中的操作参考页面。

# 教程：将变量与 Lambda 调用操作一起使用
<a name="tutorials-lambda-variables"></a>

Lambda 调用操作可以使用来自另一个操作的变量作为其输入的一部分，并返回新变量及其输出。有关中操作变量的信息 CodePipeline，请参见[变量参考](reference-variables.md)。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

在本教程结束时，您将具备：
+ Lambda 调用操作：
  + 消耗 CodeCommit 源`CommitId`操作中的变量
  + 输出三个新变量：`dateTime`、`testRunId` 和 `region`
+ 一个手动审批操作，它使用 Lambda 调用操作中的新变量以提供测试 URL 和测试运行 ID
+ 使用新操作更新的管道

**Topics**
+ [先决条件](#lambda-variables-prereqs)
+ [第 1 步：创建 Lambda 函数](#lambda-variables-function)
+ [步骤 2：向您的管道添加 Lambda 调用操作和手动审批操作](#lambda-variables-pipeline)

## 先决条件
<a name="lambda-variables-prereqs"></a>

在开始之前，您必须具有以下内容：
+ 您可以创建或使用带有 CodeCommit 源代码的管道[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)。
+ 编辑现有管道，使 CodeCommit 源操作具有命名空间。将命名空间 `SourceVariables` 分配给操作。

## 第 1 步：创建 Lambda 函数
<a name="lambda-variables-function"></a>

使用以下步骤可创建 Lambda 函数和 Lambda 执行角色。创建 Lambda 函数后，可以将 Lambda 操作添加到您的管道中。

**创建 Lambda 函数和执行角色**

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

1. 选择**创建函数**。将 **Author from scratch (从头开始创作)** 保持选中状态：

1. 在 **Function name (函数名称)** 中，输入您的函数的名称，例如 **myInvokeFunction**。在 **Runtime (运行时)** 中，保持选中默认选项。

1. 展开 **Choose or create an execution role (选择或创建执行角色)**。选择 **Create a new role with basic Lambda permissions (创建具有基本 Lambda 权限的新角色)**。

1. 选择**创建函数**。

1. 要使用来自另一个操作的变量，必须将它传递给 Lambda 调用操作配置中的 `UserParameters`。您将在本教程的后面部分的管道中配置操作，但假设将传递变量，您将添加代码。

   要生成新变量，请将输入上名为 `outputVariables` 的属性设置为 `putJobSuccessResult`。请注意，您不能将变量作为 `putJobFailureResult` 的一部分生成。

   ```
    const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
   ```

   在新函数中，在**代码**选项卡上，将以下示例代码粘贴到 `index.mjs` 下方。

   ```
   import { CodePipeline } from '@aws-sdk/client-codepipeline';
   
   export const handler = async (event, context) => {
       const codepipeline = new CodePipeline({});
       
       // Retrieve the Job ID from the Lambda action
       const jobId = event["CodePipeline.job"].id;
       
       // Retrieve UserParameters
       const params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
       
       // The region from where the lambda function is being executed
       const lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           
           try {
               await codepipeline.putJobSuccessResult(params);
               return message;
           } catch (err) {
               throw err;
           }
       };
       
       // Notify CodePipeline of a failed job
       const putJobFailure = async (message) => {
           const params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           
           try {
               await codepipeline.putJobFailureResult(params);
               throw message;
           } catch (err) {
               throw err;
           }
       };
       
       try {
           console.log("Testing commit - " + params);
           
           // Your tests here
           
           // Succeed the job
           return await putJobSuccess("Tests passed.");
       } catch (ex) {
           // If any of the assertions failed then fail the job
           return await putJobFailure(ex);
       }
   };
   ```

1. 允许该函数自动保存。

1. 复制屏幕顶部的**函数 ARN** 字段中包含的 Amazon 资源名称（ARN）。

1. 最后一步，打开 AWS Identity and Access Management (IAM) 控制台，网址为[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。修改 Lambda 执行角色以添加以下策略：。[AWSCodePipelineCustomActionAccess](https://console.aws.amazon.com/iam/home?region=us-west-2#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCodePipelineCustomActionAccess)有关创建 Lambda 执行角色或修改角色策略的步骤，请参阅[第 2 步：创建 Lambda 函数](actions-invoke-lambda-function.md#actions-invoke-lambda-function-create-function) 。

## 步骤 2：向您的管道添加 Lambda 调用操作和手动审批操作
<a name="lambda-variables-pipeline"></a>

在此步骤中，将 Lambda 调用操作添加到您的管道中。可以在名为 **Test** 的阶段中添加操作。操作类型是一个调用动作。然后，您可以在调用操作后面添加手动审批操作。

**向管道添加 Lambda 操作和手动审批操作**

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

   将显示与您的 AWS 账户关联的所有管道的名称。选择要添加操作的管道。

1. 将 Lambda 测试操作添加到您的管道中。

   1. 要编辑您的管道，请选择**编辑**。在现有管道中的源操作后面添加一个阶段。输入阶段的名称，例如 **Test**。

   1. 在新阶段中，选择**添加操作组**来添加操作。在 **Action name (操作名称)** 中，输入调用操作的名称，例如 **Test\$1Commit**。

   1. 对于**操作提供程序**，选择 **AWS Lambda**。

   1. 在 **Input artifacts (输入构件)** 中，选择源操作输出构件的名称，例如 `SourceArtifact`。

   1. 在中 **FunctionName**，添加您创建的 Lambda 函数的 ARN。

   1. 在 **Variable namespace (变量命名空间)** 中，添加命名空间名称，例如 **TestVariables**。

   1. 在**输出构件**中，添加输出构件名称，如 **LambdaArtifact**。

   1. 选择**完成**。

1. 将手动审批操作添加到您的管道中。

   1. 如果您的管道仍处于编辑模式，则在调用操作后面添加一个阶段。输入阶段的名称，例如 **Approval**。

   1. 在新阶段中，选择要添加操作的图标。在 **Action name (操作名称)** 中，输入审批操作的名称，例如 **Change\$1Approval**。

   1. 在 **Action provider (操作提供程序)** 中，选择 **Manual approval (手动审批)**。

   1. 在 **URL for review (用于审查的 URL)** 中，通过为 `CommitId` 变量和 `region` 变量添加变量语法，来构建 URL。确保您使用分配给提供输出变量的操作的命名空间。

      在此示例中，带有 CodeCommit 动作变量语法的 URL 具有默认命名空间`SourceVariables`。Lambda 区域输出变量具有 `TestVariables` 命名空间。此 URL 如下所示：

      ```
      https://#{TestVariables.region}.console.aws.amazon.com/codesuite/codecommit/repositories/MyDemoRepo/commit/#{SourceVariables.CommitId}
      ```

      在 **Comments (注释)** 中，通过添加 `testRunId` 变量的变量语法，构建审批消息文本。对于此示例，使用 Lambda `testRunId` 输出变量的变量语法的 URL 具有 `TestVariables` 命名空间。输入以下消息。

      ```
      Make sure to review the code before approving this action. Test Run ID: #{TestVariables.testRunId}
      ```

1. 选择 **Done (完成)** 以关闭操作的编辑屏幕，然后选择 **Done (完成)** 以关闭阶段的编辑屏幕。要保存管道，请选择 **Done (完成)**。已完成的管道现在包含一个结构，该结构带有源、测试、审批和部署阶段。

   选择 **Release change (发布更改)** 以通过管道结构运行最新更改。

1. 当管道到达手动审批阶段时，选择 **Review (审核)**。解析的变量显示为提交 ID 的 URL。您的审批人可以选择该 URL 来查看提交。

1. 当成功运行管道后，您还可以在操作执行历史记录页面上查看变量值。

# 教程：在管道中使用 AWS Step Functions 调用操作
<a name="tutorials-step-functions"></a>

您可以使用创建 AWS Step Functions 和配置状态机。本教程介绍如何将调用操作添加到管道以便从管道激活状态机执行。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

在本教程中，您将执行以下任务：
+ 在中创建标准状态机 AWS Step Functions。
+ 直接输入状态机输入 JSON。还可以将状态机输入文件上传到 Amazon Simple Storage Service (Amazon S3) 桶。
+ 通过添加状态机操作来更新管道。

**Topics**
+ [先决条件：创建或选择简单管道](#tutorials-step-functions-prereq)
+ [步骤 1：创建示例状态机](#tutorials-step-functions-sample)
+ [步骤 2：将 Step Functions 调用操作添加到管道](#tutorials-step-functions-pipeline)

## 先决条件：创建或选择简单管道
<a name="tutorials-step-functions-prereq"></a>

在本教程中，您将向现有管道添加调用操作。您可以使用在[教程：创建一个简单的管道（S3 存储桶）](tutorials-simple-s3.md)或[教程：创建简单的管道（CodeCommit 存储库）](tutorials-simple-codecommit.md)中创建的管道。

您可以将现有管道与一个源操作和至少一个两阶段结构结合使用，但在此示例中不使用源构件。

**注意**  
您可能需要通过添加运行此操作所需的其他权限来更新管道所使用的服务角色。为此，请打开 AWS Identity and Access Management (IAM) 控制台，找到该角色，然后将权限添加到该角色的策略中。有关更多信息，请参阅 [为 CodePipeline 服务角色添加权限](how-to-custom-role.md#how-to-update-role-new-services)。

## 步骤 1：创建示例状态机
<a name="tutorials-step-functions-sample"></a>

在 Step Functions 控制台中，使用 `HelloWorld` 示例模板创建状态机。有关说明，请参阅 *AWS Step Functions 开发者指南* 中的[创建状态机](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started.html#create-state-machine)。

## 步骤 2：将 Step Functions 调用操作添加到管道
<a name="tutorials-step-functions-pipeline"></a>

将 Step Functions 调用操作添加到管道，如下所示：

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

   将显示与您的 AWS 账户关联的所有管道的名称。

1. 在 **Name** 中，选择您要编辑的管道的名称。这将打开管道的详细视图，包括管道每个阶段中每个操作的状态。

1. 在管道详细信息页中，选择**编辑**。

1. 在简单管道的第二个阶段，选择 **Edit stage (编辑阶段)**。选择**删除**。这将立即删除您不再需要的第二个阶段。

1. 在示意图底部，选择 **\$1 添加阶段**。

1. 在 **Stage name (阶段名称)** 中，输入阶段的名称，例如 **Invoke**，然后选择 **Add stage(添加阶段)**。

1. 选择 **\$1 添加操作组**。

1. 在 **Action name (操作名称)** 中，输入名称，例如 **Invoke**。

1. 在**操作提供程序**中，选择 **AWS Step Functions**。允许**区域**默认为管道区域。

1. 在 **Input artifacts (输入构件)** 中，选择 `SourceArtifact`。

1. 在 **State machine ARN (状态机 ARN)** 中，选择之前创建的状态机的 Amazon 资源名称 (ARN)。

1. （可选）在 **Execution name prefix (执行名称前缀)** 中，输入要添加到状态机执行 ID 的前缀。

1. 在 **Input type (输入类型)** 中，选择 **Literal (文本)**。

1. 在 **Input (输入)** 中，输入 `HelloWorld` 示例状态机所需的输入 JSON。
**注意**  
状态机执行的输入与中 CodePipeline 用来描述操作输入工件的术语不同。

   在此示例中，输入以下 JSON：

   ```
   {"IsHelloWorldExample": true}
   ```

1. 选择**完成**。

1. 在所编辑的阶段上，选择 **Done (完成)**。在 AWS CodePipeline 窗格中，选择**保存**，然后选择警告消息上的**保存**。

1. 要提交所做的更改并开始管道执行，请选择**发布更改**，然后选择**发布**。

1. 在已完成的管道上，选择调用操作中的 **AWS Step Functions**。在 AWS Step Functions 控制台中，查看您的状态机执行 ID。ID 显示您的状态机名称 `HelloWorld` 和带有前缀 `my-prefix` 的状态机执行 ID。

   ```
   arn:aws:states:us-west-2:account-ID:execution:HelloWorld:my-prefix-0d9a0900-3609-4ebc-925e-83d9618fcca1
   ```

# 教程：创建 AWS AppConfig 用作部署提供者的管道
<a name="tutorials-AppConfig"></a>

在本教程中，您将配置一个管道，该管道在部署阶段 AWS AppConfig 用作部署操作提供者，持续提供配置文件。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**Topics**
+ [先决条件](#tutorials-AppConfig-prereq)
+ [第 1 步：创建您的 AWS AppConfig 资源](#tutorials-AppConfig-application)
+ [步骤 2：将文件上传到 S3 源桶](#tutorials-AppConfig-bucket)
+ [步骤 3：创建管道](#tutorials-AppConfig-pipeline)
+ [步骤 4：对任何源文件进行更改并验证部署](#tutorials-AppConfig-verify)

## 先决条件
<a name="tutorials-AppConfig-prereq"></a>

在开始本教程之前，您必须完成以下步骤：
+ 本例将 S3 源用于您的管道。创建或使用已启用版本控制的 Amazon S3 桶。按照[步骤 1：为您的应用程序创建一个 S3 源存储桶](tutorials-simple-s3.md#s3-create-s3-bucket)中的说明创建 S3 存储桶。

## 第 1 步：创建您的 AWS AppConfig 资源
<a name="tutorials-AppConfig-application"></a>

在本节中，您将创建以下资源：
+ 中的*应用程序* AWS AppConfig 是一个逻辑代码单元，可为您的客户提供功能。
+ 中的*环境* AWS AppConfig 是由 AppConfig 目标组成的逻辑部署组，例如测试版或生产环境中的应用程序。
+ *配置文件*是一组影响应用程序行为的设置。配置文件使您 AWS AppConfig 能够在其存储位置访问您的配置。
+ （可选）中的*部署策略* AWS AppConfig 定义了配置部署的行为，例如在部署期间的任何给定时间应收到新部署配置的客户端的百分比。

**创建应用程序、环境、配置文件和部署策略**

1. 登录到 AWS 管理控制台。

1. 使用以下主题中的步骤在中创建您的资源 AWS AppConfig。
   + [创建应用程序](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-application.html)。
   + [创建一个环境](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-environment.html)。
   + [创建 AWS CodePipeline 配置文件](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-configuration-and-profile.html)。
   + （可选）[选择预定义的部署策略或创建自己的部署策略](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-deployment-strategy.html)。

## 步骤 2：将文件上传到 S3 源桶
<a name="tutorials-AppConfig-bucket"></a>

在本节中，创建一个或多个配置文件。然后将源文件压缩并推送到管道用于源阶段的桶。

**创建配置文件**

1. 在每个区域中为每个配置创建一个 `configuration.json` 文件。包括以下内容：

   ```
   Hello World!
   ```

1. 使用以下步骤压缩和上传配置文件。

**压缩和上传源文件**

1. 创建包含文件的 .zip 文件并将文件命名为 .zip 文件 `configuration-files.zip`。例如，您的 .zip 文件可以使用以下结构：

   ```
   .
   └── appconfig-configurations
       └── MyConfigurations
           ├── us-east-1
           │   └── configuration.json
           └── us-west-2
               └── configuration.json
   ```

1. 在桶的 Amazon S3 控制台中，选择**上传**，然后按照说明上传 .zip 文件。

## 步骤 3：创建管道
<a name="tutorials-AppConfig-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个具有 Amazon S3 操作的源阶段，其中源构件是用于配置的文件。
+ 包含部署操作的 AppConfig 部署阶段。

**使用向导创建管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyAppConfigPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 将**高级设置**中的各项设置保留为默认值，然后选择**下一步**。

1. 在**步骤 3：添加源阶段**的**源提供程序**中，选择 **Amazon S3**。在**桶**中，选择 S3 源桶的名称。

   在 **S3 对象键**中，输入您的 .zip 文件：`configuration-files.zip`。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中：

   1. 在**部署提供程序**中，选择**AWS AppConfig**。

   1. 在**应用程序**中，选择您在中创建的应用程序的名称 AWS AppConfig。该字段显示应用程序的 ID。

   1. 在**环境**中，选择您在中创建的环境的名称 AWS AppConfig。该字段显示您的环境的 ID。

   1. 在**配置配置文件**中，选择您在中创建的配置文件的名称 AWS AppConfig。该字段显示您的配置文件的 ID。

   1. 在**部署策略**中，选择部署策略的名称。这可以是您在中创建的部署策略， AppConfig 也可以是您从中预定义的部署策略中选择的策略 AppConfig。该字段显示您的部署策略的 ID。

   1. 在**输入构件配置路径**中，输入文件路径。确保您的输入构件配置路径与 S3 桶 .zip 文件中的目录结构相匹配。在此示例中，输入以下文件路径：`appconfig-configurations/MyConfigurations/us-west-2/configuration.json`。

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

1. 在**步骤 7：查看**中，查看信息，然后选择**创建管道**。

## 步骤 4：对任何源文件进行更改并验证部署
<a name="tutorials-AppConfig-verify"></a>

对源文件进行更改，然后将更改上传到桶。这将触发您的管道运行。通过查看版本来验证您的配置是否可用。

# 教程：使用带有 GitHub 管道源的完整克隆
<a name="tutorials-github-gitclone"></a>

您可以在中为 GitHub 源操作选择完全克隆选项 CodePipeline。使用此选项可在管道构建操作中运行 Git 元数据的 CodeBuild 命令。

**注意**  
此处描述的完整克隆选项是指指定是否 CodePipeline 应克隆存储库元数据，这些元数据只能由 CodeBuild 命令使用。要将 GitHub [用户访问令牌](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app)用于 CodeBuild 项目，请按照此处的步骤安装 GitHub 应用程序 AWS 连接器，然后将应用程序安装字段留空。 CodeConnections 将使用用户访问令牌进行连接。



**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

在本教程中，您将创建一个连接到 GitHub 仓库的管道，对源数据使用完整克隆选项，并运行一个用于克隆仓库并对仓库执行 Git 命令的 CodeBuild 构建。

**注意**  
此功能不适用于亚太地区（香港）、非洲（开普敦）、中东（巴林）、欧洲（苏黎世） AWS GovCloud 或（美国西部）地区。要参考其他可用操作，请参阅 [产品和服务与 CodePipeline](integrations.md)。有关在欧洲地区（米兰）区域使用此操作的注意事项，请参阅[CodeStarSourceConnection 适用于 Bitbucket Cloud GitHub、、 GitHub 企业服务器、 GitLab .com 和 GitLab 自我管理操作](action-reference-CodestarConnectionSource.md)中的说明。

**Topics**
+ [先决条件](#tutorials-github-gitclone-prereq)
+ [步骤 1：创建自述文件](#tutorials-github-gitclone-file)
+ [步骤 2：创建管道并构建项目](#tutorials-github-gitclone-pipeline)
+ [步骤 3：更新 CodeBuild 服务角色策略以使用连接](#tutorials-github-gitclone-rolepolicy)
+ [步骤 4：在构建输出中查看存储库命令](#tutorials-github-gitclone-view)

## 先决条件
<a name="tutorials-github-gitclone-prereq"></a>

在开始之前，您必须执行以下操作：
+ 使用您的 GitHub 账户创建 GitHub 存储库。
+ 准备好您的 GitHub 凭证。当你使用 AWS 管理控制台 来建立连接时，系统会要求你使用自己的 GitHub 凭据登录。

## 步骤 1：创建自述文件
<a name="tutorials-github-gitclone-file"></a>

创建存储 GitHub 库后，使用以下步骤添加自述文件。

1. 登录您的 GitHub 存储库并选择您的存储库。

1. 要创建新文件，请选择**添加文件 > 创建新文件**。将文件命名为 `README.md` 文件并添加以下文本。

   ```
   This is a GitHub repository!
   ```

1. 选择**提交更改**。

   确保 `README.md` 文件位于存储库的根级别。

## 步骤 2：创建管道并构建项目
<a name="tutorials-github-gitclone-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个与您的 GitHub 仓库连接和操作的源阶段。
+ 带有生成操作的 AWS CodeBuild 生成阶段。

**使用向导创建管道**

1. 登录 CodePipeline 控制台，网址为[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyGitHubPipeline**。

1. 在本教程中，为**管道类型**选择 **V1**。也可以选择 **V2**；但请注意，不同管道类型具有不同的特性和价格。有关更多信息，请参阅 [管道类型](pipeline-types.md)。

1. 在**服务角色**中，选择**新建服务角色**。
**注意**  
如果您选择使用现有的 CodePipeline 服务角色，请确保已`codestar-connections:UseConnection`将 IAM 权限添加到您的服务角色策略中。有关 CodePipeline 服务角色的说明，请参阅[为 CodePipeline 服务角色添加权限](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**高级设置**下，保留原定设置值。在**构件存储**中，选择**默认位置**以将默认构件存储（如指定为默认值的 Amazon S3 项目存储桶）用于为管道选择的区域中的管道。
**注意**  
这不是源代码的源存储桶。这是管道的项目存储。每个管道都需要一个单独的构件存储，例如 S3 存储桶。

   选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**来源提供商**中，选择 **GitHub （通过 GitHub应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub 源操作的连接，请参阅[GitHub 连接](connections-github.md)。

      您可以为与特定提供程序的所有连接安装一个应用程序。如果您已经安装了 GitHub 应用程序 AWS 连接器，请选择它并跳过此步骤。
**注意**  
如果要创建[用户访问令牌](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app)，请确保您已经为 GitHub 应用程序安装了 Conn AWS ector，然后将 “应用程序安装” 字段留空。 CodeConnections 将使用用户访问令牌进行连接。有关更多信息，请参阅[中的访问您的源提供商 CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/access-tokens.html)。

   1. 在 **Repository name (存储库名称)** 中，选择 GitHub 存储库的名称。

   1. 在**分支名称**中，键入要使用的存储库分支。

   1. 确保选择了**在源代码更改时启动管道**选项。

   1. 在**输出构件格式**下，选择**完整克隆**，对源存储库启用 Git 克隆选项。只有提供的操作 CodeBuild 才能使用 Git 克隆选项。在本教程[步骤 3：更新 CodeBuild 服务角色策略以使用连接](#tutorials-github-gitclone-rolepolicy)中，您将使用更新 CodeBuild 项目服务角色的权限，以使用此选项。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，添加一个构建阶段：

   1. 在**构建提供程序**中，选择 **AWS CodeBuild**。允许**区域**默认为管道区域。

   1. 选择**创建项目**。

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境映像**中，选择**托管映像**。对于**操作系统**，选择 **Ubuntu**。

   1. 对于**运行时**，选择**标准**。**对于 “**图像**”，选择:5.0 aws/codebuild/standard。**

   1. 对于**服务角色**，选择**新建服务角色**。
**注意**  
记下您的 CodeBuild 服务角色的名称。在本教程的最后一步，您会用到此角色名称。

   1. 在**构建规范**下，为**构建规范**选择**插入构建命令**。选择**切换到编辑器**，然后将以下内容粘贴到**构建命令**。
**注意**  
在构建规范的 `env` 部分中，确保启用了 Git 命令的凭证助手，如本示例所示。

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git archive --format=zip HEAD > application.zip
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
          - application.zip
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. 选择 “**继续” CodePipeline**。这将返回到 CodePipeline控制台并创建一个使用您的构建命令进行配置的 CodeBuild 项目。构建项目使用服务角色来管理 AWS 服务 权限。此步骤可能需要几分钟时间。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。

## 步骤 3：更新 CodeBuild 服务角色策略以使用连接
<a name="tutorials-github-gitclone-rolepolicy"></a>

初始管道运行将失败，因为必须更新 CodeBuild 服务角色才能使用连接。在服务角色策略中添加 `codestar-connections:UseConnection` IAM 权限。有关在 IAM 控制台中更新策略的说明，请参阅[添加连接 Bitbucket、 GitHub、En GitHub terprise Server 或 GitLab .com 的 CodeBuild GitClone 权限](troubleshooting.md#codebuild-role-connections)。

## 步骤 4：在构建输出中查看存储库命令
<a name="tutorials-github-gitclone-view"></a>

1. 成功更新服务角色后，在失败 CodeBuild 阶段选择 “**重试**”。

1. 管道成功运行后，在成功的构建阶段上，选择**查看详细信息**。

   在详细信息页面上，选择**日志**选项卡。查看编 CodeBuild 译输出。这些命令将输出所输入变量的值。

   这些命令输出 `README.md` 文件内容，列出目录中的文件，克隆存储库，查看日志，然后将存储库存档为 ZIP 文件。

# 教程：使用带有 CodeCommit 管道源的完整克隆
<a name="tutorials-codecommit-gitclone"></a>

您可以在中为 CodeCommit 源操作选择完全克隆选项 CodePipeline。使用此选项 CodeBuild 允许在管道构建操作中访问 Git 元数据。

在本教程中，您将创建一个访问 CodeCommit 仓库的管道，对源数据使用完整克隆选项，并运行一个用于克隆仓库并对仓库执行 Git 命令的 CodeBuild 构建。

**注意**  
CodeBuild 操作是唯一支持使用 Git 克隆选项提供的 Git 元数据的下游操作。此外，虽然您的管道可以包含跨账户操作，但操作和 CodeBuild 操作必须位于同一个账户中，完整克隆选项才能成功。 CodeCommit

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**Topics**
+ [先决条件](#tutorials-codecommit-gitclone-prereq)
+ [步骤 1：创建自述文件](#tutorials-codecommit-gitclone-file)
+ [步骤 2：创建管道并构建项目](#tutorials-codecommit-gitclone-pipeline)
+ [步骤 3：更新 CodeBuild 服务角色策略以克隆存储库](#tutorials-codecommit-gitclone-rolepolicy)
+ [步骤 4：在构建输出中查看存储库命令](#tutorials-codecommit-gitclone-view)

## 先决条件
<a name="tutorials-codecommit-gitclone-prereq"></a>

在开始之前，您必须在与您的管道相同的 AWS 账户和区域中创建 CodeCommit 存储库。

## 步骤 1：创建自述文件
<a name="tutorials-codecommit-gitclone-file"></a>

使用以下步骤将自述文件添加到您的源存储库。README 文件提供了供 CodeBuild 下游操作读取的示例源文件。

**添加自述文件**

1. 登录您的存储库并选择您的存储库。

1. 要创建新文件，请选择**添加文件 > 创建文件**。将文件命名为 `README.md` 文件并添加以下文本。

   ```
   This is a CodeCommit repository!
   ```

1. 选择**提交更改**。

   确保 `README.md` 文件位于存储库的根级别。

## 步骤 2：创建管道并构建项目
<a name="tutorials-codecommit-gitclone-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 带有源操作的 CodeCommit 源舞台。
+ 带有生成操作的 AWS CodeBuild 生成阶段。

**使用向导创建管道**

1. 登录 CodePipeline 控制台，网址为[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyCodeCommitPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，执行下列操作之一：
   + 选择**现有服务角色**。
   + 选择您现有的 CodePipeline 服务角色。在服务角色策略中，该角色必须有 `codecommit:GetRepository` IAM 权限。请参见[为 CodePipeline 服务角色添加权限](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**高级设置**下，保留原定设置值。选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，执行以下操作：

   1. 在**源提供程序**中，选择 **CodeCommit**。

   1. 在**存储库名称**中，选择存储库的名称。

   1. 在**分支名称**中，选择您的分支名称。

   1. 确保选择了**在源代码更改时启动管道**选项。

   1. 在**输出构件格式**下，选择**完整克隆**，对源存储库启用 Git 克隆选项。只有提供的操作 CodeBuild 才能使用 Git 克隆选项。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，执行以下操作：

   1. 在**构建提供程序**中，选择 **AWS CodeBuild**。允许**区域**默认为管道区域。

   1. 选择**创建项目**。

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境映像**中，选择**托管映像**。对于**操作系统**，选择 **Ubuntu**。

   1. 对于**运行时**，选择**标准**。**对于 “**图像**”，选择:5.0 aws/codebuild/standard。**

   1. 对于**服务角色**，选择**新建服务角色**。
**注意**  
记下您的 CodeBuild 服务角色的名称。在本教程的最后一步，您会用到此角色名称。

   1. 在**构建规范**下，为**构建规范**选择**插入构建命令**。选择**切换到编辑器**，然后在**构建命令**下粘贴以下代码。

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git describe --all
        #post_build:
          #commands:
            # - command
            # - command
      #artifacts:
        #files:
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. 选择 “**继续” CodePipeline**。这将使您返回 CodePipeline 控制台并创建一个使用您的构建命令进行配置的 CodeBuild 项目。该构建项目使用服务角色来管理 AWS 服务 权限。此步骤可能需要几分钟时间。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。

## 步骤 3：更新 CodeBuild 服务角色策略以克隆存储库
<a name="tutorials-codecommit-gitclone-rolepolicy"></a>

初始管道运行将失败，因为您需要更新 CodeBuild 服务角色，使其具有从存储库中提取的权限。

在服务角色策略中添加 `codecommit:GitPull` IAM 权限。有关在 IAM 控制台中更新策略的说明，请参阅[为 CodeCommit 源操作添加 CodeBuild GitClone 权限](troubleshooting.md#codebuild-role-codecommitclone)。

## 步骤 4：在构建输出中查看存储库命令
<a name="tutorials-codecommit-gitclone-view"></a>

**查看构建输出**

1. 成功更新服务角色后，在失败 CodeBuild 阶段选择 “**重试**”。

1. 管道成功运行后，在成功的构建阶段上，选择**查看详细信息**。

   在详细信息页面上，选择**日志**选项卡。查看编 CodeBuild 译输出。这些命令将输出所输入变量的值。

   这些命令输出 `README.md` 文件内容，列出目录中的文件，克隆存储库，查看日志，然后运行 `git describe --all`。

# 教程：使用 AWS CloudFormation StackSets 部署操作创建管道
<a name="tutorials-stackset-deployment"></a>

在本教程中，您将使用 AWS CodePipeline 控制台创建带有部署操作的管道，用于创建堆栈集和创建堆栈实例。管道运行时，模板会创建堆栈集，还会创建和更新部署了堆栈集的实例。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

有两种方法可以管理堆栈集的权限：自我管理的 IAM 角色和托 AWS管的 IAM 角色。本教程提供了自托管权限的示例。

要在中最有效地使用 Stackset CodePipeline，您应该清楚地了解其背后的概念 CloudFormation StackSets 及其工作原理。参见《*AWS CloudFormation 用户指南*》中的[StackSets 概念](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html)。

**Topics**
+ [先决条件](#tutorials-stackset-deployment-prereq)
+ [步骤 1：上传示例 AWS CloudFormation 模板和参数文件](#tutorials-stackset-deployment-upload)
+ [步骤 2：创建管道](#tutorials-stackset-action-pipeline)
+ [步骤 3：查看初始部署](#tutorials-stackset-action-initial)
+ [步骤 4：添加动 CloudFormationStackInstances 作](#tutorials-stacksets-instances)
+ [步骤 5：查看部署的堆栈集资源](#tutorials-stacksets-view)
+ [第 6 步：更新您的堆栈集](#tutorials-stacksets-update)

## 先决条件
<a name="tutorials-stackset-deployment-prereq"></a>

对于堆栈集操作，您可以使用两个不同的账户：管理账户和目标账户。在管理员账户中创建堆栈集。在目标账户中创建属于堆栈集的单个堆栈。

**使用管理员账户创建管理员角色**
+ 按照[为堆栈集操作设置基本权限](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup)中的说明进行操作。您的角色必须命名为 **`AWSCloudFormationStackSetAdministrationRole`**。

**在目标账户中创建服务角色**
+ 在信任管理员账户的目标账户中创建服务角色。按照[为堆栈集操作设置基本权限](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup)中的说明进行操作。您的角色必须命名为 **`AWSCloudFormationStackSetExecutionRole`**。

## 步骤 1：上传示例 AWS CloudFormation 模板和参数文件
<a name="tutorials-stackset-deployment-upload"></a>

为您的堆栈集模板和参数文件创建源桶。下载示例 AWS CloudFormation 模板文件，设置参数文件，然后压缩文件，然后再上传到 S3 源存储桶。

**注意**  
即使唯一的源文件是模板，也要确保先压缩源文件，再上传到 S3 源桶。



**创建 S3 源桶**

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

1. 选择**创建存储桶**。

1. 在**桶名称**中，输入桶的名称。

   在**区域**中，选择要在其中创建管道的区域。请选择**创建存储桶**。

1. 创建存储桶后，系统会显示成功横幅。选择**转到存储桶详细信息**。

1. 在**属性**选项卡上，选择**版本控制**。选择**启用版本控制**，然后选择**保存**。

**创建 AWS CloudFormation 模板文件**

1. 下载以下示例模板文件，用于生成堆栈集的 CloudTrail 配置:[https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml](https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml).

1. 将该文件保存为 `template.yml`。

**创建 parameters.txt 文件**

1. 创建包含部署参数的文件。参数是您要在运行时在堆栈中更新的值。以下示例文件将更新堆栈集的模板参数，以启用日志验证和全局事件。

   ```
   [
     {
       "ParameterKey": "EnableLogFileValidation",
       "ParameterValue": "true"
     }, 
     {
       "ParameterKey": "IncludeGlobalEvents",
       "ParameterValue": "true"
     }
   ]
   ```

1. 将该文件保存为 `parameters.txt`。

**创建 accounts.txt 文件**

1. 创建包含账户（您要从中创建实例）的文件，如以下示例文件所示。

   ```
   [
       "111111222222","333333444444"
   ]
   ```

1. 将该文件保存为 `accounts.txt`。

**创建和上传源文件**

1. 将文件合并为单个 ZIP 文件。您的文件应该在您的 ZIP 文件中如下所示。

   ```
   template.yml
   parameters.txt
   accounts.txt
   ```

1. 将 ZIP 文件上传到 S3 桶。此文件是由 “创建**管道” 向导为中的部署操作创建**的源项目 CodePipeline。

## 步骤 2：创建管道
<a name="tutorials-stackset-action-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 具有 S3 源操作的源阶段，其中源构件是您的模板文件和任何支持源文件。
+ 一个部署阶段，其中包含用于创建 CloudFormation 堆栈集的堆栈集部署操作。
+ 带有 CloudFormation 堆栈实例部署操作的部署阶段，用于在目标账户中创建堆栈和实例。

**使用 CloudFormationStackSet 操作创建管道**

1. 登录 AWS 管理控制台 并打开 CodePipeline 控制台，[网址为 http://console.aws.amazon。 com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyStackSetsPipeline**。

1. 在本教程中，为**管道类型**选择 **V1**。也可以选择 **V2**；但请注意，不同管道类型具有不同的特性和价格。有关更多信息，请参阅 [管道类型](pipeline-types.md)。

1. 在**服务角色**中，选择**新建服务角色** CodePipeline 以允许在 IAM 中创建服务角色。

1. 在**构件存储**中，保留默认值。
**注意**  
这不是源代码的源存储桶。这是管道的项目存储。每个管道都需要一个单独的构件存储，例如 S3 存储桶。创建或编辑管道时，管道区域中必须有一个工件存储桶，并且每个运行操作的 AWS 区域都必须有一个工件存储桶。  
有关更多信息，请参阅[输入和输出构件](welcome-introducing-artifacts.md)和[CodePipeline 管道结构参考](reference-pipeline-structure.md)。

   选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，在**源提供程序**中，选择 **Amazon S3**。

1. 在**桶**中，输入您在本教程中创建的 S3 源桶，例如 `BucketName`。在 **S3 对象键**中，输入 ZIP 文件的文件路径和文件名，例如 `MyFiles.zip`。

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

1. 在**步骤 4：添加构建阶段**中，选择**跳过构建阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在**步骤 6：添加部署阶段**中：

   1. 在**部署提供程序**中，选择 **AWS CloudFormation 堆栈集**。

   1. 在**堆栈集名称**中，为堆栈集输入名称。这是模板将创建的堆栈集的名称。
**注意**  
记下您的堆栈集名称。当您将第二个 StackSets 部署操作添加到管道中时，您将使用它。

   1. 在**模板路径**中，输入构件名称和上传模板文件的文件路径。例如，使用默认源构件名称 `SourceArtifact` 输入以下内容。

      ```
      SourceArtifact::template.yml
      ```

   1. 在**部署目标**中，输入构件名称和上传账户文件的文件路径。例如，使用默认源构件名称 `SourceArtifact` 输入以下内容。

      ```
      SourceArtifact::accounts.txt
      ```

   1. 在**部署目标**中 AWS 区域，输入一个用于部署初始堆栈实例的区域，例如`us-east-1`。

   1. 展开**部署选项**。在**参数**中，输入构件名称和上传参数文件的文件路径。例如，使用默认源构件名称 `SourceArtifact` 输入以下内容。

      ```
      SourceArtifact::parameters.txt
      ```

      要将参数作为文字输入而不是文件路径，请输入以下内容：

      ```
      ParameterKey=EnableLogFileValidation,ParameterValue=true
      ParameterKey=IncludeGlobalEvents,ParameterValue=true
      ```

   1. 在**功能**中，选择 CAPABILITY\$1IAM 和 CAPABILITY\$1NAMED\$1IAM。

   1. 在**权限模式**中，选择 SELF\$1MANAGED。

   1. 在**失效容限百分比**中，输入 `20`。

   1. 在**最大并发百分比**中，输入 `25`。

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

   1. 在**步骤 7：审核**中，选择**创建管道**。将显示您的管道。

   1. 允许您的管道运行。

## 步骤 3：查看初始部署
<a name="tutorials-stackset-action-initial"></a>

查看初始部署的资源和状态。验证部署已成功创建堆栈集后，您可以将另一个操作添加到**部署**阶段。

**查看资源**

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

1. 在**管道**下，选择您的管道并选择**查看**。该图显示了您的管道源和部署阶段。

1. 选择对 CloudFormation 管道中**CloudFormationStackSet**操作的操作。您的堆栈集的模板、资源和事件显示在 CloudFormation 控制台中。

1. 在左侧导航面板中，选择**StackSets**。在列表中，选择新的堆栈集。

1. 选择**堆栈实例**选项卡。验证已在 us-east-1 区域中为您提供的每个账户创建了一个堆栈实例。验证每个堆栈实例的状态为 `CURRENT`。

## 步骤 4：添加动 CloudFormationStackInstances 作
<a name="tutorials-stacksets-instances"></a>

在管道中创建下一个操作 CloudFormation StackSets 以允许创建剩余堆栈实例。

**在管道中创建下一操作**

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

   在**管道**下，选择您的管道并选择**查看**。该图显示了您的管道源和部署阶段。

1. 选择以编辑管道。管道将在**编辑**模式下显示。

1. 在**部署**阶段上，选择**编辑**。

1. 在 **AWS CloudFormation 堆栈集**部署操作下，选择**添加操作组**。

1. 在**编辑操作**页面上，添加操作详细信息：

   1. 在**操作名称**中，为操作输入名称。

   1. 在**操作提供程序**中，选择 **AWS CloudFormation 堆栈实例**。

   1. 在**输入构件**中，选择 **SourceArtifact**。

   1. 在**堆栈集名称**中，为堆栈集输入名称。这是您在第一个操作中提供的堆栈集的名称。

   1. 在**部署目标**中，输入构件名称和上传账户文件的文件路径。例如，使用默认源构件名称 `SourceArtifact` 输入以下内容。

      ```
      SourceArtifact::accounts.txt
      ```

   1. 在**部署目标**中 AWS 区域，输入用于部署剩余堆栈实例的区域，`eu-central-1`例如`us-east-2`和如下：

      ```
      us-east2, eu-central-1
      ```

   1. 在**失效容限百分比**中，输入 `20`。

   1. 在**最大并发百分比**中，输入 `25`。

   1. 选择**保存**。

   1. 手动发布更改。更新的管道将在“部署”阶段显示两个操作。

## 步骤 5：查看部署的堆栈集资源
<a name="tutorials-stacksets-view"></a>

查看堆栈集部署的资源和状态。

**查看资源**

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

1. 在**管道**下，选择您的管道，然后选择**查看**。该图显示了您的管道源和部署阶段。

1. 选择对 CloudFormation 管道中**`AWS CloudFormation Stack Instances`**操作的操作。您的堆栈集的模板、资源和事件显示在 CloudFormation 控制台中。

1. 在左侧导航面板中，选择**StackSets**。在列表中，选择您的堆栈集。

1. 选择**堆栈实例**选项卡。验证已在预期区域中创建或更新您提供的每个账户的所有剩余堆栈实例。验证每个堆栈实例的状态为 `CURRENT`。

## 第 6 步：更新您的堆栈集
<a name="tutorials-stacksets-update"></a>

更新您的堆栈集并将更新部署到实例。在此示例中，您还将更改您指定进行更新的部署目标。不属于更新的实例将变为已过期状态。

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

1. 在**管道**下，选择您的管道，然后选择**编辑**。在**部署**阶段上，选择**编辑**。

1. 选择编辑管道中的 **AWS CloudFormation 堆栈集**操作。在**描述**中，使用堆栈集的新描述覆盖现有描述。

1. 选择编辑管道中的 **AWS CloudFormation 堆栈实例**操作。在**部署目标**中 AWS 区域，删除创建操作时输入的`us-east-2`值。

1. 保存更改。选择**发布更改**以运行管道。

1. 在 CloudFormation中打开您的操作。选择 “**StackSet 信息**” 选项卡。在**StackSet 描述**中，验证是否显示了新的描述。

1. 选择**堆栈实例**选项卡。在**状态**下，验证 us-east-2 中堆栈实例的状态为 `OUTDATED`。

# 教程：为管道创建变量检查规则作为“入口”条件
<a name="tutorials-varcheckrule"></a>

在本教程中，您将配置一个管道，该管道使用 GitHub作为源代码阶段的源操作提供者来持续传送文件。完成的管道会在您对源存储库中的源文件进行更改时检测更改。管道运行后，会根据进入构建阶段的条件中提供的源存储库名称和分支名称检查输出变量。

**重要**  
作为创建管道的一部分，客户提供的 S3 工件存储桶将 CodePipeline 用于项目。（这与用于 S3 源操作的存储桶不同。） 如果 S3 工件存储桶与您的管道账户位于不同的账户中，请确保 S3 工件存储桶归其所有 AWS 账户 ，该存储桶是安全且可靠的。

**重要**  
在此过程中，您在管道中添加的许多操作都涉及在创建管道之前需要创建的 AWS 资源。 AWS 源操作的资源必须始终在您创建管道的同一 AWS 区域创建。例如，如果您在美国东部（俄亥俄州）地区创建管道，则您的 CodeCommit 存储库必须位于美国东部（俄亥俄州）区域。  
您可以在创建管道时添加跨区域操作。 AWS 跨区域操作的资源必须位于您计划执行操作的同一 AWS 区域。有关更多信息，请参阅 [在中添加跨区域操作 CodePipeline](actions-create-cross-region.md)。

此示例使用带有 GitHub （版本 2）源操作和 CodeBuild生成操作的示例管道，其中生成阶段的输入条件将检查变量。

## 先决条件
<a name="tutorials-varcheckrule-prereq"></a>

在开始之前，您必须执行以下操作：
+ 使用您的 GitHub 账户创建 GitHub 存储库。
+ 准备好您的 GitHub 凭证。当你使用 AWS 管理控制台 来建立连接时，系统会要求你使用自己的 GitHub 凭据登录。
+ 与存储库的连接，将 GitHub （通过 GitHub App）设置为管道的源操作。要创建与存储 GitHub 库的连接，请参阅[GitHub 连接](connections-github.md)。

## 第 1 步：创建示例源文件并将其添加到 GitHub 存储库中
<a name="tutorials-varcheckrule-push"></a>

在本节中，您将创建示例源文件并将其添加到管道用于源阶段的存储库中。在此示例中，您生成并添加以下内容：
+ 一个 `README.md` 文件。

创建存储 GitHub 库后，按照以下步骤添加自述文件。

1. 登录您的 GitHub 存储库并选择您的存储库。

1. 要创建新文件，请选择**添加文件**，然后选择**创建新文件**。将文件命名为 `README.md` 并添加以下文本。

   ```
   This is a GitHub repository!
   ```

1. 选择**提交更改**。在本教程中，请添加包含大写单词“Update”的提交消息，如下例所示：

   ```
   Update to source files
   ```
**注意**  
字符串的规则检查区分大小写。

   确保 `README.md` 文件位于存储库的根级别。

## 步骤 2：创建管道
<a name="tutorials-varcheckrule-create-pipeline"></a>

在此部分中，您将使用以下操作创建管道：
+ 一个与您的 GitHub 仓库连接和操作的源阶段。
+ 为变量检查规则配置了 On Entry 条件的 CodeBuild 构建阶段。

**使用向导创建管道**

1. 登录 CodePipeline 控制台，网址为[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 在**欢迎**页面、**入门**页面或**管道**页面上，选择**创建管道**。

1. 在**步骤 1：选择创建选项**页面上的**创建选项**下，选择**构建自定义管道**选项。选择**下一步**。

1. 在**步骤 2：选择管道设置**的**管道名称**中，输入 **MyVarCheckPipeline**。

1. CodePipeline 提供 V1 和 V2 类型的管道，它们的特性和价格各不相同。在控制台中，您只能选择 V2 类型。有关更多信息，请参阅[管道类型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。有关定价的信息 CodePipeline，请参阅[定价](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服务角色**中，选择**新建服务角色**。
**注意**  
如果您选择使用现有的 CodePipeline 服务角色，请确保已`codeconnections:UseConnection`将 IAM 权限添加到您的服务角色策略中。有关 CodePipeline服务角色的说明，请参阅[为 CodePipeline 服务角色添加权限](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**高级设置**下，保留原定设置值。

   选择**下一步**。

1. 在**步骤 3：添加源阶段**页面上，添加源阶段：

   1. 在**来源提供商**中，选择 **GitHub（通过 GitHub 应用程序）**。

   1. 在**连接**下，选择一个现有连接或创建一个新连接。要创建或管理 GitHub源操作的连接，请参阅[GitHub 连接](connections-github.md)。

   1. 在 **Repository name (存储库名称)** 中，选择 GitHub 存储库的名称。

   1. 在**分支名称**中，键入要使用的存储库分支。

   1. 确保**没有触发器**选项已选中。

   选择**下一步**。

1. 在**步骤 4：添加构建阶段**中，添加一个构建阶段：

   1. 在**构建提供程序**中，选择 **AWS CodeBuild**。允许**区域**默认为管道区域。

   1. 选择**创建项目**。

   1. 在**项目名称**中，输入此构建项目的名称。

   1. 在**环境映像**中，选择**托管映像**。对于**操作系统**，选择 **Ubuntu**。

   1. 对于**运行时**，选择**标准**。**对于 “**图像**”，选择:5.0 aws/codebuild/standard。**

   1. 对于**服务角色**，选择**新建服务角色**。
**注意**  
记下您的 CodeBuild 服务角色的名称。在本教程的最后一步，您会用到此角色名称。

   1. 在**构建规范**下，为**构建规范**选择**插入构建命令**。选择**切换到编辑器**，然后将以下内容粘贴到**构建命令**。

      ```
      version: 0.2
      #env:
        #variables:
           # key: "value"
           # key: "value"
        #parameter-store:
           # key: "value"
           # key: "value"
        #git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
          #commands:
            # - command
            # - command
        #pre_build:
          #commands:
            # - command
            # - command
        build:
          commands:
            - 
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
           - '*'
          # - location
        name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. 选择 “**继续” CodePipeline**。这将返回到 CodePipeline 控制台并创建一个使用您的构建命令进行配置的 CodeBuild 项目。构建项目使用服务角色来管理 AWS 服务 权限。此步骤可能需要几分钟时间。

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

1. 在**步骤 5：添加测试阶段**中，选择**跳过测试阶段**，并通过再次选择**跳过**接受警告消息。

   选择**下一步**。

1. 在 “**步骤 6：添加部署阶段**” 页上，选择 “**跳过部署阶段**”，然后再次选择 “**跳过**”，接受警告消息。选择**下一步**。

1. 在 “**步骤 7：查看**” 中，选择 “**创建管道**”。

## 步骤 2：编辑构建阶段以添加条件和规则
<a name="tutorials-varcheckrule-create-condition"></a>

在此步骤中，您要编辑阶段，为变量检查规则添加“进入时”条件。

1. 选择管道，然后选择**编辑**。选择在构建阶段添加入口规则。

   在**规则提供者**中，选择**VariableCheck**。

1. 在**变量**中，输入要检查的一个或多个变量。在**值**中，输入要对照已解析的变量进行检查的字符串值。在以下示例屏幕中，为“等于”检查创建了一条规则，为“包含”检查创建了另一条规则。  
![\[“等于”变量检查的规则创建页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/varcheck-tut-create-rule-equals.png)  
![\[“包含”变量检查的规则创建页面\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/varcheck-tut-create-rule-contains.png)

1. 选择**保存**。

   选择**完成**。

## 步骤 3：运行管道并查看已解析的变量
<a name="tutorials-varcheckrule-run"></a>

在此步骤中，您将查看变量检查规则的已解析值和结果。

1. 如以下示例所示，在规则检查成功后查看已解析的运行。  
![\[成功运行\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/varcheck-tut-run-succeeded.png)

1. 在**时间线**选项卡上查看变量信息。  
![\[显示“时间线”选项卡的历史记录页面，变量显示 succeeded\]](http://docs.aws.amazon.com/zh_cn/codepipeline/latest/userguide/images/varcheck-tut-history.png)