本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 入门 CodeBuild
在以下教程中，您将使用 AWS CodeBuild 将示例源代码输入文件的集合构建到源代码的可部署版本中。
两个教程都有相同的输入和结果，但其中一个使用 AWS CodeBuild 控制台，另一个使用控制台 AWS CLI。
**重要**
我们不建议您使用 AWS root 账户完成本教程。
**Topics**
+ [
## 控制台 AWS CodeBuild 使用入门
](#getting-started)
+ [
## 开始 AWS CodeBuild 使用 AWS CLI
](#getting-started-cli)
## 控制台 AWS CodeBuild 使用入门
在本教程中，您将使用 AWS CodeBuild 将一组示例源代码输入文件（*构建输入工件*或*构建输入*）构建为源代码的可部署版本（*构建输出工件*或*构建输出*）。具体而言，您将指示 CodeBuild 使用常见的构建工具 Apache Maven 将一组 Java 类文件生成到 Java 存档 (JAR) 文件中。您无需熟悉 Apache Maven 或 Java 即可完成本教程。
您可以 CodeBuild 通过 CodeBuild 控制台 AWS CodePipeline、 AWS CLI、或 AWS SDKs。本教程演示如何使用 CodeBuild 控制台。有关使用 CodePipeline 的信息，请参阅 [ CodeBuild 搭配使用 CodePipeline](how-to-create-pipeline.md)。
**重要**
本教程中的步骤要求您创建可能会对您的 AWS 账户产生费用的资源（例如 S3 存储桶）。其中包括与 Amazon S3 和 CloudWatch 日志相关的 AWS 资源和操作可能产生的费用。 CodeBuild AWS KMS有关更多信息，请参阅[AWS 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**
+ [
### 步骤 1：创建源代码
](#getting-started-create-source-code-console)
+ [
### 步骤 2：创建 buildspec 文件
](#getting-started-create-build-spec-console)
+ [
### 步骤 3：创建两个 S3 存储桶
](#getting-started-input-bucket-console)
+ [
### 步骤 4：上传源代码和 buildspec 文件
](#getting-started-upload-source-code-console)
+ [
### 步骤 5：创建构建项目
](#getting-started-create-build-project-console)
+ [
### 步骤 6：运行构建
](#getting-started-run-build-console)
+ [
### 步骤 7：查看汇总的构建信息
](#getting-started-monitor-build-console)
+ [
### 步骤 8：查看详细的构建信息
](#getting-started-build-log-console)
+ [
### 步骤 9：获取构建输出构件
](#getting-started-output-console)
+ [
### 步骤 10：删除 S3 存储桶
](#getting-started-clean-up-console)
+ [
### 总结
](#getting-started-next-steps-console)
### 步骤 1：创建源代码
（一部分：[控制台 AWS CodeBuild 使用入门](#getting-started)）
在此步骤中，您将创建要生成 CodeBuild 到输出存储桶的源代码。此源代码包含两个 Java 类文件和一个 Apache Maven 项目对象模型 (POM) 文件。
1. 在您的本地计算机或实例上的空目录中，创建此目录结构。
```
(root directory name)
`-- src
|-- main
| `-- java
`-- test
`-- java
```
1. 使用您选择的文本编辑器创建此文件，将其命名为 `MessageUtil.java`，然后保存在 `src/main/java` 目录中。
```
public class MessageUtil {
private String message;
public MessageUtil(String message) {
this.message = message;
}
public String printMessage() {
System.out.println(message);
return message;
}
public String salutationMessage() {
message = "Hi!" + message;
System.out.println(message);
return message;
}
}
```
创建此类文件是用来输出传入的字符串。`MessageUtil` 构造函数用于设置字符串。`printMessage` 方法用于创建输出。`salutationMessage` 方法用于输出 `Hi!` 后跟字符串。
1. 创建此文件，将其命名为 `TestMessageUtil.java`，然后将它保存在 `/src/test/java` 目录中。
```
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestMessageUtil {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
assertEquals(message,messageUtil.printMessage());
}
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
```
此类文件用于将 `MessageUtil` 类中的 `message` 变量设置为 `Robert`。然后，通过检查输出中是否出现字符串 `Robert` 和 `Hi!Robert` 来测试是否成功设置 `message` 变量。
1. 创建此文件，将其命名为 `pom.xml`，然后保存在根（顶级）目录中。
```
4.0.0
org.example
messageUtil
1.0
jar
Message Utility Java Sample App
junit
junit
4.11
test
org.apache.maven.plugins
maven-compiler-plugin
3.8.0
```
Apache Maven 使用此文件中的指令将 `MessageUtil.java` 和 `TestMessageUtil.java` 文件转换为名为 `messageUtil-1.0.jar` 的文件，然后运行指定测试。
此时，您的目录结构应如下所示。
```
(root directory name)
|-- pom.xml
`-- src
|-- main
| `-- java
| `-- MessageUtil.java
`-- test
`-- java
`-- TestMessageUtil.java
```
### 步骤 2：创建 buildspec 文件
（上一步：[步骤 1：创建源代码](#getting-started-create-source-code-console)）
在此步骤中，您将创建一个构建规范 (build spec) 文件。*buildspec* 是一组生成命令和相关设置，采 CodeBuild 用 YAML 格式，用于运行构建。如果没有构建规范， CodeBuild 则无法成功地将您的构建输入转换为构建输出，也无法在构建环境中找到要上传到输出存储桶的构建输出项目。
创建此文件，将其命名为 `buildspec.yml`，然后保存在根（顶级）目录中。
```
version: 0.2
phases:
install:
runtime-versions:
java: corretto11
pre_build:
commands:
- echo Nothing to do in the pre_build phase...
build:
commands:
- echo Build started on `date`
- mvn install
post_build:
commands:
- echo Build completed on `date`
artifacts:
files:
- target/messageUtil-1.0.jar
```
**重要**
因为 buildspec 声明必须为有效的 YAML，所以 buildspec 声明中的空格至关重要。如果 buildspec 声明中的空格数与此不匹配，则构建可能会立即失败。您可以使用 YAML 验证程序测试 buildspec 声明是否为有效的 YAML。
**注意**
您可以在创建构建项目时单独声明构建命令，而不是将 buildspec 文件包含在源代码中。如果您需要使用其他构建命令来构建源代码，而不是每次更新源代码存储库，这个方法很有用。有关更多信息，请参阅 [buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)。
在此 buildspec 声明中：
+ `version` 表示正在使用的 buildspec 标准的版本。此 buildspec 声明使用最新版本 `0.2`。
+ `phases` 表示您可以指示 CodeBuild 运行命令的生成阶段。这些构建阶段包括 `install`、`pre_build`、`build` 和 `post_build`。您无法更改这些构建阶段名称的拼写，也无法创建更多构建阶段名称。
在本示例中，在该`build`阶段 CodeBuild 运行`mvn install`命令。此命令指示 Apache Maven 编译和测试 Java 类文件，然后将编译完的文件打包为构建输出构件。出于完整性考虑，本示例的每个构建阶段中都放了几条 `echo` 命令。您稍后查看本教程中详细的构建信息时，这些 `echo` 命令的输出可以帮助您更好地理解 CodeBuild 运行命令的方式以及顺序。（尽管本示例中包含了所有构建阶段，但如果您不打算在某个构建阶段运行任何命令，则无需包含该构建阶段。） 对于每个构建阶段，按所列顺序从头到尾 CodeBuild 运行每个指定的命令，一次运行一个命令。
+ `artifacts`表示 CodeBuild上传到输出存储桶的一组构建输出项目。 `files`表示要包含在生成输出中的文件。 CodeBuild 上传在构建环境的`target`相对目录中找到的单个`messageUtil-1.0.jar`文件。文件 `messageUtil-1.0.jar` 和目录 `target` 只是根据本示例中 Apache Maven 创建和存储构建输出构件的方式来命名的。在您自己的构建项目中，这些文件和目录名称会有所不同。
有关更多信息，请参阅[Buildspec 参考](build-spec-ref.md)。
此时，您的目录结构应如下所示。
```
(root directory name)
|-- pom.xml
|-- buildspec.yml
`-- src
|-- main
| `-- java
| `-- MessageUtil.java
`-- test
`-- java
`-- TestMessageUtil.java
```
### 步骤 3：创建两个 S3 存储桶
（上一步：[步骤 2：创建 buildspec 文件](#getting-started-create-build-spec-console)）
尽管您可以为本教程使用单个存储桶，但使用两个存储桶使您可以更容易地查看构建输入的来源以及构建输出的去向。
+ 其中一个存储桶（*输入存储桶*）用于存储构建输入。在本教程中，此输入存储桶的名称是`codebuild-region-ID-account-ID-input-bucket`，其中*region-ID*是存储桶的 AWS 区域，*account-ID*是您的 AWS 账户 ID。
+ 另一个存储桶（*输出存储桶*）用于存储构建输出。在本教程中，此输出存储桶的名称为 `codebuild-region-ID-account-ID-output-bucket`。
如果您为这些存储桶选择了不同的名称，请务必在本教程中使用它们。
这两个存储桶必须与您的版本位于同一个 AWS 区域。例如，如果您指示 CodeBuild 在美国东部（俄亥俄州）区域运行构建，则这些存储桶也必须位于美国东部（俄亥俄州）区域。
有关更多信息，请参阅《Amazon Simple Storage Service 用户指南》中的[创建存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。
**注意**
尽管 CodeBuild 还支持存储在 CodeCommit GitHub、和 Bitbucket 存储库中的构建输入，但本教程并未向您展示如何使用它们。有关更多信息，请参阅 [计划构建](planning.md)。
### 步骤 4：上传源代码和 buildspec 文件
（上一步：[步骤 3：创建两个 S3 存储桶](#getting-started-input-bucket-console)）
在此步骤中，您将源代码和 buildspec 文件添加到输入存储桶中。
使用操作系统的 ZIP 实用工具，创建一个名为 `MessageUtil.zip` 的文件，其中包含 `MessageUtil.java`、`TestMessageUtil.java`、`pom.xml` 和 `buildspec.yml`。
`MessageUtil.zip` 文件的目录结构必须如下所示。
```
MessageUtil.zip
|-- pom.xml
|-- buildspec.yml
`-- src
|-- main
| `-- java
| `-- MessageUtil.java
`-- test
`-- java
`-- TestMessageUtil.java
```
**重要**
请不要包含 `(root directory name)` 目录，而只包含 `(root directory name)` 目录中的目录和文件。
将 `MessageUtil.zip` 文件上传至名为 `codebuild-region-ID-account-ID-input-bucket` 的输入存储桶中。
**重要**
对于 CodeCommit GitHub、和 Bitbucket 存储库，按照惯例，您必须在每个存储库的根目录（顶层）`buildspec.yml`中存储一个名为的构建规范文件，或者将构建规范声明作为构建项目定义的一部分。请勿创建包含存储库源代码和 buildspec 文件的 ZIP 文件。
仅对于存储在 S3 存储桶中的构建输入，您必须创建一个包含源代码的 ZIP 文件和一个（按照惯例）位于根（顶级）位置的名为 `buildspec.yml` 的 buildspec 文件，或者将 buildspec 声明作为构建项目定义的一部分包含。
如果您要为 buildspec 文件使用其他名称，或者要在根位置之外的位置引用 buildspec，则可指定 buildspec 覆盖作为构建项目定义的一部分。有关更多信息，请参阅 [buildspec 文件名称和存储位置](build-spec-ref.md#build-spec-ref-name-storage)。
### 步骤 5：创建构建项目
（上一步：[步骤 4：上传源代码和 buildspec 文件](#getting-started-upload-source-code-console)）
在此步骤中，您将创建一个 AWS CodeBuild 用于运行构建的生成项目。*构建项目*包含有关如何运行构建的信息，包括从何处获取源代码、要使用的构建环境、要运行的构建命令以及将构建输出存储在何处。*构建环境*代表操作系统、编程语言运行时和用于运行构建的 CodeBuild 工具的组合。构建环境以 Docker 映像的形式表示。有关更多信息，请参阅 Docker 文档网站上的 [Docker 概述](https://docs.docker.com/get-started/overview/)。
对于这个构建环境，你需要使用包含 Java 开发套件 (JDK) 和 Apache Maven 版本的 Docker 镜像。 CodeBuild
**创建构建项目**
1. 登录 AWS 管理控制台 并在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /hom AWS CodeBuild e 中打开控制台。
1. 使用 AWS 区域选择器选择支持 CodeBuild 的地 AWS 区。有关更多信息，请参阅 *Amazon Web Services 一般参考* 中的 [AWS CodeBuild 端点和配额](https://docs.aws.amazon.com/general/latest/gr/rande.html#codebuild_region)。
1. 如果显示 CodeBuild 信息页面，请选择 “**创建构建项目**”。否则，请在导航窗格中，展开**构建**，选择**构建项目**，然后选择**创建构建项目**。
1. 在**创建构建项目**页面上的**项目配置**中，对于**项目名称**，输入此构建项目的名称（在此示例中为 `codebuild-demo-project`）。每个 AWS 账户中的构建项目名称必须是唯一的。如果您使用其他名称，请确保在本教程中通篇使用它。
**注意**
在**创建构建项目**页面上，您可能会看到类似于以下内容的错误消息：**您没有权限执行此操作**。这很可能是因为您以 AWS 管理控制台 无权创建构建项目的用户身份登录。要解决此问题，请退出 AWS 管理控制台，然后使用属于以下 IAM 实体之一的证书重新登录：
您 AWS 账户中的管理员用户。有关更多信息，请参阅用户*指南中的创建您的第一个 AWS 账户 root 用户*[和群组](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html)。
您 AWS 账户中的用户 `AWSCodeBuildAdminAccess``AmazonS3ReadOnlyAccess`，且该用户或该用户所属的 IAM 群组附加了、和`IAMFullAccess`托管策略。如果您的 AWS 账户中没有具有这些权限的用户或群组，并且您无法将这些权限添加到您的用户或群组，请联系您的 AWS 账户管理员寻求帮助。有关更多信息，请参阅 [AWS 的托管（预定义）策略 AWS CodeBuild](auth-and-access-control-iam-identity-based-access-control.md#managed-policies)。
这两个选项都可让您获得创建构建项目所需的管理员权限，以便您能够完成本教程。建议您始终使用完成任务所需的最低权限。有关更多信息，请参阅 [AWS CodeBuild 权限参考](auth-and-access-control-permissions-reference.md)。
1. 在**源**中，对于**源提供商**，选择 **Amazon S3**。
1. 对于 **Bucket**，选择 **codebuild-*region-ID*-*account-ID*-input-** buck
1. 对于 **S3 对象键**，输入 **MessageUtil.zip**。
1. 在**环境**中，对于**环境映像**，让**托管映像**处于选中状态。
1. 对于**操作系统**，选择 **Amazon Linux**。
1. 对于**运行时**，选择**标准**。
1. 对于**图片**，选择 **aws/codebuild/amazonlinux-x** 86\$164-standard: corretto11。
1. 在**服务角色**中，将**新建服务角色**保持选中状态，并将**角色名称**保持不变。
1. 对于 **buildspec**，将**使用 buildspec 文件**保留为选中状态。
1. 在**构件**中，对于**类型**，选择 **Amazon S3**。
1. 对于**存储桶名称**，选择 **codebuild-*region-ID*-*account-ID*-output-** bucket。
1. 将**名称**和**路径**留空。
1. 选择**创建构建项目**。
### 步骤 6：运行构建
（上一步：[步骤 5：创建构建项目](#getting-started-create-build-project-console)）
在此步骤中，您将指示 AWS CodeBuild 使用构建项目中的设置运行构建。
**运行构建**
1. 在 [https://console.aws.amazon.com/codesuite/codebuild](https://console.aws.amazon.com/codesuite/codebuild/home) /home 中打开 AWS CodeBuild 控制台。
1. 在导航窗格中，选择**构建项目**。
1. 在生成项目列表中，选择 **codebuild-demo-project**，然后选择**开始构建**。构建会立即开始。
### 步骤 7：查看汇总的构建信息
（上一步：[步骤 6：运行构建](#getting-started-run-build-console)）
在此步骤中，您将查看有关构建状态的汇总信息。
#### 查看汇总的构建信息
1. 如果未显示**codebuild-demo-project:****页面，请在导航栏中选择 “**生成历史记录**”。接下来，在生成项目列表中，对于 P **ro** ject，选择 B **uild 运行**链接**codebuild-demo-project**。应该只有一个匹配的链接。（如果您之前已完成本教程，请在**已完成**列中选择具有最新值的链接。）
1. 在**构建状态**页面上，在**阶段详细信息**中，应显示以下构建阶段，并且**状态**列中为**已成功**：
+ **SUBMITTED**
+ **QUEUED**
+ **PROVISIONING**
+ **DOWNLOAD\$1SOURCE**
+ **INSTALL**
+ **PRE\$1BUILD**
+ **BUILD**
+ **POST\$1BUILD**
+ **UPLOAD\$1ARTIFACTS**
+ **FINALIZING**
+ **COMPLETED**
在**构建状态**中，应显示**已成功**。
如果您看到的是**正在进行**，请选择刷新按钮。
1. 在每个构建阶段的旁边，**持续时间**值表示构建阶段持续的时间。**结束时间**值表示构建阶段的结束时间。
### 步骤 8：查看详细的构建信息
（上一步：[步骤 7：查看汇总的构建信息](#getting-started-monitor-build-console)）
在此步骤中，您将在 Logs 中查看有关构建版本的 CloudWatch 详细信息。
**注意**
为了保护敏感信息， CodeBuild 日志中隐藏了以下内容：
AWS 访问密钥 IDs。有关更多信息，请参阅《AWS Identity and Access Management 用户指南》**中的[管理 IAM 用户的访问密钥](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。
使用参数存储指定的字符串。有关更多信息，请参阅《Amazon EC2 Systems Manager 用户指南》**中的 [Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html) 和 [Systems Manager Parameter Store 控制台演练](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-walk.html#sysman-paramstore-console)。
使用指定的字符串 AWS Secrets Manager。有关更多信息，请参阅 [密钥管理](security-key-management.md)。
**查看详细的构建信息**
1. 上一步完成后，构建详细页面继续显示，**Build logs** 中显示了构建日志的最后 10000 行内容。要在 “日志” 中查看整个构建 CloudWatch 日志，请选择 “**查看整个日志**” 链接。
1. 在 CloudWatch 日志日志流中，您可以浏览日志事件。默认情况下，只显示最近的一组日志事件。要查看以前的日志事件，请滚动到列表开头。
1. 在本教程中，大多数日志事件包含的是关于 CodeBuild 下载构建相关文件并将其安装到构建环境中的详细信息，您可能并不关心这些信息。您可以使用**筛选事件**框来减少显示的信息。例如，如果您在**筛选事件**中输入 `"[INFO]"`，则仅显示那些包含 `[INFO]` 的事件。有关更多信息，请参阅 *Amazon CloudWatch 用户指南*中的[筛选条件和模式语法](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/FilterAndPatternSyntax.html)。
### 步骤 9：获取构建输出构件
（上一步：[步骤 8：查看详细的构建信息](#getting-started-build-log-console)）
在此步骤中，您将获得 CodeBuild 生成并上传到输出存储桶的`messageUtil-1.0.jar`文件。
您可以使用 CodeBuild 控制台或 Amazon S3 控制台来完成此步骤。
**获取构建输出工件（AWS CodeBuild 控制台）**
1. 在 CodeBuild 控制台仍处于打开状态且仍显示上一步中的构建详细信息页面的情况下，选择**构建详细信息**选项卡，然后向下滚动到 Artifac **t** s 部分。
**注意**
如果未显示构建详细信息页面，请在导航栏中选择**构建历史记录**，然后选择**构建运行**链接。
1. 指向 Amazon S3 文件夹的链接位于**构件上传位置**下方。该链接会打开 Amazon S3 文件夹，您可以在这里找到 `messageUtil-1.0.jar` 构建输出构件文件。
**获取构建输出构件（Amazon S3 控制台）**
1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 打开 `codebuild-region-ID-account-ID-output-bucket`。
1. 打开 `codebuild-demo-project` 文件夹。
1. 打开 `target` 文件夹，您可以在此处找到 `messageUtil-1.0.jar` 构建输出构件文件。
### 步骤 10：删除 S3 存储桶
（上一步：[步骤 9：获取构建输出构件](#getting-started-output-console)）
为防止持续向您的 AWS 账户收费，您可以删除本教程中使用的输入和输出存储桶。有关更多信息，请参阅《Amazon Simple Storage Service 用户指南》**中的[删除或清空存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html)。
如果您使用 IAM 用户或管理员 IAM 用户删除这些存储桶，则该用户必须具有更多访问权限。在标记（*\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1*和*\$1\$1\$1 END ADDING STATEMENTS HERE \$1\$1\$1*）之间添加以下语句到用户的现有访问策略。
此语句中的省略号 (...) 旨在力求简洁。请勿删除现有访问策略中的任何语句。请勿在策略中输入这些省略号。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:DeleteBucket",
"s3:DeleteObject"
],
"Resource": "*"
}
]
}
```
------
### 总结
在本教程中，您曾经 AWS CodeBuild 将一组 Java 类文件生成到 JAR 文件中。然后查看了构建的结果。
现在，您可以尝试 CodeBuild 在自己的场景中使用。按照[计划构建](planning.md)中的说明进行操作。如果您觉得自己还没准备好，可以尝试构建一些示例。有关更多信息，请参阅 [基于使用场景的 CodeBuild 示例](use-case-based-samples.md)。
## 开始 AWS CodeBuild 使用 AWS CLI
在本教程中，您将使用 AWS CodeBuild 将一组示例源代码输入文件（称为*构建输入工件*或*构建输入*）构建为源代码的可部署版本（称为*构建输出构件*或*构建输出*）。具体而言，您将指示 CodeBuild 使用常见的构建工具 Apache Maven 将一组 Java 类文件生成到 Java 存档 (JAR) 文件中。您无需熟悉 Apache Maven 或 Java 即可完成本教程。
您可以 CodeBuild 通过 CodeBuild 控制台 AWS CodePipeline、 AWS CLI、或 AWS SDKs。本教程演示了如何 CodeBuild 与 AWS CLI. 有关使用的信息 CodePipeline，请参见[ CodeBuild 搭配使用 CodePipeline](how-to-create-pipeline.md)。
**重要**
本教程中的步骤要求您创建可能会对您的 AWS 账户产生费用的资源（例如 S3 存储桶）。其中包括与 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**
+ [
### 步骤 1：创建源代码
](#getting-started-cli-create-source-code)
+ [
### 步骤 2：创建 buildspec 文件
](#getting-started-cli-create-build-spec)
+ [
### 步骤 3：创建两个 S3 存储桶
](#getting-started-cli-input-bucket)
+ [
### 步骤 4：上传源代码和 buildspec 文件
](#getting-started-cli-upload-source-code)
+ [
### 步骤 5：创建构建项目
](#getting-started-cli-create-build-project)
+ [
### 步骤 6：运行构建
](#getting-started-cli-run-build)
+ [
### 步骤 7：查看汇总的构建信息
](#getting-started-cli-monitor-build)
+ [
### 步骤 8：查看详细的构建信息
](#getting-started-cli-build-log)
+ [
### 步骤 9：获取构建输出构件
](#getting-started-cli-output)
+ [
### 步骤 10：删除 S3 存储桶
](#getting-started-cli-clean-up)
+ [
### 总结
](#getting-started-cli-next-steps)
### 步骤 1：创建源代码
（一部分：[开始 AWS CodeBuild 使用 AWS CLI](#getting-started-cli)）
在此步骤中，您将创建要生成 CodeBuild 到输出存储桶的源代码。此源代码包含两个 Java 类文件和一个 Apache Maven 项目对象模型 (POM) 文件。
1. 在您的本地计算机或实例上的空目录中，创建此目录结构。
```
(root directory name)
`-- src
|-- main
| `-- java
`-- test
`-- java
```
1. 使用您选择的文本编辑器创建此文件，将其命名为 `MessageUtil.java`，然后保存在 `src/main/java` 目录中。
```
public class MessageUtil {
private String message;
public MessageUtil(String message) {
this.message = message;
}
public String printMessage() {
System.out.println(message);
return message;
}
public String salutationMessage() {
message = "Hi!" + message;
System.out.println(message);
return message;
}
}
```
创建此类文件是用来输出传入的字符串。`MessageUtil` 构造函数用于设置字符串。`printMessage` 方法用于创建输出。`salutationMessage` 方法用于输出 `Hi!` 后跟字符串。
1. 创建此文件，将其命名为 `TestMessageUtil.java`，然后将它保存在 `/src/test/java` 目录中。
```
import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;
public class TestMessageUtil {
String message = "Robert";
MessageUtil messageUtil = new MessageUtil(message);
@Test
public void testPrintMessage() {
System.out.println("Inside testPrintMessage()");
assertEquals(message,messageUtil.printMessage());
}
@Test
public void testSalutationMessage() {
System.out.println("Inside testSalutationMessage()");
message = "Hi!" + "Robert";
assertEquals(message,messageUtil.salutationMessage());
}
}
```
此类文件用于将 `MessageUtil` 类中的 `message` 变量设置为 `Robert`。然后，通过检查输出中是否出现字符串 `Robert` 和 `Hi!Robert` 来测试是否成功设置 `message` 变量。
1. 创建此文件，将其命名为 `pom.xml`，然后保存在根（顶级）目录中。
```
4.0.0
org.example
messageUtil
1.0
jar
Message Utility Java Sample App
junit
junit
4.11
test
org.apache.maven.plugins
maven-compiler-plugin
3.8.0
```
Apache Maven 使用此文件中的指令将 `MessageUtil.java` 和 `TestMessageUtil.java` 文件转换为名为 `messageUtil-1.0.jar` 的文件，然后运行指定测试。
此时，您的目录结构应如下所示。
```
(root directory name)
|-- pom.xml
`-- src
|-- main
| `-- java
| `-- MessageUtil.java
`-- test
`-- java
`-- TestMessageUtil.java
```
### 步骤 2：创建 buildspec 文件
（上一步：[步骤 1：创建源代码](#getting-started-cli-create-source-code)）
在此步骤中，您将创建一个构建规范 (build spec) 文件。*buildspec* 是一组生成命令和相关设置，采 CodeBuild 用 YAML 格式，用于运行构建。如果没有构建规范， CodeBuild 则无法成功地将您的构建输入转换为构建输出，也无法在构建环境中找到要上传到输出存储桶的构建输出项目。
创建此文件，将其命名为 `buildspec.yml`，然后保存在根（顶级）目录中。
```
version: 0.2
phases:
install:
runtime-versions:
java: corretto11
pre_build:
commands:
- echo Nothing to do in the pre_build phase...
build:
commands:
- echo Build started on `date`
- mvn install
post_build:
commands:
- echo Build completed on `date`
artifacts:
files:
- target/messageUtil-1.0.jar
```
**重要**
因为 buildspec 声明必须为有效的 YAML，所以 buildspec 声明中的空格至关重要。如果 buildspec 声明中的空格数与此不匹配，则构建可能会立即失败。您可以使用 YAML 验证程序测试 buildspec 声明是否为有效的 YAML。
**注意**
您可以在创建构建项目时单独声明构建命令，而不是将 buildspec 文件包含在源代码中。如果您需要使用其他构建命令来构建源代码，而不是每次更新源代码存储库，这个方法很有用。有关更多信息，请参阅 [buildspec 语法](build-spec-ref.md#build-spec-ref-syntax)。
在此 buildspec 声明中：
+ `version` 表示正在使用的 buildspec 标准的版本。此 buildspec 声明使用最新版本 `0.2`。
+ `phases` 表示您可以指示 CodeBuild 运行命令的生成阶段。这些构建阶段包括 `install`、`pre_build`、`build` 和 `post_build`。您无法更改这些构建阶段名称的拼写，也无法创建更多构建阶段名称。
在本示例中，在该`build`阶段 CodeBuild 运行`mvn install`命令。此命令指示 Apache Maven 编译和测试 Java 类文件，然后将编译完的文件打包为构建输出构件。出于完整性考虑，本示例的每个构建阶段中都放了几条 `echo` 命令。您稍后查看本教程中详细的构建信息时，这些 `echo` 命令的输出可以帮助您更好地理解 CodeBuild 运行命令的方式以及顺序。（尽管本示例中包含了所有构建阶段，但如果您不打算在某个构建阶段运行任何命令，则无需包含该构建阶段。） 对于每个构建阶段，按所列顺序从头到尾 CodeBuild 运行每个指定的命令，一次运行一个命令。
+ `artifacts`表示 CodeBuild上传到输出存储桶的一组构建输出项目。 `files`表示要包含在生成输出中的文件。 CodeBuild 上传在构建环境的`target`相对目录中找到的单个`messageUtil-1.0.jar`文件。文件 `messageUtil-1.0.jar` 和目录 `target` 只是根据本示例中 Apache Maven 创建和存储构建输出构件的方式来命名的。在您自己的构建项目中，这些文件和目录名称会有所不同。
有关更多信息，请参阅[Buildspec 参考](build-spec-ref.md)。
此时，您的目录结构应如下所示。
```
(root directory name)
|-- pom.xml
|-- buildspec.yml
`-- src
|-- main
| `-- java
| `-- MessageUtil.java
`-- test
`-- java
`-- TestMessageUtil.java
```
### 步骤 3：创建两个 S3 存储桶
（上一步：[步骤 2：创建 buildspec 文件](#getting-started-cli-create-build-spec)）
尽管您可以为本教程使用单个存储桶，但使用两个存储桶使您可以更容易地查看构建输入的来源以及构建输出的去向。
+ 其中一个存储桶（*输入存储桶*）用于存储构建输入。在本教程中，此输入存储桶的名称是`codebuild-region-ID-account-ID-input-bucket`，其中*region-ID*是存储桶的 AWS 区域，*account-ID*是您的 AWS 账户 ID。
+ 另一个存储桶（*输出存储桶*）用于存储构建输出。在本教程中，此输出存储桶的名称为 `codebuild-region-ID-account-ID-output-bucket`。
如果您为这些存储桶选择了不同的名称，请务必在本教程中使用它们。
这两个存储桶必须与您的版本位于同一个 AWS 区域。例如，如果您指示 CodeBuild 在美国东部（俄亥俄州）区域运行构建，则这些存储桶也必须位于美国东部（俄亥俄州）区域。
有关更多信息，请参阅《Amazon Simple Storage Service 用户指南》中的[创建存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket.html)。
**注意**
尽管 CodeBuild 还支持存储在 CodeCommit GitHub、和 Bitbucket 存储库中的构建输入，但本教程并未向您展示如何使用它们。有关更多信息，请参阅 [计划构建](planning.md)。
### 步骤 4：上传源代码和 buildspec 文件
（上一步：[步骤 3：创建两个 S3 存储桶](#getting-started-cli-input-bucket)）
在此步骤中，您将源代码和 buildspec 文件添加到输入存储桶中。
使用操作系统的 ZIP 实用工具，创建一个名为 `MessageUtil.zip` 的文件，其中包含 `MessageUtil.java`、`TestMessageUtil.java`、`pom.xml` 和 `buildspec.yml`。
`MessageUtil.zip` 文件的目录结构必须如下所示。
```
MessageUtil.zip
|-- pom.xml
|-- buildspec.yml
`-- src
|-- main
| `-- java
| `-- MessageUtil.java
`-- test
`-- java
`-- TestMessageUtil.java
```
**重要**
请不要包含 `(root directory name)` 目录，而只包含 `(root directory name)` 目录中的目录和文件。
将 `MessageUtil.zip` 文件上传至名为 `codebuild-region-ID-account-ID-input-bucket` 的输入存储桶中。
**重要**
对于 CodeCommit GitHub、和 Bitbucket 存储库，按照惯例，您必须在每个存储库的根目录（顶层）`buildspec.yml`中存储一个名为的构建规范文件，或者将构建规范声明作为构建项目定义的一部分。请勿创建包含存储库源代码和 buildspec 文件的 ZIP 文件。
仅对于存储在 S3 存储桶中的构建输入，您必须创建一个包含源代码的 ZIP 文件和一个（按照惯例）位于根（顶级）位置的名为 `buildspec.yml` 的 buildspec 文件，或者将 buildspec 声明作为构建项目定义的一部分包含。
如果您要为 buildspec 文件使用其他名称，或者要在根位置之外的位置引用 buildspec，则可指定 buildspec 覆盖作为构建项目定义的一部分。有关更多信息，请参阅 [buildspec 文件名称和存储位置](build-spec-ref.md#build-spec-ref-name-storage)。
### 步骤 5：创建构建项目
（上一步：[步骤 4：上传源代码和 buildspec 文件](#getting-started-cli-upload-source-code)）
在此步骤中，您将创建一个 AWS CodeBuild 用于运行构建的生成项目。*构建项目*包含有关如何运行构建的信息，包括从何处获取源代码、要使用的构建环境、要运行的构建命令以及将构建输出存储在何处。*构建环境*代表操作系统、编程语言运行时和用于运行构建的 CodeBuild 工具的组合。构建环境以 Docker 映像的形式表示。有关更多信息，请参阅 Docker 文档网站上的 [Docker 概述](https://docs.docker.com/get-started/overview/)。
对于这个构建环境，你需要使用包含 Java 开发套件 (JDK) 和 Apache Maven 版本的 Docker 镜像。 CodeBuild
**创建构建项目**
1. AWS CLI 使用运行**create-project**命令：
```
aws codebuild create-project --generate-cli-skeleton
```
输出中将显示 JSON 格式的数据。将数据复制到本地计算机或安装实例上名`create-project.json` AWS CLI 为的文件。如果您选择使用其他文件名，请务必在本教程中使用该名称。
按照以下格式修改所复制的数据，然后保存结果：
```
{
"name": "codebuild-demo-project",
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/MessageUtil.zip"
},
"artifacts": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-output-bucket"
},
"environment": {
"type": "LINUX_CONTAINER",
"image": "aws/codebuild/standard:5.0",
"computeType": "BUILD_GENERAL1_SMALL"
},
"serviceRole": "serviceIAMRole"
}
```
*serviceIAMRole*替换为 CodeBuild 服务角色的 Amazon 资源名称 (ARN)（例如）。`arn:aws:iam::account-ID:role/role-name`要创建该文件，请参阅 [CodeBuild 允许与其他 AWS 服务进行交互](setting-up-service-role.md)。
在此数据中：
+ `name` 表示此构建项目的必需标识符（在本示例中为 `codebuild-demo-project`）。构建项目名称在您账户的所有构建项目中必须是唯一的。
+ 对于 `source`，`type` 是一个必需值，表示源代码的存储库类型（在本示例中，`S3` 表示 Amazon S3 存储桶)。
+ 对于 `source`，`location` 表示源代码的路径（在本示例中，为输入存储桶名称后跟 ZIP 文件名称）。
+ 对于 `artifacts`，`type` 是一个必需值，表示构建输出构件的存储库类型（在本示例中，`S3` 表示 Amazon S3 存储桶）。
+ 对于 `artifacts`，`location` 表示您先前创建或识别的输出存储桶的名称（在本示例中为 `codebuild-region-ID-account-ID-output-bucket`）。
+ 对于 `environment`，`type` 是表示构建环境类型的必填值（在本例中为 `LINUX_CONTAINER`）。
+ f `image` o `environment` r，是必填值，它表示此构建项目使用的 Docker 映像名称和标签组合，由 Docker 镜像存储库类型指定（在本示例中，`aws/codebuild/standard:5.0`对于 Docker 镜像存储库中的 Docker 镜像）。 CodeBuild `aws/codebuild/standard`是 Docker 镜像的名称。 `5.0`是 Docker 镜像的标签。
要查找您可以在自己方案中使用的更多 Docker 映像，请参阅[构建环境参考](build-env-ref.md)。
+ F `computeType` or`environment`，是一个必填值，它表示 CodeBuild 使用的计算资源（在本例中为`BUILD_GENERAL1_SMALL`）。
**注意**
原始 JSON 格式数据中的其他可用值，如 `description`、`buildspec`、`auth` (包括 `type` 和 `resource`)、`path`、`namespaceType`、`name` (对于 `artifacts`)、`packaging`、`environmentVariables` (包括 `name` 和 `value`)、`timeoutInMinutes`、`encryptionKey` 和 `tags` (包括 `key` 和 `value`) 为可选的值。本教程中未使用这些值，因此它们没有在这里显示。有关更多信息，请参阅 [创建构建项目 (AWS CLI)](create-project.md#create-project-cli)。
1. 切换到您刚才保存的文件所在的目录，然后再次运行 **create-project** 命令。
```
aws codebuild create-project --cli-input-json file://create-project.json
```
如果成功，输出中将显示与此类似的数据。
```
{
"project": {
"name": "codebuild-demo-project",
"serviceRole": "serviceIAMRole",
"tags": [],
"artifacts": {
"packaging": "NONE",
"type": "S3",
"location": "codebuild-region-ID-account-ID-output-bucket",
"name": "message-util.zip"
},
"lastModified": 1472661575.244,
"timeoutInMinutes": 60,
"created": 1472661575.244,
"environment": {
"computeType": "BUILD_GENERAL1_SMALL",
"image": "aws/codebuild/standard:5.0",
"type": "LINUX_CONTAINER",
"environmentVariables": []
},
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/MessageUtil.zip"
},
"encryptionKey": "arn:aws:kms:region-ID:account-ID:alias/aws/s3",
"arn": "arn:aws:codebuild:region-ID:account-ID:project/codebuild-demo-project"
}
}
```
+ `project` 表示有关此构建项目的信息。
+ `tags` 表示已经声明的所有标签。
+ `packaging` 表示构建输出构件将如何存储在输出存储桶中。`NONE` 表示在输出存储桶中创建文件夹。构建输出构件存储在该文件夹中。
+ `lastModified` 表示构建项目最后一次更改的时间，采用 Unix 时间格式。
+ `timeoutInMinutes`表示如果构建尚未完成，则在该分钟后 CodeBuild 停止构建。（默认为 60 分钟。）
+ `created` 表示构建项目的创建时间，采用 Unix 时间格式。
+ `environmentVariables`表示已声明且可在构建期间使用的任何环境变量。 CodeBuild
+ `encryptionKey`表示 CodeBuild 用于加密生成输出工件的客户托管密钥的 ARN。
+ `arn` 表示构建项目的 ARN。
**注意**
运行该**create-project**命令后，可能会输出类似于以下内容的错误消息：**用户:无权执行：*user-ARN*codebuild: CreateProject**。这很可能是因为您使用了没有足够权限的用户凭据 CodeBuild 来创建构建项目。 AWS CLI 要修复此问题，请使用属于以下任一 IAM 实体的凭证配置 AWS CLI ：
您 AWS 账户中的管理员用户。有关更多信息，请参阅用户*指南中的创建您的第一个 AWS 账户 root 用户*[和群组](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html)。
您 AWS 账户中的用户 `AWSCodeBuildAdminAccess``AmazonS3ReadOnlyAccess`，且该用户或该用户所属的 IAM 群组附加了、和`IAMFullAccess`托管策略。如果您的 AWS 账户中没有具有这些权限的用户或群组，并且您无法将这些权限添加到您的用户或群组，请联系您的 AWS 账户管理员寻求帮助。有关更多信息，请参阅 [AWS 的托管（预定义）策略 AWS CodeBuild](auth-and-access-control-iam-identity-based-access-control.md#managed-policies)。
### 步骤 6：运行构建
（上一步：[步骤 5：创建构建项目](#getting-started-cli-create-build-project)）
在此步骤中，您将指示 AWS CodeBuild 使用构建项目中的设置运行构建。
**运行构建**
1. AWS CLI 使用运行**start-build**命令：
```
aws codebuild start-build --project-name project-name
```
*project-name*替换为上一步中的构建项目名称（例如，`codebuild-demo-project`）。
1. 如果成功，输出中将显示与以下内容类似的数据：
```
{
"build": {
"buildComplete": false,
"initiator": "user-name",
"artifacts": {
"location": "arn:aws:s3:::codebuild-region-ID-account-ID-output-bucket/message-util.zip"
},
"projectName": "codebuild-demo-project",
"timeoutInMinutes": 60,
"buildStatus": "IN_PROGRESS",
"environment": {
"computeType": "BUILD_GENERAL1_SMALL",
"image": "aws/codebuild/standard:5.0",
"type": "LINUX_CONTAINER",
"environmentVariables": []
},
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/MessageUtil.zip"
},
"currentPhase": "SUBMITTED",
"startTime": 1472848787.882,
"id": "codebuild-demo-project:0cfbb6ec-3db9-4e8c-992b-1ab28EXAMPLE",
"arn": "arn:aws:codebuild:region-ID:account-ID:build/codebuild-demo-project:0cfbb6ec-3db9-4e8c-992b-1ab28EXAMPLE"
}
}
```
+ `build` 表示有关此构建的信息。
+ `buildComplete` 表示构建是否完成 (`true`)。否则为 `false`。
+ `initiator` 表示启动构建的实体。
+ `artifacts` 表示有关构建输出的信息，包括其位置。
+ `projectName` 表示构建项目的名称。
+ `buildStatus` 表示运行 **start-build** 命令时当前构建的状态。
+ `currentPhase` 表示运行 **start-build** 命令时的当前构建阶段。
+ `startTime` 表示构建过程开始的时间，采用 Unix 时间格式。
+ `id` 表示构建的 ID。
+ `arn` 表示构建的 ARN。
记下此 `id` 值。您在下一个步骤中需要用到它。
### 步骤 7：查看汇总的构建信息
（上一步：[步骤 6：运行构建](#getting-started-cli-run-build)）
在此步骤中，您将查看有关构建状态的汇总信息。
**查看汇总的构建信息**
+ AWS CLI 使用运行**batch-get-builds**命令。
```
aws codebuild batch-get-builds --ids id
```
*id*替换为上一步输出中显示的`id`值。
如果成功，输出中将显示与此类似的数据。
```
{
"buildsNotFound": [],
"builds": [
{
"buildComplete": true,
"phases": [
{
"phaseStatus": "SUCCEEDED",
"endTime": 1472848788.525,
"phaseType": "SUBMITTED",
"durationInSeconds": 0,
"startTime": 1472848787.882
},
... The full list of build phases has been omitted for brevity ...
{
"phaseType": "COMPLETED",
"startTime": 1472848878.079
}
],
"logs": {
"groupName": "/aws/codebuild/codebuild-demo-project",
"deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=region-ID#logEvent:group=/aws/codebuild/codebuild-demo-project;stream=38ca1c4a-e9ca-4dbc-bef1-d52bfEXAMPLE",
"streamName": "38ca1c4a-e9ca-4dbc-bef1-d52bfEXAMPLE"
},
"artifacts": {
"md5sum": "MD5-hash",
"location": "arn:aws:s3:::codebuild-region-ID-account-ID-output-bucket/message-util.zip",
"sha256sum": "SHA-256-hash"
},
"projectName": "codebuild-demo-project",
"timeoutInMinutes": 60,
"initiator": "user-name",
"buildStatus": "SUCCEEDED",
"environment": {
"computeType": "BUILD_GENERAL1_SMALL",
"image": "aws/codebuild/standard:5.0",
"type": "LINUX_CONTAINER",
"environmentVariables": []
},
"source": {
"type": "S3",
"location": "codebuild-region-ID-account-ID-input-bucket/MessageUtil.zip"
},
"currentPhase": "COMPLETED",
"startTime": 1472848787.882,
"endTime": 1472848878.079,
"id": "codebuild-demo-project:38ca1c4a-e9ca-4dbc-bef1-d52bfEXAMPLE",
"arn": "arn:aws:codebuild:region-ID:account-ID:build/codebuild-demo-project:38ca1c4a-e9ca-4dbc-bef1-d52bfEXAMPLE"
}
]
}
```
+ `buildsNotFound`表示任何没有可用信息的版本的构建 IDs 。在本示例中，其应该为空。
+ `builds` 表示有关每个具备信息的构建项目的信息。在本示例中，输出中只显示了有关一个构建项目的信息。
+ `phases` 表示 CodeBuild 在生成过程中运行的一组生成阶段。有关每个构建阶段的信息将分别列出，其中包含：`startTime`、`endTime` 和 `durationInSeconds` (采用 Unix 时间格式的构建阶段开始时间和结束时间，以及构建阶段的持续时间，以秒为单位)，以及 `phaseType` (如 `SUBMITTED`、`PROVISIONING`、`DOWNLOAD_SOURCE`、`INSTALL`、`PRE_BUILD`、`BUILD`、`POST_BUILD`、`UPLOAD_ARTIFACTS`、 `FINALIZING` 或 `COMPLETED`)，还有 `phaseStatus` (如 `SUCCEEDED`、`FAILED`、`FAULT`、 `TIMED_OUT`、`IN_PROGRESS` 或 `STOPPED`)。首次运行 **batch-get-builds** 命令时，可能不会有很多（或没有）阶段。使用相同构建 ID 再次运行 **batch-get-builds** 命令后，输出中应当会出现更多构建阶段。
+ `logs`表示 Amazon CloudWatch 日志中有关构建日志的信息。
+ `md5sum` MD5 并`sha256sum`表示版本输出工件的 SHA-256 哈希值。只有在构建项目的 `packaging` 值设置为 `ZIP` 时，这些内容才会显示在输出中。（在本教程中您未设置此值。） 您可以将这些哈希值和校验和工具一起使用，确认文件的完整性和真实性。
**注意**
您还可以使用 Amazon S3 控制台查看这些哈希值。选中构建输出构件旁边的框，然后依次选择**操作**和**属性**。**在 “**属性**” 窗格中，展开 “**元数据**”，然后查看-content-**x-amz-meta-codebuildmd5 和-content-sha256 的**值。x-amz-meta-codebuild**（在 Amazon S3 控制台中，不应将构建输出项目的**ETag**值解释为 MD5 或 SHA-256 哈希。）
如果您使用 AWS SDKs 来获取这些哈希，则这些值将命名为 and `codebuild-content-md5`。`codebuild-content-sha256`
+ `endTime` 表示构建过程结束的时间，采用 Unix 时间格式。
**注意**
Amazon S3 元数据有一个名为`buildArn`的 CodeBuild 标头，`x-amz-meta-codebuild-buildarn`其中包含将 CodeBuild 构件发布到 Amazon S3 的版本。添加 `buildArn` 是为了允许对通知进行源跟踪并引用生成构件的构建。
### 步骤 8：查看详细的构建信息
（上一步：[步骤 7：查看汇总的构建信息](#getting-started-cli-monitor-build)）
在此步骤中，您将在 Logs 中查看有关构建版本的 CloudWatch 详细信息。
**注意**
为了保护敏感信息， CodeBuild 日志中隐藏了以下内容：
AWS 访问密钥 IDs。有关更多信息，请参阅《AWS Identity and Access Management 用户指南》**中的[管理 IAM 用户的访问密钥](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。
使用参数存储指定的字符串。有关更多信息，请参阅《Amazon EC2 Systems Manager 用户指南》**中的 [Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html) 和 [Systems Manager Parameter Store 控制台演练](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-walk.html#sysman-paramstore-console)。
使用指定的字符串 AWS Secrets Manager。有关更多信息，请参阅 [密钥管理](security-key-management.md)。
**查看详细的构建信息**
1. 使用您的 Web 浏览器，转到上一步的输出中显示的 `deepLink` 位置（如 `https://console.aws.amazon.com/cloudwatch/home?region=region-ID#logEvent:group=/aws/codebuild/codebuild-demo-project;stream=38ca1c4a-e9ca-4dbc-bef1-d52bfEXAMPLE`）。
1. 在 CloudWatch 日志日志流中，您可以浏览日志事件。默认情况下，只显示最近的一组日志事件。要查看以前的日志事件，请滚动到列表开头。
1. 在本教程中，大多数日志事件包含的是关于 CodeBuild 下载构建相关文件并将其安装到构建环境中的详细信息，您可能并不关心这些信息。您可以使用**筛选事件**框来减少显示的信息。例如，如果您在**筛选事件**中输入 `"[INFO]"`，则仅显示那些包含 `[INFO]` 的事件。有关更多信息，请参阅 *Amazon CloudWatch 用户指南*中的[筛选条件和模式语法](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html)。
CloudWatch 日志流的这些部分与本教程有关。
```
...
[Container] 2016/04/15 17:49:42 Entering phase PRE_BUILD
[Container] 2016/04/15 17:49:42 Running command echo Entering pre_build phase...
[Container] 2016/04/15 17:49:42 Entering pre_build phase...
[Container] 2016/04/15 17:49:42 Phase complete: PRE_BUILD Success: true
[Container] 2016/04/15 17:49:42 Entering phase BUILD
[Container] 2016/04/15 17:49:42 Running command echo Entering build phase...
[Container] 2016/04/15 17:49:42 Entering build phase...
[Container] 2016/04/15 17:49:42 Running command mvn install
[Container] 2016/04/15 17:49:44 [INFO] Scanning for projects...
[Container] 2016/04/15 17:49:44 [INFO]
[Container] 2016/04/15 17:49:44 [INFO] ------------------------------------------------------------------------
[Container] 2016/04/15 17:49:44 [INFO] Building Message Utility Java Sample App 1.0
[Container] 2016/04/15 17:49:44 [INFO] ------------------------------------------------------------------------
...
[Container] 2016/04/15 17:49:55 -------------------------------------------------------
[Container] 2016/04/15 17:49:55 T E S T S
[Container] 2016/04/15 17:49:55 -------------------------------------------------------
[Container] 2016/04/15 17:49:55 Running TestMessageUtil
[Container] 2016/04/15 17:49:55 Inside testSalutationMessage()
[Container] 2016/04/15 17:49:55 Hi!Robert
[Container] 2016/04/15 17:49:55 Inside testPrintMessage()
[Container] 2016/04/15 17:49:55 Robert
[Container] 2016/04/15 17:49:55 Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.018 sec
[Container] 2016/04/15 17:49:55
[Container] 2016/04/15 17:49:55 Results :
[Container] 2016/04/15 17:49:55
[Container] 2016/04/15 17:49:55 Tests run: 2, Failures: 0, Errors: 0, Skipped: 0
...
[Container] 2016/04/15 17:49:56 [INFO] ------------------------------------------------------------------------
[Container] 2016/04/15 17:49:56 [INFO] BUILD SUCCESS
[Container] 2016/04/15 17:49:56 [INFO] ------------------------------------------------------------------------
[Container] 2016/04/15 17:49:56 [INFO] Total time: 11.845 s
[Container] 2016/04/15 17:49:56 [INFO] Finished at: 2016-04-15T17:49:56+00:00
[Container] 2016/04/15 17:49:56 [INFO] Final Memory: 18M/216M
[Container] 2016/04/15 17:49:56 [INFO] ------------------------------------------------------------------------
[Container] 2016/04/15 17:49:56 Phase complete: BUILD Success: true
[Container] 2016/04/15 17:49:56 Entering phase POST_BUILD
[Container] 2016/04/15 17:49:56 Running command echo Entering post_build phase...
[Container] 2016/04/15 17:49:56 Entering post_build phase...
[Container] 2016/04/15 17:49:56 Phase complete: POST_BUILD Success: true
[Container] 2016/04/15 17:49:57 Preparing to copy artifacts
[Container] 2016/04/15 17:49:57 Assembling file list
[Container] 2016/04/15 17:49:57 Expanding target/messageUtil-1.0.jar
[Container] 2016/04/15 17:49:57 Found target/messageUtil-1.0.jar
[Container] 2016/04/15 17:49:57 Creating zip artifact
```
在此示例中， CodeBuild 成功完成了预构建、生成和生成后的构建阶段。它运行单元测试并成功构建 `messageUtil-1.0.jar` 文件。
### 步骤 9：获取构建输出构件
（上一步：[步骤 8：查看详细的构建信息](#getting-started-cli-build-log)）
在此步骤中，您将获得 CodeBuild 生成并上传到输出存储桶的`messageUtil-1.0.jar`文件。
您可以使用 CodeBuild 控制台或 Amazon S3 控制台来完成此步骤。
**获取构建输出工件（AWS CodeBuild 控制台）**
1. 在 CodeBuild 控制台仍处于打开状态且仍显示上一步中的构建详细信息页面的情况下，选择**构建详细信息**选项卡，然后向下滚动到 Artifac **t** s 部分。
**注意**
如果未显示构建详细信息页面，请在导航栏中选择**构建历史记录**，然后选择**构建运行**链接。
1. 指向 Amazon S3 文件夹的链接位于**构件上传位置**下方。该链接会打开 Amazon S3 文件夹，您可以在这里找到 `messageUtil-1.0.jar` 构建输出构件文件。
**获取构建输出构件（Amazon S3 控制台）**
1. 打开 Amazon S3 控制台，网址为 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。
1. 打开 `codebuild-region-ID-account-ID-output-bucket`。
1. 打开 `codebuild-demo-project` 文件夹。
1. 打开 `target` 文件夹，您可以在此处找到 `messageUtil-1.0.jar` 构建输出构件文件。
### 步骤 10：删除 S3 存储桶
（上一步：[步骤 9：获取构建输出构件](#getting-started-cli-output)）
为防止持续向您的 AWS 账户收费，您可以删除本教程中使用的输入和输出存储桶。有关更多信息，请参阅《Amazon Simple Storage Service 用户指南》**中的[删除或清空存储桶](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html)。
如果您使用 IAM 用户或管理员 IAM 用户删除这些存储桶，则该用户必须具有更多访问权限。在标记（*\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1*和*\$1\$1\$1 END ADDING STATEMENTS HERE \$1\$1\$1*）之间添加以下语句到用户的现有访问策略。
此语句中的省略号 (...) 旨在力求简洁。请勿删除现有访问策略中的任何语句。请勿在策略中输入这些省略号。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:DeleteBucket",
"s3:DeleteObject"
],
"Resource": "*"
}
]
}
```
------
### 总结
在本教程中，您曾经 AWS CodeBuild 将一组 Java 类文件生成到 JAR 文件中。然后查看了构建的结果。
现在，您可以尝试 CodeBuild 在自己的场景中使用。按照[计划构建](planning.md)中的说明进行操作。如果您觉得自己还没准备好，可以尝试构建一些示例。有关更多信息，请参阅 [基于使用场景的 CodeBuild 示例](use-case-based-samples.md)。