本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# CodeBuild 使用以案例為基礎的範例
您可以使用這些以使用案例為基礎的範例來實驗 AWS CodeBuild：
[跨服務範例](cross-service-samples.md)
要實驗的跨服務範例清單 AWS CodeBuild。
[建置徽章範例](sample-build-badges.md)
示範如何使用組建徽章設定 CodeBuild。
[測試報告範例](sample-test-report-cli.md)
使用 AWS CLI 來建立、執行和檢視測試報告的結果。
[CodeBuild 的 Docker 範例](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 建立 BitBucket、GitHub Enterprise Server 和 GitHub 提取請求與 Webhook。
[使用語意版本控制在建置時間設定成品名稱](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 檔案，以便 CodeBuild 專案在 Amazon EFS 檔案系統上掛載和建置。範例說明將示範如何建立 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 主題的訂閱者。範例指示說明如何設定許可，以便 CodeBuild 可以與 Amazon SNS 和 CloudWatch 通訊、如何在 Amazon SNS 中建立和識別 CodeBuild 主題、如何訂閱主題的收件人，以及如何在 CloudWatch 中設定規則。
# CodeBuild 的 Amazon ECR 範例
此範例使用 Amazon Elastic Container Registry (Amazon ECR) 映像儲存庫中的 Docker 映像來建置範例 Go 專案。
**重要**
執行此範例可能會導致 AWS 您的帳戶產生費用。這包括 AWS CodeBuild 與 Amazon S3、、 AWS KMS CloudWatch Logs 和 Amazon ECR 相關的 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)、[Amazon CloudWatch 定價](https://aws.amazon.com/cloudwatch/pricing)和 [Amazon Elastic Container Registry 定價](https://aws.amazon.com/ecr/pricing)。
**Topics**
+ [執行 Amazon ECR 範例](#sample-ecr-running)
## 執行 Amazon ECR 範例
使用下列指示來執行 CodeBuild 的 Amazon ECR 範例。
**如何執行此範例**
1. 若要在 Amazon ECR 中建立 Docker 映像並將其推送至映像儲存庫，請完成 [執行「發佈 Docker 映像到 Amazon ECR」範例](sample-docker.md#sample-docker-running)區段中的步驟[「將 Docker 映像發佈至 Amazon ECR」範例](sample-docker.md)。
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. 建立組建專案、執行組建，以及檢視相關的組建資訊。
如果您使用 AWS CLI 來建立建置專案，`create-project`命令的 JSON 格式輸入可能會與此類似。(以您自己的值取代預留位置。)
```
{
"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. 如果下列其中一項為 true，您必須將許可新增至 Amazon ECR 中的映像儲存庫，讓 AWS CodeBuild 可以將 Docker 映像提取至建置環境。
+ 您的專案使用 CodeBuild 登入資料來提取 Amazon ECR 映像。這個行為可由 `ProjectEnvironment` 中屬性 `imagePullCredentialsType` 的值 `CODEBUILD` 看出。
+ 您的專案使用跨帳戶 Amazon ECR 映像。在這種情況下，您的專案必須使用其服務角色來提取 Amazon ECR 映像。若要啟用這種行為，請將您 `ProjectEnvironment` 的 `imagePullCredentialsType` 屬性設定成 `SERVICE_ROLE`。
1. 在 [https://console.aws.amazon.com/ecr/](https://console.aws.amazon.com/ecr/) 開啟 Amazon ECR 主控台。
1. 在儲存庫名稱的清單中，選擇您建立或選取的儲存庫名稱。
1. 從導覽窗格，依序選擇 **Permissions (許可)**、**Edit (編輯)** 和 **Add statement (新增陳述式)**。
1. 針對 **Statement name (陳述式名稱)**，輸入識別符 (例如 **CodeBuildAccess**)。
1. 用於**生效**時，請保留選取**允許**。這樣做表示您允許存取另一個 AWS 帳戶。
1. 用於 **Principal (委託人)**，執行下列其中一項操作：
+ 如果您的專案使用 CodeBuild 登入資料來提取 Amazon ECR 映像，請在**服務主體**中輸入 **codebuild.amazonaws.com**。
+ 如果您的專案使用跨帳戶 Amazon ECR 映像，請在**AWS 帳戶 IDs** 中輸入IDs。 AWS
1. 略過 **All IAM entities (所有 IAM 實體)** 清單。
1. 針對 **Action (動作)**，選取所有僅限提取的動作：**ecr:GetDownloadUrlForLayer**、**ecr:BatchGetImage** 和 **ecr:BatchCheckLayerAvailability**。
1. 針對**條件**，新增下列項目：
```
{
"StringEquals":{
"aws:SourceAccount":"",
"aws:SourceArn":"arn:aws:codebuild:::project/"
}
}
```
1. 選擇**儲存**。
此政策會顯示在 **Permissions (許可)** 中。委託人是您在此程序的步驟 3 中針對 **Principal (委託人)** 輸入的委託人：
+ 如果您的專案使用 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. 建立組建專案、執行組建，以及檢視組建資訊。
如果您使用 AWS CLI 來建立建置專案，`create-project`命令的 JSON 格式輸入可能會與此類似。(以您自己的值取代預留位置。)
```
{
"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)
}
```
# 的 Amazon 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)。 *Amazon Elastic File System *
此範例說明如何設定 CodeBuild 專案，使其掛載並建置 Java 應用程式至 Amazon EFS 檔案系統。開始之前，您必須準備好建置上傳至 S3 輸入儲存貯體或 AWS CodeCommit、GitHub、GitHub Enterprise Server 或 Bitbucket 儲存庫的 Java 應用程式。
檔案系統傳輸中的資料會受到加密。若要使用不同的映像加密傳輸中的資料，請參閱[加密傳輸中的資料](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html)。
**Topics**
+ [AWS CodeBuild 搭配 Amazon Elastic File System 使用](#sample-efs-high-level-steps)
+ [Amazon EFS 整合疑難排解](sample-efs-troubleshooting.md)
## AWS CodeBuild 搭配 Amazon 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：建立 CodeBuild 專案以搭配 Amazon EFS 使用](#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 管理主控台 ，並在 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)：// 開啟 Amazon VPC 主控台。
1. 選擇您建立的 VPC CloudFormation。
1. 在 **Description (描述)** 標籤上，記下 VPC 的名稱及其 ID。當您稍後在這個範例建立您的 AWS CodeBuild 專案時，會需要這兩個項目。
### 步驟 2：使用 VPC 建立 Amazon Elastic File System 檔案系統
使用您先前建立的 VPC，為此範例建立簡單的 Amazon EFS 檔案系統。
1. 登入 AWS 管理主控台 ，並在 https：// 開啟 Amazon EFS 主控台。 [ https://console.aws.amazon.com/efs/](https://console.aws.amazon.com/efs/)
1. 選擇 **Create file system (建立檔案系統)**。
1. 從 **VPC** 中，選擇您在此範例中稍早記下的 VPC 名稱。
1. 將與您的子網路相關聯的可用區域保持選取。
1. 選擇 **Next Step (後續步驟)**。
1. 在**新增標籤**中，針對預設**名稱**索引鍵，在**值**中輸入 Amazon EFS 檔案系統的名稱。
1. 將 **Bursting (爆量)** 與 **General Purpose (一般用途)** 分別選為預設效能及傳輸量模式，然後選擇 **Next Step (下一步)**。
1. 對於 **Configure new client (設定新用戶端)**，請選擇 **Next Step (下一個步驟)**。
1. 選擇 **Create File System (建立檔案系統)**。
1. （選用） 建議您將政策新增至 Amazon EFS 檔案系統，以強制執行傳輸中資料的加密。在 Amazon EFS 主控台中，選擇**檔案系統政策**，選擇**編輯**，選擇標示**為所有用戶端強制執行傳輸中加密的**方塊，然後選擇**儲存**。
### 步驟 3：建立 CodeBuild 專案以搭配 Amazon EFS 使用
建立使用您先前在此範例中建立之 VPC 的 AWS CodeBuild 專案。當組建執行時，它會掛載先前建立的 Amazon EFS 檔案系統。接下來，組件會儲存由您的 Java 應用程式於檔案系統的掛載點目錄中建立的 .jar 檔案。
1. 在 https：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 從導覽窗格，選擇 **Build projects (建置專案)**，然後選擇 **Create build project (建立建置專案)**。
1. 在**專案名稱** 中，輸入您的專案名稱。
1. 從 **Source provider (來源供應商)**，選擇包含您希望建置的 Java 應用程式的儲存庫。
1. 輸入 CodeBuild 用來尋找應用程式的資訊，例如儲存庫 URL。每個來源供應商的選項不同。如需詳細資訊，請參閱[Choose source provider](create-project.md#create-project-source-provider)。
1. 從 **Environment image (環境映像)**，選擇 **Managed image (受管映像)**。
1. 從 **Operating system (作業系統)**，選擇 **Amazon Linux 2**。
1. 從 **Runtime(s) (執行時間)**，選擇 **Standard (標準)**。
1. 在**影像**中，選擇 **aws/codebuild/amazonlinux-x86\$164-standard：4.0。**
1. 從 **Environment type** (環境類型) 中選擇 **Linux**。
1. 在 **Service role (服務角色)** 下，選擇 **New service role (新服務角色)**。在**角色名稱**中，輸入 CodeBuild 為您建立的角色名稱。
1. 展開 **Additional configuration (其他組態)**。
1. 選取 **Enable this flag if you want to build Docker images or want your builds to get elevated privileges (若想建置 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. 從 **Subnets (子網路)**，選擇與您的 VPC 關聯的一或多個私有子網路。您必須在掛載 Amazon EFS 檔案系統的建置中使用私有子網路。如果您使用公有子網路，則建置會失敗。
1. 從 **Security Groups** (安全群組) 中選擇預設的安全群組。
1. 在 **File systems** (檔案系統) 中，輸入下列資訊：
+ 針對 **Identifier (識別碼)**，輸入唯一的檔案系統識別碼。它必須少於 129 個字元，且只包含英數字元和底線。CodeBuild 使用此識別符來建立可識別彈性檔案系統的環境變數。環境變量格式是大寫英文字母的 `CODEBUILD_`。例如，如果您輸入 `my_efs`，環境變數則為 `CODEBUILD_MY_EFS`。
+ 針對 **ID**，請選擇檔案系統 ID。
+ （選用） 在檔案系統中輸入目錄。CodeBuild 掛載此目錄。如果您將**目錄路徑**保留空白，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. 如為 **Build specification (建置規格)**，選擇 **Insert build commands (插入建置命令)**，然後選擇 **Switch to editor (切換到編輯器)**。
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. 對所有其他設定使用預設值，然後選擇 **Create build project (建立建置專案)**。當建置完成時，您專案的主控台頁面就會顯示。
1. 選擇 **Start build (開始組建)**。
### 步驟 4：檢閱建置專案
建置 AWS CodeBuild 專案之後：
+ 您有由 Java 應用程式建立的 .jar 檔案，該檔案建置在掛載點目錄下的 Amazon EFS 檔案系統。
+ 可辨識您檔案系統的環境變數，會使用您在建立專案時輸入的檔案系統識別碼建立。
如需詳細資訊，請參閱《Amazon Elastic [File System 使用者指南》中的掛](https://docs.aws.amazon.com/efs/latest/ug/mounting-fs.html)載檔案系統。 *Amazon Elastic File System *
# Amazon EFS 整合疑難排解
以下是使用 CodeBuild 設定 Amazon EFS 時可能遇到的錯誤。
**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：/' 失敗。 許可遭拒
使用 CodeBuild 掛載 Amazon EFS 不支援 IAM 授權。如果您使用的是自訂 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 之間的範例整合。
| 樣本 | Description |
| --- | --- |
| [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 檔案之後，您可以建立管道。使用 AWS CLI 執行 **create-pipeline** 命令，並將 檔案傳遞至 `--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 檔案之後，您可以建立管道。使用 AWS CLI 執行 **create-pipeline** 命令，並將 檔案傳遞至 `--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 檔案的目錄。在 JSON 檔案的 CodeBuild 階段的 `configuration` 區段中，關鍵字 `PrimarySource` 用來指定主要來源。
+ 每個輸入來源安裝在其自己的目錄中。此目錄會存放在內建的環境變數，`$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 檔案之後，您可以建立管道。使用 AWS CLI 執行 **create-pipeline** 命令，並將 檔案傳遞至 `--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 開發人員指南*》中的[什麼是 AWS Config？](https://docs.aws.amazon.com/config/latest/developerguide/WhatIsConfig.html)。
您可以在 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：//[https://console.aws.amazon.com/config](https://console.aws.amazon.com/config) 開啟 AWS Config 主控台。
1. 在**資源庫存**頁面上，選取**資源類型**下的 **AWS CodeBuild 專案**。向下捲動並選取 **CodeBuild project (CodeBuild 專案)** 核取方塊。
1. 選擇 **Look up** (查閱)。
1. 新增 CodeBuild 專案清單後，請在 **Config 時間軸**欄中選擇 CodeBuild 專案名稱連結。
## 步驟 3：在 AWS Config 主控台中檢視 AWS CodeBuild 資料
在資源**庫存**頁面上查詢資源時，您可以選擇 AWS Config 時間軸以檢視 CodeBuild 專案的詳細資訊。資源的詳細資訊頁面提供該資源之組態、關係以及對其所做之變更的相關資訊。
頁面頂端的區塊統稱為時間軸。時間軸顯示記錄的日期和時間。
如需詳細資訊，請參閱[《 開發人員指南》中的在 AWS Config 主控台中檢視組態詳細資訊](https://docs.aws.amazon.com/config/latest/developerguide/view-manage-resource-console.html)。 *AWS Config *
# CodeBuild 的建置通知範例
Amazon CloudWatch Events 具有 的內建支援 AWS CodeBuild。CloudWatch Events 是描述 AWS 資源變更的系統事件串流。使用 CloudWatch Events，您可以撰寫宣告規則，將感興趣的事件與要採取的自動化動作建立關聯。此範例使用 Amazon CloudWatch Events 和 Amazon Simple Notification Service (Amazon SNS)，每當組建成功、失敗、從一個組建階段移至另一個組建階段，或這些事件的任意組合時，就會傳送組建通知給訂閱者。
**重要**
執行此範例可能會導致 AWS 您的帳戶產生費用。這包括 CodeBuild 以及與 Amazon CloudWatch 和 Amazon SNS 相關的 AWS 資源和動作的可能費用。如需詳細資訊，請參閱 [CodeBuild 定價](https://aws.amazon.com/codebuild/pricing)、[Amazon CloudWatch 定價](https://aws.amazon.com/cloudwatch/pricing)和 [Amazon 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，請將下列陳述式 （介於 *\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1 *和 *\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1* 之間） 新增至使用者 （或使用者相關聯的 IAM 群組）。不建議使用 AWS 根帳戶。此陳述式可讓您檢視、建立、訂閱和測試 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 uses CloudWatch Events 中建立或識別主題，以透過 Amazon SNS 傳送建置通知至此主題。
建立主題：
1. 開啟位於 https：//[https://console.aws.amazon.com/sns](https://console.aws.amazon.com/sns) 的 Amazon SNS 主控台。
1. 請選擇**建立主題**。
1. 在 **Create new topic (建立新主題)** 中，針對 **Topic name (主題名稱)**，輸入主題的名稱 (例如 **CodeBuildDemoTopic**)。(如果您選擇其他名稱，請在此範例中全部換成此名稱。)
1. 請選擇**建立主題**。
1. 在**主題詳細資訊：CodeBuildDemoTopic** 頁面上，複製**主題 ARN** 值。您在下一個步驟中需要使用到此數值。
![\[主題 ARN 值。\]](http://docs.aws.amazon.com/zh_tw/codebuild/latest/userguide/images/topic-arn.png)
如需詳細資訊，請參閱《*Amazon SNS 開發人員指南*》中的[建立主題](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html)。
1. 讓一或多個收件人訂閱主題來接收電子郵件通知。
讓收件人訂閱主題：
1. 從上一個步驟開啟 Amazon SNS 主控台後，在導覽窗格中，選擇**訂閱**，然後選擇**建立訂閱**。
1. 在 **Create subscription (建立訂閱)** 中，對於 **Topic ARN (主題 ARN)**，貼上您從上個步驟複製的主題 ARN。
1. 對於**通訊協定**，選擇**電子郵件**。
1. 針對 **Endpoint (端點)**，輸入收件人的完整電子郵件地址。
![\[訂閱組態。\]](http://docs.aws.amazon.com/zh_tw/codebuild/latest/userguide/images/create-subscription.png)
1. 選擇 **Create Subscription** (建立訂閱)。
1. Amazon SNS 會傳送訂閱確認電子郵件給收件人。若要開始接收電子郵件通知，收件人必須選擇訂閱確認電子郵件中的 **Confirm subscription (確認訂閱)** 連結。收件人按一下連結後，如果成功訂閱，Amazon SNS 會在收件人的 Web 瀏覽器中顯示確認訊息。
如需詳細資訊，請參閱《*Amazon SNS 開發人員指南*》中的[訂閱主題](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html)。
1. 如果您使用 使用者而非 AWS 根帳戶或管理員使用者來使用 CloudWatch Events，請將下列陳述式 （介於 *\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1* 和 *\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1* 之間） 新增至使用者 （或使用者相關聯的 IAM 群組）。不建議使用 AWS 根帳戶。此陳述式用於允許使用者使用 CloudWatch Events。省略符號 (`...`) 用於簡化和協助您找到新增陳述式的位置。請不要移除任何陳述式，也不要在現有政策中輸入這些省略符號。
------
#### [ 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 Events 中建立規則。若要這樣做，請開啟 CloudWatch 主控台，網址為 https：//[https://console.aws.amazon.com/cloudwatch](https://console.aws.amazon.com/cloudwatch)。
1. 在導覽窗格中，在 **Events (事件)** 下方選擇 **Rules (規則)**，然後選擇 **Create rule (建立規則)**。
1. 在 **Step 1: Create rule page (步驟 1：建立規則頁面)** 上，應該已選取 **Event Pattern (事件模式)** 和 **Build event pattern to match events by service (建構事件的模式，依服務來匹配事件)**。
1. 針對**服務名稱**，選擇 **CodeBuild**。在 **Event Type (事件類型)** 中，應該已選取 **All Events (所有事件)**。
1. 下列程式碼應顯示於 **Event Pattern Preview (事件模式預覽)** 中：
```
{
"source": [
"aws.codebuild"
]
}
```
1. 選擇 **Edit (編輯)**，將 **Event Pattern Preview (事件模式預覽)** 中的程式碼換成下列兩個規則模式之一。
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"
]
}
}
```
在上個規則中，依需要進行下列程式碼變更。
+ 若要在每次建置階段變更時觸發事件 (對每個建置，最多可傳送九次通知)，請保留 `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)。
**注意**
如果希望建置狀態變更和建置階段變更都觸發事件，您必須建立兩個不同的規則：一個用於建置狀態變更，另一個用於建置階段變更。如果您嘗試將兩個規則合併成單一規則，合併的規則可能產生非預期的結果，或完全停止運作。
完成取代程式碼時，選擇 **Save (儲存)**。
1. 在 **Targets** (目標) 中，選擇 **Add target (新增目標)**。
1. 在目標清單中，選擇 **SNS topic (SNS 主題)**。
1. 對於 **Topic (主題)**，選擇您稍早識別或建立的主題。
1. 展開 **Configure input (設定輸入)**，然後選擇 **Input Transformer (輸入轉換器)**。
1. 在 **Input Path (輸入路徑)** 方塊中，輸入下列其中一個輸入路徑。
如果規則的 `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. 在 **Input Template (輸入範本)** 方塊中，輸入下列其中一個輸入範本。
如果規則的 `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. 在 **Step 2: Configure rule details (步驟 2：設定規則詳細資訊)** 頁面上，輸入名稱和選填的描述。針對 **State (狀態)**，將 **Enabled (啟用)** 保留為選取狀態。
1. 選擇**建立規則**。
1. 建立組建專案、執行組建，以及檢視組建資訊。
1. 確認 CodeBuild 現在已成功傳送建置通知。例如，檢查您的收件匣中是否有組建通知電子郵件。
若要變更規則的行為，請在 CloudWatch 主控台中選擇您要變更的規則，選擇**動作**，然後選擇**編輯**。變更規則，選擇 **Configure details (設定詳細資訊)**，然後選擇 **Update rule (更新規則)**。
若要停止使用規則來傳送建置通知，請在 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 專案產生的公開可用 URL 存取。這可讓任何人檢視 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：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 如果顯示 CodeBuild 資訊頁面，請選擇**建立組建專案**。否則，請在導覽窗格中展開**組**建，選擇**組建專案**，然後選擇**建立組建專案**。
1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。組建專案名稱在每個 AWS 帳戶中必須是唯一的。您也可以包含建置專案的選用描述，以協助其他使用者了解此專案的用途。
1. 在 **Source (來源)** 中，針對 **Source provider (來源供應商)**，選擇來源碼提供商類型，然後執行下列其中一項：
**注意**
CodeBuild 不支援使用 Amazon S3 來源提供者建置徽章。由於 AWS CodePipeline 使用 Amazon S3 進行成品傳輸，因此屬於 CodePipeline 中建立管道一部分的建置專案不支援建置徽章。
+ 如果您選擇 **CodeCommit**，則對於**儲存庫**，請選擇儲存庫的名稱。選取 **Enable build badge (啟用組建徽章)**，讓專案的組建狀態變成可見且可嵌入。
+ 如果您選擇了 **GitHub**，請遵循說明來與 GitHub 連線 (或重新連線)。在 GitHub **授權應用程式**頁面上，針對**組織存取**，選擇您要 AWS CodeBuild 能夠存取的每個儲存庫旁的**請求**存取。選擇 **Authorize application (授權應用程式)** 後，請回到 AWS CodeBuild 主控台，針對 **Repository (儲存庫)** 選擇包含來源碼的儲存庫名稱。選取 **Enable build badge (啟用組建徽章)**，讓專案的組建狀態變成可見且可嵌入。
+ 如果您選擇了 **Bitbucket**，請遵循說明來與 Bitbucket 連線 (或重新連線)。在 Bitbucket **Confirm access to your account (確認存取您的帳戶)** 頁面上，針對 **Organization access (組織存取)**，選擇 **Grant access (授予存取)**。在您選擇**授予存取權**後，返回 AWS CodeBuild 主控台，針對**儲存庫**，選擇包含原始碼的儲存庫名稱。選取 **Enable build badge (啟用組建徽章)**，讓專案的組建狀態變成可見且可嵌入。
**重要**
更新您的專案來源可能會影響專案組建徽章的準確度。
1. 在 **Environment (環境)** 中：
針對 **Environment image (環境映像)**，執行下列其中一項作業：
+ 若要使用由 管理的 Docker 映像 AWS CodeBuild，請選擇**受管映像**，然後從**作業系統**、**執行期 （些）**、**映像**和**映像版本**進行選擇。若可用，請從 **Environment type (環境類型)** 進行選擇。
+ 若要使用另一個 Docker 映像，請選擇 **Custom image (自訂映像)**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您選擇**其他登錄**檔，請針對**外部登錄檔 URL**，使用 格式，在 Docker Hub 中輸入 Docker 映像檔的名稱和標籤`docker repository/docker image name`。如果您選擇 **Amazon ECR**，請使用 **Amazon ECR 儲存庫**和 **Amazon ECR 映像**來選擇 AWS 帳戶中的 Docker 映像。
+ 若要使用私有 Docker 映像，請選擇**自訂映像**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。針對 **Image registry (映像登錄)** 選擇 **Other registry (其他登錄)**，然後輸入私人 Docker 映像的憑證的 ARN。登入資料必須由 Secrets Manager 建立。如需詳細資訊，請參閱《 AWS Secrets Manager使用者指南》**中的 [What Is AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
1. 在 **Service role (服務角色)** 中，執行下列其中一項作業：
+ 如果您沒有 CodeBuild 服務角色，請選擇**新服務角色**。在**角色名稱**中，輸入新角色的名稱。
+ 如果您有 CodeBuild 服務角色，請選擇**現有服務角色**。在**角色 ARN** 中，選擇服務角色。
**注意**
當您使用 主控台建立或更新組建專案時，您可以同時建立 CodeBuild 服務角色。根據預設，此角色只能與該建置專案搭配運作。如果您使用主控台將此服務角色與另一個建置專案建立關聯，則會更新此角色以與其他建置專案搭配運作。服務角色最多可以與 10 個組建專案搭配運作。
1. 在 **Buildspec** 中，執行下列其中一項操作：
+ 選擇**使用 buildspec 檔案**以使用來源碼根目錄中的 buildspec.yml 檔案。
+ 選擇**插入建置命令**以使用主控台插入建置命令。
如需更多資訊，請參閱[Buildspec 參考](build-spec-ref.md)。
1. 在 **Artifacts (成品)** 中，針對 **Type (類型)**，執行下列其中一項操作：
+ 如果您不要建立建置輸出成品，則請選擇 **No artifacts (無成品)**。
+ 若要將建置輸出存放在 S3 儲存貯體，請選擇 **Amazon S3**，然後執行下列動作：
+ 如果您想要使用專案名稱做為組建輸出 ZIP 檔案或資料夾名稱，則請將 **Name (名稱)** 保留空白。否則請輸入名稱。根據預設，成品名稱是專案名稱。如果想使用不同的名稱，請在成品名稱方塊中輸入名稱。如果要輸出 ZIP 檔案，請包含 zip 副檔名。
+ 針對 **Bucket name (儲存貯體名稱)**，選擇輸出儲存貯體的名稱。
+ 如果您在本程序稍早選擇 **Insert build commands (插入組建命令)**，然後針對 **Output files (輸出檔案)**，輸入要放入組建輸出 ZIP 檔案或資料夾之組建中的檔案位置。針對多個位置，以逗號區隔每個位置 (例如，`appspec.yml, target/my-app.jar`)。如需詳細資訊，請參閱[Buildspec 語法](build-spec-ref.md#build-spec-ref-syntax)中的 `files` 描述。
1. 展開 **Additional configuration (其他組態)**，並適當地選擇選項。
1. 選擇 **Create build project (建立建置專案)**。在 **Review (檢閱)** 頁面上，選擇 **Start build (開始建置)** 來執行建置。
# 存取 AWS CodeBuild 建置徽章
您可以使用 AWS CodeBuild 主控台或 AWS CLI 來存取建置徽章。
+ 在 CodeBuild 主控台的組建專案清單中，於**名稱**欄中選擇與組建專案對應的連結。在**建置專案：*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 中的 `tag` 參數來取代 `branch` 參數，以從來源儲存庫指定標籤。例如：
```
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)
## 執行測試報告範例
使用下列步驟來執行 trest 報告範例。
**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 檔案中指定測試檔案的位置。
支援下列測試報告檔案格式：
+ 小黃瓜 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)。 *Amazon S3 *
+ 建立 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": ""
}
]
}
```
# CodeBuild 的 Docker 範例
本節說明 Docker 和 之間的範例整合 AWS CodeBuild。
| 樣本 | Description |
| --- | --- |
| [CodeBuild 自訂映像範例中的 Docker](sample-docker-custom-image.md) | 此範例使用 CodeBuild 和自訂 Docker 組建映像 (`docker:dind`在 Docker Hub 中） 來建置和執行 Docker 映像。 |
| [CodeBuild 的 Docker 映像建置伺服器範例](sample-docker-server.md) | 此範例會將 Docker 組建卸載至受管映像組建伺服器。 |
| [Windows Docker 建置 CodeBuild 的範例](sample-windows-docker-custom-image.md) | 此範例使用 CodeBuild 建置並執行 Windows Docker 映像。 |
| [CodeBuild 的「將 Docker 映像發佈至 Amazon ECR 映像儲存庫」範例](sample-docker.md) | 此範例會產生建置輸出 Docker 映像，然後將 Docker 映像推送至 Amazon Elastic Container Registry (Amazon ECR) 映像儲存庫。 |
| [具有 CodeBuild AWS Secrets Manager 範例的私有登錄檔](sample-private-registry.md) | 此範例說明如何使用存放在私有登錄檔中的 Docker 映像做為 CodeBuild 執行時間環境。 |
# CodeBuild 自訂映像範例中的 Docker
下列範例會使用 和自訂 Docker 建置映像 (`docker:dind`在 Docker Hub 中） 來建置 AWS CodeBuild 和執行 Docker 映像。
若要了解如何使用 CodeBuild 提供的建置映像搭配 Docker 支援來建置 Docker 映像，請參閱我們的 [「將 Docker 映像發佈至 Amazon ECR」範例](sample-docker.md)。
**重要**
執行此範例可能會導致 AWS 您的帳戶產生費用。這包括 CodeBuild 和與 Amazon S3 相關的 AWS 資源和動作 AWS KMS，以及 CloudWatch Logs 的可能費用。如需詳細資訊，請參閱 [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)和 [Amazon CloudWatch 定價](https://aws.amazon.com/cloudwatch/pricing)。
**Topics**
+ [在自訂映像範例中執行 Docker](#sample-docker-custom-image-running)
## 在自訂映像範例中執行 Docker
使用下列程序在自訂映像範例中執行 Docker。如需此範例的詳細資訊，請參閱 [CodeBuild 自訂映像範例中的 Docker](#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. 建立組建專案、執行組建，以及檢視相關的組建資訊。
如果您使用 AWS CLI 來建立建置專案，`create-project`命令的 JSON 格式輸入可能會與此類似。(以您自己的值取代預留位置。)
```
{
"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"
```
# CodeBuild 的 Docker 映像建置伺服器範例
下列範例會將 Docker 組建卸載至受管映像組建伺服器。您可以調整此範例，在 CodeBuild 專案組態中佈建專用且受管的 Docker 映像建置伺服器。請注意，在為專案主動執行組建時，佈建的執行個體處於作用中狀態，而當組建未執行時，執行個體會停止。佈建的執行個體會在回收前儲存長達一個月。如需詳細資訊，請參閱 [ CodeBuild Docker 伺服器功能](https://aws.amazon.com/blogs//aws/accelerate-ci-cd-pipelines-with-the-new-aws-codebuild-docker-server-capability)。
**重要**
執行此範例可能會導致 AWS 您的帳戶產生費用。這包括 CodeBuild 以及與 Amazon S3 相關的 AWS 資源和動作 AWS KMS，以及 CloudWatch Logs 的可能費用。如需詳細資訊，請參閱 [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)和 [Amazon 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. 如果您使用 AWS CLI 建立建置專案，`create-project`命令的 JSON 格式輸入可能看起來像這樣。(以您自己的值取代預留位置。)
```
{
"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`機群。
如果您使用 AWS CLI 來建立機群，`create-fleet`命令的 JSON 格式輸入可能看起來像這樣。(以您自己的值取代預留位置。)
```
{
"name": "fleet-name",
"baseCapacity": 1,
"environmentType": "WINDOWS_EC2",
"computeType": "BUILD_GENERAL1_MEDIUM"
}
```
1. 建立組建專案、執行組建，以及檢視相關的組建資訊。
如果您使用 AWS CLI 來建立建置專案，`create-project`命令的 JSON 格式輸入可能會與此類似。(以您自己的值取代預留位置。)
```
{
"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'"
```
# CodeBuild 的「將 Docker 映像發佈至 Amazon ECR 映像儲存庫」範例
此範例會產生建置輸出 Docker 映像，然後將 Docker 映像推送至 Amazon Elastic Container Registry (Amazon ECR) 映像儲存庫。您可以調整此範例將 Docker 影像推送至 Docker Hub。如需詳細資訊，請參閱[將 'Publish Docker 映像修改為 Amazon ECR' 範例，以推送至 Docker Hub](sample-docker-docker-hub.md)。
若要了解如何使用自訂 Docker 建置映像 (Docker Hub 中的 `docker:dind`) 來建置 Docker 映像，請參閱我們的[自訂映像中的 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 您的帳戶產生費用。這包括 AWS CodeBuild 與 Amazon S3、、 AWS KMS CloudWatch Logs 和 Amazon ECR 相關的 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)、[Amazon CloudWatch 定價](https://aws.amazon.com/cloudwatch/pricing)和 [Amazon Elastic Container Registry 定價](https://aws.amazon.com/ecr/pricing)。
**Topics**
+ [執行「發佈 Docker 映像到 Amazon ECR」範例](#sample-docker-running)
+ [將 'Publish Docker 映像修改為 Amazon ECR' 範例，以推送至 Docker Hub](sample-docker-docker-hub.md)
## 執行「發佈 Docker 映像到 Amazon ECR」範例
使用下列程序來執行將 Docker 映像發佈至 Amazon ECR 的範例。如需此範例的詳細資訊，請參閱 [CodeBuild 的「將 Docker 映像發佈至 Amazon ECR 映像儲存庫」範例](#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 根帳戶。此陳述式允許建立 Amazon ECR 儲存庫來存放 Docker 映像。省略符號 (`...`) 用於簡化和協助您找到新增陳述式的位置。請不要移除任何陳述式，也不要在政策中輸入這些省略符號。如需詳細資訊，請參閱[《 使用者指南》中的使用內嵌政策 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 服務角色的政策。此陳述式允許 CodeBuild 將 Docker 映像上傳至 Amazon 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. 針對 **Operating system (作業系統)**，選擇 **Ubuntu**。
1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。
1. 針對**映像**，選擇 **aws/codebuild/standard:5.0**。
1. 新增下列環境變數：
+ 值為 *region-ID* 的 AWS\$1DEFAULT\$1REGION
+ 值為 *account-ID* 的 AWS\$1ACCOUNT\$1ID
+ 值為 Latest 的 IMAGE\$1TAG
+ 值為 *Amazon-ECR-repo-name* 的 IMAGE\$1REPO\$1NAME
如果您使用 AWS CLI 來建立建置專案，`create-project`命令的 JSON 格式輸入可能會與此類似。(以您自己的值取代預留位置。)
```
{
"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. 在 [https://console.aws.amazon.com/ecr/](https://console.aws.amazon.com/ecr/) 開啟 Amazon ECR 主控台。
1. 選擇儲存庫名稱。此映像應列在 **Image tag (映像標籤)** 欄中。
### 目錄結構
此範例假設此目錄結構。
```
(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`的 。
# 將 'Publish Docker 映像修改為 Amazon ECR' 範例，以推送至 Docker Hub
若要將「公開 Docker 影像調整為 Amazon ECR」範例，以便將 Docker 影像推送至 Docker Hub，而不是 Amazon ECR，請編輯範例程式碼。如需範例的詳細資訊，請參閱 [CodeBuild 的「將 Docker 映像發佈至 Amazon ECR 映像儲存庫」範例](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，移至儲存庫，然後選擇 **Tags (標籤)** 索引標籤。`latest` 標籤應該包含最近的 **Last Updated (上次更新)** 值。
# 具有 CodeBuild AWS Secrets Manager 範例的私有登錄檔
此範例說明如何使用存放在私有登錄檔中的 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，您必須具有下列項目：
+ 存放 Docker Hub 登入資料的 Secrets Manager 秘密。這些登入資料會用來存取您的私有儲存庫。
**注意**
您需要為建立的秘密付費。
+ 私有儲存庫或帳戶。
+ 授予 Secrets Manager 秘密存取權的 CodeBuild 服務角色 IAM 政策。
請依照下列步驟建立這些資源，然後使用存放在私有登錄檔中的 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_tw/codebuild/latest/userguide/images/private-registry-sample-iam.png)
1. 若要使用主控台搭配私有登錄檔中所儲存的環境來建立專案，請在建立專案的同時執行下列動作。如需相關資訊，請參閱[建立組建專案 (主控台)](create-project.md#create-project-console)。
**注意**
如果您的私有登錄檔位於 VPC 中，則必須具有公有網際網路存取。CodeBuild 無法從 VPC 中的私有 IP 地址提取映像。
1. 在**環境映像**中，選擇**自訂映像**。
1. 針對 **Environment type (環境類型)**，選擇 **Linux** 或 **Windows**。
1. 針對**映像登錄**檔，選擇**其他登錄檔**。
1. 在**外部登錄 URL** 中，輸入映像位置，然後在**登錄登入資料中 - 選擇性**輸入 Secrets Manager 登入資料的 ARN 或名稱。
**注意**
如果您目前所在區域不存在您的登入資料，則您必須使用 ARN。如果登入資料存在於不同的區域，則無法使用登入資料名稱。
# 設定自我託管執行器的私有登錄登入資料
使用下列指示來設定自我託管執行器的登錄登入資料。
**注意**
請注意，只有在映像被私有登錄檔的映像覆寫時，才會使用這些登入資料。
------
#### [ AWS Management Console ]
1. 在 https：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 建立建置專案或選取現有的專案。如需詳細資訊，請參閱 [建立組建專案 (主控台)](create-project.md#create-project-console) 及 [變更建置專案的設定 (主控台)](change-project.md#change-project-console)。
1. 在**環境中**，選擇**其他組態**。
1. **在其他組態**中，輸入來自 的秘密名稱或 ARN AWS Secrets Manager for **Registry 登入資料 - 選用**。
![\[登錄檔登入資料組態。\]](http://docs.aws.amazon.com/zh_tw/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 儲存貯體中的建置輸出建立靜態網站
您可以停用組建中的成品加密。建議您執行此作業，如此一來您就可以將成品發佈至設定為託管網站的位置。(您不能發佈加密成品。) 此範例說明如何使用 Webhooks 觸發建置，並將其成品發佈到設定為網站的 S3 儲存貯體。
1. 按照[設定靜態網站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/HostingWebsiteOnS3Setup.html)中的說明，將 S3 儲存貯體設定為像網站一樣運作。
1. 在 https：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 如果顯示 CodeBuild 資訊頁面，請選擇**建立組建專案**。否則，請在導覽窗格中展開**組**建，選擇**組建專案**，然後選擇**建立組建專案**。
1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。組建專案名稱在每個 AWS 帳戶中必須是唯一的。您也可以包含建置專案的選用描述，以協助其他使用者了解此專案的用途。
1. 在 **Source (來源)** 中，針對 **Source provider (來源供應商)**，選擇 **GitHub**。請遵循說明來與 GitHub 連線 (或重新連線)，然後選擇 **Authorize (授權)**。
針對 **Webhook**，選取 **Rebuild every time a code change is pushed to this repository (在每次將程式碼變更推送至此儲存庫時重建)**。只有當您選擇 **Use a repository in my account (使用帳戶中的儲存庫)** 時，才能選取此核取方塊。
![\[Webhook 組態。\]](http://docs.aws.amazon.com/zh_tw/codebuild/latest/userguide/images/webhook.png)
1. 在 **Environment (環境)** 中：
針對 **Environment image (環境映像)**，執行下列其中一項作業：
+ 若要使用由 管理的 Docker 映像 AWS CodeBuild，請選擇**受管映像**，然後從**作業系統**、**執行期 （些）**、**映像**和**映像版本**進行選擇。若可用，請從 **Environment type (環境類型)** 進行選擇。
+ 若要使用另一個 Docker 映像，請選擇 **Custom image (自訂映像)**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您選擇**其他登錄**檔，請針對**外部登錄檔 URL**，使用 格式，在 Docker Hub 中輸入 Docker 映像檔的名稱和標籤`docker repository/docker image name`。如果您選擇 **Amazon ECR**，請使用 **Amazon ECR 儲存庫**和 **Amazon ECR 映像**來選擇 AWS 帳戶中的 Docker 映像。
+ 若要使用私有 Docker 映像，請選擇**自訂映像**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。針對 **Image registry (映像登錄)** 選擇 **Other registry (其他登錄)**，然後輸入私人 Docker 映像的憑證的 ARN。登入資料必須由 Secrets Manager 建立。如需詳細資訊，請參閱《 AWS Secrets Manager使用者指南》**中的 [What Is AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
1. 在 **Service role (服務角色)** 中，執行下列其中一項作業：
+ 如果您沒有 CodeBuild 服務角色，請選擇**新服務角色**。在**角色名稱**中，輸入新角色的名稱。
+ 如果您有 CodeBuild 服務角色，請選擇**現有服務角色**。在**角色 ARN** 中，選擇服務角色。
**注意**
當您使用 主控台建立或更新組建專案時，您可以同時建立 CodeBuild 服務角色。根據預設，此角色只能與該建置專案搭配運作。如果您使用主控台將此服務角色與另一個建置專案建立關聯，則會更新此角色以與其他建置專案搭配運作。服務角色最多可以與 10 個組建專案搭配運作。
1. 在 **Buildspec** 中，執行下列其中一項操作：
+ 選擇**使用 buildspec 檔案**以使用來源碼根目錄中的 buildspec.yml 檔案。
+ 選擇**插入建置命令**以使用主控台插入建置命令。
如需更多資訊，請參閱[Buildspec 參考](build-spec-ref.md)。
1. 在**成品**中，針對**類型**選擇 **Amazon S3**，將建置輸出存放在 S3 儲存貯體中。
1. 針對 **Bucket name (儲存貯體名稱)**，選擇您設定做為網站的 S3 儲存貯體的名稱。
1. 如果您選擇在**環境中****插入組建命令**，則針對**輸出檔案**，輸入您要放入輸出儲存貯體之組建中檔案的位置。如果您有多個位置，請使用逗號分隔每個位置 (例如 **appspec.yml, target/my-app.jar**)。如需詳細資訊，請參閱[Artifacts reference-key in the buildspec file](build-spec-ref.md#artifacts-build-spec)。
1. 選取 **Disable artifacts encryption (停用成品加密)**。
1. 展開 **Additional configuration (其他組態)**，並適當地選擇選項。
1. 選擇 **Create build project (建立建置專案)**。在組建專案頁面上，在 **Build history (組建歷史記錄)** 中選擇 **Start build (啟動組建)** 來執行組建。
1. （選用） 遵循《[Amazon S3 開發人員指南》中的範例：使用 Amazon CloudFront 加速您的網站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/website-hosting-cloudfront-walkthrough.html)。 *Amazon S3 *
# 多個輸入來源和輸出成品範例
您可以使用多個輸入來源和一組以上的輸出成品來建立 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
```
您可以使用 API 搭配 `StartBuild` 中的 `sourceVersion` 屬性，以覆寫主要來源的版本。若要覆寫一個或多個次要來源版本，請使用 `secondarySourceVersionOverride` 屬性。
中`start-build`命令的 JSON 格式輸入 AWS CLI 可能如下所示：
```
{
"projectName": "sample-project",
"secondarySourcesVersionOverride": [
{
"sourceIdentifier": "source1",
"sourceVersion": "codecommit-branch"
},
{
"sourceIdentifier": "source2",
"sourceVersion": "github-branch"
},
]
}
```
# 建立不含來源的建置專案
您可以在設定**NO\$1SOURCE**來源時選擇來源類型來設定 CodeBuild 專案。當來源類型為 **NO\$1SOURCE** 時，您將無法指定 buildspec 檔案，因為專案並無任何來源。相反地，您必須在 `create-project` CLI 命令的 JSON 格式輸入的 `buildspec` 屬性中指定 YAML 格式 buildspec 字串。這看起來類似下述：
```
{
"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)。
# CodeBuild 的 buildspec 檔案範例中的執行時間版本
如果您使用 Amazon Linux 2 (AL2) 標準映像版本 1.0 或更新版本，或 Ubuntu 標準映像版本 2.0 或更新版本，您可以在 buildspec 檔案的 `runtime-versions`區段中指定一或多個執行時間。下列範例示範如何變更專案執行時間、指定多個執行時間，以及指定相依於另一個執行時間的執行時間。如需支援的執行時間資訊，請參閱[CodeBuild 提供的 Docker 映像](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。
+ 指定 Java 版本 8 的 `runtime-versions` 區段：
```
phases:
install:
runtime-versions:
java: corretto8
```
+ 指定 Java 版本 11 的 `runtime-versions` 區段：
```
phases:
install:
runtime-versions:
java: corretto11
```
下列範例示範如何使用 Ubuntu 標準映像 5.0 或 Amazon Linux 2 標準映像 3.0 指定不同版本的 Python：
+ 指定 Python 3.7 版的`runtime-versions`區段：
```
phases:
install:
runtime-versions:
python: 3.7
```
+ 指定 Python 3.8 版的`runtime-versions`區段：
```
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：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 建立建置專案。如需詳細資訊，請參閱[建立組建專案 (主控台)](create-project.md#create-project-console)及[執行建置 (主控台)](run-build-console.md)。除了下列設定外，保留所有設定的預設值。
+ 針對 **Environment (環境)**：
+ 針對 **Environment image (環境映像)**，選擇 **Managed image (受管映像)**。
+ 針對 **Operating system** (作業系統)，請選擇 **Amazon Linux 2**。
+ 針對 **Runtime(s) (執行時間)**，選擇 **Standard (標準)**。
+ 針對**映像**，選擇 **aws/codebuild/amazonlinux-x86\$164-standard：4.0。**
1. 選擇 **Start build (開始組建)**。
1. 在 **Build configuration (組建組態)** 上，接受預設值，然後選擇 **Start build (開始組建)**。
1. 建置完成後，在 **Build logs (建置日誌)** 索引標籤上檢視建置輸出。您應該會看到類似下列的輸出：
```
[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. 將 `runtime-versions` 區段更新為 Java 版本 11：
```
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：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 建立建置專案。如需詳細資訊，請參閱[建立組建專案 (主控台)](create-project.md#create-project-console)及[執行建置 (主控台)](run-build-console.md)。除了下列設定外，保留所有設定的預設值。
+ 針對 **Environment (環境)**：
+ 針對 **Environment image (環境映像)**，選擇 **Managed image (受管映像)**。
+ 針對 **Operating system** (作業系統)，請選擇 **Amazon Linux 2**。
+ 針對 **Runtime(s) (執行時間)**，選擇 **Standard (標準)**。
+ 針對**映像**，選擇 **aws/codebuild/amazonlinux-x86\$164-standard：4.0。**
1. 選擇 **Create build project (建立建置專案)**。
1. 選擇 **Start build (開始組建)**。
1. 在 **Build configuration (組建組態)** 上，接受預設值，然後選擇 **Start build (開始組建)**。
1. 建置完成後，在 **Build logs (建置日誌)** 索引標籤上檢視建置輸出。您應該會看到類似下列的輸出。其中顯示 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、GitHub 和 GitHub Enterprise Server，請使用下列其中一項：
+ 提取請求做為提取請求參考 (例如，`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 或 GitHub Enterprise 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：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 建立建置專案。如需詳細資訊，請參閱 [建立組建專案 (主控台)](create-project.md#create-project-console) 及 [執行建置 (主控台)](run-build-console.md)。除了下列設定外，保留所有設定的預設值：
+ 在 **Source (來源)** 中：
+ 針對 **Source provider (來源供應商)**，選擇 **GitHub**。如果您未連接至 GitHub，請遵循指示來連接。
+ 針對 **Repository (儲存庫)**，選擇 **Public repository (公有儲存庫)**。
+ 針對 **Repository URL (儲存庫 URL)**，輸入 **https://github.com/aws/aws-sdk-ruby.git**。
+ 在 **Environment (環境)** 中：
+ 針對 **Environment image (環境映像)**，選擇 **Managed image (受管映像)**。
+ 針對 **Operating system** (作業系統)，請選擇 **Amazon Linux 2**。
+ 針對 **Runtime(s) (執行時間)**，選擇 **Standard (標準)**。
+ 針對**映像**，選擇 **aws/codebuild/amazonlinux-x86\$164-standard：4.0。**
1. 針對 **Build specifications (組建規格)**，選擇 **Insert build commands (插入組建命令)**，然後選擇 **Switch to editor (切換到編輯器)**。
1. 在 **Build commands (組建命令)** 中，將預留位置文字更換為以下內容：
```
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. 在 **Build configuration (組建組態)** 上，接受預設值，然後選擇 **Start build (開始組建)**。
1. 對於 **Source version (來源版本)**，輸入 **046e8b67481d53bdc86c3f6affdd5d1afae6d369**。這是 `https://github.com/aws/aws-sdk-ruby.git` 儲存庫中遞交的 SHA。
1. 選擇 **Start build (開始組建)**。
1. 當組建完成時，您應該會看到下列：
+ 在 **Build logs (組建日誌)** 標籤上，使用的專案來源的版本。請見此處範例。
```
[Container] Date Time Running command echo $CODEBUILD_RESOLVED_SOURCE_VERSION
046e8b67481d53bdc86c3f6affdd5d1afae6d369
[Container] Date Time Phase complete: BUILD State: SUCCEEDED
```
+ 在 **Environment variables (環境變數)** 標籤上，**Resolved source version (已解決的來源版本)** 會符合用來建立組建的遞交 ID。
+ 在 **Phase details (階段詳細資訊)** 標籤上，`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. 從左側導覽窗格，選擇 **Build projects (組建專案)**，然後選擇您稍早建立的專案。
1. 選擇 **Start build (開始組建)**。
1. 在 **Source version (來源版本)** 中，輸入 **refs/heads/main^\$1046e8b67481d53bdc86c3f6affdd5d1afae6d369\$1**。這是相同的遞交 ID 和分支的參考，格式為 `refs/heads/branchname^{full-commit-SHA}`。
1. 選擇 **Start build (開始組建)**。
1. 當組建完成時，您應該會看到下列：
+ 在 **Build logs (組建日誌)** 標籤上，使用的專案來源的版本。請見此處範例。
```
[Container] Date Time Running command echo $CODEBUILD_RESOLVED_SOURCE_VERSION
046e8b67481d53bdc86c3f6affdd5d1afae6d369
[Container] Date Time Phase complete: BUILD State: SUCCEEDED
```
+ 在 **Environment variables (環境變數)** 標籤上，**Resolved source version (已解決的來源版本)** 會符合用來建立組建的遞交 ID。
+ 在 **Phase details (階段詳細資訊)** 標籤上，`DOWNLOAD_SOURCE` 階段的持續時間應該較您僅使用遞交 ID 來指定來源的版本時更短。
# CodeBuild 的第三方來源儲存庫範例
本節說明第三方來源儲存庫與 CodeBuild 之間的範例整合。
| 樣本 | Description |
| --- | --- |
| BitBucket pull 請求和 Webhook 篩選條件範例 – 請參閱 [執行 CodeBuild 的「Bitbucket pull request and Webhook filter」範例](sample-bitbucket-pull-request.md) | 此範例示範如何使用 Bitbucket 儲存庫建立提取請求。它還說明如何使用 Bitbucket Webhook 來觸發 CodeBuild 來建立專案的建置。 |
| GitHub Enterprise Server 範例 – 請參閱 [執行 CodeBuild 的 GitHub Enterprise Server 範例](sample-github-enterprise.md) | 此範例示範如何在 GitHub Enterprise Server 儲存庫安裝憑證時設定 CodeBuild 專案。它還顯示如何啟用 Webhook，以便 CodeBuild 每次將程式碼變更推送到您的 GitHub Enterprise Server 儲存庫時重建原始程式碼。 |
| GitHub 提取請求和 Webhook 篩選條件範例 – 請參閱 [執行 CodeBuild 的 GitHub 提取請求和 Webhook 篩選條件範例](sample-github-pull-request.md) | 此範例說明如何使用 GitHub Enterprise Server 儲存庫建立提取請求。它還顯示如何啟用 Webhook，以便 CodeBuild 每次將程式碼變更推送到您的 GitHub Enterprise Server 儲存庫時重建原始程式碼。 |
# 執行 CodeBuild 的「Bitbucket pull request and Webhook filter」範例
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 連線錯誤，則必須重新連線以授予 CodeBuild 許可來管理您的 Webhook。
## 步驟 1：使用 Bitbucket 建立建置專案並啟用 Webhook
下列步驟說明如何使用 Bitbucket 建立 AWS CodeBuild 專案做為來源儲存庫，並啟用 Webhook。
1. 在 https：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 如果顯示 CodeBuild 資訊頁面，請選擇**建立組建專案**。否則，請在導覽窗格中展開**組**建，選擇**組建專案**，然後選擇**建立組建專案**。
1. 選擇 **Create build project (建立建置專案)**。
1. 在 **Project configuration (專案組態)** 中：
**Project name (專案名稱)**
輸入此建置專案的名稱。組建專案名稱在每個 AWS 帳戶中必須是唯一的。您也可以包含建置專案的選用描述，以協助其他使用者了解此專案的用途。
1. 在 **Source (來源)** 中：
**來源提供者**
選擇 **Bitbucket**。依照指示來連接 （或重新連線） 與 Bitbucket，然後選擇**授權**。
**儲存庫**
在**我的 Bitbucket 帳戶中選擇儲存庫**。
如果您先前尚未連線到 Bitbucket 帳戶，請輸入您的 Bitbucket 使用者名稱和密碼，然後選取**儲存 Bitbucket 登入**資料。
**Bitbucket 儲存庫**
輸入 Bitbucket 儲存庫的 URL。
1. 在**主要來源 Webhook 事件**中，選取下列項目。
**注意**
只有在您在上一個步驟**的我的 Bitbucket 帳戶中選擇儲存庫**時，才會顯示**主要來源 Webhook 事件**區段。
1. 當您建立專案時，請選取 **Rebuild every time a code change is pushed to this repository (在每次將程式碼變更推送至此儲存庫時重建)**。
1. 從 **Event type (事件類型)**，選擇一或多個事件。
1. 若要篩選事件觸發組建的時間，請在 **Start a build under these conditions (在這些情況下開始組建)** 下新增一或多個選用的篩選條件。
1. 若要篩選何時不觸發事件，請在 **Don't start a build under these conditions (在這些情況下不開始組建)** 下新增一或多個選用的篩選條件。
1. 如有需要，請選擇**新增篩選條件群組**以新增另一個篩選條件群組。
如需 Bitbucket Webhook 事件類型和篩選條件的詳細資訊，請參閱 [Bitbucket Webhook 事件](bitbucket-webhook.md)。
1. 在 **Environment (環境)** 中：
**環境映像**
選擇下列其中一項：
若要使用由 管理的 Docker 映像 AWS CodeBuild：
選擇**受管映像**，然後從**作業系統**、**執行時間**、**映像**和**映像版本**進行選擇。若可用，請從 **Environment type (環境類型)** 進行選擇。
若要使用另一個 Docker 映像：
選擇**自訂映像**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您選擇**其他登錄**檔，請針對**外部登錄檔 URL**，使用 格式，在 Docker Hub 中輸入 Docker 映像檔的名稱和標籤`docker repository/docker image name`。如果您選擇 **Amazon ECR**，請使用 **Amazon ECR 儲存庫**和 **Amazon ECR 映像**來選擇 AWS 帳戶中的 Docker 映像。
若要使用私有 Docker 映像：
選擇**自訂映像**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。針對 **Image registry (映像登錄)** 選擇 **Other registry (其他登錄)**，然後輸入私人 Docker 映像的憑證的 ARN。登入資料必須由 Secrets Manager 建立。如需詳細資訊，請參閱*AWS Secrets Manager 《 使用者指南*》中的[什麼是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
**服務角色**
選擇下列其中一項：
+ 如果您沒有 CodeBuild 服務角色，請選擇**新服務角色**。在**角色名稱**中，輸入新角色的名稱。
+ 如果您有 CodeBuild 服務角色，請選擇**現有服務角色**。在**角色 ARN** 中，選擇服務角色。
當您使用 主控台建立或更新組建專案時，您可以同時建立 CodeBuild 服務角色。根據預設，此角色只能與該建置專案搭配運作。如果您使用主控台將此服務角色與另一個建置專案建立關聯，則會更新此角色以與其他建置專案搭配運作。服務角色最多可以與 10 個組建專案搭配運作。
1. 在 **Buildspec** 中，執行下列其中一項操作：
+ 選擇**使用 buildspec 檔案**以使用來源碼根目錄中的 buildspec.yml 檔案。
+ 選擇**插入建置命令**以使用主控台插入建置命令。
如需更多資訊，請參閱[Buildspec 參考](build-spec-ref.md)。
1. 在 **Artifacts (成品)** 中：
**類型**
選擇下列其中一項：
+ 如果您不要建立建置輸出成品，則請選擇 **No artifacts (無成品)**。
+ 若要將建置輸出存放在 S3 儲存貯體，請選擇 **Amazon S3**，然後執行下列動作：
+ 如果您想要使用專案名稱做為組建輸出 ZIP 檔案或資料夾名稱，則請將 **Name (名稱)** 保留空白。否則請輸入名稱。根據預設，成品名稱是專案名稱。如果想使用不同的名稱，請在成品名稱方塊中輸入名稱。如果要輸出 ZIP 檔案，請包含 zip 副檔名。
+ 針對 **Bucket name (儲存貯體名稱)**，選擇輸出儲存貯體的名稱。
+ 如果您在本程序稍早選擇 **Insert build commands (插入組建命令)**，然後針對 **Output files (輸出檔案)**，輸入要放入組建輸出 ZIP 檔案或資料夾之組建中的檔案位置。針對多個位置，以逗號區隔每個位置 (例如，`appspec.yml, target/my-app.jar`)。如需詳細資訊，請參閱[Buildspec 語法](build-spec-ref.md#build-spec-ref-syntax)中的 `files` 描述。
**其他組態**
展開 **Additional configuration (其他組態)**，並適當地設定選項。
1. 選擇 **Create build project (建立建置專案)**。在 **Review (檢閱)** 頁面上，選擇 **Start build (開始建置)** 來執行建置。
## 步驟 2：使用 Bitbucket Webhook 觸發組建
對於使用 Bitbucket Webhook 的專案，當 Bitbucket 儲存庫偵測到原始程式碼變更時， 會 AWS CodeBuild 建立組建。
1. 在 https：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 在導覽窗格上，選擇 **Build projects (建置專案)**，然後選擇與帶有 Webhook 的 Bitbucket 儲存庫相關聯的專案。如需建立 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 頁面中，選擇 **View request (檢視請求)** 來查看最近事件的清單。
1. 選擇**檢視詳細資訊**，以查看 CodeBuild 傳回之回應的詳細資訊。這看起來類似下述：
```
"response":"Webhook received and build started: https://us-east-1.console.aws.amazon.com/codebuild/home..."
"statusCode":200
```
1. 導覽至 Bitbucket 提取請求頁面來查看組建狀態。
# 執行 CodeBuild 的 GitHub Enterprise Server 範例
AWS CodeBuild 支援 GitHub Enterprise Server 做為來源儲存庫。此範例示範如何在 GitHub Enterprise Server 儲存庫安裝憑證時設定 CodeBuild 專案。它還顯示如何啟用 Webhook，以便 CodeBuild 每次將程式碼變更推送到您的 GitHub Enterprise Server 儲存庫時重建原始程式碼。
**Topics**
+ [先決條件](#sample-github-enterprise-prerequisites)
+ [步驟 1：使用 GitHub Enterprise Server 建立建置專案並啟用 Webhook](#sample-github-enterprise-running)
## 先決條件
1. 為您的 CodeBuild 專案產生個人存取字符。建議您建立 GitHub Enterprise 使用者，並產生此使用者的個人存取字符。將其複製到剪貼簿，以便在建立 CodeBuild 專案時使用。如需詳細資訊，請參閱 GitHub Help 網站上的 [Creating a personal access token for the command line](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/)。
當您建立個人存取字符時，請在定義中包含 **repo** 範圍。
![\[定義中的儲存庫範圍。\]](http://docs.aws.amazon.com/zh_tw/codebuild/latest/userguide/images/scopes.png)
1. 從 GitHub Enterprise Server 下載您的憑證。CodeBuild 使用憑證來建立與儲存庫的信任 SSL 連線。
**Linux/macOS 用戶端：**
從終端機視窗中，執行下列命令：
```
echo -n | openssl s_client -connect HOST:PORTNUMBER \
| sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' > /folder/filename.pem
```
將命令中的預留位置取代為下列值：
*HOST*。GitHub Enterprise Server 儲存庫的 IP 地址。
*PORTNUMBER*。您用來連線的連接埠號碼 (例如 443)。
*folder*。從中下載您憑證的資料夾。
*filename*。您憑證檔案的檔案名稱。
**重要**
將憑證儲存為 .pem 檔案。
**Windows 用戶端：**
使用瀏覽器從 GitHub Enterprise 下載您的憑證。若要查看網站的憑證詳細資訊，請選擇鎖定圖示。如需如何匯出憑證的資訊，請參閱您的瀏覽器文件。
**重要**
將憑證儲存為 .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 Enterprise Server 建立建置專案並啟用 Webhook
1. 在 https：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 如果顯示 CodeBuild 資訊頁面，請選擇**建立組建專案**。否則，請在導覽窗格中展開**組**建，選擇**組建專案**，然後選擇**建立組建專案**。
1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。組建專案名稱在每個 AWS 帳戶中必須是唯一的。您也可以包含建置專案的選用描述，以協助其他使用者了解此專案的用途。
1. 在**來源**中，在**來源提供者**中選擇 **GitHub Enterprise Server**。
+ 選擇**管理帳戶登入**資料，然後選擇**個人存取字符**。針對**服務**，選擇 **Secrets Manager （建議）**，然後設定您的秘密。然後在 中**，GitHub Enterprise 個人存取字符**中，輸入您的個人存取字符，然後選擇**儲存**。
+ 在 **Repository URL (儲存庫 URL)** 中，輸入儲存庫的路徑，包括儲存庫的名稱。
+ 展開 **Additional configuration (其他組態)**。
+ 選取 **Rebuild every time a code change is pushed to this repository (在每次將程式碼變更推送至儲存庫時重建)**，以便每次程式碼變更推送至此儲存庫時就重建。
+ 選取 **Enable insecure SSL (啟用不安全 SSL)**，在連線至 GitHub Enterprise Server 專案儲存庫時忽略 SSL 警告。
**注意**
建議只將 **Enable insecure SSL (啟用不安全 SSL)** 用於測試。不應用於生產環境。
![\[GitHub Enterprise Server 專案儲存庫組態。\]](http://docs.aws.amazon.com/zh_tw/codebuild/latest/userguide/images/github-enterprise.png)
1. 在 **Environment (環境)** 中：
針對 **Environment image (環境映像)**，執行下列其中一項作業：
+ 若要使用由 管理的 Docker 映像 AWS CodeBuild，請選擇**受管映像**，然後從**作業系統**、**執行期 （些）**、**映像**和**映像版本**進行選擇。若可用，請從 **Environment type (環境類型)** 進行選擇。
+ 若要使用另一個 Docker 映像，請選擇 **Custom image (自訂映像)**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您選擇**其他登錄**檔，請針對**外部登錄檔 URL**，使用 格式在 Docker Hub 中輸入 Docker 映像檔的名稱和標籤`docker repository/docker image name`。如果您選擇 **Amazon ECR**，請使用 **Amazon ECR 儲存庫**和 **Amazon ECR 映像**來選擇 AWS 帳戶中的 Docker 映像。
+ 若要使用私有 Docker 映像，請選擇**自訂映像**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。針對 **Image registry (映像登錄)** 選擇 **Other registry (其他登錄)**，然後輸入私人 Docker 映像的憑證的 ARN。登入資料必須由 Secrets Manager 建立。如需詳細資訊，請參閱《 AWS Secrets Manager使用者指南》**中的 [What Is AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
1. 在 **Service role (服務角色)** 中，執行下列其中一項作業：
+ 如果您沒有 CodeBuild 服務角色，請選擇**新服務角色**。在**角色名稱**中，輸入新角色的名稱。
+ 如果您有 CodeBuild 服務角色，請選擇**現有服務角色**。在**角色 ARN** 中，選擇服務角色。
**注意**
當您使用 主控台建立或更新組建專案時，您可以同時建立 CodeBuild 服務角色。根據預設，此角色只能與該建置專案搭配運作。如果您使用主控台將此服務角色與另一個建置專案建立關聯，則會更新此角色以與其他建置專案搭配運作。服務角色最多可以與 10 個組建專案搭配運作。
1. 展開 **Additional configuration (其他組態)**。
如果您希望 CodeBuild 使用您的 VPC：
+ 針對 **VPC**，選擇 CodeBuild 使用的 VPC ID。
+ 對於 **VPC 子網路**，選擇包含 CodeBuild 使用之資源的子網路。
+ 針對 **VPC 安全群組**，選擇 CodeBuild 用來允許存取 VPCs 中資源的安全群組。
如需詳細資訊，請參閱[AWS CodeBuild 搭配 Amazon Virtual Private Cloud 使用](vpc-support.md)。
1. 在 **Buildspec** 中，執行下列其中一項操作：
+ 選擇**使用 buildspec 檔案**以使用來源碼根目錄中的 buildspec.yml 檔案。
+ 選擇**插入建置命令**以使用主控台插入建置命令。
如需更多資訊，請參閱[Buildspec 參考](build-spec-ref.md)。
1. 在 **Artifacts (成品)** 中，針對 **Type (類型)**，執行下列其中一項操作：
+ 如果您不要建立建置輸出成品，則請選擇 **No artifacts (無成品)**。
+ 若要將建置輸出存放在 S3 儲存貯體，請選擇 **Amazon S3**，然後執行下列動作：
+ 如果您想要使用專案名稱做為組建輸出 ZIP 檔案或資料夾名稱，則請將 **Name (名稱)** 保留空白。否則請輸入名稱。根據預設，成品名稱是專案名稱。如果想使用不同的名稱，請在成品名稱方塊中輸入名稱。如果要輸出 ZIP 檔案，請包含 zip 副檔名。
+ 針對 **Bucket name (儲存貯體名稱)**，選擇輸出儲存貯體的名稱。
+ 如果您在本程序稍早選擇 **Insert build commands (插入組建命令)**，然後針對 **Output files (輸出檔案)**，輸入要放入組建輸出 ZIP 檔案或資料夾之組建中的檔案位置。針對多個位置，以逗號區隔每個位置 (例如，`appspec.yml, target/my-app.jar`)。如需詳細資訊，請參閱[Buildspec 語法](build-spec-ref.md#build-spec-ref-syntax)中的 `files` 描述。
1. 針對 **Cache type (快取類型)**，選擇以下其中一項：
+ 如果您不想要使用快取，請選擇 **No cache (無快取)**。
+ 如果您想要使用 Amazon S3 快取，請選擇 **Amazon S3**，然後執行下列動作：
+ 針對 **Bucket (儲存貯體)**，選擇存放快取的 S3 儲存貯體名稱。
+ （選用） 對於**快取路徑字首**，輸入 Amazon S3 路徑字首。**Cache path prefix (快取路徑字首)** 值類似目錄名稱。它可讓您將快取存放至儲存貯體的相同目錄下方。
**重要**
請不要在路徑字首結尾附加尾端斜線 (/)。
+ 如果您想要使用本機快取，請選擇 **Local (本機)**，然後選擇一或多個本機快取模式。
**注意**
「Docker layer cache」(Docker 層快取) 模式僅適用於 Linux。如果您選擇此模式，您的專案必須以特殊權限模式執行。
使用快取可節省大量建置時間，因為建置環境的可重複使用部分存放在快取中，並用於各建置。如需在 buildspec 檔案中指定快取的詳細資訊，請參閱[Buildspec 語法](build-spec-ref.md#build-spec-ref-syntax)。如需快取的詳細資訊，請參閱「[快取建置以改善效能](build-caching.md)」。
1. 選擇 **Create build project (建立建置專案)**。在組建專案頁面上，選擇 **Start build (啟動組建)**。
# 執行 CodeBuild 的 GitHub 提取請求和 Webhook 篩選條件範例
AWS CodeBuild 當來源儲存庫為 GitHub 時， 支援 Webhook。這表示對於在 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：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 如果顯示 CodeBuild 資訊頁面，請選擇**建立組建專案**。否則，請在導覽窗格中展開**組**建，選擇**組建專案**，然後選擇**建立組建專案**。
1. 選擇 **Create build project (建立建置專案)**。
1. 在 **Project configuration (專案組態)** 中：
**Project name (專案名稱)**
輸入此建置專案的名稱。組建專案名稱在每個 AWS 帳戶中必須是唯一的。您也可以包含建置專案的選用描述，以協助其他使用者了解此專案的用途。
1. 在 **Source (來源)** 中：
**來源提供者**
選擇 **GitHub**。請遵循說明來與 GitHub 連線 (或重新連線)，然後選擇 **Authorize (授權)**。
**儲存庫**
選擇 **Repository in my GitHub account (GitHub 帳戶中的儲存庫)**。
**GitHub 儲存庫**
輸入 GitHub 儲存庫的 URL。
1. 在**主要來源 Webhook 事件**中，選取下列項目。
**注意**
只有在您在上一個步驟**的 GitHub 帳戶中選擇儲存庫**時，才會顯示**主要來源 Webhook 事件**區段。
1. 當您建立專案時，請選取 **Rebuild every time a code change is pushed to this repository (在每次將程式碼變更推送至此儲存庫時重建)**。
1. 從 **Event type (事件類型)**，選擇一或多個事件。
1. 若要篩選事件觸發組建的時間，請在 **Start a build under these conditions (在這些情況下開始組建)** 下新增一或多個選用的篩選條件。
1. 若要篩選何時不觸發事件，請在 **Don't start a build under these conditions (在這些情況下不開始組建)** 下新增一或多個選用的篩選條件。
1. 如有需要，請選擇**新增篩選條件群組**以新增另一個篩選條件群組。
如需 GitHub Webhook 事件類型和篩選條件的詳細資訊，請參閱 [GitHub Webhook 事件](github-webhook.md)。
1. 在 **Environment (環境)** 中：
**環境映像**
選擇下列其中一項：
若要使用由 管理的 Docker 映像 AWS CodeBuild：
選擇**受管映像**，然後從**作業系統**、**執行時間**、**映像**和**映像版本**進行選擇。若可用，請從 **Environment type (環境類型)** 進行選擇。
若要使用另一個 Docker 映像：
選擇**自訂映像**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。如果您選擇**其他登錄**檔，請針對**外部登錄檔 URL**，使用 格式，在 Docker Hub 中輸入 Docker 映像檔的名稱和標籤`docker repository/docker image name`。如果您選擇 **Amazon ECR**，請使用 **Amazon ECR 儲存庫**和 **Amazon ECR 映像**來選擇 AWS 帳戶中的 Docker 映像。
若要使用私有 Docker 映像：
選擇**自訂映像**。針對**環境類型**，選擇 **ARM**、**Linux**、**Linux GPU** 或 **Windows**。針對 **Image registry (映像登錄)** 選擇 **Other registry (其他登錄)**，然後輸入私人 Docker 映像的憑證的 ARN。登入資料必須由 Secrets Manager 建立。如需詳細資訊，請參閱*AWS Secrets Manager 《 使用者指南*》中的[什麼是 AWS Secrets Manager？](https://docs.aws.amazon.com/secretsmanager/latest/userguide/)。
**服務角色**
選擇下列其中一項：
+ 如果您沒有 CodeBuild 服務角色，請選擇**新服務角色**。在**角色名稱**中，輸入新角色的名稱。
+ 如果您有 CodeBuild 服務角色，請選擇**現有服務角色**。在**角色 ARN** 中，選擇服務角色。
當您使用 主控台建立或更新組建專案時，您可以同時建立 CodeBuild 服務角色。根據預設，此角色只能與該建置專案搭配運作。如果您使用主控台將此服務角色與另一個建置專案建立關聯，則會更新此角色以與其他建置專案搭配運作。服務角色最多可以與 10 個組建專案搭配運作。
1. 在 **Buildspec** 中，執行下列其中一項操作：
+ 選擇**使用 buildspec 檔案**以使用來源碼根目錄中的 buildspec.yml 檔案。
+ 選擇**插入建置命令**以使用主控台插入建置命令。
如需更多資訊，請參閱[Buildspec 參考](build-spec-ref.md)。
1. 在 **Artifacts (成品)** 中：
**類型**
選擇下列其中一項：
+ 如果您不要建立建置輸出成品，則請選擇 **No artifacts (無成品)**。
+ 若要將建置輸出存放在 S3 儲存貯體，請選擇 **Amazon S3**，然後執行下列動作：
+ 如果您想要使用專案名稱做為組建輸出 ZIP 檔案或資料夾名稱，則請將 **Name (名稱)** 保留空白。否則請輸入名稱。根據預設，成品名稱是專案名稱。如果想使用不同的名稱，請在成品名稱方塊中輸入名稱。如果要輸出 ZIP 檔案，請包含 zip 副檔名。
+ 針對 **Bucket name (儲存貯體名稱)**，選擇輸出儲存貯體的名稱。
+ 如果您在本程序稍早選擇 **Insert build commands (插入組建命令)**，然後針對 **Output files (輸出檔案)**，輸入要放入組建輸出 ZIP 檔案或資料夾之組建中的檔案位置。針對多個位置，以逗號區隔每個位置 (例如，`appspec.yml, target/my-app.jar`)。如需詳細資訊，請參閱[Buildspec 語法](build-spec-ref.md#build-spec-ref-syntax)中的 `files` 描述。
**其他組態**
展開 **Additional configuration (其他組態)**，並適當地設定選項。
1. 選擇 **Create build project (建立建置專案)**。在 **Review (檢閱)** 頁面上，選擇 **Start build (開始建置)** 來執行建置。
## 步驟 2：確認已啟用 Webhook
1. 在 https：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 在導覽窗格中，選擇 **Build projects (建置專案)**。
1. 執行以下任意一項：
+ 選擇具有您想要驗證之 Webhook 建置專案的連結，然後選擇 **Build details (建置詳細資訊)**。
+ 選擇建置專案旁的按鈕，其中包含您要驗證的 Webhook，選擇**檢視詳細資訊**，然後選擇**建置詳細資訊**索引標籤。
1. 在**主要來源 Webhook 事件**中，選擇 **Webhook** URL 連結。
1. 在您的 GitHub 儲存庫中，在 **Settings (設定)** 頁面的 **Webhooks** 下方，確認 **Pull Requests (提取請求)** 和 **Pushes (推送)** 已選取。
1. 在您的 GitHub 設定檔設定中，在**個人設定**、**應用程式**、**授權 OAuth 應用程式**下，您應該會看到您的應用程式已獲授權存取您選取的 AWS 區域。
# 教學課程：使用 S3 進行憑證儲存的 CodeBuild 中使用 Fastlane 簽署 Apple 程式碼
[fastlane](https://docs.fastlane.tools/) 是熱門的開放原始碼自動化工具，可自動化 iOS 和 Android 應用程式的 Beta 版部署和版本。它會處理所有繁瑣的任務，例如產生螢幕擷取畫面、處理程式碼簽署，以及釋出您的應用程式。
## 先決條件
若要完成本教學課程，您必須先設定下列項目：
+ 一個 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/)之一，允許在您的本機開發環境和 CodeBuild 上進行程式碼簽署的無縫組態。Fastlane Match 會將所有程式碼簽署憑證和佈建設定檔存放在 Git 儲存庫/S3 儲存貯體/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`將 新增至 中的 `before_all `區段，`Fastfile`配對動作才能正常運作。這可確保使用具有適當許可的暫時 Fastlane 金鑰鏈。如果不使用此功能，您可能會看到建置失敗或結果不一致。
## 步驟 3：執行 `fastlane match`命令來產生個別的憑證和設定檔
指定類型 （即開發、應用程式存放區、臨機操作、企業） 的 fastlane 比對命令會在遠端存放區中無法使用時產生憑證和設定檔。憑證和設定檔將由 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：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 建立建置專案。如需詳細資訊，請參閱 [建立組建專案 (主控台)](create-project.md#create-project-console) 及 [執行建置 (主控台)](run-build-console.md)。
1. 設定您的來源提供者 （例如 GitHub、CodeCommit)。這是 iOS 專案來源儲存庫，而不是憑證儲存庫。
1. 在 **Environment (環境)** 中：
+ 選擇**預留容量**。
+ 針對**機群**，選取上面建立的機群。
+ 提供 CodeBuild 為您建立的服務角色名稱。
+ 提供下列環境變數。
+ 名稱：`MATCH_PASSWORD`、值：**、類型：Secrets Manager （在步驟 5 中為 MATCH\$1PASSWORD 建立的秘密 ARN)
+ 名稱：`FASTLANE_SESSION`、值：**、類型：Secrets Manager （在步驟 5 中為 FASTLANE\$1SESSION 建立的秘密 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。
此範例提供使用 Amazon S3 進行憑證儲存的 CodeBuild 中 Fastlane 的 iOS 程式碼簽署設定。您可能需要根據您的特定專案需求和 CodeBuild 環境來調整一些步驟。此方法利用 AWS 服務在 AWS 生態系統中增強安全性和整合。
# 教學課程：使用 GitHub 在 CodeBuild 中使用 Fastlane 簽署 Apple 程式碼以進行憑證儲存
[fastlane](https://docs.fastlane.tools/) 是熱門的開放原始碼自動化工具，可自動化 iOS 和 Android 應用程式的 Beta 版部署和版本。它會處理所有繁瑣的任務，例如產生螢幕擷取畫面、處理程式碼簽署，以及釋出您的應用程式。
此範例示範如何在在 Mac 機群上執行的 CodeBuild 專案中使用 Fastlane 設定 Apple 程式碼簽署，並將 GitHub 做為憑證和佈建設定檔的儲存體。
## 先決條件
若要完成本教學課程，您必須先設定下列項目：
+ 一個 AWS 帳戶
+ [ Apple 開發人員帳戶 ](https://developer.apple.com/)
+ 用於儲存憑證的私有 GitHub 儲存庫
+ 專案中安裝的 fastlane - 安裝 fastlane [的指南 ](https://docs.fastlane.tools/getting-started/ios/setup/)
## 步驟 1：在本機電腦上使用 GitHub 設定 Fastlane Match
[Fastlane Match](https://docs.fastlane.tools/actions/match/) 是 [ Fastlane 工具](https://fastlane.tools/)之一，允許在您的本機開發環境和 CodeBuild 上進行程式碼簽署的無縫組態。Fastlane Match 會將所有程式碼簽署憑證和佈建設定檔儲存在 Git 儲存庫/S3 儲存貯體/Google 雲端儲存中，並在需要時下載和安裝必要的憑證和設定檔。
在此範例組態中，我們將設定和使用 Git 儲存庫進行儲存。
****
1. 初始化專案中的相符項目：
```
fastlane match init
```
1. 出現提示時，請選擇 GitHub 做為儲存模式。
1. 更新您的 `*Matchfile*` 以使用 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`將 新增至 中的 `before_all `區段，`Fastfile`配對動作才能正常運作。這可確保使用具有適當許可的暫時 Fastlane 金鑰鏈。如果不使用此功能，您可能會看到建置失敗或結果不一致。
## 步驟 3：執行 `fastlane match`命令來產生個別的憑證和設定檔
指定類型 （即開發、應用程式存放區、臨機操作、企業） 的 fastlane 比對命令會在遠端存放區中無法使用時產生憑證和設定檔。憑證和設定檔將由 fastlane 存放在 GitHub 中。
```
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 主控台上產生 PAT。如需詳細資訊，請參閱下列指南：https：//[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：//[https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) 開啟 AWS CodeBuild 主控台。
1. 建立建置專案。如需詳細資訊，請參閱 [建立組建專案 (主控台)](create-project.md#create-project-console) 及 [執行建置 (主控台)](run-build-console.md)。
1. 設定您的來源提供者 （例如 GitHub、CodeCommit)。這是 iOS 專案來源儲存庫，而不是憑證儲存庫。
1. 在 **Environment (環境)** 中：
+ 選擇**預留容量**。
+ 針對**機群**，選取上面建立的機群。
+ 提供 CodeBuild 為您建立的服務角色名稱。
+ 提供下列環境變數。
+ 名稱：`MATCH_PASSWORD`、值：**、類型：Secrets Manager （在步驟 5 中為 MATCH\$1PASSWORD 建立的秘密 ARN)
+ 名稱：`FASTLANE_SESSION`、值：**、類型：Secrets Manager （在步驟 5 中為 FASTLANE\$1SESSION 建立的秘密 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 Developer 帳戶具有必要的憑證和設定檔，而且 Xcode 專案中的套件識別符符合佈建設定檔中的項目。
## 安全考量
以下是本教學課程的安全考量。
+ 將憑證的 GitHub 儲存庫保持私有，並定期稽核存取權。
+ 考慮使用 AWS Secrets Manager 來儲存敏感資訊，例如 MATCH\$1PASSWORD 和 FASTLANE\$1SESSION。
此範例提供使用 GitHub 進行憑證儲存的 CodeBuild 中 Fastlane 的 iOS 程式碼簽署設定。您可能需要根據您的特定專案需求和 CodeBuild 環境來調整一些步驟。此方法利用 AWS 服務在 AWS 生態系統中增強安全性和整合。
# 使用語意版本控制在建置時間設定成品名稱
此範例包含 buildspec 範例檔案，示範如何指定建置時所建立的成品名稱。buildspec 檔案中指定的名稱可以包含 Shell 命令和環境變數，而變成唯一的名稱。您在 buildspec 檔案中指定的名稱，將會覆寫您建立專案時在主控台輸入的名稱。
如果您建立多次，則使用 buildspec 檔案中指定的成品名稱可確保輸出成品檔名是唯一的。例如，您可以使用建置時插入成品名稱中的日期和時間戳記。
如果您要以 buildspec 檔案中的名稱覆寫您在主控台輸入的成品名稱，請執行下列操作：
1. 將組建專案設定成以 buildspec 檔案中的名稱來覆寫成品名稱。
+ 如果使用主控台來建立組建專案，請選取 **Enable semantic versioning (啟用語意版本控制)**。如需詳細資訊，請參閱[建立組建專案 (主控台)](create-project.md#create-project-console)。
+ 如果您使用 AWS CLI，請在傳遞給 的 JSON 格式檔案中將 `overrideArtifactName`設定為 true`create-project`。如需詳細資訊，請參閱[建立建置專案 (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)。