本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 基于使用场景的 CodeBuild 示例
您可以使用这些基于使用案例的示例来试验 AWS CodeBuild：
[跨服务示例](cross-service-samples.md)
用来试验 AWS CodeBuild 的跨服务示例列表。
[构建徽章示例](sample-build-badges.md)
说明如何使用构建徽章设置 CodeBuild。
[测试报告示例](sample-test-report-cli.md)
使用 AWS CLI 创建、运行和查看测试报告的结果。
[的 Docker 示例 CodeBuild](sample-docker-section.md)
演示如何使用自定义 Docker 映像、将 Docker 映像发布到 Amazon ECR 中的存储库，以及在私有注册表中使用 Docker 映像。
[将构建输出托管在 S3 存储桶中 ](sample-disable-artifact-encryption.md)
说明如何使用未加密的构建构件在 S3 存储桶中创建静态网站。
[ 多个输入和输出示例 ](sample-multi-in-out.md)
演示如何在构建项目中使用多个输入源和多个输出构件。
[ 并行测试执行示例 ](sample-parallel-test.md)
演示如何使用 `codebuild-tests-run` CLI 命令跨并行执行环境拆分和运行测试。
[ buildspec 文件示例中的运行时版本 ](sample-runtime-versions.md)
说明如何在 buildspec 文件中指定运行时及其版本。
[源版本示例](sample-source-version.md)
说明如何在 CodeBuild 构建项目中使用源的特定版本。
[的第三方源代码库示例 CodeBuild](sample-third-party-source.md)
演示如何使用 CodeBuild 创建包含 webhook 的 Bitbucket、GitHub Enterprise Server 和 GitHub 拉取请求。
[使用语义版本控制在构建时设置构件名称](sample-buildspec-artifact-naming.md)
说明如何使用语义版本控制在构建时创建构件名称。
# 的跨服务示例 CodeBuild
您可以使用这些跨服务示例进行 AWS CodeBuild实验：
[Amazon ECR 示例](sample-ecr.md)
使用 Amazon ECR 存储库中的 Docker 映像，以使用 Apache Maven 生成单个 JAR 文件。示例说明将向您展示如何创建 Docker 镜像并将其推送到 Amazon ECR、创建 Go 项目、构建项目、运行项目以及如何设置权限 CodeBuild 以允许连接 Amazon ECR。
[Amazon EFS 示例](sample-efs.md)
演示如何配置 buildspec 文件，以便在 Amazon EFS 文件系统上安装和构建 CodeBuild 项目。示例说明将向您展示如何创建 Amazon VPC、在 Amazon VPC 中创建文件系统、创建和构建使用 Amazon VPC 的项目，然后演示如何查看生成的项目文件和变量。
[AWS CodePipeline 样本](sample-codepipeline.md)
演示 AWS CodePipeline 如何使用创建包含批处理构建、多个输入源和多个输出工件的构建。本节中包括的示例 JSON 文件展示了使用单独构件和合并构件创建批量构建的管线结构。本节还提供了一个额外的 JSON 示例，用于展示具有多个输入源和多个输出构件的管线结构。
[AWS Config 样本](how-to-integrate-config.md)
演示如何设置 AWS Config。列出跟踪哪些 CodeBuild 资源并描述如何在中查找 CodeBuild 项目 AWS Config。示例说明将向您展示与 AWS Config集成的先决条件 AWS Config、设置步骤以及查找 CodeBuild 项目和数据的步骤 AWS Config。
[构建通知示例](sample-build-notifications.md)
使用 Apache Maven 生成单个 JAR 文件。给 Amazon SNS 主题的订阅者发送构建通知。示例说明向您展示了如何设置权限以便与 Amazon SNS 进行通信 CloudWatch，以及如何在 Amazon SNS 中创建和识别 CodeBuild 主题、如何为收件人订阅主题以及如何在中设置规则。 CodeBuild CloudWatch
# 的亚马逊 ECR 示例 CodeBuild
此示例使用 Amazon Elastic Container Registry（Amazon ECR）映像存储库中的 Docker 映像生成示例 Go 项目。
**重要**
运行此示例可能会导致您的 AWS 账户被扣款。其中包括与 Amazon S3、 AWS KMS、 CloudWatch 日志和 Amazon ECR 相关的 AWS 资源和操作可能产生的费用。 AWS CodeBuild 有关更多信息，请参阅[CodeBuild 定价](https://aws.amazon.com/codebuild/pricing)、[Amazon S3 定价](https://aws.amazon.com/s3/pricing)、[AWS Key Management Service 定价](https://aws.amazon.com/kms/pricing)、[亚马逊 CloudWatch 定价](https://aws.amazon.com/cloudwatch/pricing)和[亚马逊弹性容器注册表定价](https://aws.amazon.com/ecr/pricing)。
**Topics**
+ [运行 Amazon ECR 示例](#sample-ecr-running)
## 运行 Amazon ECR 示例
按照以下说明运行 Amazon ECR 示例。 CodeBuild
**要运行此示例，请执行以下操作：**
1. 要创建 Docker 映像并将其推送到 Amazon ECR 中的映像存储库，请完成 [“将 Docker 映像发布到 Amazon ECR”示例](sample-docker.md) 的 [运行“将 Docker 映像发布到 Amazon ECR”示例](sample-docker.md#sample-docker-running) 部分中的步骤。
1. 创建 Go 项目：
1. 按照本主题[Go 项目结构](#ecr-sample-go-project-file-structure)和[Go 项目文件](#sample-ecr-go-project-files)部分所述创建文件，然后将其上传到 S3 输入存储桶或 AWS CodeCommit GitHub、或 Bitbucket 存储库。
**重要**
请不要上传 `(root directory name)`，而只上传 `(root directory name)` 中的文件。
如果您使用的是 S3 输入存储桶，请务必创建一个包含这些文件的 ZIP 文件，然后将其上传到输入存储桶。请不要将 `(root directory name)` 添加到 ZIP 文件中，而只添加 `(root directory name)` 中的文件。
1. 创建构建项目、运行构建和查看相关构建信息。
如果您使用创建构建项目，则`create-project`命令的 JSON 格式输入可能与此类似。 AWS CLI (请将占位符替换为您自己的值。)
```
{
"name": "sample-go-project",
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/GoSample.zip"
},
"artifacts": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-output-bucket",
"packaging": "ZIP",
"name": "GoOutputArtifact.zip"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "BUILD_GENERAL1_SMALL"
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name",
"encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}
```
1. 要获取构建输出构件，请打开您的 S3 输出存储桶。
1. 将 `GoOutputArtifact.zip` 文件下载到您的本地计算机或实例，然后提取该文件的内容。在提取出来的内容中，获取 `hello` 文件。
1. 如果满足以下条件之一，则必须在 Amazon ECR 中为镜像存储库添加权限，这样 AWS CodeBuild 才能将其 Docker 映像拉入构建环境。
+ 您的项目使用 CodeBuild 凭证来提取 Amazon ECR 映像。这是由 `ProjectEnvironment` 的 `imagePullCredentialsType` 属性中的 `CODEBUILD` 值指示的。
+ 您的项目使用了跨账户 Amazon ECR 映像。在这种情况下，您的项目必须使用其服务角色拉取 Amazon ECR 映像。要启用此行为，请将您的 `ProjectEnvironment` 的 `imagePullCredentialsType` 属性设置为 `SERVICE_ROLE`。
1. 打开 Amazon ECR 控制台，网址为[https://console.aws.amazon.com/ecr/](https://console.aws.amazon.com/ecr/)。
1. 在存储库名称列表中，选择您创建或选择的存储库的名称。
1. 在导航窗格中，依次选择**权限**、**编辑**和**添加语句**。
1. 对于**声明名称**，输入标识符（例如 **CodeBuildAccess**）。
1. 对于**效果**，选择**允许**。这表示您希望允许访问另一个 AWS 账户。
1. 对于**主体**，执行以下操作之一：
+ 如果您的项目使用 CodeBuild 凭证提取 Amazon ECR 映像，请在**服务主体**中输入**codebuild.amazonaws.com**。
+ **如果您的项目使用跨账户 Amazon ECR 图片 IDs，请输入 IDs 您想要授予访问权限的 AWS 账户。AWS **
1. 跳过**所有 IAM 实体**列表。
1. **在 “**操作**” 中，选择仅限拉取的操作：**ecr: GetDownloadUrlForLayer**、**ecr: 和 ecr: BatchGetImage**。BatchCheckLayerAvailability**
1. 对于**条件**，请添加以下内容：
```
{
"StringEquals":{
"aws:SourceAccount":"",
"aws:SourceArn":"arn:aws:codebuild:::project/"
}
}
```
1. 选择**保存**。
此策略显示在**权限**中。主体是您在此过程的步骤 3 中为**主体**输入的内容：
+ 如果您的项目使用 CodeBuild 凭证提取 Amazon ECR 映像，则`"codebuild.amazonaws.com"`会显示在 “**服务主体**” 下。
+ **如果您的项目使用跨账户 Amazon ECR 图片，则您要授予访问权限的 AWS 账户的 ID 将显示在账户下方AWS 。 IDs**
以下示例策略同时使用 CodeBuild 凭证和跨账户 Amazon ECR 映像。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CodeBuildAccessPrincipal",
"Effect": "Allow",
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:codebuild:us-east-1:111122223333:project/MyProject",
"aws:SourceAccount": "111122223333"
}
}
},
{
"Sid": "CodeBuildAccessCrossAccount",
"Effect": "Allow",
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*"
}
]
}
```
------
+ 如果您的项目使用 CodeBuild 证书，并且您希望您的 CodeBuild 项目拥有对 Amazon ECR 存储库的开放访问权限，则可以省略`Condition`密钥并添加以下示例策略。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CodeBuildAccessPrincipal",
"Effect": "Allow",
"Resource": [
"arn:aws:codecommit:us-east-2:111122223333:MySharedDemoRepo"
],
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
]
},
{
"Sid": "CodeBuildAccessCrossAccount",
"Effect": "Allow",
"Resource": [
"arn:aws:codecommit:us-east-2:111122223333:MySharedDemoRepo"
],
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
]
}
]
}
```
------
1. 创建构建项目、运行构建和查看构建信息。
如果您使用创建构建项目，则`create-project`命令的 JSON 格式输入可能与此类似。 AWS CLI (请将占位符替换为您自己的值。)
```
{
"name": "amazon-ecr-sample-project",
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/GoSample.zip"
},
"artifacts": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-output-bucket",
"packaging": "ZIP",
"name": "GoOutputArtifact.zip"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "account-ID.dkr.ecr.region-ID.amazonaws.com/your-Amazon-ECR-repo-name:tag",
"computeType": "BUILD_GENERAL1_SMALL"
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name",
"encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}
```
1. 要获取构建输出构件，请打开您的 S3 输出存储桶。
1. 将 `GoOutputArtifact.zip` 文件下载到您的本地计算机或实例，然后提取 `GoOutputArtifact.zip` 文件的内容。在提取出来的内容中，获取 `hello` 文件。
### Go 项目结构
此示例采用以下目录结构。
```
(root directory name)
├── buildspec.yml
└── hello.go
```
### Go 项目文件
此示例将使用这些文件。
`buildspec.yml`（在 `(root directory name)`）
```
version: 0.2
phases:
install:
runtime-versions:
golang: 1.13
build:
commands:
- echo Build started on `date`
- echo Compiling the Go code
- go build hello.go
post_build:
commands:
- echo Build completed on `date`
artifacts:
files:
- hello
```
`hello.go`（在 `(root directory name)`）
```
package main
import "fmt"
func main() {
fmt.Println("hello world")
fmt.Println("1+1 =", 1+1)
fmt.Println("7.0/3.0 =", 7.0/3.0)
fmt.Println(true && false)
fmt.Println(true || false)
fmt.Println(!true)
}
```
# 的亚马逊 Elastic File System 示例 AWS CodeBuild
您可能需要在 Amazon Elastic File System 上创建您的 AWS CodeBuild 构建，这是一种适用于 Amazon EC2 实例的可扩展共享文件服务。Amazon EFS 中的存储容量是弹性的，因此会随着文件的添加和删除而增长或收缩。它具有简单的 Web 服务界面，可用于创建和配置文件系统。它还为您管理所有文件存储基础设施，因此您无需担心部署、修补或维护文件系统配置。有关更多信息，请参阅 *Amazon Elastic File System 用户指南*中的[什么是 Amazon Elastic File System？](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html)。
此示例向您展示如何配置 CodeBuild 项目，使其安装并构建 Java 应用程序到 Amazon EFS 文件系统。在开始之前，您必须准备好构建并上传到 S3 输入存储桶或 AWS CodeCommit、 GitHub、 GitHub 企业服务器或 Bitbucket 存储库的 Java 应用程序。
系统会加密文件系统的传输中数据。要使用其他映像来加密传输中的数据，请参阅[加密传输中的数据](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html)。
**Topics**
+ [AWS CodeBuild 与亚马逊 Elastic File System 一起使用](#sample-efs-high-level-steps)
+ [排查 Amazon EFS 集成问题](sample-efs-troubleshooting.md)
## AWS CodeBuild 与亚马逊 Elastic File System 一起使用
该示例涵盖了使用 Amazon EFS 所需的四个高级步骤 AWS CodeBuild。它们是：
1. 在您的 AWS 账户中创建虚拟私有云 (VPC)。
1. 创建使用此 VPC 的文件系统。
1. 创建并构建使用 VPC 的 CodeBuild 项目。该 CodeBuild 项目使用以下内容来标识文件系统：
+ 文件系统的唯一标识符。当您在构建项目中指定文件系统时，可以选择该标识符。
+ 文件系统 ID。当您在 Amazon EFS 控制台中查看文件系统时，系统会显示该 ID。
+ 挂载点。这是 Docker 容器中用于挂载文件系统的目录。
+ 挂载选项。这些选项包含了有关如何挂载文件系统的详细信息。
1. 查看构建项目，确保生成了正确的项目文件和变量。
**注意**
只有 Linux 平台支持在 Amazon EFS 中创建的文件系统。
**Topics**
+ [步骤 1：使用创建 VPC CloudFormation](#sample-efs-create-vpc)
+ [步骤 2：使用 VPC 创建 Amazon Elastic File System 文件系统](#sample-efs-create-efs)
+ [第 3 步：创建要用于 Amazon EFS 的 CodeBuild 项目](#sample-efs-create-acb)
+ [步骤 4：检查构建项目](#sample-efs-summary)
### 步骤 1：使用创建 VPC CloudFormation
使用 CloudFormation 模板创建您的 VPC。
1. 按照中的说明进行操作[CloudFormation VPC 模板](cloudformation-vpc-template.md)， CloudFormation 使用创建 VPC。
**注意**
此 CloudFormation 模板创建的 VPC 有两个私有子网和两个公有子网。当您使用 AWS CodeBuild 挂载在 Amazon EFS 中创建的文件系统时，只能使用私有子网。如果您使用其中一个公有子网，则构建会失败。
1. 登录 AWS 管理控制台 并打开 Amazon VPC 控制台，网址为[https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)。
1. 选择您创建时使用的 VPC CloudFormation。
1. 在**描述**选项卡上，记下 VPC 的名称及其 ID。在本示例的后面部分中创建您的 AWS CodeBuild 项目时，需要这两者。
### 步骤 2：使用 VPC 创建 Amazon Elastic File System 文件系统
使用您之前创建的 VPC 为本示例创建简单的 Amazon EFS 文件系统。
1. 登录 AWS 管理控制台 并打开 Amazon EFS 控制台，网址为[ https://console.aws.amazon.com/efs/](https://console.aws.amazon.com/efs/)。
1. 选择**创建文件系统**。
1. 从 **VPC**，选择您之前在本示例中记录的 VPC 名称。
1. 保持可用区与您选定子网的关联。
1. 选择**下一步**。
1. 在**添加标签**中，对于默认的**名称**键，在**值**中，输入 Amazon EFS 文件系统的名称。
1. 保留**突增**和**通用型**选定为您的默认性能和吞吐量模式，然后选择**下一步**。
1. 对于**配置客户端访问**，请选择**下一步**。
1. 选择**创建文件系统**。
1. （可选）我们建议您为您的 Amazon EFS 文件系统添加策略，以强制对传输中的数据进行加密。在 Amazon EFS 控制台中，选择**文件系统策略**，选择**编辑**，选中标有**针对所有客户端强制执行传输中加密**的复选框，然后选择**保存**。
### 第 3 步：创建要用于 Amazon EFS 的 CodeBuild 项目
创建一个使用您在本示例前面创建的 VPC 的 AWS CodeBuild 项目。运行构建时，它会挂载之前创建的 Amazon EFS 文件系统。接下来，它会将 Java 应用程序创建的 .jar 文件存储在文件系统的挂载点目录中。
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 从导航窗格中选择**构建项目**，然后选择**创建构建项目**。
1. 在**项目名称**中输入项目名称。
1. 从**源提供商**中，选择包含要构建的 Java 应用程序的存储库。
1. 输入 CodeBuild 用于定位应用程序的信息，例如存储库 URL。每个源提供商的选项有所不同。有关更多信息，请参阅 [Choose source provider](create-project.md#create-project-source-provider)。
1. 从**环境映像**中，选择**托管映像**。
1. 从**操作系统**中，选择 **Amazon Linux 2**。
1. 从**运行时**中，选择**标准**。
1. 从**图片中**，选择 **aws/codebuild/amazonlinux-x** 86\$164-standards: 4.0。
1. 从**环境类型**中，选择 **Linux**。
1. 在**服务角色**下，选择**新建服务角色**。在**角色名称**中，输入为您 CodeBuild 创建的角色的名称。
1. 展开**其他配置**。
1. 选择**如果要构建 Docker 映像或希望您的构建获得提升的特权，请启用此标志**。
**注意**
默认情况下，为非 VPC 构建启用 Docker 进程守护程序。如果您想使用 Docker 容器进行 VPC 构建，请参阅 Docker 文档网站上的[运行时权限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)并启用特权模式。此外，Windows 不支持特权模式。
1. 从 **VPC** 中，选择 VPC ID。
1. 从**子网**中，选择一个或多个与您的 VPC 关联的私有子网。您必须在挂载 Amazon EFS 文件系统的构建项目中使用私有子网。如果您使用公有子网，则构建会失败。
1. 从**安全组**中，选择默认安全组。
1. 在**文件系统**中，输入以下信息：
+ 针对**标识符**，输入文件系统的唯一标识符。该标识符必须少于 129 个字符，并且只能包含字母数字字符和下划线。 CodeBuild 使用此标识符来创建用于标识弹性文件系统的环境变量。该环境变量的格式为采用大写字母的 `CODEBUILD_`。例如，如果输入 `my_efs`，则环境变量为 `CODEBUILD_MY_EFS`。
+ 对于 **ID**，请选择文件系统 ID。
+ （可选）输入文件系统中的一个目录。 CodeBuild 装入此目录。如果将 **Directory path (目录路径)** 留为空白，则 CodeBuild 会挂载整个文件系统。该路径相对于文件系统的根目录指定。
+ 对于**挂载点**，输入构建容器中用于挂载文件系统的目录的绝对路径。如果此目录不存在，则在构建过程中 CodeBuild 创建该目录。
+ （可选）输入挂载选项。如果将**装载选项**留空，则 CodeBuild 使用其默认装载选项：
```
nfsvers=4.1
rsize=1048576
wsize=1048576
hard
timeo=600
retrans=2
```
有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[建议的 NFS 挂载选项](https://docs.aws.amazon.com/efs/latest/ug/mounting-fs-nfs-mount-settings.html)。
1. 对于**构建规范**，选择**插入构建命令**，然后选择**切换到编辑器**。
1. 在编辑器中输入以下构建规范命令。将 `` 替换为您在步骤 17 中输入的标识符。使用大写字母（例如 `CODEBUILD_MY_EFS`）。
```
version: 0.2
phases:
install:
runtime-versions:
java: corretto11
build:
commands:
- mvn compile -Dgpg.skip=true -Dmaven.repo.local=$CODEBUILD_
```
1. 对所有其他设置使用默认值，然后选择**创建构建项目**。构建完成后，系统会显示项目的控制台页面。
1. 选择**开始构建**。
### 步骤 4：检查构建项目
AWS CodeBuild 项目构建完成后：
+ 您会拥有一个由 Java 应用程序创建的 .jar 文件，该文件已被构建到您的挂载点目录下的 Amazon EFS 文件系统中。
+ 系统会使用您在创建项目时输入的文件系统标识符，创建标识文件系统的环境变量。
有关更多信息，请参阅《Amazon Elastic File System 用户指南》**中的[装载文件系统](https://docs.aws.amazon.com/efs/latest/ug/mounting-fs.html)。
# 排查 Amazon EFS 集成问题
以下是您在设置 Amazon EFS 时可能遇到的错误 CodeBuild。
**Topics**
+ [CLIENT\$1ERROR：挂载 127.0.0.1:/ 失败。权限被拒绝](#sample-efs-troubleshooting.permission-denied)
+ [CLIENT\$1ERROR：挂载 127.0.0.1:/ 失败。连接被对等方重置](#sample-efs-troubleshooting.connection-reset)
+ [VPC\$1CLIENT\$1ERROR：意外的 EC2 错误： UnauthorizedOperation](#sample-efs-troubleshooting.unauthorized-operation)
## CLIENT\$1ERROR：挂载 127.0.0.1:/ 失败。权限被拒绝
通过挂载 Amazon EFS 不支持 IAM 授权 CodeBuild。如果您使用的是自定义 Amazon EFS 文件系统策略，则需要向所有 IAM 主体授予读写权限。例如：
```
"Principal": {
"AWS": "*"
}
```
## CLIENT\$1ERROR：挂载 127.0.0.1:/ 失败。连接被对等方重置
有两种可能的原因会导致此错误：
+ CodeBuild VPC 子网与 Amazon EFS 挂载目标位于不同的可用区中。您可以通过在 Amazon EFS 挂载目标所在的同一可用区中添加 VPC 子网来解决此问题。
+ 安全组不具备与 Amazon EFS 通信的权限。您可以通过添加入站规则来允许来自 VPC（为您的 VPC 添加主要 CIDR 块）或安全组本身的所有流量，从而解决此问题。
## VPC\$1CLIENT\$1ERROR：意外的 EC2 错误： UnauthorizedOperation
当 CodeBuild项目的 VPC 配置中的所有子网均为公有子网时，就会发生此错误。您在 VPC 中必须至少有一个私有子网才能确保网络连接正常。
# AWS CodePipeline 的样品 CodeBuild
本节介绍 CodePipeline 和 CodeBuild之间的集成示例。
| 样本 | 说明 |
| --- | --- |
| [CodePipeline/CodeBuild 集成和批量构建示例](#sample-pipeline-batch) | 这些示例演示了如何使用 AWS CodePipeline 来创建使用批量构建的构建项目。 |
| [具有多个输入源和输出工件的 CodePipeline/CodeBuild 集成示例](#sample-pipeline-multi-input-output) | 此示例演示 AWS CodePipeline 如何使用创建使用多个输入源来创建多个输出构件的构建项目。 |
## CodePipeline/CodeBuild 集成和批量构建示例
AWS CodeBuild 支持批量构建。以下示例演示 AWS CodePipeline 如何使用创建使用批量构建的构建项目。
您可以使用 JSON 格式的文件来定义管道的结构，然后将其与一起使用 AWS CLI 来创建管道。有关更多信息，请参阅《AWS CodePipeline 用户指南》**中的 [AWS CodePipeline 管道结构参考](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html)。
### 使用单个构件进行批量构建
使用以下 JSON 文件作为管道结构的示例，该结构使用单个构件创建批量构建。要在中启用批量构建 CodePipeline，请将`configuration`对象的`BatchEnabled`参数设置为`true`。
```
{
"pipeline": {
"roleArn": "arn:aws:iam::account-id:role/my-AWS-CodePipeline-service-role-name",
"stages": [
{
"name": "Source",
"actions": [
{
"inputArtifacts": [],
"name": "Source1",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"version": "1",
"provider": "S3"
},
"outputArtifacts": [
{
"name": "source1"
}
],
"configuration": {
"S3Bucket": "",
"S3ObjectKey": "my-source-code-file-name.zip"
},
"runOrder": 1
},
{
"inputArtifacts": [],
"name": "Source2",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"version": "1",
"provider": "S3"
},
"outputArtifacts": [
{
"name": "source2"
}
],
"configuration": {
"S3Bucket": "",
"S3ObjectKey": "my-other-source-code-file-name.zip"
},
"runOrder": 1
}
]
},
{
"name": "Build",
"actions": [
{
"inputArtifacts": [
{
"name": "source1"
},
{
"name": "source2"
}
],
"name": "Build",
"actionTypeId": {
"category": "Build",
"owner": "AWS",
"version": "1",
"provider": "CodeBuild"
},
"outputArtifacts": [
{
"name": "build1"
},
{
"name": "build1_artifact1"
},
{
"name": "build1_artifact2"
},
{
"name": "build2_artifact1"
},
{
"name": "build2_artifact2"
}
],
"configuration": {
"ProjectName": "my-build-project-name",
"PrimarySource": "source1",
"BatchEnabled": "true"
},
"runOrder": 1
}
]
}
],
"artifactStore": {
"type": "S3",
"location": ""
},
"name": "my-pipeline-name",
"version": 1
}
}
```
以下是适用于此工作流配置的 CodeBuild buildspec 文件的示例。
```
version: 0.2
batch:
build-list:
- identifier: build1
env:
compute-type: BUILD_GENERAL1_SMALL
- identifier: build2
env:
compute-type: BUILD_GENERAL1_MEDIUM
phases:
build:
commands:
- echo 'file' > output_file
artifacts:
files:
- output_file
secondary-artifacts:
artifact1:
files:
- output_file
artifact2:
files:
- output_file
```
管道的 JSON 文件中指定的输出构件的名称必须与 buildspec 文件中定义的构建和构件的标识符相匹配。语法*buildIdentifier*用于主工件，*buildIdentifier*\$1 *artifactIdentifier* 用于次要工件。
例如，对于输出对象名称`build1`， CodeBuild 会将的主构件上传`build1`到的位置`build1`。对于输出名称`build1_artifact1`， CodeBuild 会将的次要工件`artifact1`上传`build1`到的位置`build1_artifact1`，依此类推。如果只指定了一个输出位置，则名称应为 “*buildIdentifier*只有”。
创建 JSON 文件后，可以创建管道。使用运行 **create-pipelin** e 命令并将文件传递给参数。 AWS CLI `--cli-input-json`有关更多信息，请参阅《AWS CodePipeline 用户指南》**中的[创建管道（CLI）](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create.html#pipelines-create-cli)。
### 使用合并的构件进行批量构建
使用以下 JSON 文件作为管道结构的示例，该结构使用合并的构件创建批量构建。要在中启用批量构建 CodePipeline，请将`configuration`对象的`BatchEnabled`参数设置为`true`。要将构建构件合并到同一位置，请将 `configuration` 对象的 `CombineArtifacts` 参数设置为 `true`。
```
{
"pipeline": {
"roleArn": "arn:aws:iam::account-id:role/my-AWS-CodePipeline-service-role-name",
"stages": [
{
"name": "Source",
"actions": [
{
"inputArtifacts": [],
"name": "Source1",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"version": "1",
"provider": "S3"
},
"outputArtifacts": [
{
"name": "source1"
}
],
"configuration": {
"S3Bucket": "",
"S3ObjectKey": "my-source-code-file-name.zip"
},
"runOrder": 1
},
{
"inputArtifacts": [],
"name": "Source2",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"version": "1",
"provider": "S3"
},
"outputArtifacts": [
{
"name": "source2"
}
],
"configuration": {
"S3Bucket": "",
"S3ObjectKey": "my-other-source-code-file-name.zip"
},
"runOrder": 1
}
]
},
{
"name": "Build",
"actions": [
{
"inputArtifacts": [
{
"name": "source1"
},
{
"name": "source2"
}
],
"name": "Build",
"actionTypeId": {
"category": "Build",
"owner": "AWS",
"version": "1",
"provider": "CodeBuild"
},
"outputArtifacts": [
{
"name": "output1 "
}
],
"configuration": {
"ProjectName": "my-build-project-name",
"PrimarySource": "source1",
"BatchEnabled": "true",
"CombineArtifacts": "true"
},
"runOrder": 1
}
]
}
],
"artifactStore": {
"type": "S3",
"location": ""
},
"name": "my-pipeline-name",
"version": 1
}
}
```
以下是适用于此工作流配置的 CodeBuild buildspec 文件的示例。
```
version: 0.2
batch:
build-list:
- identifier: build1
env:
compute-type: BUILD_GENERAL1_SMALL
- identifier: build2
env:
compute-type: BUILD_GENERAL1_MEDIUM
phases:
build:
commands:
- echo 'file' > output_file
artifacts:
files:
- output_file
```
如果为批量生成启用了组合工件，则只允许一个输出。 CodeBuild 会将所有版本的主要构件合并到一个 ZIP 文件中。
创建 JSON 文件后，可以创建管道。使用运行 **create-pipelin** e 命令并将文件传递给参数。 AWS CLI `--cli-input-json`有关更多信息，请参阅《AWS CodePipeline 用户指南》**中的[创建管道（CLI）](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create.html#pipelines-create-cli)。
## 具有多个输入源和输出工件的 CodePipeline/CodeBuild 集成示例
一个 AWS CodeBuild 项目可以采用多个输入源。也可以创建多个输出构件。此示例演示 AWS CodePipeline 如何使用创建使用多个输入源来创建多个输出构件的构建项目。有关更多信息，请参阅 [多输入源和输出构件示例](sample-multi-in-out.md)。
您可以使用 JSON 格式的文件来定义管道的结构，然后将其与一起使用 AWS CLI 来创建管道。使用以下 JSON 文件作为管道结构的示例，此管道结构可以创建一个具有多输入源和多输出构件的构建。稍后，此示例会介绍该文件如何指定多个输入和输出。有关更多信息，请参阅《*AWS CodePipeline 用户指南》*中的[CodePipeline 管道结构参考](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html)。
```
{
"pipeline": {
"roleArn": "arn:aws:iam::account-id:role/my-AWS-CodePipeline-service-role-name",
"stages": [
{
"name": "Source",
"actions": [
{
"inputArtifacts": [],
"name": "Source1",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"version": "1",
"provider": "S3"
},
"outputArtifacts": [
{
"name": "source1"
}
],
"configuration": {
"S3Bucket": "my-input-bucket-name",
"S3ObjectKey": "my-source-code-file-name.zip"
},
"runOrder": 1
},
{
"inputArtifacts": [],
"name": "Source2",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"version": "1",
"provider": "S3"
},
"outputArtifacts": [
{
"name": "source2"
}
],
"configuration": {
"S3Bucket": "my-other-input-bucket-name",
"S3ObjectKey": "my-other-source-code-file-name.zip"
},
"runOrder": 1
}
]
},
{
"name": "Build",
"actions": [
{
"inputArtifacts": [
{
"name": "source1"
},
{
"name": "source2"
}
],
"name": "Build",
"actionTypeId": {
"category": "Build",
"owner": "AWS",
"version": "1",
"provider": "AWS CodeBuild"
},
"outputArtifacts": [
{
"name": "artifact1"
},
{
"name": "artifact2"
}
],
"configuration": {
"ProjectName": "my-build-project-name",
"PrimarySource": "source1"
},
"runOrder": 1
}
]
}
],
"artifactStore": {
"type": "S3",
"location": "AWS-CodePipeline-internal-bucket-name"
},
"name": "my-pipeline-name",
"version": 1
}
}
```
在此 JSON 文件中：
+ 必须将输入源之一指定为 `PrimarySource`。这个源代码是 CodeBuild 查找和运行你的 buildspec 文件的目录。关键字`PrimarySource`用于指定 JSON 文件中 CodeBuild 舞台`configuration`部分的主要来源。
+ 每个输入源都安装在各自的目录中。此目录存储在内置环境变量 `$CODEBUILD_SRC_DIR`（对于主要源）和 `$CODEBUILD_SRC_DIR_yourInputArtifactName`（对于所有其他源）中。对于此示例中的管道，两个输入源目录为 `$CODEBUILD_SRC_DIR` 和 `$CODEBUILD_SRC_DIR_source2`。有关更多信息，请参阅 [构建环境中的环境变量](build-env-ref-env-vars.md)。
+ 管道的 JSON 文件中指定的输出构件的名称必须与 buildspec 文件中定义的辅助构件的名称相匹配。此管道使用以下 buildspec 文件。有关更多信息，请参阅 [buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)。
```
version: 0.2
phases:
build:
commands:
- touch source1_file
- cd $CODEBUILD_SRC_DIR_source2
- touch source2_file
artifacts:
files:
- '**/*'
secondary-artifacts:
artifact1:
base-directory: $CODEBUILD_SRC_DIR
files:
- source1_file
artifact2:
base-directory: $CODEBUILD_SRC_DIR_source2
files:
- source2_file
```
创建 JSON 文件后，可以创建管道。使用运行 **create-pipelin** e 命令并将文件传递给参数。 AWS CLI `--cli-input-json`有关更多信息，请参阅《AWS CodePipeline 用户指南》**中的[创建管道（CLI）](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create.html#pipelines-create-cli)。
# AWS Config 样品与 CodeBuild
AWS Config 提供了您的 AWS 资源清单以及这些资源的配置更改历史记录。 AWS Config 现在支持 AWS CodeBuild 作为 AWS 资源，这意味着该服务可以跟踪您的 CodeBuild 项目。有关的更多信息 AWS Config，请参阅[什么是 AWS Config？](https://docs.aws.amazon.com/config/latest/developerguide/WhatIsConfig.html) 在《*AWS Config 开发人员指南》*中。
您可以在 AWS Config 控制台的 “ CodeBuild 资源**清单” 页面上看到以下有关资源**的信息：
+ 您的 CodeBuild 配置更改的时间表。
+ 每个 CodeBuild 项目的配置详细信息。
+ 与其他 AWS 资源的关系。
+ 您的 CodeBuild 项目变更清单。
**Topics**
+ [CodeBuild 搭配使用 AWS Config](#how-to-integrate-config-run)
+ [步骤 3：在 AWS Config 控制台中查看 AWS CodeBuild 数据](#viewing-config-details)
## CodeBuild 搭配使用 AWS Config
本主题中的过程向您展示了如何设置 AWS Config 和查找 CodeBuild项目。
**Topics**
+ [先决条件](#how-to-create-a-build-project)
+ [第 1 步：设置 AWS Config](#setup-config)
+ [第 2 步：查找 AWS CodeBuild 项目](#lookup-projects)
### 先决条件
创建您的 AWS CodeBuild 项目。有关说明，请参阅[创建构建项目](create-project.md)。
### 第 1 步：设置 AWS Config
+ [设置 AWS Config （控制台）](https://docs.aws.amazon.com/config/latest/developerguide/gs-console.html)
+ [设置 AWS Config (AWS CLI)](https://docs.aws.amazon.com/config/latest/developerguide/gs-cli.html)
**注意**
完成设置后，最长可能需要 10 分钟才能在 AWS Config 控制台中看到 AWS CodeBuild 项目。
### 第 2 步：查找 AWS CodeBuild 项目
1. 登录 AWS 管理控制台并通过 [https://console.aws.amazon.com/config](https://console.aws.amazon.com/config) 打开 AWS Config 控制台。
1. 在**资源清单**页面上，在 “**资源类型**” 下选择 “**AWS CodeBuild 项目**”。向下滚动并选中**CodeBuild项目**复选框。
1. 选择**查找**。
1. 添加 CodeBuild 项目列表后，在 **Config 时间轴**列中选择 CodeBuild 项目名称链接。
## 步骤 3：在 AWS Config 控制台中查看 AWS CodeBuild 数据
在资源**清单页面上查找资源**时，您可以选择 AWS Config 时间表来查看有关您的 CodeBuild 项目的详细信息。资源的详细信息页面提供了有关该资源的配置、关系和更改次数的信息。
页面顶部的块统称为时间线。时间线显示了记录的创建日期和时间。
有关更多信息，请参阅《*AWS Config 开发人员指南》*[中的在 AWS Config 控制台中查看配置详细信息](https://docs.aws.amazon.com/config/latest/developerguide/view-manage-resource-console.html)。
# 为以下内容构建通知示例 CodeBuild
Amazon E CloudWatch vents 内置了对以下内容的支持 AWS CodeBuild。 CloudWatch 事件是描述 AWS 资源变化的系统事件流。使用 E CloudWatch vents，您可以编写声明性规则，将感兴趣的事件与要采取的自动操作关联起来。此示例使用 Amazon Events 和亚马逊简单通知服务 (Amazon SNS) Simple Notification Service 在构建成功、失败、从一个构建阶段进入另一个构建阶段或这些 CloudWatch 事件的任意组合时向订阅者发送构建通知。
**重要**
运行此示例可能会导致您的 AWS 账户被扣款。其中包括与 Amazon CodeBuild 和 Amazon SNS 相关的 AWS 资源 CloudWatch 和操作可能产生的费用。有关更多信息，请参阅[CodeBuild 定价](https://aws.amazon.com/codebuild/pricing)、[亚马逊定 CloudWatch价](https://aws.amazon.com/cloudwatch/pricing)和[亚马逊 SNS](https://aws.amazon.com/sns/pricing) 定价。
**Topics**
+ [运行构建通知示例](#sample-build-notifications-running)
+ [构建通知输入格式参考](sample-build-notifications-ref.md)
## 运行构建通知示例
按照以下过程运行构建通知示例。
**要运行此示例，请执行以下操作：**
1. 如果您已在 Amazon SNS 中设置并订阅用于此示例的主题，请跳至第 4 步。否则，如果您使用 IAM 用户而不是 AWS 根账户或管理员用户来使用 Amazon SNS，请向用户（或用户关联的 IAM 群组*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*）添加以下语句（介于*\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1*和之间）。不建议使用 r AWS oot 账户。此语句可用于查看、创建、订阅和测试向 Amazon SNS 中的主题发送通知的情况。为了简洁起见，也为了帮您查找添加语句的位置，此处使用了省略号 (`...`)。请勿删除任何语句，也不要将这些省略号键入现有策略中。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:CreateTopic",
"sns:GetTopicAttributes",
"sns:List*",
"sns:Publish",
"sns:SetTopicAttributes",
"sns:Subscribe"
],
"Resource": "*"
}
]
}
```
------
**注意**
修改该策略的 IAM 实体必须拥有在 IAM 中修改策略的权限。
有关更多信息，请参阅《IAM 用户指南》**中的[编辑客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html#edit-managed-policy-console)或[使用内联策略（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_inline-using.html#AddingPermissions_Console)中的“编辑或删除组、用户或角色的内联策略”部分。
1. 在 Amazon SNS 中创建或标识主题。 AWS CodeBuild 使用 CloudWatch 事件通过 Amazon SNS 向该主题发送构建通知。
要创建主题，请执行以下操作:
1. [在 /sns 上打开亚马逊 SNS 控制台。https://console.aws.amazon.com](https://console.aws.amazon.com/sns)
1. 选择**创建主题**。
1. 在**创建新主题**对话框中，为**主题名称**输入主题的名称（例如 **CodeBuildDemoTopic**）。（如果您选择了其他名称，请用该名称替换掉本示例中对应的名称。）
1. 选择**创建主题**。
1. 在**主题详情： CodeBuildDemoTopic**页面上，复制**主题 ARN 值。**在下一个步骤中，您需要用到此值。
![\[主题 ARN 值。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/topic-arn.png)
有关更多信息，请参阅《Amazon SNS 开发人员指南》**中的[创建主题](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html)。
1. 为一个或多个收件人订阅主题以接收电子邮件通知。
为收件人订阅主题：
1. 使用上一步中打开的 Amazon SNS 控制台，在导航窗格中，选择**订阅**，然后选择**创建订阅**。
1. 在**创建订阅**中，对于**主题 ARN**，粘贴您在上一步中复制的主题 ARN。
1. 对于**协议**，选择**电子邮件**。
1. 对于**端点**，输入收件人的完整电子邮件地址。
![\[订阅配置。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/create-subscription.png)
1. 选择**创建订阅**。
1. Amazon SNS 向收件人发送订阅确认电子邮件。要开始接收电子邮件通知，收件人必须在订阅确认电子邮件中选择**确认订阅**链接。在收件人单击该链接后，如果成功订阅，Amazon SNS 将在收件人的 Web 浏览器中显示一条确认消息。
有关更多信息，请参阅《Amazon SNS 开发人员指南》**中的[订阅主题](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html)。
1. 如果您使用用户而不是 AWS 根账户或管理员用户来处理 Ev CloudWatch ents，请向用户（或用户关联的 IAM 群组*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*）添加以下语句（介于*\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1*和之间）。不建议使用 r AWS oot 账户。此语句用于允许用户使用 CloudWatch 事件。为了简洁起见，也为了帮您查找添加语句的位置，此处使用了省略号 (`...`)。请勿删除任何语句，也不要将这些省略号键入现有策略中。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"events:*",
"iam:PassRole"
],
"Resource": "arn:aws:iam::*:role/Service*"
}
]
}
```
------
**注意**
修改该策略的 IAM 实体必须拥有在 IAM 中修改策略的权限。
有关更多信息，请参阅《IAM 用户指南》**中的[编辑客户管理型策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html#edit-managed-policy-console)或[使用内联策略（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_inline-using.html#AddingPermissions_Console)中的“编辑或删除组、用户或角色的内联策略”部分。
1. 在 “ CloudWatch 事件” 中创建规则。为此，请打开 CloudWatch 控制台，位于 [https://console.aws.amazon.com/cloudwatch](https://console.aws.amazon.com/cloudwatch)。
1. 在导航窗格中的**事件**下，选择**规则**，然后选择**创建规则**。
1. 在**步骤 1：创建规则页面**上，**事件模式**和**构建事件模式以按服务匹配事件**应已选中。
1. 对于**服务名称**，选择 **CodeBuild**。对于**事件类型**，**所有事件**应已选中。
1. **事件模式预览**中应显示以下代码：
```
{
"source": [
"aws.codebuild"
]
}
```
1. 选择**编辑**并将**事件模式预览**中的代码替换为以下两个规则模式之一。
每当一个构建开始或完成时，第一个规则模式就会为 AWS CodeBuild中的指定构建项目触发一个事件。
```
{
"source": [
"aws.codebuild"
],
"detail-type": [
"CodeBuild Build State Change"
],
"detail": {
"build-status": [
"IN_PROGRESS",
"SUCCEEDED",
"FAILED",
"STOPPED"
],
"project-name": [
"my-demo-project-1",
"my-demo-project-2"
]
}
}
```
在前面的规则中，根据需要更改以下代码。
+ 要在每次构建开始或完成时触发事件，请保留 `build-status` 数组中显示的所有值，或删除整个 `build-status` 数组。
+ 要仅在构建完成时触发事件，请从 `build-status` 阵列中删除 `IN_PROGRESS`。
+ 要仅在构建开始时触发事件，请从 `build-status` 阵列中删除除 `IN_PROGRESS` 以外的所有值。
+ 要为所有构建项目触发事件，请删除整个 `project-name` 阵列。
+ 要仅为单个构建项目触发事件，请在 `project-name` 阵列中指定每个构建项目的名称。
每当构建从一个构建阶段转到另一个构建阶段时，第二个规则模式将为 AWS CodeBuild中的指定构建项目触发一个事件。
```
{
"source": [
"aws.codebuild"
],
"detail-type": [
"CodeBuild Build Phase Change"
],
"detail": {
"completed-phase": [
"SUBMITTED",
"PROVISIONING",
"DOWNLOAD_SOURCE",
"INSTALL",
"PRE_BUILD",
"BUILD",
"POST_BUILD",
"UPLOAD_ARTIFACTS",
"FINALIZING"
],
"completed-phase-status": [
"TIMED_OUT",
"STOPPED",
"FAILED",
"SUCCEEDED",
"FAULT",
"CLIENT_ERROR"
],
"project-name": [
"my-demo-project-1",
"my-demo-project-2"
]
}
}
```
在前面的规则中，根据需要更改以下代码。
+ 要为每个构建阶段更改触发一个事件（这可以为每个构建发送最多 9 条通知），请保留 `completed-phase` 数组中显示的所有值，或删除整个 `completed-phase` 数组。
+ 要仅针对单个构建阶段更改触发事件，请删除 `completed-phase` 阵列中您不希望为其触发事件的每个构建阶段的名称。
+ 要针对所有构建阶段状态更改触发事件，请保留 `completed-phase-status` 阵列中显示的所有值，或删除整个 `completed-phase-status` 阵列。
+ 要仅针对单个构建阶段状态更改触发事件，请删除 `completed-phase-status` 阵列中您不希望对其触发事件的每个构建阶段状态的名称。
+ 要为所有构建项目触发事件，请删除 `project-name` 阵列。
+ 要为单个构建项目触发事件，请在 `project-name` 阵列中指定每个构建项目的名称。
有关事件模式的更多信息，请参阅 Amazon EventBridge 用户指南中的[事件模式](https://docs.aws.amazon.com/eventbridge/latest/userguide/filtering-examples-structure.html)。
有关使用事件模式进行筛选的更多信息，请参阅 Amazon EventBridge 用户指南中的[使用事件模式进行基于内容的筛选](https://docs.aws.amazon.com/eventbridge/latest/userguide/content-filtering-with-event-patterns.html)。
**注意**
如果要同时为构建状态更改和构建阶段更改触发事件，则必须创建两个单独的规则：一个针对构建状态更改，另一个针对构建阶段更改。如果您尝试将两个规则合并为一个规则，则合并后的规则可能产生意外结果或停止协作。
替换完代码后，选择**保存**。
1. 对于**目标**，选择**添加目标**。
1. 在目标列表中，选择 **SNS 主题**。
1. 对于**话题**，选择您之前标识或创建的主题。
1. 展开**配置输入**，然后选择**输入转换器**。
1. 在**输入路径**框中，输入以下输入路径之一。
对于 `detail-type` 值为 `CodeBuild Build State Change` 的规则，输入以下内容。
```
{"build-id":"$.detail.build-id","project-name":"$.detail.project-name","build-status":"$.detail.build-status"}
```
对于 `detail-type` 值为 `CodeBuild Build Phase Change` 的规则，输入以下内容。
```
{"build-id":"$.detail.build-id","project-name":"$.detail.project-name","completed-phase":"$.detail.completed-phase","completed-phase-status":"$.detail.completed-phase-status"}
```
要获取其他类型的信息，请参阅[构建通知输入格式参考](sample-build-notifications-ref.md)。
1. 在**输入模板**框中，输入以下输入模板之一。
对于 `detail-type` 值为 `CodeBuild Build State Change` 的规则，输入以下内容。
```
"Build '' for build project '' has reached the build status of ''."
```
对于 `detail-type` 值为 `CodeBuild Build Phase Change` 的规则，输入以下内容。
```
"Build '' for build project '' has completed the build phase of '' with a status of ''."
```
1. 选择**配置详细信息**。
1. 在**步骤 2：配置规则详细信息**页面上，输入名称和可选描述。对于**状态**，将**已启用**保持选中状态。
1. 选择****创建规则。
1. 创建构建项目、运行构建和查看构建信息。
1. 确认 CodeBuild 现在已成功发送构建通知。例如，检查您的收件箱中现在是否有构建通知电子邮件。
要更改规则的行为，请在 CloudWatch 控制台中选择要更改的规则，选择**操作**，然后选择**编辑**。对该规则进行更改，选择**配置详细信息**，然后选择**更新规则**。
要停止使用规则发送生成通知，请在 CloudWatch 控制台中选择要停止使用的规则，选择**操作**，然后选择**禁用**。
要完全删除规则，请在 CloudWatch 控制台中选择要删除的规则，选择**操作**，然后选择**删除**。
# 构建通知输入格式参考
CloudWatch 以 JSON 格式发送通知。
构建状态更改通知使用以下格式：
```
{
"version": "0",
"id": "c030038d-8c4d-6141-9545-00ff7b7153EX",
"detail-type": "CodeBuild Build State Change",
"source": "aws.codebuild",
"account": "123456789012",
"time": "2017-09-01T16:14:28Z",
"region": "us-west-2",
"resources":[
"arn:aws:codebuild:us-west-2:123456789012:build/my-sample-project:8745a7a9-c340-456a-9166-edf953571bEX"
],
"detail":{
"build-status": "SUCCEEDED",
"project-name": "my-sample-project",
"build-id": "arn:aws:codebuild:us-west-2:123456789012:build/my-sample-project:8745a7a9-c340-456a-9166-edf953571bEX",
"additional-information": {
"artifact": {
"md5sum": "da9c44c8a9a3cd4b443126e823168fEX",
"sha256sum": "6ccc2ae1df9d155ba83c597051611c42d60e09c6329dcb14a312cecc0a8e39EX",
"location": "arn:aws:s3:::codebuild-123456789012-output-bucket/my-output-artifact.zip"
},
"environment": {
"image": "aws/codebuild/standard:5.0",
"privileged-mode": false,
"compute-type": "BUILD_GENERAL1_SMALL",
"type": "LINUX_CONTAINER",
"environment-variables": []
},
"timeout-in-minutes": 60,
"build-complete": true,
"initiator": "MyCodeBuildDemoUser",
"build-start-time": "Sep 1, 2017 4:12:29 PM",
"source": {
"location": "codebuild-123456789012-input-bucket/my-input-artifact.zip",
"type": "S3"
},
"logs": {
"group-name": "/aws/codebuild/my-sample-project",
"stream-name": "8745a7a9-c340-456a-9166-edf953571bEX",
"deep-link": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logEvent:group=/aws/codebuild/my-sample-project;stream=8745a7a9-c340-456a-9166-edf953571bEX"
},
"phases": [
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:12:29 PM",
"end-time": "Sep 1, 2017 4:12:29 PM",
"duration-in-seconds": 0,
"phase-type": "SUBMITTED",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:12:29 PM",
"end-time": "Sep 1, 2017 4:13:05 PM",
"duration-in-seconds": 36,
"phase-type": "PROVISIONING",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:05 PM",
"end-time": "Sep 1, 2017 4:13:10 PM",
"duration-in-seconds": 4,
"phase-type": "DOWNLOAD_SOURCE",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:10 PM",
"end-time": "Sep 1, 2017 4:13:10 PM",
"duration-in-seconds": 0,
"phase-type": "INSTALL",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:10 PM",
"end-time": "Sep 1, 2017 4:13:10 PM",
"duration-in-seconds": 0,
"phase-type": "PRE_BUILD",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:10 PM",
"end-time": "Sep 1, 2017 4:14:21 PM",
"duration-in-seconds": 70,
"phase-type": "BUILD",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:14:21 PM",
"end-time": "Sep 1, 2017 4:14:21 PM",
"duration-in-seconds": 0,
"phase-type": "POST_BUILD",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:14:21 PM",
"end-time": "Sep 1, 2017 4:14:21 PM",
"duration-in-seconds": 0,
"phase-type": "UPLOAD_ARTIFACTS",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:14:21 PM",
"end-time": "Sep 1, 2017 4:14:26 PM",
"duration-in-seconds": 4,
"phase-type": "FINALIZING",
"phase-status": "SUCCEEDED"
},
{
"start-time": "Sep 1, 2017 4:14:26 PM",
"phase-type": "COMPLETED"
}
]
},
"current-phase": "COMPLETED",
"current-phase-context": "[]",
"version": "1"
}
}
```
构建阶段更改通知使用以下格式：
```
{
"version": "0",
"id": "43ddc2bd-af76-9ca5-2dc7-b695e15adeEX",
"detail-type": "CodeBuild Build Phase Change",
"source": "aws.codebuild",
"account": "123456789012",
"time": "2017-09-01T16:14:21Z",
"region": "us-west-2",
"resources":[
"arn:aws:codebuild:us-west-2:123456789012:build/my-sample-project:8745a7a9-c340-456a-9166-edf953571bEX"
],
"detail":{
"completed-phase": "COMPLETED",
"project-name": "my-sample-project",
"build-id": "arn:aws:codebuild:us-west-2:123456789012:build/my-sample-project:8745a7a9-c340-456a-9166-edf953571bEX",
"completed-phase-context": "[]",
"additional-information": {
"artifact": {
"md5sum": "da9c44c8a9a3cd4b443126e823168fEX",
"sha256sum": "6ccc2ae1df9d155ba83c597051611c42d60e09c6329dcb14a312cecc0a8e39EX",
"location": "arn:aws:s3:::codebuild-123456789012-output-bucket/my-output-artifact.zip"
},
"environment": {
"image": "aws/codebuild/standard:5.0",
"privileged-mode": false,
"compute-type": "BUILD_GENERAL1_SMALL",
"type": "LINUX_CONTAINER",
"environment-variables": []
},
"timeout-in-minutes": 60,
"build-complete": true,
"initiator": "MyCodeBuildDemoUser",
"build-start-time": "Sep 1, 2017 4:12:29 PM",
"source": {
"location": "codebuild-123456789012-input-bucket/my-input-artifact.zip",
"type": "S3"
},
"logs": {
"group-name": "/aws/codebuild/my-sample-project",
"stream-name": "8745a7a9-c340-456a-9166-edf953571bEX",
"deep-link": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logEvent:group=/aws/codebuild/my-sample-project;stream=8745a7a9-c340-456a-9166-edf953571bEX"
},
"phases": [
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:12:29 PM",
"end-time": "Sep 1, 2017 4:12:29 PM",
"duration-in-seconds": 0,
"phase-type": "SUBMITTED",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:12:29 PM",
"end-time": "Sep 1, 2017 4:13:05 PM",
"duration-in-seconds": 36,
"phase-type": "PROVISIONING",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:05 PM",
"end-time": "Sep 1, 2017 4:13:10 PM",
"duration-in-seconds": 4,
"phase-type": "DOWNLOAD_SOURCE",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:10 PM",
"end-time": "Sep 1, 2017 4:13:10 PM",
"duration-in-seconds": 0,
"phase-type": "INSTALL",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:10 PM",
"end-time": "Sep 1, 2017 4:13:10 PM",
"duration-in-seconds": 0,
"phase-type": "PRE_BUILD",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:13:10 PM",
"end-time": "Sep 1, 2017 4:14:21 PM",
"duration-in-seconds": 70,
"phase-type": "BUILD",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:14:21 PM",
"end-time": "Sep 1, 2017 4:14:21 PM",
"duration-in-seconds": 0,
"phase-type": "POST_BUILD",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:14:21 PM",
"end-time": "Sep 1, 2017 4:14:21 PM",
"duration-in-seconds": 0,
"phase-type": "UPLOAD_ARTIFACTS",
"phase-status": "SUCCEEDED"
},
{
"phase-context": [],
"start-time": "Sep 1, 2017 4:14:21 PM",
"end-time": "Sep 1, 2017 4:14:26 PM",
"duration-in-seconds": 4,
"phase-type": "FINALIZING",
"phase-status": "SUCCEEDED"
},
{
"start-time": "Sep 1, 2017 4:14:26 PM",
"phase-type": "COMPLETED"
}
]
},
"completed-phase-status": "SUCCEEDED",
"completed-phase-duration-seconds": 4,
"version": "1",
"completed-phase-start": "Sep 1, 2017 4:14:21 PM",
"completed-phase-end": "Sep 1, 2017 4:14:26 PM"
}
}
```
# 使用以下方法制作徽章示例 CodeBuild
AWS CodeBuild 现在支持使用构建徽章，它提供可嵌入的、动态生成的图像（*徽章*），用于显示项目最新版本的状态。可通过为您的 CodeBuild 项目生成的公开网址访问此图片。这允许任何人查看 CodeBuild 项目的状态。构建徽章不包含任何安全信息，因此它们无需身份验证。
**Topics**
+ [创建具有构建徽章的构建项目](#sample-build-badges-request-running)
+ [访问 AWS CodeBuild 构建徽章](access-badges.md)
+ [发布 CodeBuild 构建徽章](publish-badges.md)
+ [CodeBuild 徽章状态](badge-statuses.md)
## 创建具有构建徽章的构建项目
使用以下过程之一创建已启用构建徽章的构建项目。你可以使用 AWS CLI 或 AWS 管理控制台.
**创建已启用构建徽章的构建项目（AWS CLI）**
+ 有关创建构建项目的信息，请参阅[创建构建项目 (AWS CLI)](create-project.md#create-project-cli)。要在 AWS CodeBuild 项目中包含构建徽章，必须使用值*badgeEnabled*进行指定。`true`
**创建已启用构建徽章的构建项目（控制台）**
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 如果显示 CodeBuild 信息页面，请选择 “**创建构建项目**”。否则，请在导航窗格中，展开**构建**，选择**构建项目**，然后选择**创建构建项目**。
1. 在**项目名称**中，输入此构建项目的名称。每个 AWS 账户中的构建项目名称必须是唯一的。您还可以包含构建项目的可选描述，以帮助其他用户了解此项目的用途。
1. 在**源**中，对于**源提供商**，选择源代码提供商类型，然后执行以下操作之一：
**注意**
CodeBuild 不支持使用 Amazon S3 源代码提供商的构建徽章。由于 AWS CodePipeline 使用 Amazon S3 进行项目传输，因此在中创建的管道中的 CodePipeline构建项目不支持构建徽章。
+ 如果您选择了 **CodeCommit**，那么对于 **Repository (存储库)**，请选择存储库的名称。选择**启用构建徽章**，以使您的项目的构建状态可见且可嵌入。
+ 如果您选择 **GitHub**，请按照说明进行连接（或重新连接）。 GitHub在 GitHub**授权应用程序**页面上，对于**组织访问权限**，选择您希望 AWS CodeBuild 能够**访问的每个存储库旁边的请求**访问权限。选择**授权应用程序**后，返回 AWS CodeBuild 控制台，对于**存储库**，选择包含源代码的存储库的名称。选择**启用构建徽章**，以使您的项目的构建状态可见且可嵌入。
+ 如果您选择了 **Bitbucket**，请按照说明连接（或重新连接）Bitbucket。在 Bitbucket **确认对账户的访问**页面上，对于**组织访问权限**，选择**授予访问权限**。选择 “**授予访问权限**” 后，返回 AWS CodeBuild 控制台，在 “**存储库**” 中，选择包含源代码的存储库的名称。选择**启用构建徽章**，以使您的项目的构建状态可见且可嵌入。
**重要**
更新项目源可能会影响项目构建徽章的准确性。
1. 在**环境**中：
对于**环境映像**，执行下列操作之一：
+ 要使用由管理的 Docker 映像 AWS CodeBuild，请选择**托管映像**，然后从 “**操作系统**”、“**运行时**”、“映像” 和 “**映像****版本**” 中进行选择。从**环境类型**中进行选择（如果可用）。
+ 要使用其他 Docker 映像，请选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您针对**外部注册表 URL** 选择**其他注册表**，请使用 `docker repository/docker image name` 格式在 Docker Hub 中输入 Docker 映像的名称和标签。如果您选择 **Amazon ECR**，请使用**亚马逊 ECR 存储库和** A **mazon ECR 镜像**在您的账户中选择 Docker 镜像。 AWS
+ 要使用私有 Docker 映像，请选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。对于**映像注册表**，选择**其他注册表**，然后输入您的私有 Docker 映像的凭证的 ARN。凭证必须由 Secrets Manager 创建。有关更多信息，请参阅《AWS Secrets Manager 用户指南》中的[什么是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
1. 在**服务角色**中，执行下列操作之一：
+ 如果您没有 CodeBuild 服务角色，请选择 “**新建服务角色**”。在**角色名称**中，为新角色输入名称。
+ 如果您有 CodeBuild 服务角色，请选择**现有服务角色**。在**角色 ARN** 中，选择服务角色。
**注意**
使用控制台创建或更新构建项目时，可以同时创建 CodeBuild 服务角色。默认情况下，这个角色仅能与该构建项目配合使用。如果您使用控制台将此服务角色与另一个构建项目关联，则此角色将更新以便与关联的构建项目结合使用。一个服务角色最多可与 10 个构建项目结合使用。
1. 在 **Buildspec** 中，执行以下操作之一：
+ 选择**使用 buildspec 文件**，以在源代码根目录中使用 buildspec.yml 文件。
+ 选择**插入构建命令**，以使用控制台插入构建命令。
有关更多信息，请参阅[Buildspec 参考](build-spec-ref.md)。
1. 在**构件**中，对于**类型**，执行以下操作之一：
+ 如果您不想创建构建输出构件，请选择**无构件**。
+ 要将构建输出存储在 S3 存储桶中，请选择 **Amazon S3**，然后执行以下操作：
+ 如果要将项目名称用于构建输出 ZIP 文件或文件夹，请将**名称**留空。否则，请输入名称。默认情况下，构件名称是项目名称。如果您要使用其他名称，请在构件名称框中输入该名称。如果您要输出 ZIP 文件，请包含 zip 扩展名。
+ 对于**存储桶名称**，请选择输出存储桶的名称。
+ 如果您在此过程的前面部分选择了**插入构建命令**，对于**输出文件**，请输入构建（该构建要放到构建输出 ZIP 文件或文件夹中）中的文件位置。对于多个位置，使用逗号将各个位置隔开（例如，`appspec.yml, target/my-app.jar`）。有关更多信息，请参阅[buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)中 `files` 的描述。
1. 展开**其他配置**并根据需要选择选项。
1. 选择 **Create build project（创建构建项目）**。在**审核**页面上，选择**开始构建**以运行构建。
# 访问 AWS CodeBuild 构建徽章
您可以使用 AWS CodeBuild 控制台或 AWS CLI 访问版本徽章。
+ 在 CodeBuild 控制台的生成项目列表中，在**名称**列中，选择与生成项目对应的链接。在 B **uild project: *project-name*** 页面的**配置**中，选择**复制徽章 URL**。有关更多信息，请参阅 [查看构建项目的详细信息（控制台）](view-project-details.md#view-project-details-console)。
+ 在中 AWS CLI，运行`batch-get-projects`命令。构建徽章 URL 包含在输出的项目环境详细信息部分中。有关更多信息，请参阅 [查看构建项目的详细信息 (AWS CLI)](view-project-details.md#view-project-details-cli)。
构建徽章请求 URL 生成时会归入常见默认分支，但您可以指定源存储库中已用于运行构建的任何分支。例如：
```
https://codebuild.us-east-1.amazon.com/badges?uuid=...&branch=
```
您也可以通过将徽章 URL 中的 `branch` 参数替换为 `tag` 参数来在源存储库中指定标签。例如：
```
https://codebuild.us-east-1.amazon.com/badges?uuid=...&tag=
```
# 发布 CodeBuild 构建徽章
您可以使用 markdown 映像中的构建徽章 URL 显示 markdown 文件中最新构建的状态。这对于在源存储库的 readme.md 文件中显示最新版本的状态很有用（例如， GitHub 或）。 CodeCommit例如：
```
![]()
```
# CodeBuild 徽章状态
CodeBuild 构建徽章可以具有以下状态之一。
+ **PASSING** 给定分支上的最新构建已传递。
+ **FAILING** 给定分支上的最新构建已超时、失败、出现故障或停止。
+ **IN\$1PROGRESS** 给定分支上的最新构建正在进行中。
+ **UNKNOWN** 项目尚未为给定分支运行构建或根本未运行。此外，构建徽章功能可能已禁用。
# '使用 AWS CLI'样本的测试报告
您在 buildspec 文件中指定的测试将在构建期间运行。此示例向您展示了如何使用将测试合并 AWS CLI 到内置版本中 CodeBuild。您可以使用 JUnit创建单元测试，也可以使用其他工具来创建配置测试。然后，您可以评估测试结果以修复问题或优化您的应用程序。
您可以使用 CodeBuild API 或 AWS CodeBuild 控制台来访问测试结果。此示例演示如何配置报告以便将其测试结果导出到 S3 存储桶。
**Topics**
+ [运行测试报告示例](#sample-test-report-cli-run)
## 运行测试报告示例
按照以下步骤运行测试报告示例。
**Topics**
+ [先决条件](#sample-test-report-cli-prerequisites)
+ [步骤 1：创建报告组](#sample-test-report-cli-create-report)
+ [步骤 2：使用报告组配置项目](#sample-test-report-cli-create-project-with-report)
+ [步骤 3：运行和查看报告结果](#sample-test-report-cli-run-and-view-report-results)
### 先决条件
+ 创建您的测试用例。编写此示例时假设您有要包含在示例测试报告中的测试用例。您可以在 buildspec 文件中指定测试文件的位置。
支持以下测试报告文件格式：
+ Cucumber JSON (.json)
+ JUnit XML (.xml)
+ NUnit XML (.xml)
+ NUnit3 XML (.xml)
+ TestNG XML (.xml)
+ Visual Studio TRX (.trx)
+ Visual Studio TRX XML (.xml)
使用任何可以创建其中一种格式的报告文件的测试框架（例如 Surefire JUnit 插件、Testng 或 Cucumber）来创建您的测试用例。
+ 创建 S3 存储桶并记下其名称。有关更多信息，请参阅《Amazon S3 用户指南》**中的[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html)
+ 创建一个 IAM 角色并记下其 ARN。创建构建项目时，您需要 ARN。
+ 如果您的角色没有以下权限，请添加它们。
```
{
"Effect": "Allow",
"Resource": [
"*"
],
"Action": [
"codebuild:CreateReportGroup",
"codebuild:CreateReport",
"codebuild:UpdateReport",
"codebuild:BatchPutTestCases"
]
}
```
有关更多信息，请参阅 [测试报告操作的权限](test-permissions.md#test-permissions-related-to-reporting)。
### 步骤 1：创建报告组
1. 创建一个名为 `CreateReportGroupInput.json`的文件。
1. 在 S3 存储桶中创建要将测试结果导出到的文件夹。
1. 将以下内容复制到 `CreateReportGroupInput.json`。对于 ``，使用 S3 存储桶的名称。对于 ``，请输入 S3 存储桶中文件夹的路径。
```
{
"name": "",
"type": "TEST",
"exportConfig": {
"exportConfigType": "S3",
"s3Destination": {
"bucket": "",
"path": "",
"packaging": "NONE"
}
}
}
```
1. 在包含 `CreateReportGroupInput.json` 的目录中，运行以下命令：
```
aws codebuild create-report-group --cli-input-json file://CreateReportGroupInput.json
```
输出如下所示。记下 `reportGroup` 的 ARN。您可以在创建使用此报告组的项目时使用该 ARN。
```
{
"reportGroup": {
"arn": "arn:aws:codebuild:us-west-2:123456789012:report-group/",
"name": "",
"type": "TEST",
"exportConfig": {
"exportConfigType": "S3",
"s3Destination": {
"bucket": "",
"path": "",
"packaging": "NONE",
"encryptionKey": "arn:aws:kms:us-west-2:123456789012:alias/aws/s3"
}
},
"created": 1570837165.885,
"lastModified": 1570837165.885
}
}
```
### 步骤 2：使用报告组配置项目
要运行报告，您需要先创建一个使用您的报告组配置的 CodeBuild 生成项目。为报告组指定的测试用例将在您运行构建时运行。
1. 创建一个名为 `buildspec.yml` 的 buildspec 文件。
1. 使用以下 YAML 作为 `buildspec.yml` 文件的模板。请务必包含运行测试的命令。在 `reports` 部分中，指定包含测试用例结果的文件。这些文件存储了您可以访问的测试结果 CodeBuild。它们在创建后 30 天过期。这些文件与您导出到 S3 存储桶的原始测试用例结果文件不同。
```
version: 0.2
phases:
install:
runtime-versions:
java: openjdk8
build:
commands:
- echo Running tests
-
reports:
: #test file information
files:
- ''
base-directory: ''
discard-paths: false #do not remove file paths from test result files
```
**注意**
您还可以为尚未创建的报告组指定名称，而不是使用现有报告组的 ARN。如果您指定名称而不是 ARN，则会在运行生成时 CodeBuild 创建一个报告组。其名称包含您的项目名称和您在 buildspec 文件中指定的名称，格式如下：`project-name-report-group-name`。有关更多信息，请参阅[创建测试报告](report-create.md)和[报告组命名](test-report-group-naming.md)。
1. 创建一个名为 `project.json`的文件。此文件包含 **create-project** 命令的输入。
1. 将以下 JSON 复制到 `project.json`。对于 `source`，请输入包含源文件的存储库的类型和位置。对于 `serviceRole`，请指定您正在使用的角色的 ARN。
```
{
"name": "test-report-project",
"description": "sample-test-report-project",
"source": {
"type": "CODECOMMIT|CODEPIPELINE|GITHUB|S3|BITBUCKET|GITHUB_ENTERPRISE|NO_SOURCE",
"location": ""
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"cache": {
"type": "NO_CACHE"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "small"
},
"serviceRole": "arn:aws:iam:::role/service-role/"
}
```
1. 在包含 `project.json` 的目录中，运行以下命令：这将创建一个名为 `test-project` 的项目。
```
aws codebuild create-project --cli-input-json file://project.json
```
### 步骤 3：运行和查看报告结果
在此部分中，您将运行之前创建的项目的构建。在生成过程中， CodeBuild 创建包含测试用例结果的报告。该报告包含在您指定的报告组中。
1. 要开始构建，请运行以下命令。`test-report-project` 是上面创建的构建项目的名称。记下输出中显示的构建 ID。
```
aws codebuild start-build --project-name test-report-project
```
1. 运行以下命令以获取有关您的构建的信息，包括报告的 ARN。对于 ``，请指定您的构建 ID。在输出的 `reportArns` 属性中记下报告 ARN。
```
aws codebuild batch-get-builds --ids
```
1. 运行以下命令以获取有关报告的详细信息。对于 ``，请指定您的报告 ARN。
```
aws codebuild batch-get-reports --report-arns
```
输出如下所示。此示例输出显示了成功、失败、跳过、导致错误或返回未知状态的测试数量。
```
{
"reports": [
{
"status": "FAILED",
"reportGroupArn": "",
"name": "",
"created": 1573324770.154,
"exportConfig": {
"exportConfigType": "S3",
"s3Destination": {
"bucket": "",
"path": "",
"packaging": "NONE",
"encryptionKey": ""
}
},
"expired": 1575916770.0,
"truncated": false,
"executionId": "arn:aws:codebuild:us-west-2:123456789012:build/:2c254862-ddf6-4831-a53f-6839a73829c1",
"type": "TEST",
"arn": "",
"testSummary": {
"durationInNanoSeconds": 6657770,
"total": 11,
"statusCounts": {
"FAILED": 3,
"SKIPPED": 7,
"ERROR": 0,
"SUCCEEDED": 1,
"UNKNOWN": 0
}
}
}
],
"reportsNotFound": []
}
```
1. 运行以下命令列出有关报告的测试用例的信息。对于 ``，请指定报告的 ARN。对于可选 `--filter` 参数，您可以指定一个状态结果（`SUCCEEDED`、`FAILED`、`SKIPPED`、`ERROR` 或 `UNKNOWN`）。
```
aws codebuild describe-test-cases \
--report-arn \
--filter status=SUCCEEDED|FAILED|SKIPPED|ERROR|UNKNOWN
```
输出如下所示。
```
{
"testCases": [
{
"status": "FAILED",
"name": "Test case 1",
"expired": 1575916770.0,
"reportArn": "",
"prefix": "Cucumber tests for agent",
"message": "A test message",
"durationInNanoSeconds": 1540540,
"testRawDataPath": ""
},
{
"status": "SUCCEEDED",
"name": "Test case 2",
"expired": 1575916770.0,
"reportArn": "",
"prefix": "Cucumber tests for agent",
"message": "A test message",
"durationInNanoSeconds": 1540540,
"testRawDataPath": ""
}
]
}
```
# 的 Docker 示例 CodeBuild
本节介绍了 Docker 和之间的示例集成。 AWS CodeBuild
| 样本 | 说明 |
| --- | --- |
| [自定义镜像示例中的 Docker CodeBuild](sample-docker-custom-image.md) | 此示例通过使用和自定义 Docker 构建映像（在 Docker Hub `docker:dind` 中）来构建 CodeBuild 和运行 Docker 镜像。 |
| [的 Docker 镜像构建服务器示例 CodeBuild](sample-docker-server.md) | 此示例将您的 Docker 构建卸载到托管式映像编译服务器。 |
| [Windows Docker 为以下版本构建示例 CodeBuild](sample-windows-docker-custom-image.md) | 此示例使用 CodeBuild构建并运行 Windows Docker 镜像。 |
| [“将 Docker 映像发布到亚马逊 ECR 镜像存储库” 示例 CodeBuild](sample-docker.md) | 该示例会生成一个 Docker 映像作为构建输出，然后将该 Docker 映像推送到 Amazon Elastic Container Registry (Amazon ECR) 映像存储库。 |
| [带有 AWS Secrets Manager 示例的私有注册表 CodeBuild](sample-private-registry.md) | 此示例向您展示如何使用存储在私有注册表中的 Docker 镜像作为 CodeBuild 运行时环境。 |
# 自定义镜像示例中的 Docker CodeBuild
以下示例通过使用和自定义 Docker 构建映像（在 Docker Hub `docker:dind` 中）来构建 AWS CodeBuild 和运行 Docker 镜像。
要了解如何改用由 Docker 支持的构建镜像来 CodeBuild 构建 Docker 镜像，请参阅我们的。[“将 Docker 映像发布到 Amazon ECR”示例](sample-docker.md)
**重要**
运行此示例可能会导致您的 AWS 账户被扣款。其中包括与 Amazon S3 和 CloudWatch 日志相关的 AWS 资源和操作可能产生的费用。 CodeBuild AWS KMS有关更多信息，请参阅[CodeBuild 定价](https://aws.amazon.com/codebuild/pricing)、[Amazon S3 定价](https://aws.amazon.com/s3/pricing)、[AWS Key Management Service 定价](https://aws.amazon.com/kms/pricing)和[亚马逊 CloudWatch定价](https://aws.amazon.com/cloudwatch/pricing)。
**Topics**
+ [在自定义映像示例中运行 Docker](#sample-docker-custom-image-running)
## 在自定义映像示例中运行 Docker
使用以下过程在自定义映像示例中运行 Docker。有关此示例的更多信息，请参阅[自定义镜像示例中的 Docker CodeBuild](#sample-docker-custom-image)。
**在自定义映像示例中运行 Docker**
1. 按照本主题[目录结构](#sample-docker-custom-image-dir)和[文件](#sample-docker-custom-image-files)部分所述创建文件，然后将其上传到 S3 输入存储桶或 AWS CodeCommit GitHub、或 Bitbucket 存储库。
**重要**
请不要上传 `(root directory name)`，而只上传 `(root directory name)` 中的文件。
如果您使用的是 S3 输入存储桶，请务必创建一个包含这些文件的 ZIP 文件，然后将其上传到输入存储桶。请不要将 `(root directory name)` 添加到 ZIP 文件中，而只添加 `(root directory name)` 中的文件。
1. 创建构建项目、运行构建和查看相关构建信息。
如果您使用创建构建项目，则`create-project`命令的 JSON 格式输入可能与此类似。 AWS CLI (请将占位符替换为您自己的值。)
```
{
"name": "sample-docker-custom-image-project",
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/DockerCustomImageSample.zip"
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "docker:dind",
"computeType": "BUILD_GENERAL1_SMALL",
"privilegedMode": false
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name",
"encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}
```
**注意**
默认情况下，为非 VPC 构建启用 Docker 进程守护程序。如果您想使用 Docker 容器进行 VPC 构建，请参阅 Docker 文档网站上的[运行时权限和 Linux 功能](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities)并启用特权模式。此外，Windows 不支持特权模式。
1. 要查看构建结果，请在构建的日志中查找字符串 `Hello, World!`。有关更多信息，请参阅 [查看构建详细信息](view-build-details.md)。
### 目录结构
此示例采用以下目录结构。
```
(root directory name)
├── buildspec.yml
└── Dockerfile
```
### 文件
在此示例中使用的操作系统的基本映像是 Ubuntu。此示例将使用这些文件。
`buildspec.yml`（在 `(root directory name)`）
```
version: 0.2
phases:
pre_build:
commands:
- docker build -t helloworld .
build:
commands:
- docker images
- docker run helloworld echo "Hello, World!"
```
`Dockerfile`（在 `(root directory name)`）
```
FROM maven:3.3.9-jdk-8
RUN echo "Hello World"
```
# 的 Docker 镜像构建服务器示例 CodeBuild
以下示例将您的 Docker 构建卸载到托管式映像编译服务器。您可以调整此示例，以便在 CodeBuild 项目配置中配置专用的托管 Docker 镜像生成服务器。请注意，当项目的构建正在运行时，预调配的实例处于活动状态，当构建未在运行时，实例将停止。预调配的实例最多可存储一个月，然后被回收利用。有关更多信息，请参阅 [ CodeBuild Docker 服务器功能](https://aws.amazon.com/blogs//aws/accelerate-ci-cd-pipelines-with-the-new-aws-codebuild-docker-server-capability)。
**重要**
运行此示例可能会导致您的 AWS 账户被扣款。其中包括与 Amazon S3 和 CloudWatch 日志相关的 AWS 资源和操作可能产生的费用。 CodeBuild AWS KMS有关更多信息，请参阅[CodeBuild 定价](https://aws.amazon.com/codebuild/pricing)、[Amazon S3 定价](https://aws.amazon.com/s3/pricing)、[AWS Key Management Service 定价](https://aws.amazon.com/kms/pricing)和[亚马逊 CloudWatch定价](https://aws.amazon.com/cloudwatch/pricing)。
**Topics**
+ [配置 Docker 服务器](#sample-docker-server-running)
## 配置 Docker 服务器
使用以下步骤为管理 Docker 工作负载和存储 Docker 映像层的 CodeBuild 项目配置专用计算环境。
**配置 Docker 服务器**
1. 按照本主题[目录结构](#sample-docker-server-dir)和[文件](#sample-docker-server-files)部分所述创建文件，然后将其上传到 S3 输入存储桶或 AWS CodeCommit GitHub、或 Bitbucket 存储库。
**重要**
请不要上传 `(root directory name)`，而只上传 `(root directory name)` 中的文件。
如果您使用的是 S3 输入存储桶，请务必创建一个包含这些文件的 ZIP 文件，然后将其上传到输入存储桶。请不要将 `(root directory name)` 添加到 ZIP 文件中，而只添加 `(root directory name)` 中的文件。
1. 创建构建项目、运行构建和查看相关构建信息：
1. 在控制台的**环境**部分，选择**其他配置**，导航到 **Docker 服务器配置**，然后选择**为此项目启用 Docker 服务器**。然后，您可以选择 **Docker 服务器计算类型**并提供**注册表凭证**。
1. 如果您使用创建构建项目，则`create-project`命令的 JSON 格式输入可能与此类似。 AWS CLI (请将占位符替换为您自己的值。)
```
{
"name": "sample-docker-custom-image-project",
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/DockerServerSample.zip"
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/amazonlinux-x86_64-standard:5.0",
"computeType": "BUILD_GENERAL1_LARGE",
"dockerServer": [
{
"computeType": "BUILD_GENERAL1_LARGE",
"securityGroupIds": [ "security-groups-ID" ]
}
]
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name"
}
```
**注意**
为 Docker 服务器配置的安全组应支持来自在项目中配置的 VPC 的传入网络流量。它们应该支持在端口 9876 上传入。
1. 要查看构建结果，请在构建的日志中查找字符串 `Hello, World!`。有关更多信息，请参阅 [查看构建详细信息](view-build-details.md)。
### 目录结构
此示例采用以下目录结构。
```
(root directory name)
├── buildspec.yml
└── Dockerfile
```
### 文件
在此示例中使用的操作系统的基本映像是 Ubuntu。此示例将使用这些文件。
`buildspec.yml`（在 `(root directory name)`）
```
version: 0.2
phases:
build:
commands:
- docker buildx build -t helloworld --load .
- docker run helloworld echo "Hello, World!"
```
`Dockerfile`（在 `(root directory name)`）
```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN echo "Hello World"
```
# Windows Docker 为以下版本构建示例 CodeBuild
以下示例使用 CodeBuild构建和运行 Windows Docker 镜像。
**Topics**
+ [运行 Windows Docker 构建示例](#sample-windows-docker-build-running)
## 运行 Windows Docker 构建示例
使用以下过程运行 Windows Docker 构建。
**运行 Windows Docker 构建示例**
1. 按照本主题[目录结构](#sample-windows-docker-custom-image-dir)和[文件](#sample-windows-docker-custom-image-files)部分所述创建文件，然后将其上传到 S3 输入存储桶或 AWS CodeCommit GitHub、或 Bitbucket 存储库。
**重要**
请不要上传 `(root directory name)`，而只上传 `(root directory name)` 中的文件。
如果您使用的是 S3 输入存储桶，请务必创建一个包含这些文件的 ZIP 文件，然后将其上传到输入存储桶。请不要将 `(root directory name)` 添加到 ZIP 文件中，而只添加 `(root directory name)` 中的文件。
1. 创建 `WINDOWS_EC2` 实例集。
如果您使用创建队列，则`create-fleet`命令的 JSON 格式输入可能与此类似。 AWS CLI (请将占位符替换为您自己的值。)
```
{
"name": "fleet-name",
"baseCapacity": 1,
"environmentType": "WINDOWS_EC2",
"computeType": "BUILD_GENERAL1_MEDIUM"
}
```
1. 创建构建项目、运行构建和查看相关构建信息。
如果您使用创建构建项目，则`create-project`命令的 JSON 格式输入可能与此类似。 AWS CLI (请将占位符替换为您自己的值。)
```
{
"name": "project-name",
"source": {
"type": "S3",
"location": "bucket-name/DockerImageSample.zip"
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"environment": {
"type": "WINDOWS_EC2",
"image": "Windows",
"computeType": "BUILD_GENERAL1_MEDIUM",
"fleet": {
"fleetArn": "fleet-arn"
}
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name"
}
```
1. 要查看构建结果，请在构建的日志中查找字符串 `Hello, World!`。有关更多信息，请参阅 [查看构建详细信息](view-build-details.md)。
### 目录结构
此示例采用以下目录结构。
```
(root directory name)
├── buildspec.yml
└── Dockerfile
```
### 文件
在此示例中使用的操作系统的基本映像是 `mcr.microsoft.com/windows/servercore:ltsc2022`。此示例将使用这些文件。
`buildspec.yml`（在 `(root directory name)`）
```
version: 0.2
phases:
pre_build:
commands:
- docker build -t helloworld .
build:
commands:
- docker images
- docker run helloworld powershell -Command "Write-Host 'Hello World!'"
```
`Dockerfile`（在 `(root directory name)`）
```
FROM mcr.microsoft.com/windows/servercore:ltsc2022
RUN powershell -Command "Write-Host 'Hello World'"
```
# “将 Docker 映像发布到亚马逊 ECR 镜像存储库” 示例 CodeBuild
该示例会生成一个 Docker 映像作为构建输出，然后将该 Docker 映像推送到 Amazon Elastic Container Registry (Amazon ECR) 映像存储库。您可以调整该示例以将 Docker 映像推送到 Docker Hub。有关更多信息，请参阅 [调整“将 Docker 映像发布到 Amazon ECR”示例，将其推送到 Docker Hub](sample-docker-docker-hub.md)。
要了解如何使用自定义 Docker 构建映像来构建 Docker 映像（Docker Hub 中的 `docker:dind`），请参阅我们的[自定义映像示例中的 Docker](sample-docker-custom-image.md)。
此示例参考 `golang:1.12` 进行了测试。
此示例使用新的多阶段 Docker 构建功能，该功能将生成一个 Docker 映像作为构建输出。然后，它将 Docker 映像推送到 Amazon ECR 映像存储库。多阶段 Docker 映像构建有助于减小最终 Docker 映像的大小。有关更多信息，请参阅[将多阶段构建和 Docker 结合使用](https://docs.docker.com/engine/userguide/eng-image/multistage-build/)。
**重要**
运行此示例可能会导致您的 AWS 账户被扣款。其中包括与 Amazon S3、 AWS KMS、 CloudWatch 日志和 Amazon ECR 相关的 AWS 资源和操作可能产生的费用。 AWS CodeBuild 有关更多信息，请参阅[CodeBuild 定价](https://aws.amazon.com/codebuild/pricing)、[Amazon S3 定价](https://aws.amazon.com/s3/pricing)、[AWS Key Management Service 定价](https://aws.amazon.com/kms/pricing)、[亚马逊 CloudWatch 定价](https://aws.amazon.com/cloudwatch/pricing)和[亚马逊弹性容器注册表定价](https://aws.amazon.com/ecr/pricing)。
**Topics**
+ [运行“将 Docker 映像发布到 Amazon ECR”示例](#sample-docker-running)
+ [调整“将 Docker 映像发布到 Amazon ECR”示例，将其推送到 Docker Hub](sample-docker-docker-hub.md)
## 运行“将 Docker 映像发布到 Amazon ECR”示例
使用以下过程运行示例，将 Docker 映像发布到 Amazon ECR。有关此示例的更多信息，请参阅[“将 Docker 映像发布到亚马逊 ECR 镜像存储库” 示例 CodeBuild](#sample-docker)。
**要运行此示例，请执行以下操作：**
1. 如果 Amazon ECR 中已存在要使用的映像存储库，请跳至第 3 步。否则，如果您使用的是用户而不是 AWS 根账户或管理员用户来使用 Amazon ECR，请将此语句（介于*\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1*和之间*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*）添加到用户（或用户关联的 IAM 群组）。不建议使用 AWS 根账户。此语句允许创建用于存储 Docker 镜像的 Amazon ECR 存储库。为了简洁起见，也为了帮您查找添加语句的位置，此处使用了省略号 (`...`)。请勿删除任何语句，也不要将这些省略号键入策略中。有关更多信息，请参阅《用户指南》**中的[通过 AWS 管理控制台使用内联策略](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_inline-using.html#AddingPermissions_Console)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecr:CreateRepository"
],
"Resource": "*"
}
]
}
```
------
**注意**
修改该策略的 IAM 实体必须拥有在 IAM 中修改策略的权限。
1. 在 Amazon ECR 中创建映像存储库。请务必在创建构建环境和运行构建的同一 AWS 区域创建存储库。有关更多信息，请参阅《Amazon ECR 用户指南》**中的[创建存储库](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html)。该存储库的名称必须与您将在此过程的稍后部分指定的存储库名称相匹配，并以 `IMAGE_REPO_NAME` 环境变量的形式表示。确保 Amazon ECR 存储库策略为您的 CodeBuild服务 IAM 角色授予图片推送访问权限。
1. 将此语句（介于*\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1*和之间*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*）添加到您附加到 AWS CodeBuild 服务角色的策略中。此声明允许将 Docker 镜像上传 CodeBuild 到亚马逊 ECR 存储库。为了简洁起见，也为了帮您查找添加语句的位置，此处使用了省略号 (`...`)。请勿删除任何语句，也不要将这些省略号键入策略中。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ecr:BatchCheckLayerAvailability",
"ecr:CompleteLayerUpload",
"ecr:GetAuthorizationToken",
"ecr:InitiateLayerUpload",
"ecr:PutImage",
"ecr:UploadLayerPart"
],
"Resource": "*"
}
]
}
```
------
**注意**
修改该策略的 IAM 实体必须拥有在 IAM 中修改策略的权限。
1. 按照本主题[目录结构](#sample-docker-dir)和[文件](#sample-docker-files)部分所述创建文件，然后将其上传到 S3 输入存储桶或 AWS CodeCommit GitHub、或 Bitbucket 存储库。有关更多信息，请参阅《AWS CodePipeline 用户指南》**中的[映像定义文件参考](https://docs.aws.amazon.com/codepipeline/latest/userguide/file-reference.html)。
**重要**
请不要上传 `(root directory name)`，而只上传 `(root directory name)` 中的文件。
如果您使用的是 S3 输入存储桶，请务必创建一个包含这些文件的 ZIP 文件，然后将其上传到输入存储桶。请不要将 `(root directory name)` 添加到 ZIP 文件中，而只添加 `(root directory name)` 中的文件。
1. 创建构建项目、运行构建和查看构建信息。
如果您使用控制台创建项目：
1. 对于**操作系统**，选择 **Ubuntu**。
1. 对于**运行时**，选择**标准**。
1. **对于 “**图像**”，选择:5.0 aws/codebuild/standard。**
1. 添加以下环境变量：
+ AWS\$1DEFAULT\$1REGION 值为 *region-ID*
+ AWS\$1ACCOUNT\$1ID 值为 *account-ID*
+ 具有最新值的 IMAGE\$1TAG
+ IMAGE\$1REPO\$1NAME 的值为 *Amazon-ECR-repo-name*
如果您使用创建构建项目，则`create-project`命令的 JSON 格式输入可能与此类似。 AWS CLI (请将占位符替换为您自己的值。)
```
{
"name": "sample-docker-project",
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/DockerSample.zip"
},
"artifacts": {
"type": "NO_ARTIFACTS"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "BUILD_GENERAL1_SMALL",
"environmentVariables": [
{
"name": "AWS_DEFAULT_REGION",
"value": "region-ID"
},
{
"name": "AWS_ACCOUNT_ID",
"value": "account-ID"
},
{
"name": "IMAGE_REPO_NAME",
"value": "Amazon-ECR-repo-name"
},
{
"name": "IMAGE_TAG",
"value": "latest"
}
],
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name",
"encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}
```
1. 确认 CodeBuild 已成功将 Docker 镜像推送到存储库：
1. 打开 Amazon ECR 控制台，网址为[https://console.aws.amazon.com/ecr/](https://console.aws.amazon.com/ecr/)。
1. 选择存储库名称。映像应在**映像标签**列中列出。
### 目录结构
此示例采用以下目录结构。
```
(root directory name)
├── buildspec.yml
└── Dockerfile
```
### 文件
此示例将使用这些文件。
`buildspec.yml`（在 `(root directory name)`）
```
version: 0.2
phases:
pre_build:
commands:
- echo Logging in to Amazon ECR...
- aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com
build:
commands:
- echo Build started on `date`
- echo Building the Docker image...
- docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
- docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
post_build:
commands:
- echo Build completed on `date`
- echo Pushing the Docker image...
- docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
```
`Dockerfile`（在 `(root directory name)`）
```
FROM golang:1.12-alpine AS build
#Install git
RUN apk add --no-cache git
#Get the hello world package from a GitHub repository
RUN go get github.com/golang/example/hello
WORKDIR /go/src/github.com/golang/example/hello
# Build the project and send the output to /bin/HelloWorld
RUN go build -o /bin/HelloWorld
FROM golang:1.12-alpine
#Copy the build's output binary from the previous build container
COPY --from=build /bin/HelloWorld /bin/HelloWorld
ENTRYPOINT ["/bin/HelloWorld"]
```
**注意**
CodeBuild 会替换自定义 Docker 镜像的。`ENTRYPOINT`
# 调整“将 Docker 映像发布到 Amazon ECR”示例，将其推送到 Docker Hub
要调整“将 Docker 映像发布到 Amazon ECR”，以便将 Docker 映像推送到 Docker Hub 而不是推送到 Amazon ECR，请编辑示例的代码。有关示例的更多信息，请参阅 [“将 Docker 映像发布到亚马逊 ECR 镜像存储库” 示例 CodeBuild](sample-docker.md) 和 [运行“将 Docker 映像发布到 Amazon ECR”示例](sample-docker.md#sample-docker-running)。
**注意**
如果您使用的是 17.06 版本之前的 Docker 版本，请删除 `--no-include-email` 选项。
1. 将 `buildspec.yml` 文件中的这些特定于 Amazon ECR 的代码行替换为：
```
...
pre_build:
commands:
- echo Logging in to Amazon ECR...
- aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com
build:
commands:
- echo Build started on `date`
- echo Building the Docker image...
- docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
- docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
post_build:
commands:
- echo Build completed on `date`
- echo Pushing the Docker image...
- docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
...
```
利用这些特定于 Docker Hub 的代码行，可以：
```
...
pre_build:
commands:
- echo Logging in to Docker Hub...
# Type the command to log in to your Docker Hub account here.
build:
commands:
- echo Build started on `date`
- echo Building the Docker image...
- docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
- docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $IMAGE_REPO_NAME:$IMAGE_TAG
post_build:
commands:
- echo Build completed on `date`
- echo Pushing the Docker image...
- docker push $IMAGE_REPO_NAME:$IMAGE_TAG
...
```
1. 将编辑后的代码上传到 S3 输入存储桶或 AWS CodeCommit GitHub、或 Bitbucket 存储库。
**重要**
请不要上传 `(root directory name)`，而只上传 `(root directory name)` 中的文件。
如果您使用的是 S3 输入存储桶，请务必创建一个包含这些文件的 ZIP 文件，然后将其上传到输入存储桶。请不要将 `(root directory name)` 添加到 ZIP 文件中，而只添加 `(root directory name)` 中的文件。
1. 将 `create-project` 命令的 JSON 格式输入中的这些代码行替换为：
```
...
"environmentVariables": [
{
"name": "AWS_DEFAULT_REGION",
"value": "region-ID"
},
{
"name": "AWS_ACCOUNT_ID",
"value": "account-ID"
},
{
"name": "IMAGE_REPO_NAME",
"value": "Amazon-ECR-repo-name"
},
{
"name": "IMAGE_TAG",
"value": "latest"
}
]
...
```
利用这些代码行，可以：
```
...
"environmentVariables": [
{
"name": "IMAGE_REPO_NAME",
"value": "your-Docker-Hub-repo-name"
},
{
"name": "IMAGE_TAG",
"value": "latest"
}
]
...
```
1. 创建构建环境、运行构建和查看相关构建信息。
1. 确认 AWS CodeBuild 已成功将 Docker 镜像推送到存储库。登录 Docker Hub，再转至存储库，然后选择**标签**选项卡。`latest` 标签应包含最新的**上次更新**值。
# 带有 AWS Secrets Manager 示例的私有注册表 CodeBuild
此示例向您展示如何使用存储在私有注册表中的 Docker 镜像作为 AWS CodeBuild 运行时环境。私有注册表的凭证存储在 AWS Secrets Manager中。任何私有注册表均可使用 CodeBuild。此示例使用 Docker Hub。
**注意**
密钥对操作可见，在写入文件时不会被屏蔽。
**Topics**
+ [私有注册表示例要求](#sample-private-registry-requirements)
+ [使用私有注册表创建 CodeBuild 项目](private-registry-sample-create-project.md)
+ [为自托管运行程序配置私有注册表凭证](private-registry-sample-configure-runners.md)
## 私有注册表示例要求
要将私有注册表与一起使用 AWS CodeBuild，您必须具备以下条件：
+ 一个 Secrets Manager 密钥，用于储存您的 Docker Hub 凭证。该凭证可用于访问您的私有存储库。
**注意**
您将需要为您创建的密钥付费。
+ 一个私有存储库或账户。
+ 一项 CodeBuild 服务角色 IAM 策略，用于授予对你的 Secrets Manager 密钥的访问权限。
按照以下步骤创建这些资源，然后使用存储在私有注册表中的 Docker 镜像创建 CodeBuild 构建项目。
# 使用私有注册表创建 CodeBuild 项目
1. 有关如何创建免费的私有存储库的更多信息，请参阅 [Docker Hub 上的存储库](https://docs.docker.com/docker-hub/repos/)。您还可以在终端中运行以下命令来提取映像、获取其ID，并将其推送到新的存储库。
```
docker pull amazonlinux
docker images amazonlinux --format {{.ID}}
docker tag image-id your-username/repository-name:tag
docker login
docker push your-username/repository-name
```
1. 按照《*AWS Secrets Manager 用户指南》*中[创建 AWS Secrets Manager 密钥](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)中的步骤进行操作。
1. 在步骤 3 中，在**选择密钥类型**，选择**其他密钥类型**。
1. 在**密钥/值对**中，为您的 Docker Hub 用户名创建一个键值对，为您的 Docker Hub 密码创建一个键值对。
1. 继续按照[创建 AWS Secrets Manager 密钥中的步骤进行](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)操作。
1. 在步骤 5 中，在**配置自动轮换**页面上，将其关闭，因为密钥对应于您的 Docker Hub 凭证。
1. 按照[创建 AWS Secrets Manager 密钥](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)中的步骤完成操作。
有关更多信息，请参阅[什么是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)
1. 在控制台中创建 AWS CodeBuild 项目时，会 CodeBuild 附上所需的权限。如果您使用的 AWS KMS 密钥除外`DefaultEncryptionKey`，则必须将其添加到服务角色中。有关更多信息，请参阅《IAM 用户指南》**中的[修改角色（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_modify.html#roles-managingrole-editing-console)。
要使您的服务角色与 Secrets Manager 配合使用，它必须至少具有 `secretsmanager:GetSecretValue` 权限。
![\[服务角色配置。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/private-registry-sample-iam.png)
1. 要使用控制台创建一个具有在私有注册表中存储的环境的项目，请在创建项目时执行以下操作。有关信息，请参阅[创建构建项目（控制台）](create-project.md#create-project-console)。
**注意**
如果您的私有注册表位于您的 VPC 中，则它必须具有公共互联网访问权限。 CodeBuild 无法从 VPC 中的私有 IP 地址提取镜像。
1. 对于**环境映像**，选择**自定义映像**。
1. 对于**环境类型**，选择 **Linux** 或 **Windows**。
1. 对于**映像注册表**，请选择**其他注册表**。
1. 在**外部注册表 URL** 中，输入映像位置，在**注册表凭证 - 可选**中输入您的 Secrets Manager 凭证的 ARN 或名称。
**注意**
如果您的凭证在当前区域中不存在，则必须使用 ARN。如果凭证存在于其他区域中，则无法使用凭证名称。
# 为自托管运行程序配置私有注册表凭证
按照以下说明为自托管运行程序配置注册表凭证。
**注意**
请注意，只有当映像被私有注册表中的映像覆盖时，才会使用这些凭证。
------
#### [ AWS Management Console ]
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 创建构建项目或选择现有项目。有关更多信息，请参阅 [创建构建项目（控制台）](create-project.md#create-project-console) 和 [更改构建项目的设置（控制台）](change-project.md#change-project-console)。
1. 在**环境**中，选择**其他配置**。
1. 在**其他配置**中，输入**注册凭据的密钥名称或 ARN（ AWS Secrets Manager 可选**）。
![\[注册表凭证配置。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/registry-credential.png)
------
#### [ AWS CLI ]
1. 如果要创建一个新项目，请运行 **create-project** 命令。
```
aws codebuild create-project \
--name project-name \
--source type=source-type,location=source-location \
--environment "type=environment-type,image=image,computeType=compute-type,registryCredential={credentialProvider=SECRETS_MANAGER,credential=secret-name-or-arn},imagePullCredentialsType=CODEBUILD|SERVICE_ROLE" \
--artifacts type=artifacts-type \
--service-role arn:aws:iam::account-ID:role/service-role/service-role-name
```
1. 如果要更新现有项目，请运行 **update-project** 命令。
```
aws codebuild update-project \
--name project-name \
--environment "type=environment-type,image=image,computeType=compute-type,registryCredential={credentialProvider=SECRETS_MANAGER,credential=secret-name-or-arn}"
```
------
# 创建将构建输出托管在 S3 存储桶中的静态网站
您可以在构建中禁用构件加密。您可能需要禁用构件加密，以便将构件发布到配置为托管网站的位置。（您不能发布加密的构件。） 此示例演示如何使用 Webhook 触发构建并将其构件发布到配置为网站的 S3 存储桶。
1. 按照[设置静态网站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/HostingWebsiteOnS3Setup.html)中的说明操作，以配置一个以网站方式运行的 S3 存储桶。
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 如果显示 CodeBuild 信息页面，请选择 “**创建构建项目**”。否则，请在导航窗格中，展开**构建**，选择**构建项目**，然后选择**创建构建项目**。
1. 在**项目名称**中，输入此构建项目的名称。每个 AWS 账户中的构建项目名称必须是唯一的。您还可以包含构建项目的可选描述，以帮助其他用户了解此项目的用途。
1. 在 **Source (源)** 中，对于 **Source provider (源提供商)**，选择 **GitHub**。按照说明进行连接（或重新连接） GitHub，然后选择 “**授权**”。
对于 **Webhook**，选择**每次将代码更改推送到此存储库时都会重新构建**。仅当您已选中**在我的账户中使用存储库**时才选中此复选框。
![\[webhook 配置。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/webhook.png)
1. 在**环境**中：
对于**环境映像**，执行下列操作之一：
+ 要使用由管理的 Docker 映像 AWS CodeBuild，请选择**托管映像**，然后从 “**操作系统**”、“**运行时**”、“映像” 和 “**映像****版本**” 中进行选择。从**环境类型**中进行选择（如果可用）。
+ 要使用其他 Docker 映像，请选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您针对**外部注册表 URL** 选择**其他注册表**，请使用 `docker repository/docker image name` 格式在 Docker Hub 中输入 Docker 映像的名称和标签。如果您选择 **Amazon ECR**，请使用**亚马逊 ECR 存储库和** A **mazon ECR 镜像**在您的账户中选择 Docker 镜像。 AWS
+ 要使用私有 Docker 映像，请选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。对于**映像注册表**，选择**其他注册表**，然后输入您的私有 Docker 映像的凭证的 ARN。凭证必须由 Secrets Manager 创建。有关更多信息，请参阅《AWS Secrets Manager 用户指南》中的[什么是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
1. 在**服务角色**中，执行下列操作之一：
+ 如果您没有 CodeBuild 服务角色，请选择 “**新建服务角色**”。在**角色名称**中，为新角色输入名称。
+ 如果您有 CodeBuild 服务角色，请选择**现有服务角色**。在**角色 ARN** 中，选择服务角色。
**注意**
使用控制台创建或更新构建项目时，可以同时创建 CodeBuild 服务角色。默认情况下，这个角色仅能与该构建项目配合使用。如果您使用控制台将此服务角色与另一个构建项目关联，则此角色将更新以便与关联的构建项目结合使用。一个服务角色最多可与 10 个构建项目结合使用。
1. 在 **Buildspec** 中，执行以下操作之一：
+ 选择**使用 buildspec 文件**，以在源代码根目录中使用 buildspec.yml 文件。
+ 选择**插入构建命令**，以使用控制台插入构建命令。
有关更多信息，请参阅[Buildspec 参考](build-spec-ref.md)。
1. 在**构件**中，对于**类型**，选择 **Amazon S3** 以将构建输出存储在 S3 存储桶中。
1. 对于**存储桶名称**，选择您在步骤 1 中配置以用作网站的 S3 存储桶的名称。
1. 如果您在**环境**中选择了**插入构建命令**，那么对于**输出文件**，请输入构建（该构建要放到输出存储桶中）中的文件位置。如果您有多个位置，请使用逗号分隔每个位置（例如，**appspec.yml, target/my-app.jar**）。有关更多信息，请参阅 [Artifacts reference-key in the buildspec file](build-spec-ref.md#artifacts-build-spec)。
1. 选择**禁用构件加密**。
1. 展开**其他配置**并根据需要选择选项。
1. 选择 **Create build project（创建构建项目）**。在构建项目页面上的**构建历史记录**中，选择**开始构建**以运行构建。
1. （可选）按照《Amazon *S3 开发者指南》*中的 “[示例：使用亚马逊加速您的网站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/website-hosting-cloudfront-walkthrough.html)” CloudFront 中的说明进行操作。
# 多输入源和输出构件示例
您可以创建具有多个输入源和多个输出构件集的 AWS CodeBuild 构建项目。此示例演示如何设置具有以下特点的构建项目：
+ 使用多个不同类型的源和存储库。
+ 将构建构件发布到单个构建中的多个 S3 存储桶。
在以下示例中，创建一个构建项目并使用它来运行构建。示例使用构建项目的 buildspec 文件演示如何合并多个源和创建多个构件集。
要了解如何创建使用多个到 CodeBuild 的源输入创建多个输出构件的管道，请参阅[具有多个输入源和输出工件的 CodePipeline/CodeBuild 集成示例](sample-codepipeline.md#sample-pipeline-multi-input-output)。
**Topics**
+ [创建包含多个输入和输出的构建项目](sample-multi-in-out-create.md)
+ [创建没有源的构建项目](no-source.md)
# 创建包含多个输入和输出的构建项目
按照以下过程来创建包含多个输入和输出的构建项目。
**创建包含多个输入和输出的构建项目**
1. 将源上传到一个或多个 S3 存储桶、CodeCommit、GitHub、GitHub Enterprise Server 或 Bitbucket 存储库。
1. 选择一个源作为主要源。此源供 CodeBuild 查找和运行 buildspec 文件。
1. 创建构建项目。有关更多信息，请参阅 [在 中创建构建项目AWS CodeBuild](create-project.md)。
1. 创建构建项目、运行构建和获取有关构建的信息。
1. 如果使用 AWS CLI 创建构建项目，则 `create-project` 命令的 JSON 格式输入可能类似于以下内容：
```
{
"name": "sample-project",
"source": {
"type": "S3",
"location": ""
},
"secondarySources": [
{
"type": "CODECOMMIT",
"location": "https://git-codecommit.us-west-2.amazonaws.com/v1/repos/repo",
"sourceIdentifier": "source1"
},
{
"type": "GITHUB",
"location": "https://github.com/awslabs/aws-codebuild-jenkins-plugin",
"sourceIdentifier": "source2"
}
],
"secondaryArtifacts": [ss
{
"type": "S3",
"location": "",
"artifactIdentifier": "artifact1"
},
{
"type": "S3",
"location": "",
"artifactIdentifier": "artifact2"
}
],
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "BUILD_GENERAL1_SMALL"
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name",
"encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}
```
主要源在 `source` 属性下定义。所有其他源都称为辅助源，出现在 `secondarySources` 下方。所有辅助源都安装在各自的目录中。目录存储在内置环境变量 `CODEBUILD_SRC_DIR_sourceIdentifer` 中。有关更多信息，请参阅 [构建环境中的环境变量](build-env-ref-env-vars.md)。
`secondaryArtifacts` 属性包含构件定义列表。这些构件使用 buildspec 文件的 `secondary-artifacts` 块（嵌套在 `artifacts` 块内）。
buildspec 文件中的辅助构件与构件具有相同的结构，以其构件标识符分隔。
**注意**
在 [CodeBuild API](https://docs.aws.amazon.com/codebuild/latest/APIReference/) 中，辅助构件的 `artifactIdentifier` 是 `CreateProject` 和 `UpdateProject` 中的必需属性。必须使用它引用辅助构件。
使用前面的 JSON 格式的输入，项目的 buildspec 文件可能如下所示：
```
version: 0.2
phases:
install:
runtime-versions:
java: openjdk11
build:
commands:
- cd $CODEBUILD_SRC_DIR_source1
- touch file1
- cd $CODEBUILD_SRC_DIR_source2
- touch file2
artifacts:
files:
- '**.*'
secondary-artifacts:
artifact1:
base-directory: $CODEBUILD_SRC_DIR_source1
files:
- file1
artifact2:
base-directory: $CODEBUILD_SRC_DIR_source2
files:
- file2
```
可以在 `StartBuild` 中使用具有 `sourceVersion` 属性的 API 覆盖主要源的版本。要覆盖一个或多个辅助源版本，请使用 `secondarySourceVersionOverride` 属性。
`start-build` 中 AWS CLI 命令的 JSON 格式输入可能类似于以下内容：
```
{
"projectName": "sample-project",
"secondarySourcesVersionOverride": [
{
"sourceIdentifier": "source1",
"sourceVersion": "codecommit-branch"
},
{
"sourceIdentifier": "source2",
"sourceVersion": "github-branch"
},
]
}
```
# 创建没有源的构建项目
配置 CodeBuild 项目时，可以在配置源时选择 **NO\$1SOURCE** 源类型。当您的源类型为 **NO\$1SOURCE** 时，您不能指定 buildspec 文件，因为您的项目没有源。相反，您必须将 JSON 格式输入的 `buildspec` 属性中的 YAML 格式 buildspec 字符串指定给 `create-project` CLI 命令。它可能如下所示：
```
{
"name": "project-name",
"source": {
"type": "NO_SOURCE",
"buildspec": "version: 0.2\n\nphases:\n build:\n commands:\n - command"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "BUILD_GENERAL1_SMALL",
},
"serviceRole": "arn:aws:iam::account-ID:role/role-name",
"encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
}
```
有关更多信息，请参阅 [创建构建项目 (AWS CLI)](create-project.md#create-project-cli)。
# buildspec 文件示例中的运行时版本 CodeBuild
如果您使用的是 Amazon Linux 2 (AL2) 标准映像版本 1.0 或更高版本，或者使用 Ubuntu 标准映像版本 2.0 或更高版本，则可以在构建规范文件的`runtime-versions`部分中指定一个或多个运行时。以下示例向您展示了如何更改项目运行时、指定多个运行时以及指定依赖于另一个运行时的运行时。有关支持的运行时的信息，请参阅 [提供的 Docker 镜像 CodeBuild](build-env-ref-available.md)。
**注意**
如果您在构建容器中使用 Docker，则您的构建必须在特权模式下运行。有关更多信息，请参阅[手动运行 AWS CodeBuild 构建](run-build.md)和[在 中创建构建项目AWS CodeBuild](create-project.md)。
**Topics**
+ [更新 buildspec 文件中的运行时版本](sample-runtime-update-version.md)
+ [指定两个运行时](sample-runtime-two-major-version-runtimes.md)
# 更新 buildspec 文件中的运行时版本
您可以通过更新 buildspec 文件的 `runtime-versions` 部分，将项目使用的运行时修改到新版本。以下示例说明如何指定 Java 版本 8 和 11。
+ 一个 `runtime-versions` 部分，指定 Java 版本 8：
```
phases:
install:
runtime-versions:
java: corretto8
```
+ 一个 `runtime-versions` 部分，指定 Java 版本 11：
```
phases:
install:
runtime-versions:
java: corretto11
```
以下示例说明如何使用 Ubuntu 标准映像 5.0 或 Amazon Linux 2 标准映像 3.0 指定不同版本的 Python：
+ 一个 `runtime-versions` 部分，指定 Python 版本 3.7：
```
phases:
install:
runtime-versions:
python: 3.7
```
+ 一个 `runtime-versions` 部分，指定 Python 版本 3.8：
```
phases:
install:
runtime-versions:
python: 3.8
```
本示例演示一个项目，该项目从 Java 版本 8 运行时开始，然后更新到 Java 版本 10 运行时。
1. 下载并安装 Maven。有关信息，请参阅 Apache Maven 网站上的[下载 Apache Maven](https://maven.apache.org/download.cgi) 和[安装 Apache Maven](https://maven.apache.org/install.html)。
1. 切换到您的本地计算机或实例上的空目录，然后运行此 Maven 命令。
```
mvn archetype:generate "-DgroupId=com.mycompany.app" "-DartifactId=ROOT" "-DarchetypeArtifactId=maven-archetype-webapp" "-DinteractiveMode=false"
```
如果成功，将创建此目录结构和文件。
```
.
└── ROOT
├── pom.xml
└── src
└── main
├── resources
└── webapp
├── WEB-INF
│ └── web.xml
└── index.jsp
```
1. 使用以下内容创建名为 `buildspec.yml` 的文件。将此文件存储到 ` (root directory name)/my-web-app` 目录。
```
version: 0.2
phases:
install:
runtime-versions:
java: corretto8
build:
commands:
- java -version
- mvn package
artifacts:
files:
- '**/*'
base-directory: 'target/my-web-app'
```
在 buildspec 文件中：
+ `runtime-versions` 部分指定项目使用 Java 运行时版本 8。
+ `- java -version` 命令显示您的项目在执行构建时所使用的 Java 版本。
您的文件结构现在应如下所示。
```
(root directory name)
└── my-web-app
├── src
│ ├── main
│ ├── resources
│ └── webapp
│ └── WEB-INF
│ └── web.xml
│ └── index.jsp
├── buildspec.yml
└── pom.xml
```
1. 将`my-web-app`目录的内容上传到 S3 输入存储桶或 CodeCommit GitHub、或 Bitbucket 存储库。
**重要**
请不要上传 `(root directory name)` 或 `(root directory name)/my-web-app`，而只上传 `(root directory name)/my-web-app` 中的目录和文件。
如果您使用的是 S3 输入存储桶，请确保创建一个包含目录结构和文件的 ZIP 文件，然后将其上传至输入存储桶。请不要将 `(root directory name)` 或 `(root directory name)/my-web-app` 添加到 ZIP 文件中，而只添加 `(root directory name)/my-web-app` 中的目录和文件。
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 创建构建项目。有关更多信息，请参阅[创建构建项目（控制台）](create-project.md#create-project-console)和[运行构建（控制台）](run-build-console.md)。除这些设置以外，将所有设置保留为默认值。
+ 对于**环境**：
+ 对于**环境映像**，选择**托管映像**。
+ 对于**操作系统**，选择 **Amazon Linux 2**。
+ 对于**运行时**，选择**标准**。
+ 对于**图像**，选择 **aws/codebuild/amazonlinux-x** 86\$164-standards: 4.0。
1. 选择**开始构建**。
1. 在**构建配置**上，接受默认值，然后选择**开始构建**。
1. 当构建完成后，在**构建日志**选项卡上查看构建输出。您应该可以看到类似于如下所示的输出内容：
```
[Container] Date Time Phase is DOWNLOAD_SOURCE
[Container] Date Time CODEBUILD_SRC_DIR=/codebuild/output/src460614277/src
[Container] Date Time YAML location is /codebuild/output/src460614277/src/buildspec.yml
[Container] Date Time Processing environment variables
[Container] Date Time Selecting 'java' runtime version 'corretto8' based on manual selections...
[Container] Date Time Running command echo "Installing Java version 8 ..."
Installing Java version 8 ...
[Container] Date Time Running command export JAVA_HOME="$JAVA_8_HOME"
[Container] Date Time Running command export JRE_HOME="$JRE_8_HOME"
[Container] Date Time Running command export JDK_HOME="$JDK_8_HOME"
[Container] Date Time Running command for tool_path in "$JAVA_8_HOME"/bin/* "$JRE_8_HOME"/bin/*;
```
1. 使用 Java 版本 11 更新 `runtime-versions` 部分：
```
install:
runtime-versions:
java: corretto11
```
1. 保存更改后，再次运行您的构建并查看构建输出。您应看到已安装的 Java 版本为 11。您应该可以看到类似于如下所示的输出内容：
```
[Container] Date Time Phase is DOWNLOAD_SOURCE
[Container] Date Time CODEBUILD_SRC_DIR=/codebuild/output/src460614277/src
[Container] Date Time YAML location is /codebuild/output/src460614277/src/buildspec.yml
[Container] Date Time Processing environment variables
[Container] Date Time Selecting 'java' runtime version 'corretto11' based on manual selections...
Installing Java version 11 ...
[Container] Date Time Running command export JAVA_HOME="$JAVA_11_HOME"
[Container] Date Time Running command export JRE_HOME="$JRE_11_HOME"
[Container] Date Time Running command export JDK_HOME="$JDK_11_HOME"
[Container] Date Time Running command for tool_path in "$JAVA_11_HOME"/bin/* "$JRE_11_HOME"/bin/*;
```
# 指定两个运行时
您可以在同一个 CodeBuild 构建项目中指定多个运行时。此示例项目使用两个源文件：一个使用 Go 运行时，另一个使用 Node.js 运行时。
1. 创建一个名为 `my-source` 的目录。
1. 在 `my-source` 目录中，创建一个名为 `golang-app` 的目录。
1. 使用以下内容创建名为 `hello.go` 的文件。将此文件存储到 `golang-app` 目录。
```
package main
import "fmt"
func main() {
fmt.Println("hello world from golang")
fmt.Println("1+1 =", 1+1)
fmt.Println("7.0/3.0 =", 7.0/3.0)
fmt.Println(true && false)
fmt.Println(true || false)
fmt.Println(!true)
fmt.Println("good bye from golang")
}
```
1. 在 `my-source` 目录中，创建一个名为 `nodejs-app` 的目录。它应该与 `golang-app` 目录同级。
1. 使用以下内容创建名为 `index.js` 的文件。将此文件存储到 `nodejs-app` 目录。
```
console.log("hello world from nodejs");
console.log("1+1 =" + (1+1));
console.log("7.0/3.0 =" + 7.0/3.0);
console.log(true && false);
console.log(true || false);
console.log(!true);
console.log("good bye from nodejs");
```
1. 使用以下内容创建名为 `package.json` 的文件。将此文件存储到 `nodejs-app` 目录。
```
{
"name": "mycompany-app",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"run some tests here\""
},
"author": "",
"license": "ISC"
}
```
1. 使用以下内容创建名为 `buildspec.yml` 的文件。将文件存储在 `my-source` 目录中，该目录与 `nodejs-app` 以及 `golang-app` 目录同级。`runtime-versions` 部分指定 Node.js 版本 12 运行时和 Go 版本 1.13 运行时。
```
version: 0.2
phases:
install:
runtime-versions:
golang: 1.13
nodejs: 12
build:
commands:
- echo Building the Go code...
- cd $CODEBUILD_SRC_DIR/golang-app
- go build hello.go
- echo Building the Node code...
- cd $CODEBUILD_SRC_DIR/nodejs-app
- npm run test
artifacts:
secondary-artifacts:
golang_artifacts:
base-directory: golang-app
files:
- hello
nodejs_artifacts:
base-directory: nodejs-app
files:
- index.js
- package.json
```
1. 您的文件结构现在应如下所示。
```
my-source
├── golang-app
│ └── hello.go
├── nodejs.app
│ ├── index.js
│ └── package.json
└── buildspec.yml
```
1. 将`my-source`目录的内容上传到 S3 输入存储桶或 CodeCommit GitHub、或 Bitbucket 存储库。
**重要**
如果您使用的是 S3 输入存储桶，请确保创建一个包含目录结构和文件的 ZIP 文件，然后将其上传至输入存储桶。请不要将 `my-source` 添加到 ZIP 文件中，而只添加 `my-source` 中的目录和文件。
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 创建构建项目。有关更多信息，请参阅[创建构建项目（控制台）](create-project.md#create-project-console)和[运行构建（控制台）](run-build-console.md)。除这些设置以外，将所有设置保留为默认值。
+ 对于**环境**：
+ 对于**环境映像**，选择**托管映像**。
+ 对于**操作系统**，选择 **Amazon Linux 2**。
+ 对于**运行时**，选择**标准**。
+ 对于**图像**，选择 **aws/codebuild/amazonlinux-x** 86\$164-standards: 4.0。
1. 选择 **Create build project（创建构建项目）**。
1. 选择**开始构建**。
1. 在**构建配置**上，接受默认值，然后选择**开始构建**。
1. 当构建完成后，在**构建日志**选项卡上查看构建输出。您应该可以看到类似于如下所示的输出内容。它显示来自 Go 和 Node.js 运行时的输出，还显示来自 Go 和 Node.js 应用程序的输出。
```
[Container] Date Time Processing environment variables
[Container] Date Time Selecting 'golang' runtime version '1.13' based on manual selections...
[Container] Date Time Selecting 'nodejs' runtime version '12' based on manual selections...
[Container] Date Time Running command echo "Installing Go version 1.13 ..."
Installing Go version 1.13 ...
[Container] Date Time Running command echo "Installing Node.js version 12 ..."
Installing Node.js version 12 ...
[Container] Date Time Running command n $NODE_12_VERSION
installed : v12.20.1 (with npm 6.14.10)
[Container] Date Time Moving to directory /codebuild/output/src819694850/src
[Container] Date Time Registering with agent
[Container] Date Time Phases found in YAML: 2
[Container] Date Time INSTALL: 0 commands
[Container] Date Time BUILD: 1 commands
[Container] Date Time Phase complete: DOWNLOAD_SOURCE State: SUCCEEDED
[Container] Date Time Phase context status code: Message:
[Container] Date Time Entering phase INSTALL
[Container] Date Time Phase complete: INSTALL State: SUCCEEDED
[Container] Date Time Phase context status code: Message:
[Container] Date Time Entering phase PRE_BUILD
[Container] Date Time Phase complete: PRE_BUILD State: SUCCEEDED
[Container] Date Time Phase context status code: Message:
[Container] Date Time Entering phase BUILD
[Container] Date Time Running command echo Building the Go code...
Building the Go code...
[Container] Date Time Running command cd $CODEBUILD_SRC_DIR/golang-app
[Container] Date Time Running command go build hello.go
[Container] Date Time Running command echo Building the Node code...
Building the Node code...
[Container] Date Time Running command cd $CODEBUILD_SRC_DIR/nodejs-app
[Container] Date Time Running command npm run test
> mycompany-app@1.0.0 test /codebuild/output/src924084119/src/nodejs-app
> echo "run some tests here"
run some tests here
```
# 源版本示例 AWS CodeBuild
此示例演示如何使用提交 ID 以外的格式（也称为提交 SHA）指定源的版本。您可以通过以下方式指定源的版本：
+ 对于 Amazon S3 源提供商，请使用表示构建输入 ZIP 文件的对象的版本 ID。
+ 对于 CodeCommit Bitbucket 和 E GitHub nterprise Server，请使用以下任一选项： GitHub
+ 拉取请求作为拉取请求参考（例如，`refs/pull/1/head`）。
+ 分支作为分支名称。
+ 提交 ID。
+ 标签。
+ 引用和提交 ID。参考文献可以是以下之一：
+ 标签（例如，`refs/tags/mytagv1.0^{full-commit-SHA}`）。
+ 分支（例如，`refs/heads/mydevbranch^{full-commit-SHA}`）。
+ 拉取请求（例如，`refs/pull/1/head^{full-commit-SHA}`）。
+ 对于 GitLab 和 GitLab 自我管理，请使用以下方法之一：
+ 分支作为分支名称。
+ 提交 ID。
+ 标签。
**注意**
只有当您的存储库是 GitHub 或 E GitHub nterprise Server 时，您才能指定拉取请求源的版本。
如果使用参考和提交 ID 指定版本，则构建的 `DOWNLOAD_SOURCE` 阶段比仅提供版本时更快。这是因为添加引用时， CodeBuild 无需下载整个存储库即可找到提交。
+ 可以仅使用提交 ID 指定源版本，例如 `12345678901234567890123467890123456789`。如果执行此操作，则 CodeBuild 必须下载整个存储库才能找到版本。
+ 您可以按此格式使用参考和提交 ID 指定源版本：`refs/heads/branchname^{full-commit-SHA}`（例如 `refs/heads/main^{12345678901234567890123467890123456789}`）。如果执行此操作，则仅 CodeBuild 下载指定的分支以查找版本。
**注意**
为了加快构建`DOWNLOAD_SOURCE`阶段，您还可以将 **Git 克隆深度**设置为较低的数字。 CodeBuild 下载存储库的版本更少。
**Topics**
+ [使用提交 ID 指定 GitHub 存储库版本](sample-source-version-github.md)
+ [使用引用和提交 ID 指定 GitHub 存储库版本](sample-source-version-github-ref.md)
# 使用提交 ID 指定 GitHub 存储库版本
可以仅使用提交 ID 指定源版本，例如 `12345678901234567890123467890123456789`。如果执行此操作，则 CodeBuild 必须下载整个存储库才能找到版本。
**使用提交 ID 指定 GitHub 存储库版本**
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 创建构建项目。有关信息，请参阅[创建构建项目（控制台）](create-project.md#create-project-console)和[运行构建（控制台）](run-build-console.md)。除这些设置以外，将所有设置保留为默认值：
+ 在**源**中：
+ 对于**源提供商**，请选择**GitHub**。如果您未连接到 GitHub，请按照说明进行连接。
+ 对于**存储库**，选择**公共存储库**。
+ 对于**存储库 URL**，输入 **https://github.com/aws/aws-sdk-ruby.git**。
+ 在**环境**中：
+ 对于**环境映像**，选择**托管映像**。
+ 对于**操作系统**，选择 **Amazon Linux 2**。
+ 对于**运行时**，选择**标准**。
+ 对于**图像**，选择 **aws/codebuild/amazonlinux-x** 86\$164-standards: 4.0。
1. 对于**构建规范**，选择**插入构建命令**，然后选择**切换到编辑器**。
1. 在**构建命令**中，将占位符文本替换为以下内容：
```
version: 0.2
phases:
install:
runtime-versions:
ruby: 2.6
build:
commands:
- echo $CODEBUILD_RESOLVED_SOURCE_VERSION
```
在使用 Ubuntu 标准映像 2.0 时需要 `runtime-versions` 部分。这里指定了 Ruby 版本 2.6 运行时，但您可以使用任何运行时。`echo` 命令显示存储在 `CODEBUILD_RESOLVED_SOURCE_VERSION` 环境变量中的源代码的版本。
1. 在**构建配置**上，接受默认值，然后选择**开始构建**。
1. 对于**源版本**，请输入 **046e8b67481d53bdc86c3f6affdd5d1afae6d369**。这是 `https://github.com/aws/aws-sdk-ruby.git` 存储库中提交的 SHA。
1. 选择**开始构建**。
1. 在构建完成后，您应该看到以下内容：
+ 在**构建日志**选项卡上，使用了哪个版本的项目源。见下列。
```
[Container] Date Time Running command echo $CODEBUILD_RESOLVED_SOURCE_VERSION
046e8b67481d53bdc86c3f6affdd5d1afae6d369
[Container] Date Time Phase complete: BUILD State: SUCCEEDED
```
+ 在**环境变量**选项卡上，**解析的源版本**与用于创建构建的提交 ID 匹配。
+ 在**阶段详细信息**选项卡上，显示 `DOWNLOAD_SOURCE` 阶段的持续时间。
# 使用引用和提交 ID 指定 GitHub 存储库版本
您可以按此格式使用参考和提交 ID 指定源版本：`refs/heads/branchname^{full-commit-SHA}`（例如 `refs/heads/main^{12345678901234567890123467890123456789}`）。如果执行此操作，则仅 CodeBuild 下载指定的分支以查找版本。
**使用引用和提交 ID 指定 GitHub 存储库版本。**
1. 完成 [使用提交 ID 指定 GitHub 存储库版本](sample-source-version-github.md) 中的步骤。
1. 在左侧导航窗格中，选择**构建项目**，然后选择您之前创建的项目。
1. 选择**开始构建**。
1. 在**源版本**中，输入 **refs/heads/main^\$1046e8b67481d53bdc86c3f6affdd5d1afae6d369\$1**。这是相同的提交 ID 以及格式为 `refs/heads/branchname^{full-commit-SHA}` 的分支参考。
1. 选择**开始构建**。
1. 在构建完成后，您应该看到以下内容：
+ 在**构建日志**选项卡上，使用了哪个版本的项目源。见下列。
```
[Container] Date Time Running command echo $CODEBUILD_RESOLVED_SOURCE_VERSION
046e8b67481d53bdc86c3f6affdd5d1afae6d369
[Container] Date Time Phase complete: BUILD State: SUCCEEDED
```
+ 在**环境变量**选项卡上，**解析的源版本**与用于创建构建的提交 ID 匹配。
+ 在**阶段详细信息**选项卡上，`DOWNLOAD_SOURCE` 阶段的持续时间应短于仅使用提交 ID 指定源版本时的持续时间。
# 的第三方源代码库示例 CodeBuild
本节介绍第三方源代码库与之间的集成示例。 CodeBuild
| 样本 | 说明 |
| --- | --- |
| BitBucket 拉取请求和 webhook 过滤器示例 — 参见 [运行 “Bitbucket 拉取请求和 webhook 过滤器” 示例 CodeBuild](sample-bitbucket-pull-request.md) | 此示例向您演示如何使用 Bitbucket 存储库创建拉取请求。它还向您演示如何使用 Bitbucket Webhook 来触发 CodeBuild 创建一个项目的生成。 |
| GitHub 企业服务器示例 — 参见 [运行 GitHub 企业服务器示例 CodeBuild](sample-github-enterprise.md) | 此示例向您展示在 GitHub 企业服务器存储库安装了证书时如何设置 CodeBuild 项目。它还展示了如何启用 webhook，以便每次将代码更改推送到 GitHub 企业服务器存储库时都能 CodeBuild 重新生成源代码。 |
| GitHub 拉取请求和 webhook 过滤器示例 — 参见 [运行 GitHub 拉取请求和 webhook 过滤器示例 CodeBuild](sample-github-pull-request.md) | 此示例向您展示如何使用 GitHub企业服务器存储库创建拉取请求。它还展示了如何启用 webhook，以便每次将代码更改推送到 GitHub 企业服务器存储库时都能 CodeBuild 重新生成源代码。 |
# 运行 “Bitbucket 拉取请求和 webhook 过滤器” 示例 CodeBuild
AWS CodeBuild 当源存储库为 Bitbucket 时，支持 webhook。这意味着，对于源代码存储在 Bitbucket 存储库中的 CodeBuild 构建项目，每次将代码更改推送到存储库时，都可以使用 webhook 来重建源代码。有关更多信息，请参阅 [Bitbucket Webhook 事件](bitbucket-webhook.md)。
此示例向您演示如何使用 Bitbucket 存储库创建拉取请求。它还向你展示了如何使用 Bitbucket webhook CodeBuild 来触发创建项目的构建。
**注意**
使用 webhook 时，用户可能会触发意外构建。要降低这种风险，请参阅[使用 Webhook 的最佳实操](webhooks.md#webhook-best-practices)。
**Topics**
+ [先决条件](#sample-bitbucket-pull-request-prerequisites)
+ [步骤 1：使用 Bitbucket 创建构建项目并启用 webhook](#sample-bitbucket-pull-request-create)
+ [步骤 2：使用 Bitbucket webhook 触发构建](#sample-bitbucket-pull-request-trigger)
## 先决条件
要运行此示例，您必须将您的 AWS CodeBuild 项目与 Bitbucket 账户关联起来。
**注意**
CodeBuild 已更新其使用 Bitbucket 的权限。如果您之前将项目连接到 Bitbucket，但现在收到 Bitbucket 连接错误，则必须重新连接才能授予管理您的 webh CodeBuild ook 的权限。
## 步骤 1：使用 Bitbucket 创建构建项目并启用 webhook
以下步骤介绍如何使用 Bitbucket 作为源存储库创建 AWS CodeBuild 项目并启用 webhook。
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 如果显示 CodeBuild 信息页面，请选择 “**创建构建项目**”。否则，请在导航窗格中，展开**构建**，选择**构建项目**，然后选择**创建构建项目**。
1. 选择**创建构建项目**。
1. 在**项目配置**中：
**项目名称**
输入此构建项目的名称。每个 AWS 账户中的构建项目名称必须是唯一的。您还可以包含构建项目的可选描述，以帮助其他用户了解此项目的用途。
1. 在**源**中：
**源提供商**
选择 **Bitbucket**。按照说明连接（或重新连接）Bitbucket，然后选择**授权**。
**存储库**
选择**我的 Bitbucket 账户中的存储库**。
如果您之前未连接过 Bitbucket 账户，请输入您的 Bitbucket 用户名和应用程序密码，然后选择**保存 Bitbucket 凭证**。
**Bitbucket 存储库**
输入 Bitbucket 存储库的 URL。
1. 在**主要源 webhook 事件**中，选择以下内容。
**注意**
只有在上一步中选择了**我的 Bitbucket 账户中的存储库**，**主要源 Webhook 事件**部分才可见。
1. 创建项目时，选择**每次将代码更改推送到此存储库时都会重新构建**。
1. 从**事件类型**中，选择一个或多个事件。
1. 要在事件触发构建时进行筛选，请在**在这些条件下开始构建**下，添加一个或多个可选筛选条件。
1. 要在未触发事件时进行筛选，请在**在这些条件下不开始构建**下，添加一个或多个可选筛选条件。
1. 选择**添加筛选条件组**，以添加另一个筛选条件组（如果需要）。
有关 Bitbucket webhook 事件类型和筛选的更多信息，请参阅 [Bitbucket Webhook 事件](bitbucket-webhook.md)。
1. 在**环境**中：
**环境映像**
选择下列选项之一：
要使用由 AWS CodeBuild以下管理的 Docker 镜像，请执行以下操作：
选择**托管映像**，然后选择**操作系统**、**运行时**、**映像**和**映像版本**。从**环境类型**中进行选择（如果可用）。
要使用其他 Docker 映像：
选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您针对**外部注册表 URL** 选择**其他注册表**，请使用 `docker repository/docker image name` 格式在 Docker Hub 中输入 Docker 映像的名称和标签。如果您选择 **Amazon ECR**，请使用**亚马逊 ECR 存储库和** A **mazon ECR 镜像**在您的账户中选择 Docker 镜像。 AWS
要使用私有 Docker 映像，请执行以下操作：
选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。对于**映像注册表**，选择**其他注册表**，然后输入您的私有 Docker 映像的凭证的 ARN。凭证必须由 Secrets Manager 创建。有关更多信息，请参阅[什么是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/) 在《*AWS Secrets Manager 用户指南》*中。
**服务角色**
选择下列选项之一：
+ 如果您没有 CodeBuild 服务角色，请选择 “**新建服务角色**”。在**角色名称**中，为新角色输入名称。
+ 如果您有 CodeBuild 服务角色，请选择**现有服务角色**。在**角色 ARN** 中，选择服务角色。
使用控制台创建或更新构建项目时，可以同时创建 CodeBuild 服务角色。默认情况下，这个角色仅能与该构建项目配合使用。如果您使用控制台将此服务角色与另一个构建项目关联，则此角色将更新以便与关联的构建项目结合使用。一个服务角色最多可与 10 个构建项目结合使用。
1. 在 **Buildspec** 中，执行以下操作之一：
+ 选择**使用 buildspec 文件**，以在源代码根目录中使用 buildspec.yml 文件。
+ 选择**插入构建命令**，以使用控制台插入构建命令。
有关更多信息，请参阅[Buildspec 参考](build-spec-ref.md)。
1. 在**构件**中：
**类型**
选择下列选项之一：
+ 如果您不想创建构建输出构件，请选择**无构件**。
+ 要将构建输出存储在 S3 存储桶中，请选择 **Amazon S3**，然后执行以下操作：
+ 如果要将项目名称用于构建输出 ZIP 文件或文件夹，请将**名称**留空。否则，请输入名称。默认情况下，构件名称是项目名称。如果您要使用其他名称，请在构件名称框中输入该名称。如果您要输出 ZIP 文件，请包含 zip 扩展名。
+ 对于**存储桶名称**，请选择输出存储桶的名称。
+ 如果您在此过程的前面部分选择了**插入构建命令**，对于**输出文件**，请输入构建（该构建要放到构建输出 ZIP 文件或文件夹中）中的文件位置。对于多个位置，使用逗号将各个位置隔开（例如，`appspec.yml, target/my-app.jar`）。有关更多信息，请参阅 [buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)中 `files` 的描述。
**其他配置**
展开**其他配置**并根据需要设置选项。
1. 选择 **Create build project（创建构建项目）**。在**审核**页面上，选择**开始构建**以运行构建。
## 步骤 2：使用 Bitbucket webhook 触发构建
对于使用 Bitbucket webhook 的项目，当 Bitbucket 存储库检测到您的源代码发生变化时，会 AWS CodeBuild 创建一个构建。
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 在导航窗格上，选择**构建项目**，然后选择项目以与 Bitbucket 存储库和 Webhook 关联。有关创建 Bitbucket webhook 项目的信息，请参阅[步骤 1：使用 Bitbucket 创建构建项目并启用 webhook](#sample-bitbucket-pull-request-create)。
1. 在您项目的 Bitbucket 存储库中更改一些代码。
1. 在 Bitbucket 存储库上创建拉取请求。有关更多信息，请参阅[发出拉取请求](https://www.atlassian.com/git/tutorials/making-a-pull-request)。
1. 在 Bitbucket Webhook 页面上，选择**查看请求**，以查看最新事件的列表。
1. 选择**查看详细信息**以查看返回的响应的详细信息 CodeBuild。其内容如下所示：
```
"response":"Webhook received and build started: https://us-east-1.console.aws.amazon.com/codebuild/home..."
"statusCode":200
```
1. 导航到 Bitbucket 拉取请求页面以查看构建的状态。
# 运行 GitHub 企业服务器示例 CodeBuild
AWS CodeBuild 支持将 GitHub 企业服务器作为源存储库。此示例说明在 GitHub 企业服务器存储库安装了证书时如何设置 CodeBuild 项目。它还展示了如何启用 webhook，以便每次将代码更改推送到 GitHub 企业服务器存储库时都能 CodeBuild 重新生成源代码。
**Topics**
+ [先决条件](#sample-github-enterprise-prerequisites)
+ [步骤 1：使用 GitHub 企业服务器创建构建项目并启用 webhook](#sample-github-enterprise-running)
## 先决条件
1. 为您的 CodeBuild 项目生成个人访问令牌。我们建议您创建 GitHub 企业用户并为该用户生成个人访问令牌。将其复制到剪贴板，以便在创建 CodeBuild 项目时使用。有关更多信息，请参阅 GitHub 帮助网站上的[为命令行创建个人访问令牌](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/)。
在创建个人访问令牌时，请在定义中包含**存储库**范围。
![\[定义中的存储库范围。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/scopes.png)
1. 从 GitHub 企业服务器下载您的证书。 CodeBuild 使用该证书与存储库建立可信的 SSL 连接。
**Linux/macOS 客户端：**
从终端窗口中运行以下命令：
```
echo -n | openssl s_client -connect HOST:PORTNUMBER \
| sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > /folder/filename.pem
```
将命令中的占位符替换为以下值：
*HOST*。 您的 GitHub 企业服务器存储库的 IP 地址。
*PORTNUMBER*。 您用于连接的端口号（例如，443）。
*folder*。 您下载证书的文件夹。
*filename*。 您的证书文件的文件名。
**重要**
将证书另存为 .pem 文件。
**Windows 客户端：**
使用浏览器从 GitHub 企业服务器下载证书。要查看站点的证书详细信息，请选择挂锁图标。有关如何导出证书的信息，请参阅浏览器文档。
**重要**
将证书另存为 .pem 文件。
1. 将您的证书文件上传到 S3 存储桶。有关如何创建 S3 存储桶的信息，请参阅[如何创建 S3 存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html) 有关如何将对象上传到 S3 存储桶的信息，请参阅[如何将文件和文件夹上传至存储桶？](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html)
**注意**
此存储桶必须与您的版本位于同一 AWS 区域。例如，如果您指示 CodeBuild 在美国东部（俄亥俄州）地区运行构建，则存储桶必须位于美国东部（俄亥俄州）区域。
## 步骤 1：使用 GitHub 企业服务器创建构建项目并启用 webhook
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 如果显示 CodeBuild 信息页面，请选择 “**创建构建项目**”。否则，请在导航窗格中，展开**构建**，选择**构建项目**，然后选择**创建构建项目**。
1. 在**项目名称**中，输入此构建项目的名称。每个 AWS 账户中的构建项目名称必须是唯一的。您还可以包含构建项目的可选描述，以帮助其他用户了解此项目的用途。
1. 在**源代码**中，在**源提供程序**中，选择**GitHub 企业服务器**。
+ 选择**管理账户凭证**，然后选择**个人访问令牌**。对于**服务**，请选择 **Secrets Manager（推荐）**，然后配置您的密钥。然后在**GitHub 企业个人访问令牌**中，输入您的个人访问令牌并选择**保存**。
+ 在**存储库 URL** 中，输入您的存储库的路径，包括存储库的名称。
+ 展开**其他配置**。
+ 选择**每次将代码推送到此存储库时都会重建**以便每次将代码推送到此存储库时进行重建。
+ 选择 “**启用不安全 SSL**”，以便在连接到 GitHub 企业服务器项目存储库时忽略 SSL 警告。
**注意**
建议您仅将**启用不安全的 SSL** 用于测试。它不应在生产环境中使用。
![\[GitHub 企业服务器项目存储库配置。\]](http://docs.aws.amazon.com/zh_cn/codebuild/latest/userguide/images/github-enterprise.png)
1. 在**环境**中：
对于**环境映像**，执行下列操作之一：
+ 要使用由管理的 Docker 映像 AWS CodeBuild，请选择**托管映像**，然后从 “**操作系统**”、“**运行时**”、“映像” 和 “**映像****版本**” 中进行选择。从**环境类型**中进行选择（如果可用）。
+ 要使用其他 Docker 映像，请选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您针对**外部注册表 URL** 选择**其他注册表**，请使用 `docker repository/docker image name` 格式在 Docker Hub 中输入 Docker 映像的名称和标签。如果您选择 **Amazon ECR**，请使用**亚马逊 ECR 存储库和** A **mazon ECR 镜像**在您的账户中选择 Docker 镜像。 AWS
+ 要使用私有 Docker 映像，请选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。对于**映像注册表**，选择**其他注册表**，然后输入您的私有 Docker 映像的凭证的 ARN。凭证必须由 Secrets Manager 创建。有关更多信息，请参阅《AWS Secrets Manager 用户指南》中的[什么是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
1. 在**服务角色**中，执行下列操作之一：
+ 如果您没有 CodeBuild 服务角色，请选择 “**新建服务角色**”。在**角色名称**中，为新角色输入名称。
+ 如果您有 CodeBuild 服务角色，请选择**现有服务角色**。在**角色 ARN** 中，选择服务角色。
**注意**
使用控制台创建或更新构建项目时，可以同时创建 CodeBuild 服务角色。默认情况下，这个角色仅能与该构建项目配合使用。如果您使用控制台将此服务角色与另一个构建项目关联，则此角色将更新以便与关联的构建项目结合使用。一个服务角色最多可与 10 个构建项目结合使用。
1. 展开**其他配置**。
如果您 CodeBuild 想使用您的 VPC，请执行以下操作：
+ 对于 **VPC**，请选择 CodeBuild 使用的 VPC ID。
+ 对于 **VPC 子网**，请选择包含使用的 CodeBuild 资源的子网。
+ 对于 **VPC 安全组**，请选择 CodeBuild 用于允许访问中的资源的安全组 VPCs。
有关更多信息，请参阅 [AWS CodeBuild 与亚马逊 Virtual Private Cloud 一起使用](vpc-support.md)。
1. 在 **Buildspec** 中，执行以下操作之一：
+ 选择**使用 buildspec 文件**，以在源代码根目录中使用 buildspec.yml 文件。
+ 选择**插入构建命令**，以使用控制台插入构建命令。
有关更多信息，请参阅[Buildspec 参考](build-spec-ref.md)。
1. 在**构件**中，对于**类型**，执行以下操作之一：
+ 如果您不想创建构建输出构件，请选择**无构件**。
+ 要将构建输出存储在 S3 存储桶中，请选择 **Amazon S3**，然后执行以下操作：
+ 如果要将项目名称用于构建输出 ZIP 文件或文件夹，请将**名称**留空。否则，请输入名称。默认情况下，构件名称是项目名称。如果您要使用其他名称，请在构件名称框中输入该名称。如果您要输出 ZIP 文件，请包含 zip 扩展名。
+ 对于**存储桶名称**，请选择输出存储桶的名称。
+ 如果您在此过程的前面部分选择了**插入构建命令**，对于**输出文件**，请输入构建（该构建要放到构建输出 ZIP 文件或文件夹中）中的文件位置。对于多个位置，使用逗号将各个位置隔开（例如，`appspec.yml, target/my-app.jar`）。有关更多信息，请参阅[buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)中 `files` 的描述。
1. 对于**缓存类型**，请选择下列选项之一：
+ 如果您不想使用缓存，请选择**无缓存**。
+ 如果要使用 Amazon S3 缓存，请选择 **Amazon S3**，然后执行以下操作：
+ 对于**存储桶**，选择存储缓存的 S3 存储桶的名称。
+ （可选）对于**缓存路径前缀**，输入 Amazon S3 路径前缀。**缓存路径前缀**值类似于目录名称。它使您能够在存储桶的同一目录下存储缓存。
**重要**
请勿将尾部斜杠 (/) 附加到路径前缀后面。
+ 如果想要使用本地缓存，请选择**本地**，然后选择一个或多个本地缓存模式。
**注意**
Docker 层缓存模式仅适用于 Linux。如果您选择该模式，您的项目必须在特权模式下运行。
使用缓存可节省大量构建时间，因为构建环境的可重用部分被存储在缓存中，并且可跨构建使用。有关在 buildspec 文件中指定缓存的信息，请参阅[buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)。有关缓存的更多信息，请参阅 [缓存构建以提高性能](build-caching.md)。
1. 选择 **Create build project（创建构建项目）**。在构建项目页面上，选择**开始构建**。
# 运行 GitHub 拉取请求和 webhook 过滤器示例 CodeBuild
AWS CodeBuild 当源存储库为时，支持 webhook。 GitHub这意味着，对于源代码存储在存储 GitHub 库中的 CodeBuild 构建项目，每次将代码更改推送到存储库时，都可以使用 webhook 来重建源代码。有关 CodeBuild 示例，请参阅[AWS CodeBuild 示例](https://github.com/aws-samples/aws-codebuild-samples)。
**注意**
使用 webhook 时，用户可能会触发意外构建。要降低这种风险，请参阅[使用 Webhook 的最佳实操](webhooks.md#webhook-best-practices)。
**Topics**
+ [第 1 步：使用 GitHub 并启用 webhook 创建构建项目](#sample-github-pull-request-running)
+ [步骤 2：确认已启用 webhook](#verification-checks)
## 第 1 步：使用 GitHub 并启用 webhook 创建构建项目
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 如果显示 CodeBuild 信息页面，请选择 “**创建构建项目**”。否则，请在导航窗格中，展开**构建**，选择**构建项目**，然后选择**创建构建项目**。
1. 选择**创建构建项目**。
1. 在**项目配置**中：
**项目名称**
输入此构建项目的名称。每个 AWS 账户中的构建项目名称必须是唯一的。您还可以包含构建项目的可选描述，以帮助其他用户了解此项目的用途。
1. 在**源**中：
**源提供商**
选择 **GitHub**。按照说明进行连接（或重新连接）， GitHub 然后选择 “**授权**”。
**存储库**
**在我的 GitHub账户中选择 “存储库”**。
**GitHub repository**
输入 GitHub 存储库的 URL。
1. 在**主要源 webhook 事件**中，选择以下内容。
**注意**
只有在上一步中选择了**我的 GitHub 账户中的 “存储库**” 时，“**主要来源 webhook 事件**” 部分才可见。
1. 创建项目时，选择**每次将代码更改推送到此存储库时都会重新构建**。
1. 从**事件类型**中，选择一个或多个事件。
1. 要在事件触发构建时进行筛选，请在**在这些条件下开始构建**下，添加一个或多个可选筛选条件。
1. 要在未触发事件时进行筛选，请在**在这些条件下不开始构建**下，添加一个或多个可选筛选条件。
1. 选择**添加筛选条件组**，以添加另一个筛选条件组（如果需要）。
有关 GitHub webhook 事件类型和过滤器的更多信息，请参阅[GitHub webhook 事件](github-webhook.md)。
1. 在**环境**中：
**环境映像**
选择下列选项之一：
要使用由 AWS CodeBuild以下人员管理的 Docker 镜像，请执行以下操作：
选择**托管映像**，然后选择**操作系统**、**运行时**、**映像**和**映像版本**。从**环境类型**中进行选择（如果可用）。
要使用其他 Docker 映像：
选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您针对**外部注册表 URL** 选择**其他注册表**，请使用 `docker repository/docker image name` 格式在 Docker Hub 中输入 Docker 映像的名称和标签。如果您选择 **Amazon ECR**，请使用 **Amazon ECR 存储库**和 **Amazon ECR 映像**在您的 AWS 账户中选择 Docker 映像。
要使用私有 Docker 映像，请执行以下操作：
选择**自定义映像**。对于**环境类型**，请选择 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。对于**映像注册表**，选择**其他注册表**，然后输入您的私有 Docker 映像的凭证的 ARN。凭证必须由 Secrets Manager 创建。有关更多信息，请参阅[什么是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/) 在《*AWS Secrets Manager 用户指南》*中。
**服务角色**
选择下列选项之一：
+ 如果您没有 CodeBuild 服务角色，请选择 “**新建服务角色**”。在**角色名称**中，为新角色输入名称。
+ 如果您有 CodeBuild 服务角色，请选择**现有服务角色**。在**角色 ARN** 中，选择服务角色。
使用控制台创建或更新构建项目时，可以同时创建 CodeBuild 服务角色。默认情况下，这个角色仅能与该构建项目配合使用。如果您使用控制台将此服务角色与另一个构建项目关联，则此角色将更新以便与关联的构建项目结合使用。一个服务角色最多可与 10 个构建项目结合使用。
1. 在 **Buildspec** 中，执行以下操作之一：
+ 选择**使用 buildspec 文件**，以在源代码根目录中使用 buildspec.yml 文件。
+ 选择**插入构建命令**，以使用控制台插入构建命令。
有关更多信息，请参阅[Buildspec 参考](build-spec-ref.md)。
1. 在**构件**中：
**类型**
选择下列选项之一：
+ 如果您不想创建构建输出构件，请选择**无构件**。
+ 要将构建输出存储在 S3 存储桶中，请选择 **Amazon S3**，然后执行以下操作：
+ 如果要将项目名称用于构建输出 ZIP 文件或文件夹，请将**名称**留空。否则，请输入名称。默认情况下，构件名称是项目名称。如果您要使用其他名称，请在构件名称框中输入该名称。如果您要输出 ZIP 文件，请包含 zip 扩展名。
+ 对于**存储桶名称**，请选择输出存储桶的名称。
+ 如果您在此过程的前面部分选择了**插入构建命令**，对于**输出文件**，请输入构建（该构建要放到构建输出 ZIP 文件或文件夹中）中的文件位置。对于多个位置，使用逗号将各个位置隔开（例如，`appspec.yml, target/my-app.jar`）。有关更多信息，请参阅 [buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)中 `files` 的描述。
**其他配置**
展开**其他配置**并根据需要设置选项。
1. 选择 **Create build project（创建构建项目）**。在**审核**页面上，选择**开始构建**以运行构建。
## 步骤 2：确认已启用 webhook
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 在导航窗格中，选择**构建项目**。
1. 请执行以下操作之一：
+ 选择带有要验证的 Webhook 的构建项目的链接，然后选择**构建详细信息**。
+ 选择带有要验证的 Webhook 的构建项目旁边的按钮，选择**查看详细信息**，然后选择**构建详细信息**选项卡。
1. 在**主要源 Webhook 事件**中，选择 **Webhook** URL 链接。
1. 在存储 GitHub 库中，在 **“设置”** 页面的 “**Webhooks**” 下，确认已选中 “**拉取请求**和**推送**”。
1. **在您的个人 GitHub 资料设置中，在 **“个人设置”、“ OAuth****应用程序”、“授权应用程序**” 下，您应该看到您的应用程序已被授权访问您选择的 AWS 区域。**
# 教程：Apple 在 CodeBuild 使用 S3 进行证书存储时使用 Fastlane 进行代码签名
[fastlane](https://docs.fastlane.tools/) 是一款流行的开源自动化工具，可自动部署和发布 iOS 和 Android 应用程序的测试版。它可以处理所有繁琐的任务，例如生成屏幕截图、处理代码签名和发布应用程序等。
## 先决条件
要完成本教程，您首先必须设置以下条件：
+ 一个 AWS 账户
+ [Apple 开发人员账户](https://developer.apple.com/)
+ 用于存储证书的 S3 存储桶
+ 在您的项目中安装的 fastlane - fastlane 安装[指南](https://docs.fastlane.tools/getting-started/ios/setup/)
## 步骤 1：在本地计算机上使用 S3 设置 Fastlane Match
[Fastlane Match](https://docs.fastlane.tools/actions/match/) 是 [Fastlane 工具](https://fastlane.tools/)之一，它允许在本地开发环境和本地开发环境中无缝配置代码签名。 CodeBuildFastlane Match 将您的所有代码签名证书和配置文件存储在 Git repository/S3 Bucket/Google 云存储中，并在需要时下载和安装必要的证书和配置文件。
在此示例配置中，您将设置并使用 Amazon S3 存储桶进行存储。
****
1. 在项目中初始化匹配：
```
fastlane match init
```
1. 出现提示时，选择 S3 作为存储模式。
1. 更新“*Matchfile*”以使用 S3：
```
storage_mode("s3")
s3_bucket("your-s3-bucket-name")
s3_region("your-aws-region")
type("appstore") # The default type, can be: appstore, adhoc, enterprise or development
```
## 步骤 2：设置 Fastfile
使用以下通道创建或更新您的“Fastfile”。
开启 CodeBuild，每次构建和签署应用程序时，都需要运行 Fastlane Match。执行此操作的最简单方法是将 `match` 操作添加到构建应用程序的通道中。
```
default_platform(:ios)
platform :ios do
before_all do
setup_ci
end
desc "Build and sign the app"
lane :build do
match(type: "appstore", readonly: true)
gym(
scheme: "YourScheme",
export_method: "app-store"
)
end
end
```
**注意**
请务必将 `setup_ci` 添加至 `Fastfile` 中的 `before_all ` 部分，以使匹配操作正常运行。这样可以确保使用具有适当权限的临时 Fastlane 密钥链。如果不使用它，您可能会看到构建失败或结果不一致。
## 步骤 3：运行 `fastlane match` 命令以生成相应的证书和配置文件
给定类型（即开发、应用商店、临时、企业）的 fastlane match 命令将生成证书和配置文件（如果远程存储中未提供）。fastlane 将证书和配置文件存储在 S3 中。
```
bundle exec fastlane match appstore
```
命令执行将是交互式的，fastlane 将要求设置密码短语来解密证书。
## 步骤 4：为项目创建应用程序文件
根据项目的需要创建或添加应用程序文件。
****
1. 根据项目构建要求创建或添加 [Gymfile](http://docs.fastlane.tools/actions/gym/#gymfile)、[Appfile](http://docs.fastlane.tools/advanced/Appfile/)、[Snapfile](http://docs.fastlane.tools/actions/snapshot/#snapfile)、[Deliverfile](http://docs.fastlane.tools/actions/deliver/#editing-the-deliverfile)。
1. 将更改提交到远程存储库
## 步骤 5：在 Secrets Manager 中创建环境变量
创建两个用于存储 fastlane 会话 cookie 和匹配密码短语的密钥。有关在 Secrets Manager 中创建密钥的更多信息，请参阅[创建 AWS Secrets Manager 密钥](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)。
****
1. 按如下方式访问 fastlane 会话 cookie。
1. 秘密密钥：`FASTLANE_SESSION`
1. 密钥值：在本地计算机上运行以下命令时生成的会话 cookie。
**注意**
完成身份验证后，此值会保存在本地文件 `~/.fastlane/spaceship/my_appleid_username/cookie` 中。
```
fastlane spaceauth -u
```
1. Fastlane Match 密码短语-要使 Fastlane Match 能够解密存储在 S3 存储桶中的证书和配置文件，必须将您在匹配设置步骤中配置的加密密码添加到项目的环境变量中。 CodeBuild
1. 秘密密钥：`MATCH_PASSWORD`
1. 密钥值：**。密码短语是在步骤 3 中生成证书时设置的。
**注意**
在 Secrets Manager 中创建上述密钥时，请记得提供一个带有以下前缀的密钥名称：`/CodeBuild/`
## 步骤 6：创建计算实例集
为您的项目创建计算实例集。
****
1. 在控制台中，前往 CodeBuild 并创建新的计算队列。
1. 选择“macOS”作为操作系统，然后选择适当的计算类型和映像。
## 第 7 步：在中创建项目 CodeBuild
在中创建您的项目 CodeBuild。
****
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 创建构建项目。有关信息，请参阅[创建构建项目（控制台）](create-project.md#create-project-console)和[运行构建（控制台）](run-build-console.md)。
1. 设置您的源提供商（例如 GitHub， CodeCommit）。这是 iOS 项目源存储库，而不是证书存储库。
1. 在**环境**中：
+ 选择**预留容量**。
+ 对于**实例集**，选择上面创建的实例集。
+ 提供 CodeBuild 将为您创建的服务角色的名称。
+ 提供以下环境变量。
+ 名称:`MATCH_PASSWORD`，值：**，类型：Secrets Manager（在步骤 5 中为 MATCH\$1PASSWORD 创建的 Secrets ARN）
+ 名称:`FASTLANE_SESSION`，值：**，类型：Secrets Manager（在步骤 5 中为 FASTLANE\$1SESSION 创建的 Secrets ARN）
1. 在 **Buildspec** 中，添加以下内容：
```
version: 0.2
phases:
install:
commands:
- gem install bundler
- bundle install
build:
commands:
- echo "Building and signing the app..."
- bundle exec fastlane build
post_build:
commands:
- echo "Build completed on date"
artifacts:
files:
- '*/.ipa'
name: app-$(date +%Y-%m-%d)
```
## 步骤 8：配置 IAM 角色
创建项目后，请确保 CodeBuild 项目的服务角色有权访问包含证书的 S3 存储桶。将下面的策略附加到该角色：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket"
],
"Resource": "arn:aws:s3:::your-s3-bucket-name"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": "arn:aws:s3:::your-s3-bucket-name/*"
}
]
}
```
------
## 第 9 步：运行构建
运行构建。您可以查看构建状态并登录 CodeBuild。
作业完成后，您将能够查看该作业的日志。
## 问题排查
+ 如果您在获取证书时遇到问题，请确保您的 IAM 权限设置正确，以便能够访问 S3。
+ 如果您在证书解密时遇到问题，请确保在 MATCH\$1PASSWORD 环境变量中设置了正确的密码短语。
+ 对于代码签名问题，请验证您的 Apple 开发人员账户是否具有必要的证书和配置文件，并且 Xcode 项目中的捆绑包标识符是否与预调配配置文件中的捆绑包标识符匹配。
## 安全注意事项
以下是本教程的安全注意事项。
+ 确保您的 S3 存储桶具有适当的安全设置，包括静态加密。特别是，请确保存储桶没有公共访问权限， CodeBuild 并限制仅访问需要访问权限的系统。
+ 考虑使用来存储敏感信息 AWS Secrets Manager ，例如 MATCH\$1PASSWORD 和 FASTLANE\$1SESSION。
此示例提供了 CodeBuild 使用 Amazon S3 进行证书存储时使用 Fastlane 进行 iOS 代码签名的设置。您可能需要根据具体的项目要求和 CodeBuild 环境调整一些步骤。这种方法利用 AWS 服务来增强 AWS 生态系统中的安全性和集成。
# 教程：Apple CodeBuild 使用 Fastlane 进行代码签名 GitHub 用于证书存储
[fastlane](https://docs.fastlane.tools/) 是一款流行的开源自动化工具，可自动部署和发布 iOS 和 Android 应用程序的测试版。它可以处理所有繁琐的任务，例如生成屏幕截图、处理代码签名和发布应用程序等。
此示例演示了如何在 Mac 舰队上运行的 CodeBuild项目中使用 Fastlane 设置 Apple 代码签名，并将其 GitHub 作为证书和配置文件的存储空间。
## 先决条件
要完成本教程，您首先必须设置以下条件：
+ 一个 AWS 账户
+ [Apple 开发人员账户](https://developer.apple.com/)
+ 用于 GitHub 存储证书的私有存储库
+ 在您的项目中安装的 fastlane - fastlane 安装[指南](https://docs.fastlane.tools/getting-started/ios/setup/)
## 第 1 步：在本地计算机上设置 Fastlane GitHub Match
[Fastlane Match](https://docs.fastlane.tools/actions/match/) 是 [Fastlane 工具](https://fastlane.tools/)之一，它允许在本地开发环境和本地开发环境中无缝配置代码签名。 CodeBuildFastlane Match 将您的所有代码签名证书和配置文件存储在 Git repository/S3 Bucket/Google 云存储中，并在需要时下载和安装必要的证书和配置文件。
在此示例配置中，我们设置并使用 Git 存储库进行存储。
****
1. 在项目中初始化匹配：
```
fastlane match init
```
1. 出现提示时，选择 GitHub 作为存储模式。
1. 更新你的 “*匹配文件*” 以使用 GitHub：
```
git_url("https://github.com/your-username/your-certificate-repo.git")
storage_mode("git")
type("development") # The default type, can be: appstore, adhoc, enterprise or development
```
**注意**
请务必输入 Git 存储库的 HTTPS URL，以便 fastlane 成功进行身份验证和克隆。否则，当您尝试使用匹配时，可能会看到身份验证错误。
## 步骤 2：设置 Fastfile
使用以下通道创建或更新您的“Fastfile”。
开启 CodeBuild，每次构建和签署应用程序时，都需要运行 Fastlane Match。执行此操作的最简单方法是将 `match` 操作添加到构建应用程序的通道中。
```
default_platform(:ios)
platform :ios do
before_all do
setup_ci
end
desc "Build and sign the app"
lane :build do
match(type: "appstore", readonly: true)
gym(
scheme: "YourScheme",
export_method: "app-store"
)
end
end
```
**注意**
请务必将 `setup_ci` 添加至 `Fastfile` 中的 `before_all ` 部分，以使匹配操作正常运行。这样可以确保使用具有适当权限的临时 Fastlane 密钥链。如果不使用它，您可能会看到构建失败或结果不一致。
## 步骤 3：运行 `fastlane match` 命令以生成相应的证书和配置文件
给定类型（即开发、应用商店、临时、企业）的 fastlane match 命令将生成证书和配置文件（如果远程存储中未提供）。证书和配置文件将 GitHub 由 fastlane 存储在中。
```
bundle exec fastlane match appstore
```
命令执行将是交互式的，fastlane 将要求设置密码短语来解密证书。
## 步骤 4：为项目创建应用程序文件
根据项目的需要创建或添加应用程序文件。
****
1. 根据项目构建要求创建或添加 [Gymfile](http://docs.fastlane.tools/actions/gym/#gymfile)、[Appfile](http://docs.fastlane.tools/advanced/Appfile/)、[Snapfile](http://docs.fastlane.tools/actions/snapshot/#snapfile)、[Deliverfile](http://docs.fastlane.tools/actions/deliver/#editing-the-deliverfile)。
1. 将更改提交到远程存储库。
## 步骤 5：在 Secrets Manager 中创建环境变量
创建三个用于存储 fastlane 会话 cookie 和匹配密码短语的密钥。有关在 Secrets Manager 中创建密钥的更多信息，请参阅[创建 AWS Secrets Manager 密钥](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)。
****
1. 按如下方式访问 fastlane 会话 cookie。
1. 秘密密钥：`FASTLANE_SESSION`
1. 密钥值：在本地计算机上运行以下命令时生成的会话 cookie。
**注意**
完成身份验证后，此值会保存在本地文件 `~/.fastlane/spaceship/my_appleid_username/cookie` 中。
```
fastlane spaceauth -u
```
1. Fastlane Match 密码短语-要启用 Fastlane Match 来解密存储在 Git 存储库中的证书和配置文件，必须将您在匹配设置步骤中配置的加密密码添加到项目的环境变量中。 CodeBuild
1. 秘密密钥：`MATCH_PASSWORD`
1. 密钥值：``。密码短语是在步骤 3 中生成证书时设置的。
1. Fastlane `MATCH_GIT_BASIC_AUTHORIZATION`：为*匹配*设置基本授权：
1. 秘密密钥：
`MATCH_GIT_BASIC_AUTHORIZATION`
1. 密钥值：该值应是您的用户名和个人访问令牌（PAT）的 base64 编码字符串，格式为 `username:password`。您可以使用以下命令生成它：
```
echo -n your_github_username:your_personal_access_token | base64
```
你可以在 GitHub 主机的 “我的个人资料” > “设置” > “**开发者设置” > “个人访问令牌” 中生成 P** AT。有关更多信息，请参阅以下指南：[https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens)。
**注意**
在 Secrets Manager 中创建上述密钥时，请记得提供一个带有以下前缀的密钥名称：`/CodeBuild/`
## 步骤 6：创建计算实例集
为您的项目创建计算实例集。
****
1. 在控制台中，前往 CodeBuild 并创建新的计算队列。
1. 选择 `macOS` 作为操作系统，然后选择适当的计算类型和映像。
## 第 7 步：在中创建项目 CodeBuild
在中创建您的项目 CodeBuild。
****
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 创建构建项目。有关信息，请参阅[创建构建项目（控制台）](create-project.md#create-project-console)和[运行构建（控制台）](run-build-console.md)。
1. 设置您的源提供商（例如 GitHub， CodeCommit）。这是 iOS 项目源存储库，而不是证书存储库。
1. 在**环境**中：
+ 选择**预留容量**。
+ 对于**实例集**，选择上面创建的实例集。
+ 提供 CodeBuild 将为您创建的服务角色的名称。
+ 提供以下环境变量。
+ 名称:`MATCH_PASSWORD`，值：**，类型：Secrets Manager（在步骤 5 中为 MATCH\$1PASSWORD 创建的 Secrets ARN）
+ 名称:`FASTLANE_SESSION`，值：**，类型：Secrets Manager（在步骤 5 中为 FASTLANE\$1SESSION 创建的 Secrets ARN）
+ 名称:`MATCH_GIT_BASIC_AUTHORIZATION`，值：**，类型：Secrets Manager Secrets ARN（在步骤 5 中为创建的）`MATCH_GIT_BASIC_AUTHORIZATION`
1. 在 **Buildspec** 中，添加以下内容：
```
version: 0.2
phases:
install:
commands:
- gem install bundler
- bundle install
build:
commands:
- echo "Building and signing the app..."
- bundle exec fastlane build
post_build:
commands:
- echo "Build completed on date"
artifacts:
files:
- '*/.ipa'
name: app-$(date +%Y-%m-%d)
```
## 第 8 步：运行构建
运行构建。您可以查看构建状态并登录 CodeBuild。
作业完成后，您将能够查看该作业的日志。
## 问题排查
+ 如果您在访问 GitHub 存储库时遇到问题，请仔细检查您的个人访问令牌和 MATCH\$1GIT\$1BASIC\$1AUTHORIZATION 环境变量。
+ 如果您在证书解密时遇到问题，请确保在 MATCH\$1PASSWORD 环境变量中设置了正确的密码短语。
+ 对于代码签名问题，请验证您的 Apple 开发人员账户是否具有必要的证书和配置文件，并且 Xcode 项目中的捆绑包标识符是否与预调配配置文件中的捆绑包标识符匹配。
## 安全注意事项
以下是本教程的安全注意事项。
+ 将您的证书 GitHub 存储库保密，并定期审核访问权限。
+ 考虑使用来存储敏感信息 AWS Secrets Manager ，例如 MATCH\$1PASSWORD 和 FASTLANE\$1SESSION。
此示例提供了 CodeBuild 使用 Fastlane 进行 iOS 代码签名的设置， GitHub用于证书存储。您可能需要根据具体的项目要求和 CodeBuild 环境调整一些步骤。这种方法利用 AWS 服务来增强 AWS 生态系统中的安全性和集成。
# 使用语义版本控制在构建时设置构件名称
此示例包含示例 buildspec 文件，演示如何指定在构建时创建的构件名称。在 buildspec 文件中指定的名称可以包含 Shell 命令和环境变量，以使其保持唯一。在 buildspec 文件中指定的名称将覆盖创建项目时在控制台中输入的名称。
如果构建多次，则使用在 buildspec 文件中指定的构件名称可以确保输出构件文件名的唯一性。例如，您可以使用在构建时插入构件名称的日期和时间戳。
要使用 buildspec 文件中的构件名称覆盖在控制台中输入的构件名称，请执行以下操作：
1. 设置构建项目以使用 buildspec 文件中的构件名称覆盖相应的构件名称。
+ 如果您使用控制台创建您的构建项目，请选择**启用语义版本控制**。有关更多信息，请参阅 [创建构建项目（控制台）](create-project.md#create-project-console)。
+ 如果使用了 AWS CLI，请在传递给 `overrideArtifactName` 的 JSON 格式文件中将 `create-project` 设置为 true。有关更多信息，请参阅 [创建构建项目 (AWS CLI)](create-project.md#create-project-cli)。
+ 如果使用 AWS CodeBuild API，请在创建或更新项目或开始构建时在 `ProjectArtifacts` 对象上设置 `overrideArtifactName` 标记。
1. 在 buildspec 文件中指定名称。使用以下示例 buildspec 文件作为指南。
此 Linux 示例演示如何指定包含构建创建日期的构件名称：
```
version: 0.2
phases:
build:
commands:
- rspec HelloWorld_spec.rb
artifacts:
files:
- '**/*'
name: myname-$(date +%Y-%m-%d)
```
此 Linux 示例演示如何指定使用 CodeBuild 环境变量的构件名称。有关更多信息，请参阅 [构建环境中的环境变量](build-env-ref-env-vars.md)。
```
version: 0.2
phases:
build:
commands:
- rspec HelloWorld_spec.rb
artifacts:
files:
- '**/*'
name: myname-$AWS_REGION
```
此 Windows 示例演示如何指定包含构建创建日期和时间的构件名称：
```
version: 0.2
env:
variables:
TEST_ENV_VARIABLE: myArtifactName
phases:
build:
commands:
- cd samples/helloworld
- dotnet restore
- dotnet run
artifacts:
files:
- '**/*'
name: $Env:TEST_ENV_VARIABLE-$(Get-Date -UFormat "%Y%m%d-%H%M%S")
```
此 Windows 示例演示如何指定使用在 buildspec 文件中声明的变量和 CodeBuild 环境变量的构件名称。有关更多信息，请参阅 [构建环境中的环境变量](build-env-ref-env-vars.md)。
```
version: 0.2
env:
variables:
TEST_ENV_VARIABLE: myArtifactName
phases:
build:
commands:
- cd samples/helloworld
- dotnet restore
- dotnet run
artifacts:
files:
- '**/*'
name: $Env:TEST_ENV_VARIABLE-$Env:AWS_REGION
```
有关更多信息，请参阅 [的构建规范参考 CodeBuild](build-spec-ref.md)。