本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

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

完成 中的步驟後[CodePipeline 入門](getting-started-codepipeline.md)，您可以嘗試本使用者指南中的其中一個 AWS CodePipeline 教學課程。

**Topics**
+ [

# 教學課程：使用 CodePipeline 部署至 Amazon EC2 執行個體
](tutorials-ec2-deploy.md)
+ [

# 教學課程：使用 CodePipeline (V2 類型） 建置 Docker 映像並將其推送至 Amazon ECR
](tutorials-ecr-build-publish.md)
+ [

# 教學課程：使用 CodePipeline 部署至 Amazon EKS
](tutorials-eks-deploy.md)
+ [

# 教學課程：建立以運算 (V2 類型） 執行命令的管道
](tutorials-commands.md)
+ [

# 教學課程：使用 Git 標籤啟動您的管道
](tutorials-github-tags.md)
+ [

# 教學課程：篩選分支名稱，以取得啟動管道的提取請求 (V2 類型）
](tutorials-github-featurebranches.md)
+ [

# 教學課程：使用管道層級變數
](tutorials-pipeline-variables.md)
+ [

# 教學：建立簡易管道 (S3 儲存貯體)
](tutorials-simple-s3.md)
+ [

# 教學課程：建立簡單的管道 (CodeCommit 儲存庫）
](tutorials-simple-codecommit.md)
+ [

# 教學：建立四階段管道
](tutorials-four-stage-pipeline.md)
+ [

# 教學課程：設定 CloudWatch Events 規則以接收管道狀態變更的電子郵件通知
](tutorials-cloudwatch-sns-notifications.md)
+ [

# 教學課程：建立使用 建置和測試 Android 應用程式的管道 AWS Device Farm
](tutorials-codebuild-devicefarm.md)
+ [

# 教學課程：建立使用 測試 iOS 應用程式的管道 AWS Device Farm
](tutorials-codebuild-devicefarm-S3.md)
+ [

# 教學課程：建立部署至 Service Catalog 的管道
](tutorials-S3-servicecatalog.md)
+ [

# 教學課程：使用 建立管道 AWS CloudFormation
](tutorials-cloudformation.md)
+ [

# 教學課程：建立使用 AWS CloudFormation 部署動作變數的管道
](tutorials-cloudformation-action.md)
+ [

# 教學課程：使用 CodePipeline 進行 Amazon ECS 標準部署
](ecs-cd-pipeline.md)
+ [

# 教學課程：使用 Amazon ECR 來源和 ECS-to-CodeDeploy 部署建立管道
](tutorials-ecs-ecr-codedeploy.md)
+ [

# 教學：建立部署 Amazon Alexa 技能的管道
](tutorials-alexa-skills-kit.md)
+ [

# 教學課程：建立使用 Amazon S3 做為部署提供者的管道
](tutorials-s3deploy.md)
+ [

# 教學課程：建立將無伺服器應用程式發佈至 的管道 AWS Serverless Application Repository
](tutorials-serverlessrepo-auto-publish.md)
+ [

# 教學課程：使用 CodePipeline 進行 Lambda 函數部署
](tutorials-lambda-deploy.md)
+ [

# 教學課程：搭配 Lambda 叫用動作使用變數
](tutorials-lambda-variables.md)
+ [

# 教學課程：在管道中使用 AWS Step Functions 叫用動作
](tutorials-step-functions.md)
+ [

# 教學課程：建立使用 AWS AppConfig 做為部署提供者的管道
](tutorials-AppConfig.md)
+ [

# 教學課程：搭配 GitHub 管道來源使用完整複製
](tutorials-github-gitclone.md)
+ [

# 教學課程：搭配 CodeCommit 管道來源使用完整複製
](tutorials-codecommit-gitclone.md)
+ [

# 教學課程：使用 AWS CloudFormation StackSets 部署動作建立管道
](tutorials-stackset-deployment.md)
+ [

# 教學課程：建立管道的變數檢查規則做為進入條件
](tutorials-varcheckrule.md)

# 教學課程：使用 CodePipeline 部署至 Amazon EC2 執行個體
<a name="tutorials-ec2-deploy"></a>

本教學課程可協助您在 CodePipeline 中建立部署動作，將您的程式碼部署到您在 Amazon EC2 中設定的執行個體。

**注意**  
在主控台中建立管道時，CodePipeline 將使用 S3 成品儲存貯體做為成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
部署動作僅適用於 V2 `EC2` 類型管道。

## 先決條件
<a name="tutorials-ec2-deploy-prereqs"></a>

您必須先有幾個資源，才能使用此教學來建立 CD 管道。以下是在開始使用前需準備的事項：

**注意**  
所有這些資源都應在相同區域內建立 AWS 。
+ 來源控制儲存庫 （本教學課程使用 GitHub)，您將在其中新增範例`script.sh`檔案。
+ 您必須使用已透過此動作許可更新的現有 CodePipeline 服務角色。若要更新您的服務角色，請參閱 [EC2 部署動作的服務角色政策許可](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action)。

滿足這些先決條件之後，即可繼續教學並建立 CD 管道。

## 步驟 1：建立 Amazon EC2 Linux 執行個體
<a name="tutorials-ec2-deploy-instances"></a>

在此步驟中，您會建立要在其中部署範例應用程式的 Amazon EC2 執行個體。在此程序中，如果您尚未在要建立資源的區域中建立執行個體角色，請在 IAM 中建立執行個體角色。

**建立執行個體角色**

1. 開啟 IAM 主控台，網址為 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

1. 從主控台儀表板，選擇 **Roles (角色)**。

1. 選擇建**立角色**。

1. 在**選取信任實體類型**下，選取 **AWS 服務**。在**選擇使用案例**下，選取 **EC2**。在 **Select your use case (選取您的使用案例)** 下，選擇 **EC2**。選擇**下一步**。

1. 搜尋並選取名為 的政策**`AmazonSSMManagedEC2InstanceDefaultPolicy`**。

1. 搜尋並選取名為 的政策**`AmazonSSMManagedInstanceCore`**。選擇下**一步：標籤**。

1. 選擇下**一步：檢閱**。輸入角色的名稱 (例如，**EC2InstanceRole**)。
**注意**  
記下您的角色名稱，以用於下一個步驟。您會在建立執行個體時選擇此角色。
**注意**  
您將為此角色新增許可，以允許在管道建立後存取管道的 S3 成品儲存貯體。

   選擇建**立角色**。

**啟動執行個體**

1. 前往 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在側邊導覽中，選擇**執行個體**，然後從頁面頂端選取**啟動執行個體**。

1. 在**名稱**中，輸入 **MyInstances**。這會將標籤**索引鍵** **Name**和標籤**值** 指派給執行個體**MyInstances**。

1. 在**應用程式和作業系統映像 (Amazon Machine Image)** 下，找到具有 AWS 標誌的 **Amazon Linux** AMI 選項，並確認已選取。（此 AMI 描述為 Amazon Linux 2 AMI (HVM)，並標記為「免費方案合格」。)

1. 在**執行個體類型**下，選擇符合免費方案的`t2.micro`類型做為執行個體的硬體組態。

1. 在**金鑰對 （登入）** 下，選擇金鑰對或建立一個金鑰對。

1. 在**網路設定**下，確定狀態為**啟用**。

1. 展開 **Advanced Details** (進階詳細資訊)。在 **IAM 執行個體描述檔**中，選擇您在先前程序中建立的 IAM 角色 （例如 **EC2InstanceRole**)。
**注意**  
請勿將執行個體角色保留空白，因為這會建立預設角色，而且不會選取您建立的角色。

1. 在**摘要**下，於**執行個體數量**下，輸入 `2`。

1. 選擇**啟動執行個體**。

1. 您可以在 **Instances (執行個體)** 頁面上檢視啟動狀態。當您啟動執行個體時，其初始狀態是 `pending`。在執行個體啟動後，其狀態會變更為 `running`，並得到公有的 DNS 名稱。(如果 **Public DNS (公有 DNS)** 欄未顯示，請選擇 **Show/Hide (顯示/隱藏)** 圖示，然後選擇 **Public DNS (公有 DNS)**。)

## 步驟 2：將成品儲存貯體許可新增至 EC2 執行個體角色
<a name="tutorials-ec2-deploy-role-s3"></a>

您必須更新為執行個體建立的 EC2 執行個體角色，以允許它存取管道的成品儲存貯體。

**注意**  
建立執行個體時，您可以建立或使用現有的 EC2 執行個體角色。若要避免`Access Denied`錯誤，您必須將 S3 儲存貯體許可新增至執行個體角色，才能將執行個體許可授予 CodePipeline 成品儲存貯體。建立預設角色，或使用範圍縮小為管道區域成品儲存貯體的`s3:GetObject`許可來更新現有角色。

1. 在 CodePipeline 主控台中導覽至您的管道。選擇**設定**。檢視現有管道的成品存放區名稱和位置。記下成品儲存貯體 Amazon Resource Name (ARN) 並將其複製。

1. 導覽至 IAM 主控台，然後選擇 **Roles** (角色)。選擇您在本教學課程的步驟 1 中建立的執行個體角色。

1. 在**許可**標籤上，選擇**新增內嵌政策**。

1. 將下列 JSON 新增至政策文件，將 `Resource` 欄位中的值取代為儲存貯體 ARN。

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

1. 選擇**更新**。

## 步驟 3：將指令碼檔案新增至您的儲存庫
<a name="tutorials-ec2-deploy-file"></a>

貼上此範例文字，為部署中的後製指令碼步驟建立 `script.sh` 檔案。

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

**將 `script.sh` 檔案新增至來源儲存庫**

1. 開啟文字編輯器，然後將上面的檔案複製並貼到新的檔案中。

1. 遞交您的 `script.sh` 檔案並將之推送至來源儲存庫。

   1. 新增檔案。

      ```
      git add .
      ```

   1. 遞交變更。

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

   1. 推送認可。

      ```
      git push
      ```

   記下儲存庫中的路徑。

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

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

使用 CodePipeline 精靈建立管道階段並連接來源儲存庫。

**建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**使用現有的服務角色**，然後選擇已更新此動作所需許可的 CodePipeline 服務角色。若要為此動作設定 CodePipeline 服務角色，請參閱 [EC2 部署動作的服務角色政策許可](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action)。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

   1. 在**儲存庫名稱**中，選擇 GitHub 儲存庫的名稱。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**頁面上，選擇**略過**。

1. 在**步驟 5：新增部署階段**頁面上，選擇 **EC2**。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ec2deploy-action.png)

   1. 針對**目標目錄**，在您要部署的執行個體上輸入目錄，例如 `/home/ec2-user/testhelloworld`。
**注意**  
指定您希望動作在執行個體上使用的部署目錄。動作會自動在執行個體上建立指定的目錄，做為部署的一部分。

   1. 在 **PostScript** 中，輸入指令碼的路徑和檔案名稱，例如 `test/script.sh`。

   1. 選擇**下一步**。

1. 在 **Step 6: Review** (步驟 6：檢閱) 頁面上，檢閱您的管道組態，然後選擇 **Create pipeline** (建立管道) 來建立管道。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ec2deploy-pipeline.png)

1. 管道成功執行後，請選擇**檢視詳細資訊**以檢視動作上的日誌，以檢視受管運算動作輸出。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ec2deploy-logs.png)  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ec2deploy-logs2.png)

## 步驟 5：測試您的管道
<a name="tutorials-ec2-deploy-test"></a>

您的管道應具備執行end-to-end原生 AWS 持續部署所需的一切。現在，將程式碼變更推送至來源儲存庫，以測試其功能。

**測試管道**

1. 對設定的來源儲存庫進行程式碼變更、遞交並推送變更。

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 從清單中選擇管道。

1. 觀看管道階段的管道進度。您的管道應該完成，而且您的動作會在執行個體上部署指令碼。

1. 如需更多故障診斷資訊，請參閱 [EC2 部署動作失敗並顯示錯誤訊息 `No such file`](troubleshooting.md#troubleshooting-ec2-deploy)。

# 教學課程：使用 CodePipeline (V2 類型） 建置 Docker 映像並將其推送至 Amazon ECR
<a name="tutorials-ecr-build-publish"></a>

本教學課程可協助您在 CodePipeline 中建立建置動作，在原始程式碼變更後執行 Docker 映像並將其推送至 Amazon ECR。本教學課程也說明如何新增部署推送映像的 Amazon ECS 部署動作。

**重要**  
在主控台中建立管道時，CodePipeline 將使用 S3 成品儲存貯體做為成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
本教學課程適用於具有 GitHub 來源儲存庫的 CodePipeline 管道的 ECRBuildAndPublish 建置動作，以及用於部署至 Amazon ECS 叢集的 Amazon ECS 標準動作。如需使用管道搭配 ECR 映像儲存庫做為 CodePipeline 中 Amazon ECS 至 CodeDeploy 藍/綠部署動作來源的教學課程，請參閱 [教學課程：使用 Amazon ECR 來源和 ECS-to-CodeDeploy 部署建立管道](tutorials-ecs-ecr-codedeploy.md)。

**重要**  
此動作使用 CodePipeline 受管 CodeBuild 運算在建置環境中執行命令。執行命令動作會產生個別費用 AWS CodeBuild。

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

您必須先有幾個資源，才能使用此教學來建立 CD 管道。以下是在開始使用前需準備的事項：

**注意**  
所有這些資源都應在相同區域內建立 AWS 。
+ 來源控制儲存庫 （本教學課程使用 GitHub)，您將在此教學課程中新增下列項目：
  + 在步驟 1 中，您將新增範例 Dockerfile 到您的來源儲存庫，做為 CodePipeline 中 ECRBuildAndPublish 建置動作的輸入成品。
  + 在步驟 2 中，您將新增範例 imagedefinitions.json 檔案到來源儲存庫，作為 CodePipeline 中 Amazon ECS 標準部署動作的需求。
+ Amazon ECR 映像儲存庫，其中包含您從 Dockerfile 建置的映像。如需詳細資訊，請參閱《*Amazon Elastic Container Registry 使用者指南*》中的[建立儲存庫](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html)和[推送映像](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html)。
+ 在與映像儲存庫相同的區域中建立的 Amazon ECS 叢集和服務。如需詳細資訊，請參閱《Amazon Elastic Container Service 開發人員指南》中的[建立叢集](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html)和[建立](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service.html)服務。 **

滿足這些先決條件之後，即可繼續教學並建立 CD 管道。

## 步驟 1：將 Dockerfile 新增至來源儲存庫
<a name="tutorials-ecr-build-publish-file"></a>

本教學課程使用 ECRBuildAndPublish 動作來建置 Docker 映像，並將映像推送至 Amazon ECR。CodePipeline 中的受管運算動作會使用 CodeBuild 來執行 ECR 登入和映像推送的命令。您不需要將`buildspec.yml`檔案新增至原始程式碼儲存庫，即可告知 CodeBuild 如何執行此操作。對於此範例，您只能在儲存庫中提供 Dockerfile，如下所示。

貼上此範例文字以建立 `Dockerfile` 檔案。此範例 Dockerfile 與先決條件中 ECR 映像指示中使用的範例相同。

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

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

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

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

EXPOSE 80

CMD /root/run_apache.sh
```

**將 `Dockerfile` 檔案新增至來源儲存庫**

1. 開啟文字編輯器，然後將上面的 Dockerfile 複製並貼到新的檔案中。

1. 遞交您的 `Dockerfile` 檔案並將之推送至來源儲存庫。

   1. 新增檔案。

      ```
      git add .
      ```

   1. 遞交變更。

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

   1. 推送認可。

      ```
      git push
      ```

   請務必將 檔案放在儲存庫的根層級。

   ```
   / Dockerfile
   ```

## 步驟 2：將 imagedefinitions.json 檔案新增至來源儲存庫
<a name="w2aac13b9c15"></a>

本教學課程使用 CodePipeline theAmazon ECS 標準部署動作，將您的容器部署到 Amazon ECS 叢集。Amazon ECS 標準部署動作需要包含映像名稱和 URI 的 imagedefinitions.json 檔案。如需 imagedefinitions.json 檔案的詳細資訊，請參閱 [Amazon ECS 標準部署動作的 imagedefinitions.json 檔案](file-reference.md#pipelines-create-image-definitions)。

貼上此範例文字以建立 `imagedefinitions.json` 檔案。使用 Dockerfile 中的名稱，例如 `hello-world`，並使用存放映像的 Amazon ECR 儲存庫中的 URI。

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

**將 `imagedefinitions.json` 檔案新增至來源儲存庫**

1. 開啟文字編輯器，然後將上述範例複製並貼到新的檔案中。

1. 遞交您的 `imagedefinitions.json` 檔案並將之推送至來源儲存庫。

   1. 新增檔案。

      ```
      git add .
      ```

   1. 遞交變更。

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

   1. 推送認可。

      ```
      git push
      ```

   請務必將 檔案放在儲存庫的根層級。

   ```
   / imagedefinitions.json
   ```

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

使用 CodePipeline 精靈建立管道階段並連接來源儲存庫。

**建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

   1. 在**儲存庫名稱**中，選擇 GitHub 儲存庫的名稱。

   1. 在**預設分支**中，選擇您希望在管道手動啟動時或來源事件不是 Git 標籤時指定的分支。如果變更的來源不是觸發條件，或者是手動啟動管道執行，則所使用的變更將是來自預設分支的 HEAD 遞交。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**頁面上，選擇**其他建置提供者**選擇 **ECRBuildAndPublish**。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ecrbuild-wizard.png)

   1. 針對 **ECR 儲存庫名稱**，選擇您的映像儲存庫。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**。您將在下列步驟中新增 ECS 動作。

1. 在**步驟 7：檢閱**頁面上，檢閱管道組態，然後選擇**建立管道**以建立管道。

1. 編輯管道，將 Amazon ECS 部署動作新增至管道：

   1. 在右上角，選擇 **Edit (編輯)**。

   1. 在圖表的底部，選擇 **\$1 Add stage (\$1 新增階段)**。在 **Stage name (階段名稱)** 中，輸入名稱，例如 **Deploy**。

   1. 選擇 **\$1 Add action group (\$1 新增動作群組)**。

   1. 在 **​Action name (動作名稱)** 中，輸入名稱。

   1. 在**動作提供者**中，選擇 Amazon ECS。允許 **Region (區域)** 預設為管道區域。

   1. 在**輸入成品**中，從來源階段選擇輸入成品，例如 `SourceArtifact`。

   1. 針對**叢集名稱**，選擇服務執行所在的 Amazon ECS 叢集。

   1. 針對**服務名稱**，選擇要更新的服務。

   1. 選擇**儲存**。

   1. 在您編輯的階段上，選擇 **Done (完成)**。在 AWS CodePipeline 窗格中，選擇 **Save (儲存)**，然後在警告訊息中選擇 **Save (儲存)**。

   1. 若要提交您的變更並啟動管道建置，請選擇 **​Release change (發行變更)**，然後選擇 **​Release (發行)**。

1. 管道執行後，檢視管道結構和狀態。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ecrbuild-ecsaction.png)

1. 管道成功執行後，請選擇**檢視詳細資訊**以檢視動作上的日誌，以檢視受管運算動作輸出。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ecrbuild-logs.png)

1. 故障診斷任何失敗的動作。例如，如果 imagedefinitions.json 檔案不在來源儲存庫中，則 ECS 部署動作可能會失敗。以下是當 imagedefinitions.json 檔案遺失時顯示的錯誤訊息範例。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ecrbuild-ecsdebug.png)

## 步驟 4：測試管道
<a name="tutorials-ecr-build-publish-test"></a>

您的管道應具備執行end-to-end原生 AWS 持續部署所需的一切。現在，將程式碼變更推送至來源儲存庫，以測試其功能。

**測試管道**

1. 對設定的來源儲存庫進行程式碼變更、遞交並推送變更。

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 從清單中選擇管道。

1. 觀看管道階段的管道進度。您的管道應該完成，而且您的動作會將 Docker 映像推送至從程式碼變更建立的 ECR。

# 教學課程：使用 CodePipeline 部署至 Amazon EKS
<a name="tutorials-eks-deploy"></a>

本教學課程可協助您在 CodePipeline 中建立部署動作，將您的程式碼部署到您在 Amazon EKS 中設定的叢集。

EKS 動作同時支援公有和私有 EKS 叢集。私有叢集是 EKS 建議的類型；不過，支援這兩種類型。

**注意**  
在主控台中建立管道時，CodePipeline 將使用 S3 成品儲存貯體做為成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
此動作使用 CodePipeline 受管 CodeBuild 運算在建置環境中執行命令。執行命令動作會產生個別費用 AWS CodeBuild。

**注意**  
部署動作僅適用於 V2 `EKS` 類型管道。

## 先決條件
<a name="tutorials-eks-deploy-prereqs"></a>

您必須先有幾個資源，才能使用此教學來建立 CD 管道。以下是在開始使用前需準備的事項：

**注意**  
所有這些資源都應在相同區域內建立 AWS 。
+ 來源控制儲存庫 （本教學課程使用 GitHub)，您將在其中新增範例`deployment.yaml`檔案。
+ 您必須使用現有的 CodePipeline 服務角色，使用以下動作的許可進行更新[步驟 3：更新 IAM 中的 CodePipeline 服務角色政策](#tutorials-eks-deploy-role)。所需的許可取決於您建立的叢集類型。如需詳細資訊，請參閱[服務角色政策許可](action-reference-EKS.md#action-reference-EKS-service-role)。
+ 您已推送至 ECR 或映像儲存庫的工作映像和儲存庫標籤。

滿足這些先決條件之後，即可繼續教學並建立 CD 管道。

## 步驟 1：（選用） 在 Amazon EKS 中建立叢集
<a name="tutorials-eks-deploy-cluster"></a>

您可以選擇使用公有或私有端點建立 EKS 叢集。

在下列步驟中，您會在 EKS 中建立公有或私有叢集。如果您已建立叢集，則此步驟為選用。

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

在此步驟中，您會在 EKS 中建立叢集。

**建立公有叢集**

1. 開啟 EKS 主控台，然後選擇**建立叢集**。

1. 在**名稱**中，為您的叢集命名。選擇**下一步**。

1. 選擇**建立**。

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

如果您選擇使用私有端點建立叢集，請務必僅連接私有子網路，並確保其具有網際網路連線。

遵循接下來的五個子步驟來建立具有私有端點的叢集。

**在主控台中建立 VPC**

1. 開啟 VPC 主控台，然後選擇**建立 VPC**。

1. 在 **VPC 設定**下，選擇 **VPC 和更多**。

1. 選擇 建立一個公有和 4 個私有子網路。選擇**建立 VPC**。

1. 在子網路頁面上，選擇**私有**。

**判斷 VPC 中的私有子網路**

1. 導覽至您的 VPC，然後選擇 VPC ID 以開啟 VPC 詳細資訊頁面。

1. 在 VPC 詳細資訊頁面上，選擇**資源映射**索引標籤。

1. 檢視圖表並記下您的私有子網路。子網路會顯示標籤，指出公有或私有狀態，且每個子網路都會對應至路由表。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/eks-deploy-subnets.png)

   請注意，私有叢集將擁有所有私有子網路。

1. 建立公有子網路以託管 NAT 閘道。您一次只能連接一個網際網路閘道至 VPC。

**在公有子網路中建立 NAT 閘道**

1. 在公有子網路中，建立 NAT 閘道。導覽至 VPC 主控台，然後選擇**網際網路閘道**。選擇**建立網際網路閘道**。

1. 在名稱中，輸入網際網路閘道的名稱。選擇**建立網際網路閘道**。

更新私有子網路的路由表，將流量導向 NAT 閘道。

**將 NAT 閘道新增至私有子網路的路由表**

1. 導覽至 VPC 主控台，然後選擇**子網路**。

1. 針對每個私有子網路，選擇它，然後在詳細資訊頁面上選擇該子網路的路由表，選擇**編輯路由表**。

1. 更新私有子網路的路由表，將網際網路流量導向 NAT 閘道。選擇 **Add route** (新增路由)。從要新增的選項中選擇 **NAT 閘道**。選擇您建立的網際網路閘道。

1. 針對公有子網路，建立自訂路由表。確認公有子網路的網路存取控制清單 (ACL) 允許來自私有子網路的傳入流量。

1. 選擇**儲存變更**。

在此步驟中，您會在 EKS 中建立叢集。

**建立私有叢集**

1. 開啟 EKS 主控台，然後選擇**建立叢集**。

1. 在**名稱**中，為您的叢集命名。選擇**下一步**。

1. 指定您的 VPC 和其他組態資訊。選擇**建立**。

EKS 叢集可以是公有或私有叢集。此步驟適用於只有私有端點的叢集。如果您的叢集是私有的。

## 步驟 2：在 Amazon EKS 中設定私有叢集
<a name="tutorials-eks-deploy-cluster-private-configure"></a>

只有在您已建立私有叢集時，此步驟才適用。此步驟適用於只有私有端點的叢集。

**設定您的叢集**

1. 僅在**網路**索引標籤下的 EKS 叢集中連接私有子網路。在 下的**判斷 VPC 中的私有子網路區段中連接擷取的私有子網路**[步驟 1：（選用） 在 Amazon EKS 中建立叢集](#tutorials-eks-deploy-cluster)。

1. 請確定私有子網路可存取網際網路，因為 CodePipeline 會儲存並從管道的 S3 成品儲存貯體擷取成品。

## 步驟 3：更新 IAM 中的 CodePipeline 服務角色政策
<a name="tutorials-eks-deploy-role"></a>

在此步驟中，您將更新現有的 CodePipeline 服務角色，例如 `cp-service-role`，具有 CodePipeline 與叢集連線所需的許可。如果您沒有現有角色，請建立新的角色。

使用下列步驟更新您的 CodePipeline 服務角色。

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

1. 開啟 IAM 主控台，網址為 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

1. 從主控台儀表板，選擇 **Roles (角色)**。

1. 查詢 CodePipeline 服務角色，例如 `cp-service-role`。

1. 新增內嵌政策。

1. 在**政策編輯器**中，輸入以下內容。
   + 針對公有叢集，新增下列許可。

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

****  

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

------
   + 針對私有叢集，新增下列許可。如果適用，私有叢集將需要 VPC 的額外許可。

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

****  

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

------

1. 選擇**更新政策**。

## 步驟 4：建立 CodePipeline 服務角色的存取項目
<a name="tutorials-eks-deploy-access-entry"></a>

在此步驟中，您會在叢集上建立存取項目，以新增您在步驟 3 中更新的 CodePipeline 服務角色，以及受管存取政策。

1. 開啟 EKS 主控台並導覽至您的叢集。

1. 選擇**存取**索引標籤。

1. 在 **IAM 存取項目**下，選擇**建立存取項目**。

1. 在 **IAM 主體 ARN** 中，輸入您剛為動作更新的角色，例如 `cp-service-role`。選擇**下一步**。

1. 在**步驟 2：新增存取政策**頁面上，在**政策名稱**中，選擇存取的受管政策，例如 `AmazonEKSClusterAdminPolicy`。選擇 **Add Policy (新增政策)**。選擇**下一步**。
**注意**  
這是 CodePipeline 動作用來與 Kubernetes 交談的政策。最佳實務是，若要以最低權限縮減政策中的許可範圍，而非管理政策，請改為連接自訂政策。

1. 在檢閱頁面上，選擇**建立**。

## 步驟 5：建立來源儲存庫並新增`helm chart`組態檔案
<a name="tutorials-eks-deploy-source"></a>

在此步驟中，您會建立適合您 動作的組態檔案 (Kubernetes 資訊清單檔案或 Helm Chart)，並將組態檔案存放在來源儲存庫中。為您的組態使用適當的檔案。如需詳細資訊，請參閱 [https://kubernetes.io/docs/reference/kubectl/quick-reference/](https://kubernetes.io/docs/reference/kubectl/quick-reference/)：// 或 [https://helm.sh/docs/topics/charts/](https://helm.sh/docs/topics/charts/)：//。
+ 對於 Kubernetes，請使用資訊清單檔案。
+ 對於 Helm，請使用 Helm Chart。

1. 建立或使用現有的 GitHub 儲存庫。

1. 在儲存庫中為您的 Helm Chart 檔案建立新的結構，如以下範例所示。

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

1. 將 檔案新增至儲存庫的根層級。

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

使用 CodePipeline 精靈建立管道階段並連接來源儲存庫。

**建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyEKSPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇您在步驟 3 中更新的服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**頁面上，針對**來源提供者**，選擇**建立 GitHub 儲存庫的連線**。

1. 在**步驟 4：新增建置階段**頁面上，選擇**略過**。

1. 在**步驟 5：新增部署階段**頁面上，選擇 **Amazon EKS**。  
![\[Deploy configuration form with Helm selected, showing fields for release name and chart location.\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/eks-action-example.png)

   1. 在**部署組態類型**下，選擇 **Helm**。

   1. 在 **Helm Chart 位置**中，輸入發行名稱，例如 `my-release`。針對 **Helm Chart 位置**，輸入 Helm Chart 檔案的路徑，例如 `mychart`。

   1. 選擇**下一步**。

1. 在 **Step 6: Review** (步驟 6：檢閱) 頁面上，檢閱您的管道組態，然後選擇 **Create pipeline** (建立管道) 來建立管道。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/eks-deploy-pipeline.png)

1. 管道成功執行後，請選擇**檢視詳細資訊**以檢視動作上的日誌，以檢視動作輸出。

# 教學課程：建立以運算 (V2 類型） 執行命令的管道
<a name="tutorials-commands"></a>

在本教學課程中，您會設定管道，在建置階段中使用 Commands 動作持續執行提供的建置命令。如需 命令動作的詳細資訊，請參閱 [命令動作參考](action-reference-Commands.md)。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

## 先決條件
<a name="tutorials-commands-prereq"></a>

您必須已擁有下列各項目：
+ GitHub 儲存庫。您可以使用您在 中建立的 GitHub 儲存庫[教學課程：搭配 GitHub 管道來源使用完整複製](tutorials-github-gitclone.md)。

## 步驟 1：建立來源檔案並推送到您的 GitHub 儲存庫
<a name="tutorials-commands-push"></a>

在本節中，您會建立範例來源檔案，並將其推送至管道用於來源階段的儲存庫。在此範例中，您會產生並推送下列項目：
+ `README.txt` 檔案。

**建立來源檔案**

1. 使用下列文字建立檔案：

   ```
   Sample readme file
   ```

1. 儲存檔案為 `README.txt`。

**將檔案推送到您的 GitHub 儲存庫**

1. 將檔案推送或上傳至 儲存庫。這些檔案是 **Create Pipeline (建立管道)** 精靈針對 AWS CodePipeline中的部署動作所建立的來源成品。在本機目錄中，您的檔案應該如下所示：

   ```
   README.txt
   ```

1. 若要在您的本機電腦上從複製的儲存庫中使用 Git 命令列：

   1. 請執行下列命令來同時將所有檔案放入階段：

      ```
      git add -A
      ```

   1. 執行下列命令，使用遞交訊息遞交檔案。

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

   1. 執行下列命令來從本機儲存庫推送檔案到您的 ​ 儲存庫：

      ```
      git push
      ```

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

在本節中，您可以採取下列動作建立管道：
+ 儲存來源檔案的儲存庫具有 GitHub （透過 GitHub 應用程式） 動作的來源階段。
+ 具有 Commands 動作的建置階段。

**使用精靈建立管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyCommandsPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。
**注意**  
如果您使用現有的服務角色，若要使用 命令動作，您需要為服務角色新增下列許可。使用服務角色政策陳述式中的資源型許可，將許可範圍縮小到管道資源層級。如需詳細資訊，請參閱 中的政策範例[服務角色政策許可](action-reference-Commands.md#action-reference-Commands-policy)。  
logs:CreateLogGroup
logs:CreateLogStream
logs:PutLogEvents

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

   1. 在**儲存庫名稱**中，選擇 GitHub.com 儲存庫的名稱。

   1. 在**預設分支**中，選擇您希望在管道手動啟動時或來源事件不是 Git 標籤時指定的分支。如果變更的來源不是觸發條件，或者是手動啟動管道執行，則所使用的變更將是來自預設分支的 HEAD 遞交。或者，您也可以使用篩選來指定 Webhook （觸發器）。如需詳細資訊，請參閱[使用觸發和篩選來自動化啟動管道](pipelines-triggers.md)。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**命令**。
**注意**  
執行 Commands 動作會在 中產生個別費用 AWS CodeBuild。

   輸入下列命令：

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

   選擇**下一步**。  
![\[步驟 4：使用 Commands 動作新增新管道的建置階段頁面\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/commands-wizard-screen.png)

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**中，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

1. 建立動作的最後一步是將環境變數新增至動作，這會導致動作的輸出變數。在命令動作上，選擇**編輯**。在**編輯**畫面上，透過`compute`在變數命名空間欄位中輸入 ，為您的動作指定**變數命名空間**。

   新增 CodeBuild 輸出變數 `AWS_Default_Region`，然後選擇**新增變數**。  
![\[命令動作的編輯頁面\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/commands-output-edit-var.png)

## 步驟 3：執行管道並驗證建置命令
<a name="tutorials-commands-update"></a>

釋出變更以執行您的管道。透過檢視執行歷史記錄、建置日誌和輸出變數來驗證建置命令是否執行。

**檢視動作日誌和輸出變數**

1. 管道成功執行後，您可以檢視 動作的日誌和輸出。

1. 若要檢視動作的輸出變數，請選擇**歷史記錄**，然後選擇**時間軸**。

   檢視新增至動作的輸出變數。Commands 動作的輸出會顯示解析至動作區域的輸出變數。  
![\[命令動作的輸出，顯示已解析至動作區域的輸出變數\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/commands-output-variable.png)

1. 若要檢視動作的日誌，請選擇**檢視成功命令動作**的詳細資訊。檢視 Commands 動作的日誌。  
![\[Commands 動作的範例日誌\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/commands-output-logs.png)

# 教學課程：使用 Git 標籤啟動您的管道
<a name="tutorials-github-tags"></a>

在本教學課程中，您將建立連線至 GitHub 儲存庫的管道，其中針對 Git 標籤觸發類型設定來源動作。在遞交上建立 Git 標籤時，您的管道會啟動。此範例說明如何建立管道，允許根據標籤名稱的語法篩選標籤。如需使用 glob 模式篩選的詳細資訊，請參閱 [使用語法中的 glob 模式](syntax-glob.md)。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

本教學課程會透過 `CodeStarSourceConnection`動作類型連線至 GitHub。

**注意**  
此功能不適用於亞太區域 （香港）、非洲 （開普敦）、中東 （巴林） 或歐洲 （蘇黎世） 區域。若要參考其他可用的動作，請參閱 [與 CodePipeline 的產品和服務整合](integrations.md)。如需歐洲 （米蘭） 區域中此動作的考量，請參閱 中的備註[適用於 Bitbucket Cloud、GitHub、GitHub Enterprise Server、GitLab.com, 和 GitLab 自我管理動作的 CodeStarSourceConnection](action-reference-CodestarConnectionSource.md)。

**Topics**
+ [

## 先決條件
](#tutorials-github-tags-prereq)
+ [

## 步驟 1：開啟 CloudShell 並複製您的儲存庫
](#w2aac13c16c15)
+ [

## 步驟 2：建立要在 Git 標籤上觸發的管道
](#tutorials-github-tags-pipeline)
+ [

## 步驟 3：標記您的遞交以進行發佈
](#w2aac13c16c19)
+ [

## 步驟 4：釋出變更並檢視日誌
](#tutorials-github-tags-view)

## 先決條件
<a name="tutorials-github-tags-prereq"></a>

開始之前，您必須執行以下作業：
+ 使用 GitHub 帳戶建立 GitHub 儲存庫。
+ 準備好您的 GitHub 登入資料。當您使用 AWS 管理主控台 設定連線時，系統會要求您使用 GitHub 登入資料登入。

## 步驟 1：開啟 CloudShell 並複製您的儲存庫
<a name="w2aac13c16c15"></a>

您可以使用命令列界面來複製儲存庫、遞交和新增標籤。本教學課程會啟動命令列界面的 CloudShell 執行個體。

1. 登入 AWS 管理主控台。

1. 在頂端導覽列中，選擇 AWS 圖示。隨即 AWS 管理主控台 顯示 的主頁面。

1. 在頂端導覽列中，選擇 AWS CloudShell 圖示。CloudShell 隨即開啟。等待 CloudShell 環境建立。
**注意**  
如果您沒有看到 CloudShell 圖示，請確定您位於 [ CloudShell 支援的區域中](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available)。本教學假設您位於美國西部 （奧勒岡） 區域。

1. 在 GitHub 中，導覽至您的儲存庫。選擇**程式碼**，然後選擇 **HTTPS**。複製路徑。複製 Git 儲存庫的地址會複製到剪貼簿。

1. 執行下列命令來複製儲存庫。

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

1. 出現提示`Password`時，輸入您的 GitHub 帳戶`Username`和 。對於 `Password`項目，您必須使用使用者建立的字符，而不是您的帳戶密碼。

## 步驟 2：建立要在 Git 標籤上觸發的管道
<a name="tutorials-github-tags-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 與 GitHub 儲存庫和動作連線的來源階段。
+ 具有建置動作的 AWS CodeBuild 建置階段。

**使用精靈建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 登入 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyGitHubTagsPipeline**。

1. 在**管道類型**中，將預設選擇保留在 **V2**。管道類型在特性和價格方面有所不同。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。

1. 在 **Service role (服務角色)** 中，選擇 **New service role (新服務角色)**。
**注意**  
如果您選擇改用現有的 CodePipeline 服務角色，請確定您已將 `codestar-connections:UseConnection` IAM 許可新增至您的服務角色政策。如需 CodePipeline 服務角色的說明，請參閱[為 CodePipeline 服務角色新增許可](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**進階設定**底下，請保留預設值。在**Artifact store (成品存放區)** 中，針對您為管道所選取區域中的管道，選擇 **Default location (預設位置)**，即可使用預設成品存放區 (例如指定為預設值的 ​Amazon S3 成品儲存貯體)。
**注意**  
這不是原始碼的來源儲存貯體。這是管道的成品存放區。每個管道都需要有個別成品存放區，例如 S3 儲存貯體。

   選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

   1. 在**儲存庫名稱**中，選擇 GitHub 儲存庫的名稱。

   1. 在**預設分支**中，選擇您希望在管道手動啟動時或來源事件不是 Git 標籤時指定的分支。如果變更的來源不是觸發條件，或者是手動啟動管道執行，則所使用的變更將是來自預設分支的 HEAD 遞交。

   1. 在 **Webhook 事件**的**篩選條件類型**下，選擇**標籤**。

      在**標籤或模式**欄位中，輸入 `release*`。
**重要**  
將針對 WebhookV2 事件設定以觸發類型 Git 標籤開頭的管道，且不會使用 Webhook 事件 （在所有推送事件上變更偵測） 來啟動管道。

   選擇**下一步**。

1. 在 **Add build stage (新增建置階段)** 中，新增建置階段：

   1. 在 **Build provider (建置供應商)** 中，選擇 **AWS CodeBuild**。允許 **Region (區域)** 預設為管道區域。

   1. 選擇**建立專案**。

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment image (環境映像)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。針對**映像**，選擇 **aws/codebuild/standard:5.0**。

   1. 對於 **Service role (服務角色)**，選擇 **New service role (新服務角色)**。
**注意**  
請記下 CodeBuild 服務角色的名稱。在本教學課程中，您將需要最後一個步驟的角色名稱。

   1. 在 **BuildSpec** 底下，針對 **Build specifications (建置規格)** 選擇 **Insert build commands (插入建置命令)**。選擇**切換到編輯器**，並在**建置命令**下貼上以下內容。

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

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。這會傳回 CodePipeline 主控台，並建立使用您的建置命令進行設定的 CodeBuild 專案。建置專案使用服務角色來管理 AWS 服務 許可。此步驟可能需要數分鐘。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。

## 步驟 3：標記您的遞交以進行發佈
<a name="w2aac13c16c19"></a>

建立管道並指定 Git 標籤後，您可以在 GitHub 儲存庫中標記遞交。在這些步驟中，您將使用 標籤來`release-1`標記遞交。Git 儲存庫中的每個遞交都必須具有唯一的 Git 標籤。當您選擇遞交並加上標籤時，這可讓您將來自不同分支的變更納入管道部署。請注意，標籤名稱版本不適用於 GitHub 中版本的概念。

1. 參考您要標記的複製遞交 IDs。若要檢視每個分支中的遞交，請在 CloudShell 終端機中輸入下列命令來擷取您要標記IDs：

   ```
   git log
   ```

1. 在 CloudShell 終端機中，輸入 命令來標記您的遞交並將其推送至原始伺服器。標記遞交之後，您可以使用 git push 命令將標籤推送至原始伺服器。在下列範例中，輸入下列命令，將 `release-1`標籤用於 ID 為 的第二個遞交`49366bd`。此標籤將由管道`release*`標籤篩選條件篩選，並啟動管道。

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

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

## 步驟 4：釋出變更並檢視日誌
<a name="tutorials-github-tags-view"></a>

1. 管道成功執行後，在成功的建置階段，選擇**檢視日誌**。

   在**日誌**下，檢視 CodeBuild 組建輸出。命令會輸出輸入變數的值。

1. 在**歷史記錄**頁面中，檢視**觸發條件**欄。檢視觸發類型 **GitTag： Release-1**。

# 教學課程：篩選分支名稱，以取得啟動管道的提取請求 (V2 類型）
<a name="tutorials-github-featurebranches"></a>

在本教學課程中，您將建立連線至 GitHub.com 儲存庫的管道，其中來源動作設定為使用觸發組態來啟動管道，該組態會篩選提取請求。當指定的分支發生指定的提取請求事件時，您的管道就會啟動。此範例說明如何建立允許篩選分支名稱的管道。如需使用觸發程序的詳細資訊，請參閱 [新增推送和提取請求事件類型的篩選條件 (CLI)](pipelines-filter.md#pipelines-filter-cli)。如需使用 glob 格式的 regex 模式進行篩選的詳細資訊，請參閱 [使用語法中的 glob 模式](syntax-glob.md)。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

本教學課程會透過 `CodeStarSourceConnection`動作類型連線至 GitHub.com 

**Topics**
+ [

## 先決條件
](#tutorials-github-featurebranches-prereq)
+ [

## 步驟 1：建立管道以啟動指定分支的提取請求
](#tutorials-github-featurebranches-pipeline)
+ [

## 步驟 2：在 GitHub.com 中建立和合併提取請求，以啟動您的管道執行
](#tutorials-github-featurebranches-pullrequest)

## 先決條件
<a name="tutorials-github-featurebranches-prereq"></a>

開始之前，您必須執行以下作業：
+ 使用 GitHub.com 帳戶建立 GitHub.com 儲存庫。
+ 準備好您的 GitHub 登入資料。當您使用 AWS 管理主控台 設定連線時，系統會要求您使用 GitHub 登入資料登入。

## 步驟 1：建立管道以啟動指定分支的提取請求
<a name="tutorials-github-featurebranches-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 與 GitHub.com 儲存庫和動作連線的來源階段。
+ 具有建置動作的 AWS CodeBuild 建置階段。

**使用精靈建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 登入 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyFilterBranchesPipeline**。

1. 在**管道類型**中，將預設選擇保留在 **V2**。管道類型在特性和價格方面有所不同。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。

1. 在 **Service role (服務角色)** 中，選擇 **New service role (新服務角色)**。
**注意**  
如果您選擇改用現有的 CodePipeline 服務角色，請確定您已將 `codeconnections:UseConnection` IAM 許可新增至您的服務角色政策。如需 CodePipeline 服務角色的說明，請參閱[為 CodePipeline 服務角色新增許可](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**進階設定**底下，請保留預設值。在**Artifact store (成品存放區)** 中，針對您為管道所選取區域中的管道，選擇 **Default location (預設位置)**，即可使用預設成品存放區 (例如指定為預設值的 ​Amazon S3 成品儲存貯體)。
**注意**  
這不是原始碼的來源儲存貯體。這是管道的成品存放區。每個管道都需要有個別成品存放區，例如 S3 儲存貯體。

   選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

   1. 在**儲存庫名稱**中，選擇 GitHub.com 儲存庫的名稱。

   1. 在**觸發類型**下，選擇**指定篩選條件**。

      在**事件類型**下，選擇**提取請求**。選取提取請求下的所有事件，以便針對建立、更新或關閉的提取請求發生事件。

      在**分支**下，於**包含**欄位中，輸入 `main*`。  
![\[顯示為具有提取請求事件類型的觸發條件選取值main*為 的包含分支選項的影像\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/pullreq-example-triggers-edit.png)
**重要**  
將針對 WebhookV2 事件設定以此觸發類型開頭的管道，且不會使用 Webhook 事件 （在所有推送事件上變更偵測） 來啟動管道。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，在**建置提供者**中選擇 **AWS CodeBuild**。允許 **Region (區域)** 預設為管道區域。依照 中的指示，選擇或建立建置專案[教學課程：使用 Git 標籤啟動您的管道](tutorials-github-tags.md)。此動作只會在本教學課程中用作建立管道所需的第二個階段。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。

## 步驟 2：在 GitHub.com 中建立和合併提取請求，以啟動您的管道執行
<a name="tutorials-github-featurebranches-pullrequest"></a>

在本節中，您會建立並合併提取請求。這會啟動您的管道，一個執行已開啟的提取請求，另一個執行已關閉的提取請求。

**建立提取請求並啟動管道**

1. 在 GitHub.com,建立提取請求。 README.md `main` 使用類似 的訊息遞交變更`Update README.md for PR`。

1. 管道從來源修訂開始，顯示提取請求的**來源**訊息為**更新 README.md for PR**。  
![\[顯示提取請求來源訊息的影像，文字如下： Update README.md for PR\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/pullreq-example.png)

1. 選擇 **History (歷程記錄)**。在管道執行歷史記錄中，檢視啟動管道執行的 CREATED 和 MERGED 提取請求狀態事件。  
![\[顯示管道執行歷史記錄的影像，顯示啟動管道執行的 CREATED 和 MERGED 提取請求狀態事件\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/pullreq-example-history.png)

# 教學課程：使用管道層級變數
<a name="tutorials-pipeline-variables"></a>

在本教學課程中，您將建立管道，在管道層級新增變數，並執行輸出變數值的 CodeBuild 組建動作。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**Topics**
+ [

## 先決條件
](#tutorials-pipeline-variables-prereq)
+ [

## 步驟 1：建立管道和建置專案
](#tutorials-pipeline-variables-pipeline)
+ [

## 步驟 2：釋出變更並檢視日誌
](#tutorials-pipeline-variables-view)

## 先決條件
<a name="tutorials-pipeline-variables-prereq"></a>

開始之前，您必須執行以下作業：
+ 建立 CodeCommit 儲存庫。
+ 將 .txt 檔案新增至儲存庫。

## 步驟 1：建立管道和建置專案
<a name="tutorials-pipeline-variables-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 與 CodeCommit 儲存庫連線的來源階段。
+ 具有建置動作的 AWS CodeBuild 建置階段。

**使用精靈建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 登入 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyVariablesPipeline**。

1. 在**管道類型**中，將預設選擇保留在 **V2**。管道類型在特性和價格方面有所不同。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。

1. 在 **Service role (服務角色)** 中，選擇 **New service role (新服務角色)**。
**注意**  
如果您選擇改用現有的 CodePipeline 服務角色，請確定您已將 `codeconnections:UseConnection` IAM 許可新增至您的服務角色政策。如需 CodePipeline 服務角色的說明，請參閱[為 CodePipeline 服務角色新增許可](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**變數**下，選擇**新增變數**。在**名稱**中，輸入 `timeout`。在**預設**中，輸入 1000。在描述中，輸入下列描述：**Timeout**。

   這會建立變數，您可以在管道執行開始時宣告值。變數名稱必須相符`[A-Za-z0-9@\-_]+`，而且可以是空字串以外的任何項目。

1. 在**進階設定**底下，請保留預設值。在**Artifact store (成品存放區)** 中，針對您為管道所選取區域中的管道，選擇 **Default location (預設位置)**，即可使用預設成品存放區 (例如指定為預設值的 ​Amazon S3 成品儲存貯體)。
**注意**  
這不是原始碼的來源儲存貯體。這是管道的成品存放區。每個管道都需要有個別成品存放區，例如 S3 儲存貯體。

   選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在 **Source provider (來源提供者)** 中選擇 **AWS CodeCommit**。

   1. 在**儲存庫名稱**和**分支名稱**中，選擇您的儲存庫和分支。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，新增建置階段：

   1. 在 **Build provider (建置供應商)** 中，選擇 **AWS CodeBuild**。允許 **Region (區域)** 預設為管道區域。

   1. 選擇**建立專案**。

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment image (環境映像)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。針對**映像**，選擇 **aws/codebuild/standard:5.0**。

   1. 對於 **Service role (服務角色)**，選擇 **New service role (新服務角色)**。
**注意**  
請記下 CodeBuild 服務角色的名稱。在本教學課程中，您將需要最後一個步驟的角色名稱。

   1. 在 **BuildSpec** 底下，針對 **Build specifications (建置規格)** 選擇 **Insert build commands (插入建置命令)**。選擇**切換到編輯器**，並在**建置命令**下貼上以下內容。在 buildspec 中，客戶變數`$CUSTOM_VAR1`將用於輸出建置日誌中的管道變數。您將在下列步驟中將`$CUSTOM_VAR1`輸出變數建立為環境變數。

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

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。這會傳回 CodePipeline 主控台，並建立使用您的建置命令進行設定的 CodeBuild 專案。建置專案使用服務角色來管理 AWS 服務 許可。此步驟可能需要數分鐘。

   1. 在**環境變數 *- 選用***下，若要將環境變數建立為由管道層級變數解析之建置動作的輸入變數，請選擇**新增環境變數**。這會建立 buildspec 中指定為 的變數`$CUSTOM_VAR1`。在**名稱**中，輸入 `CUSTOM_VAR1`。在 **Value (值)** 中輸入 `#{variables.timeout}`。在**類型**中，選擇 `Plaintext`。

      環境變數`#{variables.timeout}`的值是以步驟 7 中為管道`timeout`建立的管道層級變數命名空間`variables`和管道層級變數為基礎。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。

## 步驟 2：釋出變更並檢視日誌
<a name="tutorials-pipeline-variables-view"></a>

1. 管道成功執行後，在您成功的建置階段，選擇**檢視詳細資訊**。

   在詳細資訊頁面上，選擇**日誌**索引標籤。檢視 CodeBuild 組建輸出。命令會輸出輸入變數的值。

1. 在左側導覽中，選擇**歷史記錄**。

   選擇最近的執行，然後選擇**變數**索引標籤。檢視管道變數的解析值。

# 教學：建立簡易管道 (S3 儲存貯體)
<a name="tutorials-simple-s3"></a>

建立管道最簡單的方法是使用 AWS CodePipeline 主控台中的**建立管道**精靈。

在本教學課程中，您會建立兩階段管道，使用版本控制的 S3 來源儲存貯體和 CodeDeploy 來釋出範例應用程式。

**注意**  
當 Amazon S3 是管道的來源提供者時，您可以將來源檔案壓縮為單一 .zip，並將 .zip 上傳至來源儲存貯體。您也可以上傳單一解壓縮檔案；不過，預期 .zip 檔案的下游動作會失敗。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

在您建立此範本管道後，您將新增另一個額外階段，然後停用並啟用階段間的轉換。

**重要**  
您在此程序中新增至管道的許多動作都涉及您在建立管道之前需要建立 AWS 的資源。來源動作 AWS 的資源一律必須在您建立管道 AWS 的相同區域中建立。例如，如果您在美國東部 （俄亥俄） 區域建立管道，則 CodeCommit 儲存庫必須位於美國東部 （俄亥俄） 區域。  
您可以在建立管道時新增跨區域動作。跨區域動作 AWS 的資源必須位於您計劃執行動作的相同 AWS 區域中。如需詳細資訊，請參閱[在 CodePipeline 中新增跨區域動作](actions-create-cross-region.md)。

在您開始之前，應先完成 [CodePipeline 入門](getting-started-codepipeline.md) 中的事前準備。

**Topics**
+ [

## 步驟 1：為您的應用程式建立 S3 來源儲存貯體
](#s3-create-s3-bucket)
+ [

## 步驟 2：建立 Amazon EC2 Windows 執行個體並安裝 CodeDeploy 代理程式
](#S3-create-instances)
+ [

## 步驟 3：在 CodeDeploy 中建立應用程式
](#S3-create-deployment)
+ [

## 步驟 4：在 CodePipeline 中建立您的第一個管道
](#s3-create-pipeline)
+ [

## (選用) 步驟 5：新增另一個階段至您的管道
](#s3-add-stage)
+ [

## （選用） 步驟 6：停用和啟用 CodePipeline 中階段之間的轉換
](#s3-configure-transitions)
+ [

## 步驟 7：清除資源
](#s3-clean-up)

## 步驟 1：為您的應用程式建立 S3 來源儲存貯體
<a name="s3-create-s3-bucket"></a>

您可以將來源檔案或應用程式存放於任何版本控制的位置。在本教學課程中，您會為範例應用程式檔案建立 S3 儲存貯體，並在該儲存貯體上啟用版本控制。啟用版本控制後，您會複製範本應用程式至該儲存貯體。

**建立 S3 儲存貯體**

1. 登入位於 的 主控台 AWS 管理主控台。開啟 S3 主控台。

1. 選擇**建立儲存貯體**。

1. 在 **Bucket Name (儲存貯體名稱)** 中，輸入儲存貯體的名稱 (例如 **awscodepipeline-demobucket-example-date**)。
**注意**  
由於 Amazon S3 中的所有儲存貯體名稱必須是唯一的，請使用您自己的名稱，而不是範例中顯示的名稱。您只要新增日期至範例名稱就可變更名稱。請記下此名稱，因為您在整個教學課程中都會用到。

   在**區域中**，選擇您要建立管道的區域，例如**美國西部 （奧勒岡）**，然後選擇**建立儲存貯**體。

1. 建立儲存貯體後，會顯示成功橫幅。選擇 **Go to bucket details (前往儲存貯體詳細資訊)**。

1. 在 **Properties (屬性)** 標籤上，選擇 **Versioning (版本控制)**。選擇 **Enable versioning (啟用版本控制)**，然後選擇 **Save (儲存)**。

   啟用版本控制時，Amazon S3 會儲存儲存貯體中每個物件的每個版本。

1. 在 **Permissions (許可)** 索引標籤上，保留預設值。如需 S3 儲存貯體和物件許可的相關資訊，請參閱[在政策中指定許可](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html)。

1. 接著，下載範本並將其儲存至本機電腦的資料夾或目錄中。

   1. 選擇下列其中一項。如果要依照本教學中針對 Windows Server 執行個體的步驟執行，請選擇 `SampleApp_Windows.zip`。
      + 如果您想要使用 CodeDeploy 部署到 Amazon Linux 執行個體，請在此處下載範例應用程式：[SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)。
      + 如果您想要使用 CodeDeploy 部署到 Windows Server 執行個體，請在此處下載範例應用程式：[SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip)。

      範例應用程式包含下列使用 CodeDeploy 部署的檔案：
      + `appspec.yml` – 應用程式規格檔案 (AppSpec 檔案） 是 CodeDeploy 用來管理部署的 [YAML](http://www.yaml.org) 格式檔案。如需 AppSpec 檔案的詳細資訊，請參閱*AWS CodeDeploy 《 使用者指南*》中的 [CodeDeploy AppSpec 檔案參考](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。
      + `index.html` – 索引檔案包含已部署範例應用程式的首頁。
      + `LICENSE.txt` – 授權檔案包含範例應用程式的授權資訊。
      + 指令碼的檔案 – 範例應用程式使用指令碼將文字檔案寫入執行個體上的位置。每個 CodeDeploy 部署生命週期事件都會寫入一個檔案，如下所示：
        + （僅限 Linux 範例） `scripts` 資料夾 – 資料夾包含下列 Shell 指令碼來安裝相依性，以及啟動和停止自動化部署的範例應用程式：`install_dependencies`、 `start_server`和 `stop_server`。
        + （僅限 Windows 範例） `before-install.bat` – 這是`BeforeInstall`部署生命週期事件的批次指令碼，將執行此指令碼來移除先前部署此範例期間寫入的舊檔案，並在執行個體上建立位置以寫入新檔案。

   1. 下載已壓縮的檔案。不要將檔案解壓縮。

1. 在 Amazon S3 主控台中，針對您的儲存貯體上傳 檔案：

   1. 選擇**上傳**。

   1. 拖放檔案或選擇 **Add files (新增檔案)**，並瀏覽到該檔案。

   1. 選擇**上傳**。

## 步驟 2：建立 Amazon EC2 Windows 執行個體並安裝 CodeDeploy 代理程式
<a name="S3-create-instances"></a>

**注意**  
本教學課程提供建立 Amazon EC2 Windows 執行個體的範例步驟。如需建立 Amazon EC2 Linux 執行個體的範例步驟，請參閱 [步驟 3：建立 Amazon EC2 Linux 執行個體並安裝 CodeDeploy 代理程式](tutorials-simple-codecommit.md#codecommit-create-deployment)。當系統提示輸入要建立的執行個體數目時，請指定 **2** 個執行個體。

在此步驟中，您會建立將部署範例應用程式的 Windows Server Amazon EC2 執行個體。在此程序中，您會使用允許在執行個體上安裝和管理 CodeDeploy 代理程式的政策來建立執行個體角色。CodeDeploy 代理程式是一種軟體套件，可讓執行個體用於 CodeDeploy 部署。您也可以連接政策，允許執行個體擷取 CodeDeploy 代理程式用來部署應用程式的檔案，並允許 SSM 管理執行個體。

**建立執行個體角色**

1. 開啟 IAM 主控台，網址為 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

1. 從主控台儀表板，選擇 **Roles (角色)**。

1. 選擇建**立角色**。

1. 在**選取信任實體類型**下，選取 **AWS 服務**。在 **Choose a use case (選擇使用案例)** 下，選取 **EC2**，然後選擇 **Next: Permissions (下一步：許可)**。

1. 搜尋並選取名為 的政策**`AmazonEC2RoleforAWSCodeDeploy`**。

1. 搜尋並選取名為 的政策**`AmazonSSMManagedInstanceCore`**。選擇下**一步：標籤**。

1. 選擇下**一步：檢閱**。輸入角色的名稱 (例如，**EC2InstanceRole**)。
**注意**  
記下您的角色名稱，以用於下一個步驟。您會在建立執行個體時選擇此角色。

   選擇建**立角色**。

**啟動執行個體**

1. 前往 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在側邊導覽中，選擇**執行個體**，然後從頁面頂端選取**啟動執行個體**。

1. 在**名稱和標籤**下，在**名稱**中輸入 **MyCodePipelineDemo**。這會將標籤**索引鍵** **Name**和標籤**值** 指派給執行個體**MyCodePipelineDemo**。稍後，您會建立 CodeDeploy 應用程式，將範例應用程式部署到執行個體。CodeDeploy 會根據標籤選取要部署的執行個體。

1. 在**應用程式和作業系統映像 (Amazon Machine Image)** 下，選擇 **Windows** 選項。（此 AMI 描述為 **Microsoft Windows Server 2019 Base**，並標記為「免費方案合格」，可在 **Quick Start** 下找到。)

1. 在**執行個體類型**下，選擇符合免費方案的`t2.micro`類型做為執行個體的硬體組態。

1. 在**金鑰對 （登入）** 下，選擇金鑰對或建立一個金鑰對。

   您也可以選擇**不使用金鑰對繼續**。
**注意**  
基於本教學的目的，您可以在不使用金鑰對的情況下繼續進行。若要使用 SSH 連接到執行個體，請建立或使用金鑰對。

1. 在**網路設定**下，執行下列動作。

   在**自動指派公有 IP** 中，請確定狀態為**啟用**。
   + 在 **Assign a security group (指派安全群組)** 旁，選擇 **Create a new security group (建立新的安全群組)**。
   + 在 **SSH** 的資料列的**來源類型**下，選擇**我的 IP**。
   + 選擇**新增安全群組**，選擇 **HTTP**，然後在**來源類型**下，選擇**我的 IP**。

1. 展開 **Advanced Details** (進階詳細資訊)。在 **IAM 執行個體描述檔**中，選擇您在先前程序中建立的 IAM 角色 （例如 **EC2InstanceRole**)。

1. 在**摘要**下，於**執行個體數量**下，輸入 `2`.。

1. 選擇**啟動執行個體**。

1. 選擇 **View all instances** (檢視所有執行個體)，以關閉確認頁面並返回主控台。

1. 您可以在 **Instances (執行個體)** 頁面上檢視啟動狀態。當您啟動執行個體時，其初始狀態是 `pending`。在執行個體啟動後，其狀態會變更為 `running`，並得到公有的 DNS 名稱。(如果 **Public DNS (公有 DNS)** 欄未顯示，請選擇 **Show/Hide (顯示/隱藏)** 圖示，然後選擇 **Public DNS (公有 DNS)**。)

1. 執行個體可能需要幾分鐘的時間才能準備就緒讓您連線。請確認您的執行個體已通過狀態檢查。您可以在 **Status Checks (狀態檢查)** 欄位查看此資訊。

## 步驟 3：在 CodeDeploy 中建立應用程式
<a name="S3-create-deployment"></a>

在 CodeDeploy 中，*應用程式*是您要部署之程式碼的名稱形式的識別符。CodeDeploy 使用此名稱，以確保在部署期間參考正確的修訂、部署組態和部署群組組合。當您稍後在本教學課程中建立管道時，請選取您在此步驟中建立的 CodeDeploy 應用程式名稱。

您先建立服務角色供 CodeDeploy 使用。如果您已建立服務角色，則不需要建立另一個角色。

**建立 CodeDeploy 服務角色**

1. 開啟 IAM 主控台，網址為 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

1. 從主控台儀表板，選擇 **Roles (角色)**。

1. 選擇建**立角色**。

1. 在**選取信任的實體**下，選擇 **AWS 服務**。在**使用案例中**，選擇 **CodeDeploy**。從列出的選項中選擇 **CodeDeploy**。選擇**下一步**。`AWSCodeDeployRole` 受管政策已連接至角色。

1. 選擇**下一步**。

1. 輸入角色的名稱 (例如 **CodeDeployRole**)，然後選擇 **Create role (建立角色)**。

**在 CodeDeploy 中建立應用程式**

1. 在 https：//[https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) 開啟 CodeDeploy 主控台。

1. 如果**應用程式**頁面未顯示，請在 AWS CodeDeploy 功能表中選擇**應用程式**。

1. 選擇**建立應用程式**。

1. 在 **Application name (應用程式名稱)** 中，輸入 `MyDemoApplication`。

1. 在 **Compute Platform (運算平台)** 中，選擇 **EC2/On-premises (EC2/ 現場部署)**。

1. 選擇**建立應用程式**。

**在 CodeDeploy 中建立部署群組**

1. 在顯示您應用程式的頁面上，選擇 **Create deployment group (建立部署群組)**。

1. 在 **Deployment group name (部署群組名稱)** 中，輸入 **MyDemoDeploymentGroup**。

1. 在**服務角色**中，選擇您先前建立的服務角色。您必須至少使用建立 AWS CodeDeploy 的服務角色中所述[的信任和許可來信任CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-create-service-role.html)。若要取得服務角色 ARN，請參閱[取得服務角色 ARN (主控台)](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#getting-started-get-service-role-console)。

1. 在 **Deployment type (部署類型)** 下，選擇 **In-place (就地進行)**。

1. 在 **Environment configuration (環境組態)** 下，選擇 **Amazon EC2 Instances (Amazon EC2 執行個體)**。在**金鑰**欄位中選擇**名稱**，然後在**值**欄位中，輸入 **MyCodePipelineDemo**。
**重要**  
在您建立 EC2​ 執行個體時，您必須在此為 **Name (名稱)** 金鑰選擇為執行個體指派的相同數值。如果您使用 **MyCodePipelineDemo** 以外的程式碼來標記執行個體，請務必在此使用該程式碼。

1. 在具有 ** AWS Systems Manager 的客服人員組態**下，選擇**現在並排程更新**。這會在執行個體上安裝 代理程式。Windows 執行個體已使用 SSM 代理程式設定，現在將使用 CodeDeploy 代理程式更新。

1. 在**部署設定**下，選擇 `CodeDeployDefault.OneAtaTime`。

1. 在**Load Balancer**下，確定未選取**啟用負載平衡**方塊。您不需要為此範例設定負載平衡器或選擇目標群組。取消選取核取方塊後，不會顯示負載平衡器選項。

1. 在 **Advanced (進階)** 區段中，保留預設值。

1. 選擇 **Create deployment group (建立部署群組)**。

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

在教學課程的此部分中，您會建立管道。該範本會自動透過管道執行。

**建立 CodePipeline 自動發行程序**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyFirstPipeline**。
**注意**  
如果您選擇了另一個管道名稱，請務必在此整個教學中皆使用該名稱 (而非 **MyFirstPipeline**)。在您建立管道後，便無法更改其名稱。管道名稱會受到一些限制。如需詳細資訊，請參閱[AWS CodePipeline 中的配額](limits.md)。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在 **Service role (服務角色)** 中，執行下列其中一項作業：
   + 選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立新的服務角色。
   + 選擇 **Existing service role (現有服務角色)** 以使用已在 IAM 中建立的服務角色。在 **Role name (角色名稱)** 中，從清單選擇您的服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**的**來源提供者**中，選擇 **Amazon S3**。在 **Bucket (儲存貯體)** 中，輸入您在 [步驟 1：為您的應用程式建立 S3 來源儲存貯體](#s3-create-s3-bucket) 中建立的 S3 儲存貯體名稱。在 **S3 物件金鑰**中，輸入有或沒有檔案路徑的物件金鑰，記得也要加入副檔名。例如，對於 `SampleApp_Windows.zip`，輸入範例檔案名稱，如下列範例所示：

   ```
   SampleApp_Windows.zip
   ```

   選擇 **下一個步驟**。

   在 **Change detection options (變更刪除選項)** 下，保持預設設定。這可讓 CodePipeline 使用 Amazon CloudWatch Events 來偵測來源儲存貯體中的變更。

    選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**的**部署提供者**中，選擇 **CodeDeploy。 ****區域**欄位預設為與您的管道 AWS 區域 相同的 。在 **Application name** (應用程式名稱) 中，輸入 `MyDemoApplication`，或選擇 **Refresh** (重新整理) 按鈕，然後從清單中選擇應用程式名稱。在 **Deployment group (部署群組)** 中，輸入 **MyDemoDeploymentGroup**，或從清單中選擇，然後選擇 **Next (下一步)**。
**注意**  
名稱「Deploy」(部署)，是預設指定給在 **Step 4: Add deploy stage (步驟 4：新增部署階段)** 步驟中建立的階段名稱，如同「Source」(來源) 是管道的第一階段所指定的名稱。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

1. 管道開始執行。當 CodePipeline 範例將網頁部署到 CodeDeploy 部署中的每個 Amazon EC2 執行個體時，您可以檢視進度、成功和失敗訊息。

恭喜您！您剛在 CodePipeline 中建立簡單的管道。管道有兩個階段：
+ 名為 **Source (來源)** 的來源階段，可偵測存放於 S3 儲存貯體中的版本控制範例應用程式變更，並將那些變更提取至管道中。
+ 使用 CodeDeploy 將這些變更部署到 EC2 執行個體的**部署**階段。

現在，請驗證結果。

**驗證您的管道是否成功執行**

1. 檢視管道初始進度。每一個階段狀態會從 **No executions yet (尚未執行)**​ 變更為 **In Progress (進行中)**，然後顯示 **Succeeded (成功)**​ 或 **Failed (失敗)**。該管道應會在幾分鐘內完成初次執行。

1. 在該動作狀態顯示 **Succeeded (成功)**​ 後，在 **Deploy (部署)**​ 階段，選擇 **Details (詳細資訊)**。這會開啟 CodeDeploy 主控台。

1. 在 **Deployment group (部署群組)** 索引標籤的 **Deployment lifecycle events (部署生命週期事件)** 下，選擇執行個體 ID。這會開啟 EC2 主控台。

1. 在 **Description (敘述)** 標籤的 **Public DNS (公有 DNS)** 中複製地址，然後貼上至您 Web 瀏覽器的地址列中。檢視索引頁面以了解您上傳至 S3 儲存貯體的範例應用程式。

   網頁會顯示您上傳到 S3 儲存貯體的範例應用程式。

如需關於階段、動作以及管道如何運作的更多資訊，請參閱 [CodePipeline 概念](concepts.md)。

## (選用) 步驟 5：新增另一個階段至您的管道
<a name="s3-add-stage"></a>

現在，在管道中新增另一個階段，以使用 CodeDeploy 從預備伺服器部署到生產伺服器。首先，在 CodeDeploy 的 CodePipelineDemoApplication 中建立另一個部署群組。 CodeDeploy 然後您將新增一個階段，該階段包括了使用此部署群組的動作。若要新增另一個階段，您可以使用 CodePipeline 主控台或 AWS CLI 來擷取和手動編輯 JSON 檔案中管道的結構，然後執行 **update-pipeline**命令以使用您的變更更新管道。

**Topics**
+ [

### 在 CodeDeploy 中建立第二個部署群組
](#s3-add-stage-part-1)
+ [

### 在您的管道中新增部署群組以做為另一個階段
](#s3-add-stage-part-2)

### 在 CodeDeploy 中建立第二個部署群組
<a name="s3-add-stage-part-1"></a>

**注意**  
在教學課程的這個部分中，您會建立第二個部署群組，但會部署到與之前相同的 Amazon EC2 執行個體。這僅用於示範用途。它旨在無法向您展示 CodePipeline 中顯示錯誤的方式。

**在 CodeDeploy 中建立第二個部署群組**

1. 在 https：//[https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) 開啟 CodeDeploy 主控台。

1. 選擇 **Applications** (應用程式)，然後在應用程式清單中選擇 `MyDemoApplication`。

1. 選擇 **Deployment groups (部署群組)** 索引標籤，然後選擇 **Create deployment group (建立部署群組)**。

1. 在 **Create deployment group (建立部署群組)** 頁面上的 **Deployment group name (部署群組名稱)** 中，輸入第二個部署群組的名稱 (例如 **CodePipelineProductionFleet**)。

1. 在**服務角色**中，選擇您用於初始部署的相同 CodeDeploy 服務角色 （而非 CodePipeline 服務角色）。

1. 在 **Deployment type (部署類型)** 下，選擇 **In-place (就地進行)**。

1. 在 **Environment configuration (環境組態)** 下，選擇 **Amazon EC2 Instances (Amazon EC2 執行個體)**。在**金鑰**方塊中選擇**名稱**，然後在**值**方塊中，`MyCodePipelineDemo`從清單中選擇。將 **Deployment settings (部署設定)** 保留為預設組態。

1. 在 **Deployment configuration (部署組態)** 下，選擇 `CodeDeployDefault.OneAtaTime`。

1. 在 **Load Balancer (負載平衡器)** 下，清除 **Enable load balancing (啟用負載平衡)**。

1.  選擇 **Create deployment group (建立部署群組)**。

### 在您的管道中新增部署群組以做為另一個階段
<a name="s3-add-stage-part-2"></a>

現在您已擁有另一個部署群組，您可新增使用此部署群組的階段，以部署到您在稍早使用的相同 EC2 執行個體。您可以使用 CodePipeline 主控台或 AWS CLI 新增此階段。

**Topics**
+ [

#### 建立第三個階段 (主控台)
](#s3-add-stage-part-2-console)
+ [

#### 建立第三個階段 (CLI)
](#s3-add-stage-part-2-cli)

#### 建立第三個階段 (主控台)
<a name="s3-add-stage-part-2-console"></a>

您可以使用 CodePipeline 主控台來新增使用新部署群組的新階段。由於此部署群組是部署在您已使用中的 EC2 執行個體，故在此階段的部署動作失敗。

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**名稱**中，選擇您建立的管道名稱 MyFirstPipeline。

1. 在管道詳細資訊頁面上，選擇 **Edit (編輯)**。

1. 在 **Edit (編輯)** 頁面上，選擇 **\$1 Add stage (\$1 新增階段)** 以在 Deploy (部署) 階段後立即新增一個階段。  
![\[顯示編輯畫面上 + 新增階段按鈕的影像\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/edit-pipeline-console-pol.png)

1. 在 **Add stage (新增階段)** 的 **Stage name (階段名稱)** 中，輸入 **Production**。選擇 **Add stage (新增階段)**。

1. 在新階段中，選擇 **\$1 Add action group (\$1 新增動作群組)**。

1. 在 **Edit action (編輯動作)** 的 **Action name (動作名稱)** 中，輸入 **Deploy-Second-Deployment**。在**動作提供者**的**部署**下，選擇 **CodeDeploy**。

1. 在 CodeDeploy 區段的應用程式**名稱**中，`MyDemoApplication`從下拉式清單中選擇 ，就像您在建立管道時所做的一樣。在 **Deployment group (部署群組)** 中，選擇您剛才建立的部署群組 **CodePipelineProductionFleet**。在 **Input artifacts** (輸入成品) 中，從來源動作中選擇輸入成品。選擇**儲存**。

1. 在 **Edit (編輯)** 頁面中，選擇 **Save (儲存)**。在 **Save pipeline changes (儲存管道變更)** 中，選擇 **Save (儲存)**。

1. 雖然新階段已新增至您的管道，但由於沒有發生觸發另一個管道執行的變更，所以會顯示 **No executions yet (尚未執行)**。您必須手動重新執行最新的修訂版本，來查看已編輯管道的執行情形。在管道詳細資訊頁面上，選擇**釋出變更**，然後在出現提示時選擇**釋出**。這將會在管道的來源動作所指定的各個來源位置中執行最新的可用版本。

   或者，若要使用 從本機 Linux、macOS 或 Unix 機器的終端機或本機 Windows 機器的命令提示字元 AWS CLI 重新執行管道，請執行 **start-pipeline-execution**命令，指定管道的名稱。這會再次透過管道，在您的來源儲存貯體中執行應用程式。

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

   此命令會傳回 `pipelineExecutionId`​ 物件。

1. 返回 CodePipeline 主控台，然後在管道清單中，選擇 **MyFirstPipeline** 開啟檢視頁面。

   該管道顯示了三個階段，以及透過這三個階段執行的成品狀態。管道可能需要五分鐘以執行所有階段。和之前一樣，您會看到該部署在前兩個階段已成功，但 **Production (生產)** 階段會顯示 **Deploy-Second-Deployment (部署-第二-部署)** 動作失敗。

1. 在 **Deploy-Second-Deployment (部署-第二-部署)** 動作中，選擇 **Details (詳細資訊)**。系統會將您重新導向至 CodeDeploy 部署的 頁面。在此案例中，該失敗是部署至所有 EC2​ 執行個體之第一個執行個體群組的結果，造成第二個部署群組沒有任何執行個體。
**注意**  
此失敗是刻意設計的，以說明在管道階段中發生失敗時的情況。

#### 建立第三個階段 (CLI)
<a name="s3-add-stage-part-2-cli"></a>

雖然使用 AWS CLI 將階段新增至管道比使用 主控台更為複雜，但它可讓您更清楚地了解管道的結構。

**為管道建立第三階段**

1. 在本機 Linux、macOS 或 Unix 機器上開啟終端機工作階段，或在本機 Windows 機器上開啟命令提示，然後執行 **get-pipeline**命令來顯示您剛建立的管道結構。對於 **MyFirstPipeline**，您可能輸入下列命令：

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

   此命令會傳回 MyFirstPipeline 的結構。該輸出的第一部分應如下所示：

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

   該輸出的最後一個部分包含了管道中繼資料，應如下所示：

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

1. 複製並貼上此結構至純文字編輯器中，然後將檔案儲存為 **pipeline.json**。為方便起見，請將此檔案儲存在您執行 **aws codepipeline**​ 命令的相同目錄中。
**注意**  
您可透過 **get-pipeline** 命令直接將 JSON 輸送到檔案，如下所示：  

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

1. 複製 **Deploy (部署)** 階段區段，並貼在前兩個階段的後面。由於它是一個部署階段 (如同 **Deploy (部署)**​ 階段)，故您可使用它做為第三階段的範本。

1. 變更階段的名稱和部署群組的詳細資訊。

   下列範例顯示您在**部署**階段之後新增至 pipeline.json 檔案的 JSON。使用新數值編輯強調元素。請記得包含逗號，以分隔 **Deploy (部署)** 和 **Production (生產)** 階段定義。

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

1. 如果您使用的是使用 **get-pipeline** 命令擷取的管道結構，則必須從 JSON 檔案中移除 `metadata` 行。否則，**update-pipeline** 命令無法使用它。移除 `"metadata": { }` 行，以及 `"created"`、`"pipelineARN"` 和 `"updated"` 欄位。

   例如，從結構中移除下列幾行：

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

   儲存檔案。

1. 執行 **update-pipeline**​ 命令，指定管道 JSON 檔案，如以下所示：

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

   此命令會傳回已更新管道的整個結構。
**重要**  
請確認在檔案名稱之前包含 `file://`。這是此命令必要項目。

1.  執行 **start-pipeline-execution**​ 命令，指定管道名稱。這會再次透過管道，在您的來源儲存貯體中執行應用程式。

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

   此命令會傳回 `pipelineExecutionId`​ 物件。

1. 開啟 CodePipeline 主控台，然後從管道清單中選擇 **MyFirstPipeline**。

   該管道顯示了三個階段，以及透過這三個階段執行的成品狀態。管道可能需要五分鐘以執行所有階段。和之前一樣，雖然該部署在前兩個階段已成功，**Production (生產)**​ 階段仍會顯示 **Deploy-Second-Deployment (部署-第二-部署)**​ 動作失敗。

1. 在 **Deploy-Second-Deployment (部署-第二-部署)** 動作中，選擇 **Details (詳細資訊)** 以查看該失敗的詳細資訊。系統會將您重新導向至 CodeDeploy 部署的詳細資訊頁面。在此案例中，該失敗是部署至所有 EC2​ 執行個體之第一個執行個體群組的結果，造成第二個部署群組沒有任何執行個體。
**注意**  
此失敗是刻意設計的，以說明在管道階段中發生失敗時的情況。

## （選用） 步驟 6：停用和啟用 CodePipeline 中階段之間的轉換
<a name="s3-configure-transitions"></a>

您可在管道中的階段之間啟用或停用轉換。在階段間停用轉換，可讓您手動控制階段與階段之間的轉換。例如，您可能想執行管道的前兩個階段，但不希望在準備好部署至生產前轉換至第三個階段，或您正在針對該階段的問題或失敗進行故障排除。

**停用和啟用 CodePipeline 管道中階段之間的轉換**

1. 開啟 CodePipeline 主控台，然後從管道清單中選擇 **MyFirstPipeline**。

1. 在管道的詳細資訊頁面上，選擇在第二階段 (**部署**) 和您在上一節 (**生產**) 中新增的第三階段之間**停用轉換**按鈕。

1. 在 **Disable transition (停用轉換)** 中，輸入在階段間停用轉換的原因，然後選擇 **Disable (停用)**。

   階段之間的箭號會顯示圖示與顏色變更，並會顯示 **Enable transition (啟用轉換)** 按鈕。  
![\[本圖顯示將轉換停用的原因顯示為「在故障疑難排解時停用轉換」\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/codepipeline-disabled-transition-pol.png)

1. 再次將您的範例上傳至 S3 儲存貯體。由於該儲存貯體是版本控制的，此變更會啟動該管道。

1. 返回您管道的詳細資訊頁面並查看階段狀態。管道檢視將改變，以顯示前兩個階段的進度與成功狀態，但第三個階段上不會發生變更。此程序可能需要幾分鐘的時間。

1. 選擇兩階段之間的 **Enable transition (啟用轉換)** 按鈕以啟用轉換。在 **Enable transition (啟用轉換)** 對話方塊中，選擇 **Enable (啟用)**。該階段會在幾分鐘內開始執行，並嘗試處理已透過管道前兩個階段執行的成品。
**注意**  
如果您希望第三個階段成功，請在啟用轉換之前編輯 CodePipelineProductionFleet 部署群組，並指定應用程式部署所在的不同 EC2 執行個體集。有關如何執行此操作的詳細資訊，請參閱[變更部署群組設定](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-change-deployment-group-settings.html)。如果您建立更多 EC2 執行個體，您可能需要支付額外費用。

## 步驟 7：清除資源
<a name="s3-clean-up"></a>

您可以將本教學課程中建立的一些資源應用在 [教學：建立四階段管道](tutorials-four-stage-pipeline.md) 中。例如，您可以重複使用 CodeDeploy 應用程式和部署。您可以使用 CodeBuild 等提供者設定建置動作，這是雲端中全受管的建置服務。您也可以透過組件伺服器或系統來設定使用供應商的組件動作，例如 Jenkins。

不過，在您完成這些教學課程之後，應該刪除管道以及其所使用的資源，才不會因為持續使用那些資源而付費。首先，刪除管道，然後刪除 CodeDeploy 應用程式及其相關聯的 Amazon EC2 執行個體，最後刪除 S3 儲存貯體。

**清除此教學中使用的資源**

1. 若要清除 CodePipeline 資源，請遵循 [中刪除管道 AWS CodePipeline](pipelines-delete.md)中的指示。

1. 若要清除 CodeDeploy 資源，請依照 中的[說明清除資源 （主控台）](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console)。

1. 若要刪除 S3 儲存貯體，請按照[刪除或清空儲存貯體](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-or-empty-bucket.html)中的說明進行。如果您不想建立更多管道，請刪除用以存放管道成品所建立的 S3 儲存貯體。如需此儲存貯體的詳細資訊，請參閱 [CodePipeline 概念](concepts.md)。

# 教學課程：建立簡單的管道 (CodeCommit 儲存庫）
<a name="tutorials-simple-codecommit"></a>

在本教學課程中，您會使用 CodePipeline 將 CodeCommit 儲存庫中維護的程式碼部署至單一 Amazon EC2 執行個體。當您將變更推送至 CodeCommit 儲存庫時，就會觸發您的管道。管道會使用 CodeDeploy 做為部署服務，將您的變更部署至 Amazon EC2 執行個體。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

管道有兩個階段：
+ CodeCommit 來源動作的來源階段 (**來源**)。
+ Code**Deploy** 部署動作的部署階段 (CodeDeploy)。

開始使用 的最簡單方法是 AWS CodePipeline 使用 CodePipeline 主控台中的**建立管道**精靈。

**注意**  
開始之前，請確定您已設定 Git 用戶端來使用 CodeCommit。如需說明，請參閱[設定 CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html)。

## 步驟 1：建立 CodeCommit 儲存庫
<a name="codecommit-create-repository"></a>

首先，在 CodeCommit 中建立儲存庫。您的管道會在執行時從此儲存庫獲得原始程式碼。您也可以建立本機儲存庫，在將程式碼推送至 CodeCommit 儲存庫之前，在其中維護和更新程式碼。

**建立 CodeCommit 儲存庫**



1. 前往 [https://console.aws.amazon.com/codecommit/](https://console.aws.amazon.com/codecommit/) 開啟 CodeCommit 主控台。

1. 在區域選擇器中，選擇您要建立儲存庫和管道的 AWS 區域 。如需詳細資訊，請參閱 [AWS 區域 和端點](https://docs.aws.amazon.com/general/latest/gr/rande.html)。

1. 請在 **Repositories** (儲存庫) 頁面上，選擇 **Create repository** (建立儲存庫)。

1. 在 **Create repository (建立儲存庫)** 頁面的 **Repository name (儲存庫名稱)** 中，輸入儲存庫的名稱 (例如 **MyDemoRepo**)。

1. 選擇**建立**。

**注意**  
本教學課程的其餘步驟會使用 **MyDemoRepo** 做為 CodeCommit 儲存庫的名稱。如果您選擇不同名稱，請在此教學課程中都使用此名稱。

**設定本機儲存庫**

在此步驟中，您會設定本機儲存庫來連線至遠端 CodeCommit 儲存庫。
**注意**  
您不需要設定本機儲存庫。您也可以使用 主控台上傳檔案，如中所述[步驟 2：將範本程式碼新增至 CodeCommit 儲存庫](#codecommit-add-code)。

1. 隨著新儲存庫在主控台開啟後，選擇頁面右上角的 **Clone URL (複製 URL)**，然後選擇 **Clone SSH (複製 SSH)**。複製 Git 儲存庫的地址會複製到剪貼簿。

1. 在終端機或命令列，導覽至您要存放本機儲存庫的本機目錄。我們在此教學中使用 `/tmp`。

1. 執行以下命令來複製儲存庫，將 SSH 地址取代為您在上一個步驟中複製的地址。此命令會建立名為 `MyDemoRepo` 的目錄。您將範例應用程式複製到此目錄。

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

## 步驟 2：將範本程式碼新增至 CodeCommit 儲存庫
<a name="codecommit-add-code"></a>

在此步驟中，您會下載為 CodeDeploy 範例演練建立之範例應用程式的程式碼，並將其新增至 CodeCommit 儲存庫。



1. 接著，下載範本並將其儲存至本機電腦的資料夾或目錄中。

   1. 選擇下列其中一項。選擇`SampleApp_Linux.zip`是否要遵循本教學課程中的 Linux 執行個體步驟。
      + 如果您想要使用 CodeDeploy 部署到 Amazon Linux 執行個體，請在此處下載範例應用程式：[SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip)。
      + 如果您想要使用 CodeDeploy 部署到 Windows Server 執行個體，請在此處下載範例應用程式：[SampleApp\$1Windows.zip](samples/SampleApp_Windows.zip)。

      範例應用程式包含下列使用 CodeDeploy 部署的檔案：
      + `appspec.yml` – 應用程式規格檔案 (AppSpec 檔案） 是 CodeDeploy 用來管理部署的 [YAML](http://www.yaml.org) 格式檔案。如需 AppSpec 檔案的詳細資訊，請參閱*AWS CodeDeploy 《 使用者指南*》中的 [CodeDeploy AppSpec 檔案參考](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。
      + `index.html` – 索引檔案包含已部署範例應用程式的首頁。
      + `LICENSE.txt` – 授權檔案包含範例應用程式的授權資訊。
      + 指令碼的檔案 – 範例應用程式使用指令碼將文字檔案寫入執行個體上的位置。每個 CodeDeploy 部署生命週期事件都會寫入一個檔案，如下所示：
        + （僅限 Linux 範例） `scripts` 資料夾 – 資料夾包含下列 Shell 指令碼來安裝相依性，以及啟動和停止自動化部署的範例應用程式：`install_dependencies`、 `start_server`和 `stop_server`。
        + （僅限 Windows 範例） `before-install.bat` – 這是`BeforeInstall`部署生命週期事件的批次指令碼，將執行此指令碼來移除先前部署此範例期間寫入的舊檔案，並在執行個體上建立位置以寫入新檔案。

   1. 下載已壓縮的檔案。

1. 將檔案從 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 解壓縮至您先前建立的本機目錄 (例如：`/tmp/MyDemoRepo` 或 `c:\temp\MyDemoRepo`)。

   請務必直接將檔案放入您的本機儲存庫。不要包含 `SampleApp_Linux` 資料夾。例如，在本機 Linux、macOS 或 Unix 機器上，您的目錄和檔案階層應該如下所示：

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

1. 若要將檔案上傳至您的儲存庫，請使用下列其中一種方法。

   1. 若要使用 CodeCommit 主控台上傳您的檔案：

      1. 開啟 CodeCommit 主控台，然後從儲存庫清單中選擇您的**儲存庫**。

      1. 選擇 **Add file (新增檔案)**，然後選擇 **Upload file (上傳檔案)**。

      1. 選取 **Choose file (選擇檔案)**，然後瀏覽您的檔案。若要在資料夾下新增檔案，請選擇**建立檔案**，然後使用檔案名稱輸入資料夾名稱，例如 `scripts/install_dependencies`。將檔案內容貼到新檔案中。

         輸入您的使用者名稱和電子郵件地址來確定變更。

         選擇 **Commit changes (遞交變更)**。

      1. 為每個檔案重複此步驟。

         您的儲存庫內容看起來應該如下所示：

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

   1. 若要使用 git 命令上傳檔案：

      1. 將目錄變更為您的本機儲存庫：

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

      1. 請執行下列命令來同時將所有檔案放入階段：

         ```
         git add -A
         ```

      1. 請執行下列命令來確認檔案並附加確認訊息：

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

      1. 執行下列命令，將檔案從本機儲存庫推送至 CodeCommit 儲存庫：

         ```
         git push
         ```

1. 您下載並新增至本機儲存庫的檔案現在已新增至 CodeCommit `MyDemoRepo`儲存庫中的`main`分支，並準備好包含在管道中。

## 步驟 3：建立 Amazon EC2 Linux 執行個體並安裝 CodeDeploy 代理程式
<a name="codecommit-create-deployment"></a>

在此步驟中，您會建立部署範例應用程式的 Amazon EC2 執行個體。在此程序中，請建立允許在執行個體上安裝和管理 CodeDeploy 代理程式的執行個體角色。CodeDeploy 代理程式是一種軟體套件，可讓執行個體用於 CodeDeploy 部署。您也可以連接政策，允許執行個體擷取 CodeDeploy 代理程式用來部署應用程式的檔案，並允許 SSM 管理執行個體。

**建立執行個體角色**

1. 開啟 IAM 主控台，網址為 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

1. 從主控台儀表板，選擇 **Roles (角色)**。

1. 選擇建**立角色**。

1. 在**選取信任實體類型**下，選取 **AWS 服務**。在**選擇使用案例**下，選取 **EC2**。在 **Select your use case (選取您的使用案例)** 下，選擇 **EC2**。選擇**下一步：許可**。

1. 搜尋並選取名為 的政策**`AmazonEC2RoleforAWSCodeDeploy`**。

1. 搜尋並選取名為 的政策**`AmazonSSMManagedInstanceCore`**。選擇下**一步：標籤**。

1. 選擇下**一步：檢閱**。輸入角色的名稱 (例如，**EC2InstanceRole**)。
**注意**  
記下您的角色名稱，以用於下一個步驟。您會在建立執行個體時選擇此角色。

   選擇建**立角色**。

**啟動執行個體**

1. 前往 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。

1. 在側邊導覽中，選擇**執行個體**，然後從頁面頂端選取**啟動執行個體**。

1. 在**名稱**中，輸入 **MyCodePipelineDemo**。這會將標籤**索引鍵** **Name**和標籤**值** 指派給執行個體**MyCodePipelineDemo**。稍後，您會建立 CodeDeploy 應用程式，將範例應用程式部署到此執行個體。CodeDeploy 會根據標籤選取要部署的執行個體。

1. 在**應用程式和作業系統映像 (Amazon Machine Image)** 下，找到具有 AWS 標誌的 **Amazon Linux** AMI 選項，並確認已選取。（此 AMI 描述為 Amazon Linux 2 AMI (HVM)，並標記為「免費方案合格」。)

1. 在**執行個體類型**下，選擇符合免費方案的`t2.micro`類型做為執行個體的硬體組態。

1. 在**金鑰對 （登入）** 下，選擇金鑰對或建立一個金鑰對。

   您也可以選擇**不使用金鑰對繼續**。
**注意**  
基於本教學的目的，您可以在不使用金鑰對的情況下繼續進行。若要使用 SSH 連接到執行個體，請建立或使用金鑰對。

1. 在**網路設定**下，執行下列動作。

   在**自動指派公有 IP** 中，請確定狀態為**啟用**。

   針對建立的安全群組，選擇 **HTTP**，然後在**來源類型**下，選擇**我的 IP**。

1. 展開 **Advanced Details** (進階詳細資訊)。在 **IAM 執行個體描述檔**中，選擇您在先前程序中建立的 IAM 角色 （例如 **EC2InstanceRole**)。

1. 在**摘要**下，於**執行個體數量**下，輸入 `1`.。

1. 選擇**啟動執行個體**。

1. 您可以在 **Instances (執行個體)** 頁面上檢視啟動狀態。當您啟動執行個體時，其初始狀態是 `pending`。在執行個體啟動後，其狀態會變更為 `running`，並得到公有的 DNS 名稱。(如果 **Public DNS (公有 DNS)** 欄未顯示，請選擇 **Show/Hide (顯示/隱藏)** 圖示，然後選擇 **Public DNS (公有 DNS)**。)

## 步驟 4：在 CodeDeploy 中建立應用程式
<a name="codecommit-create-codedeploy-app"></a>

在 CodeDeploy 中，[https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html)是一種資源，其中包含您要部署的軟體應用程式。稍後，您將此應用程式與 CodePipeline 搭配使用，以自動將範例應用程式部署到您的 Amazon EC2 執行個體。

首先，您要建立允許 CodeDeploy 執行部署的角色。然後，您可以建立 CodeDeploy 應用程式。

**建立 CodeDeploy 服務角色**

1. 開啟 IAM 主控台，網址為 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

1. 從主控台儀表板，選擇 **Roles (角色)**。

1. 選擇建**立角色**。

1. 在**選取信任的實體**下，選擇 **AWS 服務**。在**使用案例中**，選擇 **CodeDeploy**。從列出的選項中選擇 **CodeDeploy**。選擇**下一步**。`AWSCodeDeployRole` 受管政策已連接至角色。

1. 選擇**下一步**。

1. 輸入角色的名稱 (例如 **CodeDeployRole**)，然後選擇 **Create role (建立角色)**。

**在 CodeDeploy 中建立應用程式**

1. 在 https：//[https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) 開啟 CodeDeploy 主控台。

1. 如果**應用程式**頁面未顯示，請在功能表中選擇**應用程式**。

1. 選擇**建立應用程式**。

1. 在 **Application name (應用程式名稱)** 中，輸入 **MyDemoApplication**。

1. 在 **Compute Platform (運算平台)** 中，選擇 **EC2/On-premises (EC2/ 現場部署)**。

1. 選擇**建立應用程式**。

**在 CodeDeploy 中建立部署群組**

[https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html)是一種資源，可定義部署相關設定，例如要部署哪些執行個體以及部署這些執行個體的速度。

1. 在顯示您應用程式的頁面上，選擇 **Create deployment group (建立部署群組)**。

1. 在 **Deployment group name (部署群組名稱)** 中，輸入 **MyDemoDeploymentGroup**。

1. 在**服務角色**中，選擇您先前建立之服務角色的 ARN （例如，**`arn:aws:iam::account_ID:role/CodeDeployRole`**)。

1. 在 **Deployment type (部署類型)** 下，選擇 **In-place (就地進行)**。

1. 在 **Environment configuration (環境組態)** 下，選擇 **Amazon EC2 Instances (Amazon EC2 執行個體)**。在**金鑰**欄位中，輸入 **Name**。在**值**欄位中，輸入您用來標記執行個體的名稱 （例如，**MyCodePipelineDemo**)。

1. 在具有 ** AWS Systems Manager 的客服人員組態**下，選擇**現在並排程更新**。這會在執行個體上安裝 代理程式。Linux 執行個體已使用 SSM 代理程式設定，現在將使用 CodeDeploy 代理程式更新。

1. 在 **Deployment configuration (部署組態)** 下，選擇 `CodeDeployDefault.OneAtaTime`。

1. 在**Load Balancer**下，確定未選取**啟用負載平衡**。您不需要為此範例設定負載平衡器或選擇目標群組。

1. 選擇 **Create deployment group (建立部署群組)**。

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

您現在已準備好建立和執行您的第一個管道。在此步驟中，您會建立管道，在程式碼推送至 CodeCommit 儲存庫時自動執行。

**建立 CodePipeline 管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

   前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyFirstPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**的**來源提供者**中，選擇 **CodeCommit**。在**儲存庫名稱**中，選擇您在 中建立的 CodeCommit 儲存庫名稱[步驟 1：建立 CodeCommit 儲存庫](#codecommit-create-repository)。在 **Branch name (分支名稱)** 中，選擇 `main`，然後選擇 **Next step (下一個步驟)**。

   選取儲存庫名稱和分支之後，會出現一則訊息，顯示要為此管道建立的 Amazon CloudWatch Events 規則。

   在 **Change detection options (變更刪除選項)** 下，保持預設設定。這可讓 CodePipeline 使用 Amazon CloudWatch Events 來偵測來源儲存庫中的變更。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。
**注意**  
在此教學中，您將部署無須建置服務的程式碼，因此可以略過此步驟。不過，如果您的原始程式碼需要在部署到執行個體之前建置，您可以在此步驟中設定 [CodeBuild](https://aws.amazon.com/codebuild/)。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**的**部署提供者**中，選擇 **CodeDeploy**。在 **Application name (應用程式名稱)** 中，選擇 **MyDemoApplication**。在 **Deployment group (部署群組)** 中，選擇 **MyDemoDeploymentGroup**，然後選擇 **Next step (下一個步驟)**。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

1. 管道會在建立後開始執行。它會從您的 CodeCommit 儲存庫下載程式碼，並建立 CodeDeploy 部署到您的 EC2 執行個體。當 CodePipeline 範例將網頁部署到 CodeDeploy 部署中的 Amazon EC2 執行個體時，您可以檢視進度、成功和失敗訊息。  
![\[在 CodePipeline 主控台中開始執行的管道檢視。\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/codepipeline-firstpipeline-codecommit-pol.png)

恭喜您！您剛在 CodePipeline 中建立簡單的管道。

下一步，您會驗證結果。

**驗證您的管道是否成功執行**

1. 檢視管道初始進度。每一個階段狀態會從 **No executions yet (尚未執行)**​ 變更為 **In Progress (進行中)**，然後顯示 **Succeeded (成功)**​ 或 **Failed (失敗)**。該管道應會在幾分鐘內完成初次執行。

1. 管道狀態顯示**成功**後，在**部署**階段的狀態區域中，選擇 **CodeDeploy**。這會開啟 CodeDeploy 主控台。如果未顯示 **Succeeded (成功)**，請參閱 [CodePipeline 故障診斷](troubleshooting.md)。

1.  在 **Deployments (部署)** 標籤上，選擇部署 ID。在部署的頁面上的 **Deployment lifecycle events (部署生命週期事件)** 下，選擇執行個體 ID。這會開啟 EC2 主控台。

1. 在 **Description (敘述)** 標籤的 **Public DNS (公有 DNS)** 中複製地址 (例如，`ec2-192-0-2-1.us-west-2.compute.amazonaws.com`)，然後貼上至 Web 瀏覽器的地址列中。

   網頁會顯示您下載並推送至 CodeCommit 儲存庫的範例應用程式。

如需關於階段、動作以及管道如何運作的更多資訊，請參閱 [CodePipeline 概念](concepts.md)。

## 步驟 6：修改 CodeCommit 儲存庫中的程式碼
<a name="codecommit-push-code"></a>

您的管道設定為在對 CodeCommit 儲存庫進行程式碼變更時執行。在此步驟中，您會變更屬於 CodeCommit 儲存庫中範例 CodeDeploy 應用程式一部分的 HTML 檔案。推送這些變更時，您的管道會再次執行，並會在您稍早存取的 Web 地址顯示您所做的變更。

1. 將目錄變更為您的本機儲存庫：

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

1. 使用文字編輯器修改 `index.html` 檔案：

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

1. 修訂 `index.html` 檔案的內容，變更網頁的背景顏色和一些文字，然後儲存檔案。

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

1. 透過執行下列命令來遞交變更並推送至 CodeCommit 儲存庫，一次一個命令：

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

   ```
   git push
   ```

**驗證您的管道是否成功執行**

1. 檢視管道初始進度。每一個階段狀態會從 **No executions yet (尚未執行)**​ 變更為 **In Progress (進行中)**，然後顯示 **Succeeded (成功)**​ 或 **Failed (失敗)**。管道的執行應會在幾分鐘內完成。

1. 動作狀態顯示 **Succeeded (成功)** 後，請重新整理您先前在瀏覽器中存取的示範頁面。

   隨即顯示更新的網頁。

## 步驟 7：清除資源
<a name="codecommit-clean-up"></a>

您可以將在此教學中建立的一些資源用在本指南的其他教學。例如，您可以重複使用 CodeDeploy 應用程式和部署。不過，在您完成這些教學課程之後，應該刪除管道以及其所使用的資源，才不會因為持續使用那些資源而付費。首先，刪除管道，然後刪除 CodeDeploy 應用程式及其相關聯的 Amazon EC2 執行個體，最後刪除 CodeCommit 儲存庫。

**清除此教學中使用的資源**

1. 若要清除 CodePipeline 資源，請遵循 [中刪除管道 AWS CodePipeline](pipelines-delete.md)中的指示。

1. 若要清除 CodeDeploy 資源，請遵循[清除部署逐步解說資源](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up)中的指示。

1. 若要刪除 CodeCommit 儲存庫，請遵循[刪除 CodeCommit 儲存庫](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html)中的指示。

## 步驟 8：深入閱讀
<a name="codecommit-optional-tasks"></a>

進一步了解 CodePipeline 的運作方式：
+ 如需關於階段、動作以及管道如何運作的更多資訊，請參閱 [CodePipeline 概念](concepts.md)。
+ 如需使用 CodePipeline 可執行之動作的相關資訊，請參閱 [與 CodePipeline 動作類型的整合](integrations-action-type.md)。
+ 嘗試這個更進階的教學：[教學：建立四階段管道](tutorials-four-stage-pipeline.md)。這個教學會建立多階段管道，其中包含在部署程式碼前的程式碼建置步驟。

# 教學：建立四階段管道
<a name="tutorials-four-stage-pipeline"></a>

現在您已在 [教學：建立簡易管道 (S3 儲存貯體)](tutorials-simple-s3.md)或 [教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)中建立您的第一個管道，您可以開始建立更複雜的管道。本教學課程將逐步引導您建立四階段管道，該管道使用來源的 GitHub 儲存庫、建置專案的 Jenkins 建置伺服器，以及部署建置程式碼至預備伺服器的 CodeDeploy 應用程式。下圖顯示初始三階段管道。

![\[顯示具有來源動作的來源階段、具有 Jenkins 動作的建置階段，以及具有部署動作的部署階段的圖表。\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/flow-codepipeline-codecommit-jenkins.png)


在建立管道之後，您將會使用測試動作來編輯管道以將之新增到階段中，藉以測試程式碼，同時也使用 Jenkins。

在建立此管道前，您必須設定必要資源。例如，如果您想要為原始程式碼使用 GitHub 儲存庫，必須在新增到管道前建立儲存庫。在設定的環節中，本教學將會帶您演練如何在 EC2 執行個體上設定 Jenkins，以進行示範。

**重要**  
您在此程序中新增至管道的許多動作都涉及您在建立管道之前需要建立 AWS 的資源。來源動作 AWS 的資源一律必須在您建立管道 AWS 的相同區域中建立。例如，如果您在美國東部 （俄亥俄） 區域建立管道，則 CodeCommit 儲存庫必須位於美國東部 （俄亥俄） 區域。  
您可以在建立管道時新增跨區域動作。跨區域動作 AWS 的資源必須位於您計劃執行動作的相同 AWS 區域中。如需詳細資訊，請參閱[在 CodePipeline 中新增跨區域動作](actions-create-cross-region.md)。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

在您開始此教學前，應已完成 [CodePipeline 入門](getting-started-codepipeline.md)​ 中的一般先決條件。

**Topics**
+ [

## 步驟 1：完成事前準備
](#tutorials-four-stage-pipeline-prerequisites)
+ [

## 步驟 2：在 CodePipeline 中建立管道
](#tutorials-four-stage-pipeline-pipeline-create)
+ [

## 步驟 3：新增另一個階段至您的管道
](#tutorials-four-stage-pipeline-add-stage)
+ [

## 步驟 4：清除資源
](#tutorials-four-stage-pipeline-clean-up)

## 步驟 1：完成事前準備
<a name="tutorials-four-stage-pipeline-prerequisites"></a>

若要與 Jenkins 整合， AWS CodePipeline 會要求您在要與 CodePipeline 搭配使用的任何 Jenkins 執行個體上安裝適用於 Jenkins 的 CodePipeline 外掛程式。您也應該設定專用 IAM 使用者或角色，以用於 Jenkins 專案和 CodePipeline 之間的許可。整合 Jenkins 和 CodePipeline 的最簡單方法是在 EC2 執行個體上安裝 Jenkins，該執行個體使用您為 Jenkins 整合建立的 IAM 執行個體角色。為讓在 Jenkins 動作管道內的連結能夠成功連線，您必須在伺服器或 EC2 執行個體上進行代理與防火牆設定，以允許您的 Jenkins 專案使用送入至連接埠的連線。請確定您在允許對那些連接埠 (例如若您限制 Jenkins 只使用 HTTPS 連線則為 443 與 8443，或者若您允許 HTTPS 連線則是 80 與 8080) 的連線前，已設定 Jenkins 來驗證使用者身分並強化存取控制。如需詳細資訊，請參閱[保護 Jenkins 安全](https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins)。

**注意**  
此教學使用程式碼範例並設定將範本自 Haml 轉換為 HTML 的組建步驟。您也可以依照[Copy (複製) 或 Clone (複製) 範本到 GitHub 儲存庫](#tutorials-four-stage-pipeline-prerequisites-github)中的步驟，自 GitHub 儲存庫下載開放原始範本程式碼。您將需要 GitHub 程式庫中完整的範本，而不只是 .zip 檔。  
此教學也假設：  
您對於安裝及管理 Jenkins 還有建立 Jenkins 專案的操作非常熟悉。
您已在代管您的 Jenkins 專案的相同電腦或執行個體上安裝適用於 Ruby 的 Rake 與 Haml Gem。
您已設定必要的系統環境變數，讓 Rake 命令可從終端機或命令列執行 (例如在 Windows 系統上，修改 PATH 變數以加入您安裝了 Rake 的目錄)。

**Topics**
+ [

### Copy (複製) 或 Clone (複製) 範本到 GitHub 儲存庫
](#tutorials-four-stage-pipeline-prerequisites-github)
+ [

### 建立用於 Jenkins 整合的 IAM 角色
](#tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role)
+ [

### 安裝和設定 Jenkins 和 CodePipeline Plugin for Jenkins
](#tutorials-four-stage-pipeline-prerequisites-jenkins-configure)

### Copy (複製) 或 Clone (複製) 範本到 GitHub 儲存庫
<a name="tutorials-four-stage-pipeline-prerequisites-github"></a>

**複製範本並推送到 GitHub 儲存庫**

1. 從 GitHub 儲存庫下載範本程式碼，或複製程式庫到您的本機電腦。有兩種範本套件：
   + 如果您要將範例部署到 Amazon Linux、RHEL 或 Ubuntu Server 執行個體，請選擇 [codepipeline-jenkins-aws-codedeploy\$1linux.zip](https://github.com/awslabs/aws-codepipeline-jenkins-aws-codedeploy_linux)。
   + 如果您要將範例部署到 Windows Server 執行個體，請選擇 [CodePipeline-Jenkins-AWSCodeDeploy\$1Windows.zip](https://github.com/awslabs/AWSCodePipeline-Jenkins-AWSCodeDeploy_windows)。

1. 從儲存庫中，選擇 **Fork (延伸)**​ 來複製範本儲存庫到 Github 帳戶中的儲存庫。如需詳細資訊，請參閱 [GitHub 文件](https://help.github.com/articles/create-a-repo/)。

### 建立用於 Jenkins 整合的 IAM 角色
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role"></a>

最佳實務是考慮啟動 EC2 執行個體來託管您的 Jenkins 伺服器，並使用 IAM 角色授予執行個體與 CodePipeline 互動所需的許可。

1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 開啟 IAM 主控台。

1. 在 IAM 主控台的導覽面板中，選擇**角色**，然後選擇**建立角色**。

1. 在 **Select type of trusted entity** (選取可信任執行個體類型) 下，選擇 **AWS 服務**。在 **Choose the service that will use this role (選擇將使用此角色的服務)** 下，選擇 **EC2**。在 **Select your use case (選取您的使用案例)** 下，選擇 **EC2**。

1. 選擇**下一步：許可**。在 **Attach permissions policies (附加許可政策)** 頁面上，選取 `AWSCodePipelineCustomActionAccess` 受管政策，然後選擇 **Next: Tags (下一步：標籤)**。選擇下**一步：檢閱**。

1. 在**檢閱**頁面**的角色名稱**中，輸入要特別為 Jenkins 整合建立的角色名稱 （例如 *JenkinsAccess*)，然後選擇**建立角色**。

當您建立要在其中安裝 Jenkins 的 EC2 執行個體時，請在**步驟 3：設定執行個體詳細資訊**中，確定您選擇執行個體角色 （例如 *JenkinsAccess*)。

如需執行個體角色和 Amazon EC2 的詳細資訊，請參閱 [Amazon EC2 的 IAM 角色](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)、[使用 IAM 角色將許可授予在 Amazon EC2 執行個體上執行的應用程式](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html)，以及[建立角色以將許可委派給 AWS 服務](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html)。

### 安裝和設定 Jenkins 和 CodePipeline Plugin for Jenkins
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-configure"></a>

**安裝 Jenkins 和 CodePipeline Plugin for Jenkins**

1. 建立您將安裝 Jenkins 的 EC2 執行個體，並在**步驟 3：設定執行個體詳細資訊**中，確定您選擇您建立的執行個體角色 （例如 *JenkinsAccess*)。如需建立 EC2 執行個體的詳細資訊，請參閱《[Amazon EC2 使用者指南》中的啟動 Amazon EC2 執行個體](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html)。 *Amazon EC2 * 
**注意**  
如果您已有想要使用的 Jenkins 資源，您可以這麼做，但您必須建立特殊 IAM 使用者、將 `AWSCodePipelineCustomActionAccess`受管政策套用到該使用者，然後在 Jenkins 資源上設定並使用該使用者的存取憑證。如果您想要使用 Jenkins UI 來供應登入資料，請設定 Jenkins 為僅允許使用 HTTPS。如需詳細資訊，請參閱[CodePipeline 故障診斷](troubleshooting.md)。

1. 在 EC2 執行個體上安裝 Jenkins。如需更多資訊，請參閱說明[安裝 Jenkins](https://www.jenkins.io/doc/book/installing/linux/) 與[啟動並存取 Jenkins](https://wiki.jenkins.io/JENKINS/Starting-and-Accessing-Jenkins.html) 的 Jenkins 文件，以及 [與 CodePipeline 的產品和服務整合](integrations.md) 中的 [details of integration with Jenkins](integrations-action-type.md#JenkinsInt_2)。

1. 啟動 Jenkins，然後在首頁上選擇 **Manage Jenkins (管理 Jenkins)**。

1. 在 **Manage Jenkins (管理 Jenkins)** 頁面上，選擇 **Manage Plugins (管理外掛程式)**。

1. 選擇 **Available (可用)** 標籤，並在 **Filter (篩選條件)** 搜尋方塊中輸入 **AWS CodePipeline**。從清單中選擇**適用於 Jenkins 的 CodePipeline 外掛程式**，然後選擇**立即下載並在重新啟動後安裝**。

1. 在 **Installing Plugins/Upgrades (安裝外掛程式/升級)** 頁面上，選擇 **Restart Jenkins when installation is complete and no jobs are running (安裝完成且沒有正在執行的工作時重新啟動 Jenkins)**。

1. 選擇 **Back to Dashboard (返回儀表板)**。

1. 在主要頁面上，選擇 **New Item (新項目)**。

1. 在 **Item Name (項目名稱)** 中，輸入 Jenkins 的名稱 (例如，*MyDemoProject*)。選擇 **Freestyle project (自由形式專案)**，然後選擇 **OK (確定)**。
**注意**  
請確定專案的名稱符合 CodePipeline 的要求。如需詳細資訊，請參閱[AWS CodePipeline 中的配額](limits.md)。

1. 在專案的組態頁面上，勾選 **Execute concurrent builds if necessary (若需要請執行同時進行的組建)** 核取方塊。​ 在 **Source Code Management (原始程式碼管理)** 中，選擇 **AWS CodePipeline**。如果您已在 EC2 執行個體上安裝 Jenkins，並使用您為 CodePipeline 和 Jenkins 之間整合所建立的 IAM 使用者 AWS CLI 設定檔來設定 ，請將所有其他欄位保留空白。

1. 選擇**進階**，然後在**提供者**中輸入動作提供者的名稱，因為它會顯示在 CodePipeline 中 （例如 *MyJenkinsProviderName*)。請確認此名稱為唯一且易記。您將會在此教學後面部分中將組建動作新增到管道，然後會在新增測試動作時在次重複此操作。
**注意**  
此動作名稱必須符合 CodePipeline 中動作的命名要求。如需詳細資訊，請參閱[AWS CodePipeline 中的配額](limits.md)。

1. 在 **Build Triggers (組建觸發)** 中，清除任何核取方塊，然後選擇 **Poll SCM (輪詢 SCM)**。在 **Schedule (排程)** 中，輸入五個星號，並以空格間隔，如下所示：

   ```
   * * * * *
   ```

   這會每分鐘輪詢 CodePipeline。

1. 在 **Build (組建)** 中，選擇 **Add build step (新增組建步驟)**。選擇**執行 shell **(Amazon Linux、RHEL 或 Ubuntu Server) **執行批次命令** (Windows Server)，然後輸入下列內容：

   ```
   rake
   ```
**注意**  
請確認您的環境使用執行 Rake 所需的變數及設定來配置；否則組建將會失敗。

1. 選擇**新增建置後動作**，然後選擇 **AWS CodePipeline Publisher**。選擇 **Add (新增)**，然後在 **Build Output Locations (組建輸出位置)** 中，將位置保留為空白。此組態為預設。將會在組建程結束時建立壓縮檔。

1. 選擇 **Save (儲存)** 來儲存您的 Jenkins 專案。

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

在此部分的教學中，您將會使用 **Create Pipeline (建立管道)**​ 精靈來建立管道。

**建立 CodePipeline 自動發行程序**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 如有需要，可使用區域選擇器，將區域變更為您的管道資源所在的區域。例如，如果您在 中為上一個教學課程建立資源`us-east-2`，請確定區域選擇器設定為美國東部 （俄亥俄）。

   如需 CodePipeline 可用區域和端點的詳細資訊，請參閱[AWS CodePipeline 端點和配額](https://docs.aws.amazon.com/general/latest/gr/codepipeline.html)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**頁面上，在**管道名稱**中，輸入管道的名稱。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**頁面的**來源提供者**中，選擇 **GitHub**。

1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

1. 在**步驟 4：新增建置階段**中，選擇**新增 Jenkins**。在**提供者名稱**中，輸入您在 CodePipeline Plugin for Jenkins （例如 *MyJenkinsProviderName*) 中提供的動作名稱。此名稱必須與適用於 Jenkins 的 CodePipeline 外掛程式中的名稱完全相符。在 **Server URL (伺服器 URL)**，輸入 Jenkins 安裝的 EC2 執行個體。在 **Project name (專案名稱)** 中，輸入您在 Jenkins 中建立的專案名稱，例如 *MyDemoProject*，然後選擇 **Next (下一步)**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**中，重複使用您在 中建立的 CodeDeploy 應用程式和部署群組[教學：建立簡易管道 (S3 儲存貯體)](tutorials-simple-s3.md)。在**部署提供者**中，選擇 **CodeDeploy**。在 **Application name (應用程式名稱)** 中，輸入 **CodePipelineDemoApplication**，或選擇 refresh (重新整理) 按鈕，然後從清單中選擇應用程式名稱。在 **Deployment group (部署群組)** 中，輸入 **CodePipelineDemoFleet**，或從清單中選擇，然後選擇 **Next (下一步)**。
**注意**  
您可以使用自己的 CodeDeploy 資源或建立新的資源，但可能會產生額外費用。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

1. 管道會自動在管道中啟動並執行範本。當管道將 Haml 範例建置至 HTML 並將其部署至 CodeDeploy 部署中的每個 Amazon EC2 執行個體時，您可以檢視進度、成功和失敗訊息。

## 步驟 3：新增另一個階段至您的管道
<a name="tutorials-four-stage-pipeline-add-stage"></a>

現在您將建立測試階段然後和測試動作到階段中，該階段使用包含在範本中的 Jenkins 測試來判定網頁是否有任何內容。此測試僅用於示範用途。

**注意**  
如果您不希望新增另一個階段到您的管道，您可以在部署動作之前或之後新增測試動作到管道的 Staging (預備) 階段。

### 新增測試階段到管道
<a name="tutorials-four-stage-pipeline-add-stage-console"></a>

**Topics**
+ [

#### 查詢執行個體的 IP 地址
](#tutorials-four-stage-pipeline-instance-ip-lookup)
+ [

#### 建立用於測試部署的 Jenkins 專案
](#tutorials-four-stage-pipeline-create-jenkins-project)
+ [

#### 建立第四個階段
](#tutorials-four-stage-pipeline-create-fourth-stage)

#### 查詢執行個體的 IP 地址
<a name="tutorials-four-stage-pipeline-instance-ip-lookup"></a>

**驗證您想要部署程式碼的執行個體 IP 地址**

1. 在該管道狀態顯示 **Succeeded (成功)​** 後，在 Staging (預備)​ 階段的狀態區域中，選擇 **Details (詳細資訊)**。

1. 在**部署詳細資訊**區段中，在**執行個體 ID** 中選擇其中一個成功部署的執行個體中的執行個體 ID。

1. 複製執行個體的 IP 地址 (例如，*192.168.0.4*)。您將會在 Jenkins 測試中使用此 IP 地址。

#### 建立用於測試部署的 Jenkins 專案
<a name="tutorials-four-stage-pipeline-create-jenkins-project"></a>

**建立 Jenkins 專案**

1. 在您安裝了 Jenkins 的執行個體上開啟 Jenkins，並從首頁選擇 **New Item (新項目)**。

1.  在 **Item Name (項目名稱)** 中，輸入 Jenkins 的名稱 (例如，*MyTestProject*)。選擇 **Freestyle project (自由形式專案)**，然後選擇 **OK (確定)**。
**注意**  
請確定專案的名稱符合 CodePipeline 要求。如需詳細資訊，請參閱[AWS CodePipeline 中的配額](limits.md)。

1. 在專案的組態頁面上，勾選 **Execute concurrent builds if necessary (若需要請執行同時進行的組建)** 核取方塊。​ 在 **Source Code Management (原始程式碼管理)** 中，選擇 **AWS CodePipeline**。如果您已在 EC2 執行個體上安裝 Jenkins，並使用您為 CodePipeline 和 Jenkins 之間整合所建立的 IAM 使用者 AWS CLI 設定檔來設定 ，請將所有其他欄位保留空白。
**重要**  
如果您正在設定 Jenkins 專案，但未安裝在 Amazon EC2 執行個體上，或安裝在執行 Windows 作業系統的 EC2 執行個體上，請完成代理主機和連接埠設定所需的欄位，並提供您為 Jenkins 和 CodePipeline 之間整合所設定之 IAM 使用者或角色的登入資料。

1. 選擇 **Advanced (進階)**，並在 **Category (目錄)** 中選擇 **Test (測試)**。

1. 在 **Provider (提供者)** 中，輸入您用於建置專案的相同名稱 (例如，*MyJenkinsProviderName*)。在此教學後面部分中，您將會在新增測試動作到管道時使用此名稱。
**注意**  
此名稱必須符合動作的 CodePipeline 命名要求。如需詳細資訊，請參閱[AWS CodePipeline 中的配額](limits.md)。

1. 在 **Build Triggers (組建觸發)** 中，清除任何核取方塊，然後選擇 **Poll SCM (輪詢 SCM)**。在 **Schedule (排程)** 中，輸入五個星號，並以空格間隔，如下所示：

   ```
   * * * * *
   ```

   這會每分鐘輪詢 CodePipeline。

1. 在 **Build (組建)** 中，選擇 **Add build step (新增組建步驟)**。如果您要部署到 Amazon Linux、RHEL 或 Ubuntu Server 執行個體，請選擇**執行 shell。 **接著，輸入下列內容，其中 IP 地址為您之前複製的 EC2 執行個體地址：

   ```
   TEST_IP_ADDRESS=192.168.0.4 rake test
   ```

   如果您要部署到 Windows Server 執行個體，請選擇**執行批次命令**，然後輸入以下內容，其中 IP 地址是您先前複製的 EC2 執行個體地址：

   ```
   set TEST_IP_ADDRESS=192.168.0.4 rake test
   ```
**注意**  
測試假設預設連接埠為 80。若您想要指定不同的連接埠，請新增測試連接埠陳述式，如下所示：  

   ```
   TEST_IP_ADDRESS=192.168.0.4 TEST_PORT=8000 rake test
   ```

1. 選擇**新增建置後動作**，然後選擇 **AWS CodePipeline Publisher**。請勿選擇 **Add (新增)**。

1. 選擇 **Save (儲存)** 來儲存您的 Jenkins 專案。

#### 建立第四個階段
<a name="tutorials-four-stage-pipeline-create-fourth-stage"></a>

**新增階段到內含 Jenkins 測試動作的管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在**名稱**中，選擇您建立的管道名稱 MySecondPipeline。

1. 在管道詳細資訊頁面上，選擇 **Edit (編輯)**。

1. 在 **Edit (編輯)** 頁面上，選擇 **\$1 Stage (\$1 階段)** 以在 Build (建置) 階段後立即新增一個階段。

1. 在新階段的名稱欄位中，輸入名稱 (例如 **Testing**)，然後選擇 **\$1 Add action group (\$1 新增動作群組)**。

1. 在 **Action name (動作名稱)** 中，輸入 *MyJenkinsTest-Action*。在 **Test provider (測試供應者)** 中，選擇您在 Jenkins 中指定的供應者名稱 (例如 *MyJenkinsProviderName*)。在 **Project name (專案名稱)** 中，輸入您在 Jenkins 中建立的專案名稱 (例如 *MyTestProject*)。在 **Input artifacts (輸入成品)** 中，從 Jenkins 組建中選擇預設名稱為 *BuildArtifact* 的成品，然後選擇 **Done (完成)**。
**注意**  
由於 Jenkins 測試動作會在 Jenkins 建置步驟中建置的應用程式上運作，請使用建置成品作為測試動作的輸入成品。

   如需有關輸入和輸出成品以及管道結構的詳細資訊，請參閱 [CodePipeline 管道結構參考](reference-pipeline-structure.md)。

1. 在 **Edit (編輯)** 頁面上，選擇 **Save pipeline changes (儲存管道變更)**。在 **Save pipeline changes (儲存管道變更)** 對話方塊中，選擇 **Save and continue (儲存並繼續)**。

1. 雖然新階段已新增至您的管道，但由於沒有發生觸發另一個管道執行的變更，所以會顯示該階段為 **No executions yet (尚未執行)**。若要透過修訂後的管道執行範例，請在管道詳細資訊頁面上，選擇**釋出變更**。

   管道檢視會顯示管道中的階段與動作，以及在那四個階段間執行的版本狀態。管道執行所有階段所需花費的時間將根據成品大小、組建與測試動作的複雜度、以及其他因素而定。

## 步驟 4：清除資源
<a name="tutorials-four-stage-pipeline-clean-up"></a>

在您完成本教學之後，您應該刪除管道以及其所使用的資源，如此您才不會因為持續使用那些資源而付費。如果您不打算繼續使用 CodePipeline，請刪除管道，然後刪除 CodeDeploy 應用程式及其相關聯的 Amazon EC2 執行個體，最後刪除用於存放成品的 Amazon S3 儲存貯體。若您不想要繼續使用，也應考慮是否刪除其他資源，例如 GitHub 儲存庫。

**清除此教學中使用的資源**

1. 在本機 Linux、macOS 或 Unix 機器上開啟終端機工作階段，或在本機 Windows 機器上開啟命令提示，然後執行 **delete-pipeline**命令來刪除您建立的管道。對於 **MySecondPipeline**，建議您輸入下列命令：

   ```
   aws codepipeline delete-pipeline --name "MySecondPipeline"
   ```

   此命令不會傳回任何結果。

1. 若要清除 CodeDeploy 資源，請遵循[清除](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-walkthrough.html#getting-started-walkthrough-clean-up)中的指示。

1. 若要清除您的執行個體資源，請刪除您安裝 Jenkins 的 EC2 執行個體。如需詳細資訊，請參閱[清理您的執行個體](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-clean-up-your-instance.html)。

1. 如果您不想建立更多管道或再次使用 CodePipeline，請刪除用於儲存管道成品的 Amazon S3 儲存貯體。若要刪除​儲存貯體，請按照[刪除儲存貯體](https://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html)中的說明進行。

1. 若您不想要再次使用此管道的其他資源，請考慮依照該特定資源的說明來刪除這些資源。例如，若您想要刪除 GitHub 儲存庫，請依照 GitHub 網站上的[刪除儲存庫](https://help.github.com/articles/deleting-a-repository/)中的說明來操作。

# 教學課程：設定 CloudWatch Events 規則以接收管道狀態變更的電子郵件通知
<a name="tutorials-cloudwatch-sns-notifications"></a>

在 中設定管道之後 AWS CodePipeline，您可以設定 CloudWatch Events 規則，以便在管道的執行狀態變更時，或在管道的階段或動作中傳送通知。如需使用 CloudWatch Events 設定管道狀態變更通知的詳細資訊，請參閱 [監控 CodePipeline 事件](detect-state-changes-cloudwatch-events.md)。

在本教學中，您會設定通知，在管道狀態變更為 FAILED (失敗) 時傳送電子郵件。本教學課程在建立 CloudWatch Events 規則時使用輸入轉換器方法。它會將訊息結構描述詳細資訊轉換成可供人閱讀的文字訊息。

**注意**  
當您建立本教學課程的資源時，例如 Amazon SNS 通知和 CloudWatch Events 規則，請確定在 AWS 與管道相同的區域中建立資源。

**Topics**
+ [

## 步驟 1：使用 Amazon SNS 設定電子郵件通知
](#create-filter-for-target)
+ [

## 步驟 2：建立規則並將 SNS 主題新增為目標
](#create-notification-rule)
+ [

## 步驟 3：清除資源
](#notifications-clean-up-resources)

## 步驟 1：使用 Amazon SNS 設定電子郵件通知
<a name="create-filter-for-target"></a>

Amazon SNS 會協調主題的使用，將訊息傳遞給訂閱端點或用戶端。使用 Amazon SNS 建立通知主題，然後使用您的電子郵件地址訂閱主題。Amazon SNS 主題將新增為 CloudWatch Events 規則的目標。如需詳細資訊，請參閱《[Amazon Simple Notification Service 開發人員指南](https://docs.aws.amazon.com/sns/latest/dg/)》。

在 Amazon SNS 中建立或識別主題。CodePipeline 將使用 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 (主題名稱)**，輸入主題的名稱 (例如 **PipelineNotificationTopic**)。  
![\[使用 Amazon SNS 建立通知主題。\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/tutorial-SNS-topic.png)

1. 請選擇**建立主題**。

   如需詳細資訊，請參閱《*Amazon SNS 開發人員指南*》中的[建立主題](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html)。

讓一或多個收件人訂閱主題來接收電子郵件通知。讓收件人訂閱主題：

1. 在 Amazon SNS 主控台**的主題**清單中，選取新主題旁的核取方塊。選擇 **​Actions, Subscribe to topic (動作、訂閱主題)**。

1. 在 **​Create subscription (建立訂閱)** 對話方塊中，確認 ARN 有出現在 **​Topic ARN (主題 ARN)** 中。

1. 對於**通訊協定**，選擇**電子郵件**。

1. 針對 **​Endpoint (端點)**，輸入收件人的完整電子郵件地址。

1. 選擇 **Create Subscription** (建立訂閱)。

1. Amazon SNS 會傳送訂閱確認電子郵件給收件人。若要接收電子郵件通知，收件人必須選擇此電子郵件中的 **​Confirm subscription (確認訂閱)** 連結。收件人按一下連結後，如果成功訂閱，Amazon SNS 會在收件人的 Web 瀏覽器中顯示確認訊息。

   如需詳細資訊，請參閱《*Amazon SNS 開發人員指南*》中的[訂閱主題](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html)。

## 步驟 2：建立規則並將 SNS 主題新增為目標
<a name="create-notification-rule"></a>

使用 CodePipeline 做為事件來源來建立 CloudWatch Events 通知規則。

1. 透過 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 開啟 CloudWatch 主控台。

1. 在導覽窗格中，選擇 **Events (事件)**。

1. 選擇**建立規則**。在 **​Event source (事件來源)** 下，選擇 **AWS CodePipeline**。針對**事件類型**，選擇**管道執行狀態變更**。

1. 選擇 **​Specific state(s) (特定狀態)**，然後選擇 **FAILED**。

1. 選擇 **​Edit (編輯)**，開啟 **Event Pattern Preview (事件模式預覽)** 窗格的 JSON 編輯器。使用您管道的名稱新增 **pipeline** 參數，如下列名為 "myPipeline" 管道的範例所示。

   您可以複製此處的事件模式並將其貼到主控台中：

   ```
   {
     "source": [
       "aws.codepipeline"
     ],
     "detail-type": [
       "CodePipeline Pipeline Execution State Change"
     ],
     "detail": {
       "state": [
         "FAILED"
       ],
       "pipeline": [
         "myPipeline"
       ]
     }
   }
   ```

1. 在 **Targets** (目標) 中，選擇 **Add target (新增目標)**。

1. 在目標清單中，選擇 **​SNS topic (SNS 主題)**。針對 **​Topic (主題)**，輸入您建立的主題。

1. 展開 **​Configure input (設定輸入)**，然後選擇 **​Input Transformer (輸入轉換器)**。

1. 在 **​Input Path (輸入路徑)** 方塊中，輸入下列鍵/值對。

   ```
   { "pipeline" : "$.detail.pipeline" }
   ```

   在 **​Input Template (輸入範本)** 方塊中，輸入下列內容：

   ```
   "The Pipeline <pipeline> has failed."
   ```

1. 選擇**設定詳細資訊**。

1. 在 **​Configure rule details (設定規則詳細資訊)** 頁面上，輸入名稱及選擇性描述。針對 **​State (狀態)**，將 **​Enabled (啟用)** 保留在選取狀態。

1. 選擇**建立規則**。

1. 確認 CodePipeline 現在正在傳送建置通知。例如，檢查您的收件匣中是否有組建通知電子郵件。

1. 若要變更規則的行為，請在 CloudWatch 主控台中選擇規則，然後選擇**動作**、**編輯**。編輯規則，選擇 **​Configure details (設定詳細資訊)**，然後選擇 **​Update rule (更新規則)**。

   若要停止使用規則來傳送建置通知，請在 CloudWatch 主控台中選擇規則，然後選擇**動作**、**停用**。

   若要刪除規則，請在 CloudWatch 主控台中選擇規則，然後選擇**動作**、**刪除**。

## 步驟 3：清除資源
<a name="notifications-clean-up-resources"></a>

在您完成本教學之後，您應該刪除管道以及其所使用的資源，如此您才不會因為持續使用那些資源而付費。

如需有關如何清除 SNS 通知和刪除 Amazon CloudWatch Events 規則的資訊，請參閱《Amazon CloudWatch Events API 參考`DeleteRule`》中的[清除 （取消訂閱 Amazon SNS 主題）](https://docs.aws.amazon.com/sns/latest/dg/CleanUp.html) 和參考。 [Amazon CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/)

# 教學課程：建立使用 建置和測試 Android 應用程式的管道 AWS Device Farm
<a name="tutorials-codebuild-devicefarm"></a>

您可以使用 AWS CodePipeline 來設定持續整合流程，在每次推送遞交時，在其中建置和測試您的應用程式。本教學會示範如何建立及設定管道，使用 GitHub 儲存庫中的來源碼建置及測試您的 Android 應用程式。管道會偵測新 GitHub 遞交的到達，然後使用 [CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html) 建置應用程式和 [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) 進行測試。

**重要**  
在主控台中建立管道時，CodePipeline 將使用 S3 成品儲存貯體做為成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**重要**  
您在此程序中新增至管道的許多動作都涉及您在建立管道之前需要建立 AWS 的資源。來源動作 AWS 的資源一律必須在您建立管道 AWS 的相同區域中建立。例如，如果您在美國東部 （俄亥俄） 區域建立管道，則 CodeCommit 儲存庫必須位於美國東部 （俄亥俄） 區域。  
您可以在建立管道時新增跨區域動作。跨區域動作 AWS 的資源必須位於您計劃執行動作的相同 AWS 區域中。如需詳細資訊，請參閱[在 CodePipeline 中新增跨區域動作](actions-create-cross-region.md)。

您可以使用現有的 Android 應用程式和測試定義來試用，也可以使用 [ Device Farm 提供的範例應用程式和測試定義](https://github.com/aws-samples/aws-device-farm-sample-app-for-android)。

**開始之前**

1. 登入 AWS Device Farm 主控台，然後選擇**建立新專案**。

1. 選擇您的專案。在瀏覽器中，複製新專案的 URL。URL 包含專案 ID。

1. 複製並保留此專案 ID。您可以在 CodePipeline 中建立管道時使用它。

   這裡有專案的 URL 範例。若要擷取專案 ID，請複製 `projects/` 後面的值。在此範例中，專案 ID 為 `eec4905f-98f8-40aa-9afc-4c1cfexample`。

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## 設定 CodePipeline 以使用您的 Device Farm 測試
<a name="codepipeline-configure-tests"></a>

1. 

   在應用程式程式碼的根[https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)目錄中新增並遞交名為 的檔案，然後將其推送到您的儲存庫。CodeBuild 使用此檔案來執行建置應用程式所需的命令和存取成品。

   ```
   version: 0.2
   
   phases:
     build:
       commands:
         - chmod +x ./gradlew
         - ./gradlew assembleDebug
   artifacts:
     files:
        - './android/app/build/outputs/**/*.apk'
     discard-paths: yes
   ```

1. (選擇性) 若您[使用 Calabash 或 Appium 測試您的應用程式](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-intro.html)，請將測試定義檔案新增至您的儲存庫。在後續步驟中，您可以將 Device Farm 設定為使用 定義來執行您的測試套件。

   如果您使用 Device Farm 內建測試，則可以略過此步驟。

1. 若要建立您的管道及新增來源階段，請執行下列作業：

   1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

   1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

   1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

   1. 在**步驟 2：選擇管道設定**頁面上，在**管道名稱**中，輸入管道的名稱。

   1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

   1. 在 **Service role (服務角色)** 中，讓 **New service role (新服務角色)** 維持在選取狀態，然後讓 **Role name (角色名稱)** 維持不變。若您已擁有現有服務角色，您也可以選擇使用它。
**注意**  
如果您使用 2018 年 7 月之前建立的 CodePipeline 服務角色，則需要新增 Device Farm 的許可。若要這樣做，請開啟 IAM 主控台、尋找角色，然後將下列許可新增至角色的政策。如需詳細資訊，請參閱[將許可新增至 CodePipeline 服務角色](how-to-custom-role.md#how-to-update-role-new-services)。  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

   1. 在**步驟 3：新增來源階段**頁面的**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

   1. 在 **​Repository (儲存庫)** 中，選擇來源儲存庫。

   1. 在 **​Branch (分支)** 中，選擇您希望使用的分支。

   1. 保留來源動作的其餘預設值。選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，新增建置階段：

   1. 在**建置提供者**中，選擇**其他建置提供者**，然後選擇 **AWS CodeBuild**。允許 **Region (區域)** 預設為管道區域。

   1. 選擇**建立專案**。

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment image (環境映像)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。針對**映像**，選擇 **aws/codebuild/standard:5.0**。

      CodeBuild 使用此已安裝 Android Studio 的作業系統映像來建置您的應用程式。

   1. 針對**服務角色**，選擇現有的 CodeBuild 服務角色或建立新的角色。

   1. 對於 **Build specifications (建置規格)**，選擇 **Use a buildspec file (使用 buildspec 檔案)**。

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。這會傳回 CodePipeline 主控台，並建立 CodeBuild 專案，使用儲存庫`buildspec.yml`中的 進行組態。建置專案使用服務角色來管理 AWS 服務 許可。此步驟可能需要數分鐘。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。您應該會看到圖表，顯示該來源及建置階段。

1. 將 Device Farm 測試動作新增至管道：

   1. 在右上角，選擇 **Edit (編輯)**。

   1. 在圖表的底部，選擇 **\$1 Add stage (\$1 新增階段)**。在 **Stage name (階段名稱)** 中，輸入名稱，例如 **Test**。

   1. 選擇 **\$1 Add action group (\$1 新增動作群組)**。

   1. 在 **​Action name (動作名稱)** 中，輸入名稱。

   1. 在**動作提供者**中，選擇 **AWS Device Farm**。允許 **Region (區域)** 預設為管道區域。

   1. 在 ​**Input artifacts (輸入成品)** 中，選擇與測試階段之前的階段輸出成品相符的輸入成品，例如 `BuildArtifact`。

      在 AWS CodePipeline 主控台中，將滑鼠暫留在管道圖表中的資訊圖示上，即可找到每個階段的輸出成品名稱。若您的管道是從 **​Source (來源)** 階段直接測試您的應用程式，請選擇 **​SourceArtifact**​。若管道包含 **​Build (建置)** 階段，請選擇 **​BuildArtifact**。

   1. 在 **ProjectId** 中，輸入您的 Device Farm 專案 ID。使用本教學課程開頭的步驟，擷取您的專案 ID。

   1. 在 **DevicePoolArn** 中，輸入裝置集區的 ARN。若要取得專案可用的裝置集區 ARNs，包括熱門裝置的 ARN，請使用 AWS CLI 輸入下列命令：

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. 在 **AppType** 中，輸入 **Android**。

      以下是 **AppType** 的有效值清單：
      + **iOS**
      + **Android**
      + **Web**

   1. 在 **​App (應用程式)** 中，輸入已編譯的應用程式套件路徑。路徑為相對於測試階段輸入成品根的相對路徑。通常，此路徑與 `app-release.apk` 相似。

   1. 在 **TestType** 中，輸入您的測試類型，然後在 **Test** 中，輸入測試定義檔案的路徑。路徑為相對於您測試輸入成品根的相對路徑。

      以下是 **TestType** 的有效值清單：
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**注意**  
不支援自訂環境節點。

   1. 在剩餘欄位中，提供適用於您測試及應用程式類型的組態。

   1. (選擇性) 在 **Advanced (進階)** 中，提供您測試執行的組態資訊。

   1. 選擇**儲存**。

   1. 在您編輯的階段上，選擇 **Done (完成)**。在 AWS CodePipeline 窗格中，選擇 **Save (儲存)**，然後在警告訊息中選擇 **Save (儲存)**。

   1. 若要提交您的變更並啟動管道建置，請選擇 **​Release change (發行變更)**，然後選擇 **​Release (發行)**。

# 教學課程：建立使用 測試 iOS 應用程式的管道 AWS Device Farm
<a name="tutorials-codebuild-devicefarm-S3"></a>

 您可以使用 AWS CodePipeline 輕鬆設定持續整合流程，在每次來源儲存貯體變更時測試您的應用程式。本教學課程示範如何建立及設定管道，以從 S3 儲存貯體測試您建置的 iOS 應用程式。管道會透過 Amazon CloudWatch Events 偵測已儲存變更的到達，然後使用 [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) 測試建置的應用程式。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**重要**  
您在此程序中新增至管道的許多動作都涉及您在建立管道之前需要建立 AWS 的資源。來源動作 AWS 的資源一律必須在您建立管道 AWS 的相同區域中建立。例如，如果您在美國東部 （俄亥俄） 區域建立管道，則 CodeCommit 儲存庫必須位於美國東部 （俄亥俄） 區域。  
您可以在建立管道時新增跨區域動作。跨區域動作 AWS 的資源必須位於您計劃執行動作的相同 AWS 區域中。如需詳細資訊，請參閱[在 CodePipeline 中新增跨區域動作](actions-create-cross-region.md)。

您可以透過使用您現有的 iOS 應用程式，或可使用[範例 iOS 應用程式](samples/s3-ios-test-1.zip)來試用。

**開始之前**

1. 登入 AWS Device Farm 主控台，然後選擇**建立新專案**。

1. 選擇您的專案。在瀏覽器中，複製新專案的 URL。URL 包含專案 ID。

1. 複製並保留此專案 ID。您可以在 CodePipeline 中建立管道時使用它。

   這裡有專案的 URL 範例。若要擷取專案 ID，請複製 `projects/` 後面的值。在此範例中，專案 ID 為 `eec4905f-98f8-40aa-9afc-4c1cfexample`。

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## 設定 CodePipeline 以使用您的 Device Farm 測試 (Amazon S3 範例）
<a name="codepipeline-configure-tests-S3"></a>

1. 建立或使用已啟用版本控制的 S3 儲存貯體。遵循[步驟 1：為您的應用程式建立 S3 來源儲存貯體](tutorials-simple-s3.md#s3-create-s3-bucket)中的說明，建立 S3 儲存貯體。

1. 在儲存貯體的 Amazon S3 主控台中，選擇**上傳**，然後依照指示上傳 .zip 檔案。

   您的範例應用程式必須封裝在 .zip 檔案中。

1. 若要建立您的管道及新增來源階段，請執行下列作業：

   1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

   1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

   1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

   1. 在**步驟 2：選擇管道設定**頁面上，在**管道名稱**中，輸入管道的名稱。

   1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

   1. 在 **Service role (服務角色)** 中，讓 **New service role (新服務角色)** 維持在選取狀態，然後讓 **Role name (角色名稱)** 維持不變。若您已擁有現有服務角色，您也可以選擇使用它。
**注意**  
如果您使用 2018 年 7 月之前建立的 CodePipeline 服務角色，則必須新增 Device Farm 的許可。若要這樣做，請開啟 IAM 主控台、尋找角色，然後將下列許可新增至角色的政策。如需詳細資訊，請參閱[將許可新增至 CodePipeline 服務角色](how-to-custom-role.md#how-to-update-role-new-services)。  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

   1. 在**步驟 3：新增來源階段**頁面的**來源提供者**中，選擇 **Amazon S3**。

   1. 在 **Amazon S3 位置**中，輸入儲存貯體，例如 `my-storage-bucket`，以及物件金鑰，例如`s3-ios-test-1.zip`您的 .zip 檔案。

   1. 選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，為您的管道建立預留位置建置階段。這可讓您在精靈中建立管道。在您使用精靈建立您的二階段管道之後，您便不再需要此預留位置建置階段。在完成管道後，便會刪除此第二階段，並會在步驟 5 中建立新的測試階段。

   

   1. 在 **​Build provider (建置提供者)** 中，選擇 **​Add Jenkins (新增 Jenkins)**。此建置選取為預留位置。不會使用。

   1. 在 **​Provider name (提供者名稱)** 中，輸入名稱。該名稱為預留位置。不會使用。

   1. 在 **​Server URL (伺服器 URL)** 中，輸入文字。該文字為預留位置。不會使用。

   1. 在 **​Project name (專案名稱)** 中，輸入名稱。該名稱為預留位置。不會使用。

   1. 選擇**下一步**。

   1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

      選擇**下一步**。

   1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。

   1. 在**步驟 7：檢閱**中，選擇**建立管道**。您應該會看到圖表，顯示該來源及建置階段。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/codepipeline-view-pipeline-S3.png)

1. 將 Device Farm 測試動作新增至管道，如下所示：

   1. 在右上角，選擇 **Edit (編輯)**。

   1. 選擇 **Edit stage (編輯階段)**。選擇 **刪除**。這會刪除預留位置階段，因為針對建立管道，您已不再需要它。

   1. 在圖表的底部，選擇 **\$1 Add stage (\$1 新增階段)**。

   1. 在階段名稱中，輸入階段的名稱，例如測試，然後選擇 **Add stage (新增階段)**。

   1. 選擇 **\$1 Add action group (\$1 新增動作群組)**。

   1. 在 **Action name (動作名稱)** 中，輸入名稱，例如 DeviceFarmTest。

   1. 在**動作提供者**中，選擇 **AWS Device Farm**。允許 **Region (區域)** 預設為管道區域。

   1. 在 ​**Input artifacts (輸入成品)** 中，選擇與測試階段之前的階段輸出成品相符的輸入成品，例如 `SourceArtifact`。

      在 AWS CodePipeline 主控台中，將滑鼠暫留在管道圖表中的資訊圖示上，即可找到每個階段的輸出成品名稱。若您的管道是從 **​Source (來源)** 階段直接測試您的應用程式，請選擇 **​SourceArtifact**​。若管道包含 **​Build (建置)** 階段，請選擇 **​BuildArtifact**。

   1. 在 **ProjectId** 中，選擇您的 Device Farm 專案 ID。使用本教學課程開頭的步驟，擷取您的專案 ID。

   1. 在 **DevicePoolArn** 中，輸入裝置集區的 ARN。若要取得專案可用的裝置集區 ARNs，包括熱門裝置的 ARN，請使用 AWS CLI 輸入下列命令：

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. 在 **AppType** 中，輸入 **iOS**。

      以下是 **AppType** 的有效值清單：
      + **iOS**
      + **Android**
      + **Web**

   1. 在 **​App (應用程式)** 中，輸入已編譯的應用程式套件路徑。路徑為相對於測試階段輸入成品根的相對路徑。通常，此路徑與 `ios-test.ipa` 相似。

   1. 在 **TestType** 中，輸入您的測試類型，然後在 **Test** 中，輸入測試定義檔案的路徑。路徑為相對於您測試輸入成品根的相對路徑。

      如果您使用的是其中一個內建 Device Farm 測試，請輸入在 Device Farm 專案中設定的測試類型，例如 BUILTIN\$1FUZZ。在 **FuzzEventCount** 中，以毫秒為單位輸入時間，例如 6000。在 **FuzzEventThrottle** 中，以毫秒為單位輸入時間，例如 50。

      如果您未使用其中一個內建 Device Farm 測試，請輸入您的測試類型，然後在**測試**中輸入測試定義檔案的路徑。路徑為相對於您測試輸入成品根的相對路徑。

      以下是 **TestType** 的有效值清單：
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTNG**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTNG**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**注意**  
不支援自訂環境節點。

   1. 在剩餘欄位中，提供適用於您測試及應用程式類型的組態。

   1. (選擇性) 在 **Advanced (進階)** 中，提供您測試執行的組態資訊。

   1. 選擇**儲存**。

   1. 在您編輯的階段上，選擇 **Done (完成)**。在 AWS CodePipeline 窗格中，選擇 **Save (儲存)**，然後在警告訊息中選擇 **Save (儲存)**。

   1. 若要提交您的變更並啟動管道執行，請選擇 **​Release change (發行變更)**，然後選擇 **​Release (發行)**。

# 教學課程：建立部署至 Service Catalog 的管道
<a name="tutorials-S3-servicecatalog"></a>

Service Catalog 可讓您根據 AWS CloudFormation 範本建立和佈建產品。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

本教學課程說明如何建立和設定管道，以將產品範本部署至 Service Catalog，並交付您在來源儲存庫中所做的變更 （已在 GitHub、CodeCommit 或 Amazon S3 中建立）。

**注意**  
當 Amazon S3 是管道的來源提供者時，您必須將所有封裝為單一 .zip 檔案的來源檔案上傳至儲存貯體。否則，來源動作會失敗。

首先，在 Service Catalog 中建立產品，然後在其中建立管道 AWS CodePipeline。本教學課程提供兩種設定部署組態的選項：
+ 在 Service Catalog 中建立產品，並將範本檔案上傳至您的來源儲存庫。在 CodePipeline 主控台中提供產品版本和部署組態 （不含單獨的組態檔案）。請參閱 [選項 1：在沒有組態檔案的情況下部署至 Service Catalog](#tutorials-S3-servicecatalog-ex1-configure)。
**注意**  
範本檔案可以 YAML 或 JSON 格式建立。
+ 在 Service Catalog 中建立產品，並將範本檔案上傳至您的來源儲存庫。以單獨組態檔提供產品版本和部署組態。請參閱 [選項 2：使用組態檔案部署至 Service Catalog](#tutorials-S3-servicecatalog-ex2-configure)。

## 選項 1：在沒有組態檔案的情況下部署至 Service Catalog
<a name="tutorials-S3-servicecatalog-ex1-configure"></a>

在此範例中，您會上傳 S3 儲存貯體的範例 AWS CloudFormation 範本檔案，然後在 Service Catalog 中建立您的產品。接著，您可以在 CodePipeline 主控台中建立管道並指定部署組態。

### 步驟 1：上傳範例範本檔案到來源儲存庫
<a name="tutorials-S3-servicecatalog-configure"></a>

1. 開啟文字編輯器。將以下項目貼到檔案以建立範例範本。儲存檔案為 `S3_template.json`。

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   此範本允許 AWS CloudFormation 建立可供 Service Catalog 使用的 S3 儲存貯體。

1. 將 `S3_template.json` 檔案上傳至 AWS CodeCommit 儲存庫。

### 步驟 2：在 Service Catalog 中建立產品
<a name="tutorials-S3-servicecatalog-product"></a>

1. 身為 IT 管理員，請登入 Service Catalog 主控台，前往**產品**頁面，然後選擇**上傳新產品**。

1. 在 **Upload new product (上傳新產品)** 頁面上，完成下列動作：

   1. 在 **Product name (產品名稱)** 中，輸入您想要使用的新產品名稱。

   1. 在 **Description (敘述)** 中輸入產品型錄描述。此處的描述會顯示在產品列表中，以協助使用者選擇正確的產品。

   1. 在 **Provided by (提供者)** 中輸入 IT 部門或管理員的名稱。

   1. 選擇**下一步**。

1. (選擇性) 在 **Enter support details (輸入支援詳細資訊)** 中，請輸入產品支援聯絡資訊，然後選擇 **Next (下一步)**。

1. 於 **Version details (版本詳細資訊)** 中，完成以下項目：

   1. 選擇 **Upload a template file (上傳範本檔案)**。瀏覽您的 `S3_template.json` 檔案並上傳。

   1. 在 **Version title (版本標題)** 中，輸入產品版本名稱 (例如，**devops S3 v2**)。

   1. 在 **Description (敘述)** 中，輸入區分此版本與其他版本的詳細資訊。

   1. 選擇**下一步**。

1. 在 **Review (檢閱)** 頁面上，確認資訊正確，然後選擇 **Create (建立)**。

1. 在瀏覽器中複製 **Products (產品)** 頁面上的 URL。這會包含產品 ID。複製並保留此產品 ID。您可以在 CodePipeline 中建立管道時使用它。

   以下是名為 `my-product` 的產品 URL。若要擷取產品 ID，請複製等號 (`=`) 和 & (`&`) 之間的值。在此範例中，產品 ID 為 `prod-example123456`。

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**注意**  
在您離開頁面之前複製您的產品 URL。您離開此頁面後，您必須使用 CLI 取得您的產品 ID。

   幾秒鐘後，您的產品即會出現在 **Products (產品)** 頁面上。可能需要重新整理瀏覽器才能在清單中看到產品。

### 步驟 3：建立管道
<a name="tutorials-S3-servicecatalog-pipeline"></a>

1. 若要命名管道和選擇管道參數，請執行下列動作：

   1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

   1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

   1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

   1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入管道的名稱。

   1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

   1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

   1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 若要在**步驟 3：新增來源階段頁面上新增來源階段**，請執行下列動作：

   1. 在 **Source provider (來源提供者)** 中選擇 **AWS CodeCommit**。

   1. 在 **Repository name (儲存庫名稱)** 和 **Branch name (分支名稱)** 中，輸入您想為來源動作使用的儲存庫和分支。

   1. 選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**中，完成下列操作：

   1. 在**部署提供者**中，選擇 **AWS Service Catalog**。

   1. 對於部署設定，選擇 **Enter deployment configuration (輸入部署設定)**。

   1. 在**產品 ID** 中，貼上您從 Service Catalog 主控台複製的產品 ID。

   1. 在 **Template file path (範本檔案路徑)** 中，輸入範本檔案存放的相對路徑。

   1. 在**產品類型**中，選擇**CloudFormation 範本**。

   1. 在**產品版本名稱**中，輸入您在 Service Catalog 中指定的產品版本名稱。如果要將範本變更部署到新產品版本，請輸入同一產品之前版本中未曾使用過的產品版本名稱。

   1. 對於 **Input artifact (輸入成品)**，請選擇來源輸入成品。

   1. 選擇**下一步**。

1. 在**步驟 7：檢閱**中，檢閱管道設定，然後選擇**建立**。

1. 管道成功執行之後，在部署階段選擇 **Details (詳細資訊)**。這會在 Service Catalog 中開啟您的產品。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. 在您的產品資訊下，選擇您的版本名稱以開啟產品範本。檢視範本部署。

### 步驟 4：推送變更並在 Service Catalog 中驗證您的產品
<a name="tutorials-S3-servicecatalog-change"></a>

1. 在 CodePipeline 主控台中檢視管道，然後在來源階段選擇**詳細資訊**。您的來源 AWS CodeCommit 儲存庫會在 主控台中開啟。選擇 **Edit (編輯)**，並在檔案中進行變更 (例如，對描述進行變更)。

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. 遞交並推送您的變更。您的管道將在您推送變更之後啟動。當管道執行完成時，在部署階段，選擇**詳細資訊**以在 Service Catalog 中開啟您的產品。

1. 在您的產品資訊下，選擇新版本名稱以開啟產品範本。查看部署的範本變更。

## 選項 2：使用組態檔案部署至 Service Catalog
<a name="tutorials-S3-servicecatalog-ex2-configure"></a>

在此範例中，您會上傳 S3 儲存貯體的範例 AWS CloudFormation 範本檔案，然後在 Service Catalog 中建立您的產品。您也可以上傳指定您部署組態的單獨組態檔案。接著，您將建立管道並指定組態檔案的位置。

### 步驟 1：上傳範例範本檔案到來源儲存庫
<a name="tutorials-S3-servicecatalog-upload2"></a>

1. 開啟文字編輯器。將以下項目貼到檔案以建立範例範本。儲存檔案為 `S3_template.json`。

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   此範本允許 AWS CloudFormation 建立可供 Service Catalog 使用的 S3 儲存貯體。

1. 將 `S3_template.json` 檔案上傳至 AWS CodeCommit 儲存庫。

### 步驟 2：建立您的產品部署組態檔案
<a name="tutorials-S3-servicecatalog-configure2"></a>

1. 開啟文字編輯器。為您的產品建立組態檔案。組態檔案用於定義 Service Catalog 部署參數/偏好設定。您將在建立管道時使用此檔案。

   此範例提供一個「devops S3 v2」的 `ProductVersionName` 和 `MyProductVersionDescription` 的 `ProductVersionDescription`。如果您要將範本變更部署到新產品版本，只要輸入同一產品之前版本中未曾使用過的產品版本名稱即可。

    儲存檔案為 `sample_config.json`。

   ```
   {
       "SchemaVersion": "1.0",
       "ProductVersionName": "devops S3 v2",
       "ProductVersionDescription": "MyProductVersionDescription",
       "ProductType": "CLOUD_FORMATION_TEMPLATE",
       "Properties": {
           "TemplateFilePath": "/S3_template.json"
       }
   }
   ```

   此檔案會在您每次執行管道時建立產品版本資訊。

1. 將 `sample_config.json` 檔案上傳至 AWS CodeCommit 儲存庫。請確定您上傳此檔案到您的來源儲存庫。

### 步驟 3：在 Service Catalog 中建立產品
<a name="tutorials-S3-servicecatalog-product2"></a>

1. 身為 IT 管理員，請登入 Service Catalog 主控台，前往**產品**頁面，然後選擇**上傳新產品**。

1. 在 **Upload new product (上傳新產品)** 頁面上，完成下列動作：

   1. 在 **Product name (產品名稱)** 中，輸入您想要使用的新產品名稱。

   1. 在 **Description (敘述)** 中輸入產品型錄描述。此處的描述顯示於產品列表中，以協助使用者選擇正確的產品。

   1. 在 **Provided by (提供者)** 中輸入 IT 部門或管理員的名稱。

   1. 選擇**下一步**。

1. (選擇性) 在 **Enter support details (輸入支援詳細資訊)** 中，請輸入產品支援聯絡資訊，然後選擇 **Next (下一步)**。

1. 於 **Version details (版本詳細資訊)** 中，完成以下項目：

   1. 選擇 **Upload a template file (上傳範本檔案)**。瀏覽您的 `S3_template.json` 檔案並上傳。

   1. 在 **Version title (版本標題)** 中，輸入產品版本名稱 (例如「devops S3 v2」)。

   1. 在 **Description (敘述)** 中，輸入區分此版本與其他版本的詳細資訊。

   1. 選擇**下一步**。

1. 在 **Review (檢閱)** 頁面上，確認資訊正確，然後選擇**確認並上傳**。

1. 在瀏覽器中複製 **Products (產品)** 頁面上的 URL。這會包含產品 ID。複製並保留此產品 ID。您可以在 CodePipeline 中建立管道時使用 。

   以下是名為 `my-product` 的產品 URL。若要擷取產品 ID，請複製等號 (`=`) 和 & (`&`) 之間的值。在此範例中，產品 ID 為 `prod-example123456`。

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**注意**  
在您離開頁面之前複製您的產品 URL。您離開此頁面後，您必須使用 CLI 取得您的產品 ID。

   幾秒鐘後，您的產品即會出現在 **Products (產品)** 頁面上。可能需要重新整理瀏覽器才能在清單中看到產品。

### 步驟 4：建立管道
<a name="tutorials-S3-servicecatalog-pipeline2"></a>

1. 若要命名管道和選擇管道參數，請執行下列動作：

   1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

   1. 選擇 **Getting started (入門)**。選擇 **Create pipeline (建立管道)** 然後輸入管道名稱。

   1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

   1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 若要新增來源階段，請執行以下操作：

   1. 在 **Source provider (來源提供者)** 中選擇 **AWS CodeCommit**。

   1. 在 **Repository name (儲存庫名稱)** 和 **Branch name (分支名稱)** 中，輸入您想為來源動作使用的儲存庫和分支。

   1. 選擇**下一步**。

1. 在 **Add build stage (新增建置階段)** 中，選擇 **Skip build stage (跳過建置階段)**，然後再次選擇 **Skip (跳過)** 來接受警告訊息​。

1. 在 **Add deploy stage (新增部署階段)** 中，完成以下項目：

   1. 在**部署提供者**中，選擇 **AWS Service Catalog**。

   1. 選擇 **Use configuration file (使用組態檔案)**。

   1. 在**產品 ID** 中，貼上您從 Service Catalog 主控台複製的產品 ID。

   1. 在 **Configuration file path (組態檔案路徑中)**，輸入您儲存庫中組態檔案的檔案路徑。

   1. 選擇**下一步**。

1. 在 **Review (檢閱)** 中檢閱您的管道設定，然後選擇 **Create (建立)**。

1. 管道成功執行後，請在部署階段選擇**詳細資訊**，以在 Service Catalog 中開啟您的產品。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/deploy-servicecatalog-pipeline.png)

1. 在您的產品資訊下，選擇您的版本名稱以開啟產品範本。檢視範本部署。

### 步驟 5：在 Service Catalog 中推送變更並驗證您的產品
<a name="tutorials-S3-servicecatalog-change2"></a>

1. 在 CodePipeline 主控台中檢視管道，然後在來源階段選擇**詳細資訊**。您的來源 AWS CodeCommit 儲存庫會在 主控台中開啟。選擇 **Edit (編輯)**，然後在檔案中進行變更 (例如，對描述進行變更)。

   ```
   "Description": "Name of Amazon S3 bucket to hold and version website content"
   ```

1. 遞交並推送您的變更。您的管道將在您推送變更之後啟動。當管道執行完成時，在部署階段，選擇**詳細資訊**以在 Service Catalog 中開啟您的產品。

1. 在您的產品資訊下，選擇新版本名稱以開啟產品範本。查看部署的範本變更。

# 教學課程：使用 建立管道 AWS CloudFormation
<a name="tutorials-cloudformation"></a>

這些範例提供範例範本，可讓您使用 AWS CloudFormation 建立管道，在每次原始程式碼變更時將應用程式部署到您的執行個體。範例範本會建立您可以在 AWS CodePipeline中檢視的管道。管道會透過 Amazon CloudWatch Events 偵測已儲存變更的到達。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**Topics**
+ [

# 範例 1：使用 建立 AWS CodeCommit 管道 AWS CloudFormation
](tutorials-cloudformation-codecommit.md)
+ [

# 範例 2：使用 建立 Amazon S3 管道 AWS CloudFormation
](tutorials-cloudformation-s3.md)

# 範例 1：使用 建立 AWS CodeCommit 管道 AWS CloudFormation
<a name="tutorials-cloudformation-codecommit"></a>

此逐步解說說明如何使用 AWS CloudFormation 主控台建立基礎設施，其中包含連線至 CodeCommit 來源儲存庫的管道。在本教學課程中，您會使用提供的範例範本檔案來建立資源堆疊，其中包含成品存放區、管道和變更偵測資源，例如 Amazon CloudWatch Events 規則。在 中建立資源堆疊之後 AWS CloudFormation，您可以在 AWS CodePipeline 主控台中檢視管道。管道是具有 CodeCommit 來源階段和 CodeDeploy 部署階段的兩階段管道。

**先決條件：**

您必須已建立下列資源，才能與 AWS CloudFormation 範例範本搭配使用：
+ 您必須先建立來源儲存庫。您可以使用您在 中建立的 AWS CodeCommit 儲存庫[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ 您必須已建立 CodeDeploy 應用程式和部署群組。您可以使用您在 中建立的 CodeDeploy 資源[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ 選擇下列其中一個連結，下載用於建立管道的範例 AWS CloudFormation 範本檔案：[YAML](samples/codepipeline-codecommit-events-yaml.zip) \$1 [JSON](samples/codepipeline-codecommit-events-json.zip)

  解壓縮檔案並將它放在您的本機電腦。
+ 下載 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 範例應用程式檔案。



**在 中建立管道 AWS CloudFormation**

1. 從 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 解壓縮檔案，並將檔案上傳至您的 AWS CodeCommit 儲存庫。您必須將解壓縮的檔案上傳到您儲存庫的根目錄。您可以依照 [步驟 2：將範本程式碼新增至 CodeCommit 儲存庫](tutorials-simple-codecommit.md#codecommit-add-code) 中的指示，將檔案推送到您的儲存庫。

1. 開啟 AWS CloudFormation 主控台，然後選擇**建立堆疊**。選擇 **With new resources (standard)** (使用新資源 (標準))。

1. 在**指定範本**下，選擇**上傳範本**。選取**選擇檔案**，然後從本機電腦選擇範本檔案。選擇**下一步**。

1. 在 **Stack name (堆疊名稱)** 中，輸入管道的名稱。即會顯示範例範本指定的參數。輸入下列參數：

   1. 在 **ApplicationName** 中，輸入 CodeDeploy 應用程式的名稱。

   1. 在 **BetaFleet** 中，輸入 CodeDeploy 部署群組的名稱。

   1. 在 **BranchName** 中，輸入您想要使用的儲存庫分支。

   1. 在 **RepositoryName** 中，輸入 CodeCommit 來源儲存庫的名稱。

1. 選擇**下一步**。接受以下頁面上的預設值，然後選擇 **Next (下一步)**。

1. 在**功能**中，選取**我確認 AWS CloudFormation 可能會建立 IAM 資源**，然後選擇**建立堆疊**。

1. 在完成您的堆疊建立之後，請檢視事件清單以檢查是否有任何錯誤。

   **疑難排解**

   在 中建立管道的 IAM 使用者 AWS CloudFormation 可能需要額外的許可，才能為管道建立資源。政策需要下列許可 AWS CloudFormation ，以允許 為 CodeCommit 管道建立所需的 Amazon CloudWatch Events 資源：

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

   在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。
**注意**  
若要檢視已建立的管道，請在堆疊**的資源**索引標籤下尋找**邏輯 ID** 欄 CloudFormation。在管道的**實體 ID** 欄中記下名稱。在 CodePipeline 中，您可以在建立堆疊的區域中檢視具有相同實體 ID （管道名稱） 的管道。

1. 在來源儲存庫中遞交並推送變更。您的變更偵測資源會套用該變更，然後您的管道便會啟動。

# 範例 2：使用 建立 Amazon S3 管道 AWS CloudFormation
<a name="tutorials-cloudformation-s3"></a>

此逐步解說說明如何使用 AWS CloudFormation 主控台建立基礎設施，其中包含連線至 Amazon S3 來源儲存貯體的管道。在本教學課程中，您會使用提供的範例範本檔案來建立資源堆疊，其中包含來源儲存貯體、成品存放區、管道和變更偵測資源，例如 Amazon CloudWatch Events 規則和 CloudTrail 追蹤。在 中建立資源堆疊之後 AWS CloudFormation，您可以在 AWS CodePipeline 主控台中檢視管道。管道是具有 Amazon S3 來源階段和 CodeDeploy 部署階段的兩階段管道。

**先決條件：**

您必須擁有下列資源，才能與 AWS CloudFormation 範例範本搭配使用：
+ 您必須已建立在執行個體上安裝 CodeDeploy 代理程式的 Amazon EC2 執行個體。您必須已建立 CodeDeploy 應用程式和部署群組。使用您在 中建立的 Amazon EC2 和 CodeDeploy 資源[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ 選擇以下連結來下載範例 AWS CloudFormation 範本檔案，以使用 Amazon S3 來源建立管道：
  + 下載管道的範例範本：[YAML](samples/codepipeline-s3-events-yaml.zip) \$1 [JSON](samples/codepipeline-s3-events-json.zip)
  + 下載 CloudTrail 儲存貯體和線索的範例範本：[YAML](samples/codepipeline-s3-cloudtrail-yaml.zip) \$1 [JSON](samples/codepipeline-s3-cloudtrail-json.zip)
  + 解壓縮檔案並將它們放在您的本機電腦。
+ 從 [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) 下載範例應用程式。

  將 .zip 檔案儲存至本機電腦。在建立堆疊之後，您會上傳 .zip 檔案。

**在 中建立管道 AWS CloudFormation**

1. 開啟 AWS CloudFormation 主控台，然後選擇**建立堆疊**。選擇 **With new resources (standard)** (使用新資源 (標準))。

1. 在**選擇範本中**，選擇**上傳範本**。選取**選擇檔案**，然後從本機電腦選擇範本檔案。選擇**下一步**。

1. 在 **Stack name (堆疊名稱)** 中，輸入管道的名稱。即會顯示範例範本指定的參數。輸入下列參數：

   1. 在 **ApplicationName** 中，輸入 CodeDeploy 應用程式的名稱。您可以取代 `DemoApplication` 預設名稱。

   1. 在 **BetaFleet** 中，輸入 CodeDeploy 部署群組的名稱。您可以取代 `DemoFleet` 預設名稱。

   1. 在 **SourceObjectKey** 中，輸入 `SampleApp_Linux.zip`。您可以在範本建立儲存貯體和管道後，將此檔案上傳到您的儲存貯體。

1. 選擇**下一步**。接受以下頁面上的預設值，然後選擇 **Next (下一步)**。

1. 在**功能**中，選取**我確認 AWS CloudFormation 可能會建立 IAM 資源**，然後選擇**建立堆疊**。

1. 在完成您的堆疊建立之後，請檢視事件清單以檢查是否有任何錯誤。

   **疑難排解**

   在 中建立管道的 IAM 使用者 AWS CloudFormation 可能需要額外的許可，才能為管道建立資源。政策需要下列許可 AWS CloudFormation ，以允許 為 Amazon S3 管道建立所需的 Amazon CloudWatch Events 資源： Amazon S3 

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. 在堆疊**的資源**索引標籤 CloudFormation中，檢視為堆疊建立的資源。
**注意**  
若要檢視已建立的管道，請在堆疊**的資源**索引標籤下尋找**邏輯 ID** 欄 CloudFormation。在管道的**實體 ID** 欄中記下名稱。在 CodePipeline 中，您可以在建立堆疊的區域中檢視具有相同實體 ID （管道名稱） 的管道。

   選擇名稱中包含 `sourcebucket` 標籤的 S3 儲存貯體，例如 `s3-cfn-codepipeline-sourcebucket-y04EXAMPLE.`。請不要選擇管道成品儲存貯體。

   來源儲存貯體是空白的，因為 CloudFormation才剛建立資源。開啟 Amazon S3 主控台並找到您的儲存`sourcebucket`貯體。選擇 **Upload (上傳)** 並遵循說明，來上傳您的 `SampleApp_Linux.zip` .zip 檔案。
**注意**  
當 Amazon S3 是管道的來源提供者時，您必須將所有封裝為單一 .zip 檔案的來源檔案上傳至儲存貯體。否則，來源動作會失敗。

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

   在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。

1. 完成下列程序中的步驟來建立 AWS CloudTrail 資源。

**在 中建立您的 AWS CloudTrail 資源 AWS CloudFormation**

1. 開啟 AWS CloudFormation 主控台，然後選擇**建立堆疊**。

1. 在 **Choose a template (選擇範本)** 中，請選擇 **Upload a template to Amazon S3 (上傳範本至 Amazon S3)**。選擇**瀏覽**，然後從本機電腦選取 AWS CloudTrail 資源的範本檔案。選擇**下一步**。

1. 在 **Stack name (堆疊名稱)** 中，輸入資源堆疊的名稱。即會顯示範例範本指定的參數。輸入下列參數：

   1. 在 **SourceObjectKey (SourceObjectKey)** 中，接受範例應用程式的壓縮檔預設值。

1. 選擇**下一步**。接受以下頁面上的預設值，然後選擇 **Next (下一步)**。

1. 在**功能**中，選取**我確認 AWS CloudFormation 可能會建立 IAM 資源**，然後選擇**建立**。

1. 在完成您的堆疊建立之後，請檢視事件清單以檢查是否有任何錯誤。

   政策需要下列許可 AWS CloudFormation ，以允許 為 Amazon S3 管道建立所需的 CloudTrail 資源：

   ```
   {
        "Effect": "Allow",
        "Action": [
           "cloudtrail:CreateTrail",
           "cloudtrail:DeleteTrail",
           "cloudtrail:StartLogging",
           "cloudtrail:StopLogging",
           "cloudtrail:PutEventSelectors"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

   在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。

1. 在來源儲存貯體中遞交並推送變更。您的變更偵測資源會套用該變更，然後您的管道便會啟動。

# 教學課程：建立使用 AWS CloudFormation 部署動作變數的管道
<a name="tutorials-cloudformation-action"></a>

在本教學課程中，您會使用 AWS CodePipeline 主控台建立具有部署動作的管道。管道執行時，此範本會建立堆疊，並建立 `outputs` 檔案。堆疊範本產生的輸出是 CodePipeline 中 AWS CloudFormation 動作產生的變數。

在從範本建立堆疊的動作中，您可以指定變數命名空間。然後，該 `outputs` 檔案產生的變數可以被後續動作使用。在此範例中，您會根據 AWS CloudFormation 動作產生的`StackName`變數建立變更集。手動核准之後，您執行變更集，然後建立根據 `StackName` 變數刪除堆疊的刪除堆疊動作。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**Topics**
+ [

## 先決條件：建立 AWS CloudFormation 服務角色和 CodeCommit 儲存庫
](#tutorials-cloudformation-action-prereq)
+ [

## 步驟 1：下載、編輯和上傳範例 AWS CloudFormation 範本
](#tutorials-cloudformation-action-upload)
+ [

## 步驟 2：建立管道
](#tutorials-cloudformation-action-pipeline)
+ [

## 步驟 3：新增 CloudFormation 部署動作以建立變更集
](#tutorials-cloudformation-action-changeset)
+ [

## 步驟 4：新增手動核准動作
](#tutorials-cloudformation-action-approval)
+ [

## 步驟 5：新增 CloudFormation 部署動作以執行變更集
](#tutorials-cloudformation-action-deployment)
+ [

## 步驟 6：新增 CloudFormation 部署動作以刪除堆疊
](#tutorials-cloudformation-action-delete)

## 先決條件：建立 AWS CloudFormation 服務角色和 CodeCommit 儲存庫
<a name="tutorials-cloudformation-action-prereq"></a>

您必須已擁有下列各項目：
+ CodeCommit 儲存庫。您可以使用您在 中建立的 AWS CodeCommit 儲存庫[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ 此範例會從範本建立 Amazon DocumentDB 堆疊。您必須使用 AWS Identity and Access Management (IAM) 來建立具有下列 Amazon DocumentDB 許可 AWS CloudFormation 的服務角色。

  ```
  "rds:DescribeDBClusters",
  "rds:CreateDBCluster",
  "rds:DeleteDBCluster",
  "rds:CreateDBInstance"
  ```

## 步驟 1：下載、編輯和上傳範例 AWS CloudFormation 範本
<a name="tutorials-cloudformation-action-upload"></a>

下載範例 AWS CloudFormation 範本檔案，並將其上傳至 CodeCommit 儲存庫。

1. 導覽至您 區域的範例範本。例如，使用 的 資料表[https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack](https://docs.aws.amazon.com/documentdb/latest/developerguide/quick_start_cfn.html#quick_start_cfn-launch_stack)來選擇區域並下載範本。下載 Amazon DocumentDB 叢集的 範本。檔案名稱為 `documentdb_full_stack.yaml`。

1. 將 `documentdb_full_stack.yaml` 檔案解壓縮，然後在文字編輯器中開啟檔案。進行下列變更：

   1. 在此範例中，將下列 `Purpose:` 參數新增至範本中的 `Parameters` 區段。

      ```
        Purpose:
          Type: String
          Default: testing
          AllowedValues:
            - testing
            - production
          Description: The purpose of this instance.
      ```

   1. 在此範例中，將下列 `StackName` 輸出新增至範本中的 `Outputs:` 區段。

      ```
        StackName:
          Value: !Ref AWS::StackName
      ```

1. 將範本檔案上傳至您的 AWS CodeCommit 儲存庫。您必須將解壓縮和編輯過的範本檔案上傳至儲存庫的根目錄。

   若要使用 CodeCommit 主控台上傳您的檔案：

   1. 開啟 CodeCommit 主控台，然後從儲存庫清單中選擇您的**儲存庫**。

   1. 選擇 **Add file (新增檔案)**，然後選擇 **Upload file (上傳檔案)**。

   1. 選取 **Choose file (選擇檔案)**，然後瀏覽您的檔案。輸入您的使用者名稱和電子郵件地址來確定變更。選擇 **Commit changes (遞交變更)**。

   您的檔案在儲存庫的根層級看起來應該像這樣：

   ```
   documentdb_full_stack.yaml
   ```

## 步驟 2：建立管道
<a name="tutorials-cloudformation-action-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 具有 CodeCommit 動作的來源階段，其中來源成品是您的範本檔案。
+ 具有 部署動作的 CloudFormation 部署階段。

系統會為精靈所建立的來源和部署階段中每個動作指派變數命名空間，分別是 `SourceVariables` 和 `DeployVariables`。由於動作已指派命名空間，因此在此範例中設定的變數可供下游動作使用。如需詳細資訊，請參閱[變數參考](reference-variables.md)。

**使用精靈建立管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyCFNDeployPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在 **Service role (服務角色)** 中，執行下列其中一項作業：
   + 選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。
   + 選擇 **Existing service role (現有服務角色)**。在 **Role name (角色名稱)** 中，從清單選擇您的服務角色。

1. 在 **Artifact store (成品存放區)** 中：

   1. 針對您為管道選取的區域中的管道，選擇**預設位置**以使用預設成品存放區，例如指定為預設的 Amazon S3 成品儲存貯體。

   1. 如果您已在管道所在的相同區域中擁有成品存放區，例如 Amazon S3 成品儲存貯體，請選擇**自訂位置**。
**注意**  
這不是原始碼的來源儲存貯體。這是管道的成品存放區。每個管道都需要有個別成品存放區，例如 S3 儲存貯體。當您建立或編輯管道時，您必須在管道區域中擁有一個成品儲存貯體，並在您執行動作的每個 AWS 區域中擁有一個成品儲存貯體。  
如需詳細資訊，請參閱[輸入和輸出成品](welcome-introducing-artifacts.md)及[CodePipeline 管道結構參考](reference-pipeline-structure.md)。

   選擇**下一步**。

1. 在**步驟 3：新增來源階段**：

   1. 在 **Source provider (來源提供者)** 中選擇 **AWS CodeCommit**。

   1. 在**儲存庫名稱**中，選擇您在 中建立的 CodeCommit 儲存庫名稱[步驟 1：建立 CodeCommit 儲存庫](tutorials-simple-codecommit.md#codecommit-create-repository)。

   1. 在 **Branch name (分支名稱)** 中，選擇包含最新程式碼更新的分支名稱。

   選取儲存庫名稱和分支之後，即會顯示要為此管道建立的 Amazon CloudWatch Events 規則。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**：

   1. 在 **Action name (動作名稱)** 中，選擇 **Deploy (部署)**。在 **Deploy provider (部署提供者)** 中，選擇 **CloudFormation**。

   1. 在 **Action mode (動作模式)** 中，選擇 **Create or update a stack (建立或更新堆疊)**。

   1. 在 **Stack name (堆疊名稱)** 中，輸入堆疊的名稱。這是範本將建立的堆疊名稱。

   1. 在 **Output file name (輸出檔案名稱)** 中，輸入輸出檔案的名稱，例如 **outputs**。這是在建立堆疊後由此動作建立的檔案名稱。

   1. 展開 **Advanced (進階)**。在 **Parameter overrides (參數覆寫)** 下，輸入範本覆寫作為索引鍵/值組。例如，此範本需要下列覆寫。

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "testing"}
      ```

      如果您未輸入覆寫，範本會建立具有預設值的堆疊。

   1. 選擇**下一步**。

   1. 在**步驟 7：檢閱**中，選擇**建立管道**。您應該會看到顯示管道階段的圖表。允許您的管道執行。您的兩階段管道已完成，並準備好新增其他階段。

## 步驟 3：新增 CloudFormation 部署動作以建立變更集
<a name="tutorials-cloudformation-action-changeset"></a>

在管道中建立下一個動作， CloudFormation 允許 在手動核准動作之前建立變更集。



1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

   在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。

1. 選擇編輯管道，或繼續在 **Edit (編輯)** 模式中顯示管道。

1. 選擇 以編輯**部署**階段。

1. 新增部署動作，為在上一個動作中建立的堆疊建立變更集。您可以在階段中的現有動作之後新增此動作。

   1. 在 **​Action name (動作名稱)** 中，輸入 **Change\$1Set**。在**動作提供者**中，選擇**AWS CloudFormation **。

   1. 在 **Input artifact (輸入成品)** 中，選擇 **SourceArtifact**。

   1. 在 **Action mode (動作模式)** 中，選擇 **Create or replace a change set (建立或取代變更集)**。

   1. 在 **Stack name (堆疊名稱)** 中，輸入變數語法，如下所示。這是堆疊名稱，變更集是為此堆疊而建立，其中預設命名空間 `DeployVariables` 已指派給該動作。

      ```
      #{DeployVariables.StackName}
      ```

   1. 在 **Change set name (變更集名稱)** 中，輸入變更集的名稱。

      ```
      my-changeset
      ```

   1. 在 **Parameter Overrides (參數覆寫)** 中，將 `Purpose` 參數從 `testing` 變更為 `production`。

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "production"}
      ```

   1. 選擇 **Done (完成)** 以儲存動作。

## 步驟 4：新增手動核准動作
<a name="tutorials-cloudformation-action-approval"></a>

在管道中建立手動核准動作。



1. 選擇編輯管道，或繼續在 **Edit (編輯)** 模式中顯示管道。

1. 選擇 以編輯**部署**階段。

1. 在建立變更集的部署動作之後新增手動核准動作。此動作可讓您在管道執行變更集 CloudFormation 之前，先驗證 中建立的資源變更集。

## 步驟 5：新增 CloudFormation 部署動作以執行變更集
<a name="tutorials-cloudformation-action-deployment"></a>

在管道中建立下一個動作， CloudFormation 允許 在手動核准動作之後執行變更集。



1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

   在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。

1. 選擇編輯管道，或繼續在 **Edit (編輯)** 模式中顯示管道。

1. 選擇 以編輯**部署**階段。

1. 新增部署動作，以執行先前手動動作中核准的變更集：

   1. 在 **Action name (動作名稱)** 中，輸入 **Execute\$1Change\$1Set**。在**動作提供者**中，選擇 **AWS CloudFormation**。

   1. 在 **Input artifact (輸入成品)** 中，選擇 **SourceArtifact**。

   1. 在 **Action mode (動作模式)** 中，選擇 **Execute a change set (執行變更組合)**。

   1. 在 **Stack name (堆疊名稱)** 中，輸入變數語法，如下所示。這是堆疊名稱，變更集是為此堆疊而建立。

      ```
      #{DeployVariables.StackName}
      ```

   1. 在 **Change set name (變更集名稱)** 中，輸入您在上一個動作中建立的變更集名稱。

      ```
      my-changeset
      ```

   1. 選擇 **Done (完成)** 以儲存動作。

   1. 繼續管道執行。

## 步驟 6：新增 CloudFormation 部署動作以刪除堆疊
<a name="tutorials-cloudformation-action-delete"></a>

在管道中建立最終動作， CloudFormation 允許 從輸出檔案中的 變數取得堆疊名稱，並刪除堆疊。



1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

   在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。

1. 選擇編輯管道。

1. 選擇 以編輯**部署**階段。

1. 新增將刪除堆疊的部署動作：

   1. 在 **Action name (動作名稱)** 中，選擇 **DeleteStack**。在 **Deploy provider (部署提供者)** 中，選擇 **CloudFormation**。

   1. 在 **Action mode (動作模式)** 中，選擇 **Delete a stack (刪除堆疊)**。

   1. 在 **Stack name (堆疊名稱)** 中，輸入變數語法，如下所示。這是動作將刪除的堆疊名稱。

   1. 選擇 **Done (完成)** 以儲存動作。

   1. 選擇 **Save (儲存)** 以儲存管道。

   管道會在儲存時執行。

# 教學課程：使用 CodePipeline 進行 Amazon ECS 標準部署
<a name="ecs-cd-pipeline"></a>

本教學課程可協助您使用 CodePipeline 的 Amazon ECS 建立完整的end-to-end持續部署 (CD) 管道。

**重要**  
在主控台中建立管道時，CodePipeline 將使用 S3 成品儲存貯體做為成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
本教學課程適用於 CodePipeline 的 Amazon ECS 標準部署動作。如需在 CodePipeline 中使用 Amazon ECS 到 CodeDeploy 藍/綠部署動作的教學課程，請參閱 [教學課程：使用 Amazon ECR 來源和 ECS-to-CodeDeploy 部署建立管道](tutorials-ecs-ecr-codedeploy.md)。 CodePipeline

**注意**  
本教學課程適用於具有來源動作之 CodePipeline 的 Amazon ECS 標準部署動作。如需使用 Amazon ECSstandard 部署動作以及 CodePipeline 中的 ECRBuildAndPublish 建置動作來推送映像的教學課程，請參閱 [教學課程：使用 CodePipeline (V2 類型） 建置 Docker 映像並將其推送至 Amazon ECR](tutorials-ecr-build-publish.md)。

## 先決條件
<a name="ecs-cd-prereqs"></a>

您必須先有幾個資源，才能使用此教學來建立 CD 管道。以下是在開始使用前需準備的事項：

**注意**  
所有這些資源都應在相同區域內建立 AWS 。
+ 來源控制儲存庫 （本教學課程使用 CodeCommit) 搭配您的 Dockerfile 和應用程式來源。如需詳細資訊，請參閱*AWS CodeCommit 《 使用者指南*》中的[建立 CodeCommit 儲存庫](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html)。
+ Docker 映像儲存庫 （本教學課程使用 Amazon ECR)，其中包含您從 Dockerfile 和應用程式來源建置的映像。如需詳細資訊，請參閱《*Amazon Elastic Container Registry 使用者指南*》中的[建立儲存庫](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html)和[推送映像](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html)。
+ 參考映像儲存庫中託管之 Docker 映像的 Amazon ECS 任務定義。如需詳細資訊，請參閱《*Amazon Elastic Container Service 開發人員指南*》中的[建立任務定義](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html)。
**重要**  
CodePipeline 的 Amazon ECS 標準部署動作會根據 Amazon ECS 服務所使用的修訂來建立任務定義的專屬修訂。如果您為任務定義建立新的修訂，但未更新 Amazon ECS 服務，部署動作會忽略這些修訂。

  以下是本教學課程使用的範例任務定義。您用於 `name`和 的值`family`將用於建置規格檔案的下一個步驟。

  ```
  {
    "ipcMode": null,
    "executionRoleArn": "role_ARN",
    "containerDefinitions": [
      {
        "dnsSearchDomains": null,
        "environmentFiles": null,
        "logConfiguration": {
          "logDriver": "awslogs",
          "secretOptions": null,
          "options": {
            "awslogs-group": "/ecs/hello-world",
            "awslogs-region": "us-west-2",
            "awslogs-stream-prefix": "ecs"
          }
        },
        "entryPoint": null,
        "portMappings": [
          {
            "hostPort": 80,
            "protocol": "tcp",
            "containerPort": 80
          }
        ],
        "command": null,
        "linuxParameters": null,
        "cpu": 0,
        "environment": [],
        "resourceRequirements": null,
        "ulimits": null,
        "dnsServers": null,
        "mountPoints": [],
        "workingDirectory": null,
        "secrets": null,
        "dockerSecurityOptions": null,
        "memory": null,
        "memoryReservation": 128,
        "volumesFrom": [],
        "stopTimeout": null,
        "image": "image_name",
        "startTimeout": null,
        "firelensConfiguration": null,
        "dependsOn": null,
        "disableNetworking": null,
        "interactive": null,
        "healthCheck": null,
        "essential": true,
        "links": null,
        "hostname": null,
        "extraHosts": null,
        "pseudoTerminal": null,
        "user": null,
        "readonlyRootFilesystem": null,
        "dockerLabels": null,
        "systemControls": null,
        "privileged": null,
        "name": "hello-world"
      }
    ],
    "placementConstraints": [],
    "memory": "2048",
    "taskRoleArn": null,
    "compatibilities": [
      "EC2",
      "FARGATE"
    ],
    "taskDefinitionArn": "ARN",
    "family": "hello-world",
    "requiresAttributes": [],
    "pidMode": null,
    "requiresCompatibilities": [
      "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "1024",
    "revision": 1,
    "status": "ACTIVE",
    "inferenceAccelerators": null,
    "proxyConfiguration": null,
    "volumes": []
  }
  ```
+ 執行使用您先前提及之任務定義的服務的 Amazon ECS 叢集。如需詳細資訊，請參閱《Amazon Elastic Container Service 開發人員指南》中的[建立叢集](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html)和[建立](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html)服務。 **

滿足這些先決條件之後，即可繼續教學並建立 CD 管道。

## 步驟 1：將組建規格檔案新增至來源儲存庫
<a name="cd-buildspec"></a>

本教學課程使用 CodeBuild 建置您的 Docker 映像並將映像推送至 Amazon ECR。將`buildspec.yml`檔案新增至您的原始程式碼儲存庫，以告知 CodeBuild 如何執行此操作。下面的範例組建規格執行下列動作：
+ 預先建置階段：
  + 登入 Amazon ECR。
  + 將儲存庫 URI 設定為 ECR 映像，並新增具有來源 Git 遞交 ID 之前七個字元的映像標籤。
+ 建置階段：
  + 建置 Docker 影像，並將映像標記為 `latest` 且具有 Git 遞交 ID。
+ 後置建置階段：
  + 使用兩個標籤將映像推送至 ECR 儲存庫。
  + 在具有 Amazon ECS 服務容器名稱和映像和標籤的建置根`imagedefinitions.json`中寫入名為 的檔案。您 CD 管道的部署階段使用此資訊來建立服務之任務定義的新修訂，接著將服務更新為使用新的任務定義。`imagedefinitions.json` 是 ECS 任務工作者所需的檔案。

貼上此範例文字以建立 `buildspec.yml` 檔案，並取代映像和任務定義的值。此文字使用範例帳戶 ID 111122223333。

```
version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json
```

組建規格是針對 中提供的範例任務定義所撰寫[先決條件](#ecs-cd-prereqs)，由 Amazon ECS 服務在本教學課程中使用。`REPOSITORY_URI` 值對應至 `image` 儲存庫 (不含任何映像標籤)，而接近檔案結尾的 `hello-world` 值對應至服務任務定義中的容器名稱。

**將 `buildspec.yml` 檔案新增至來源儲存庫**

1. 開啟文字編輯器，然後將上面的建置規格複製並貼入新的檔案。

1. 將`REPOSITORY_URI`值 (`012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world`) 取代為您的 Docker 映像的 Amazon ECR 儲存庫 URI （不含任何映像標籤）。將 `hello-world` 取代為服務任務定義中參考您 Docker 影像的容器名稱。

1. 遞交您的 `buildspec.yml` 檔案並將之推送至來源儲存庫。

   1. 新增檔案。

      ```
      git add .
      ```

   1. 遞交變更。

      ```
      git commit -m "Adding build specification."
      ```

   1. 推送認可。

      ```
      git push
      ```

## 步驟 2：建立持續部署管道
<a name="pipeline-wizard"></a>

使用 CodePipeline 精靈建立管道階段，並將來源儲存庫連線至 ECS 服務。

**建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在 **Welcome** (歡迎使用) 頁面上，選擇 **Create pipeline** (建立管道)。

   如果這是您第一次使用 CodePipeline，則會顯示簡介頁面，而不是**歡迎**。選擇 **Get Started Now** (立即開始)。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入管道的名稱。在此教學中，管道名稱為 **hello-world**。

1. 在**管道類型**中，將預設選擇保留在 **V2**。管道類型在特性和價格方面有所不同。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面上，針對**來源提供者**選擇 ** AWS CodeCommit**。

   1. 針對**儲存庫名稱**，選擇要用作管道來源位置的 CodeCommit 儲存庫名稱。

   1. 針對 **Branch name (分支名稱)**，選擇要使用的分支，然後選擇 **Next (下一步)**。

1. 在**步驟 4：新增建置階段**頁面上，針對**建置提供者**選擇 **AWS CodeBuild**，然後選擇**建立專案**。

   1. 針對 **Project name** (專案名稱)，選擇您組建專案的唯一名稱。在此教學中，專案名稱為 **hello-world**。

   1. 針對 **Environment image (環境映像)**，選擇 **Managed image (受管映像)**。

   1. 針對 **Operating system** (作業系統)，請選擇 **Amazon Linux 2**。

   1. 針對 **Runtime(s) (執行時間)**，選擇 **Standard (標準)**。

   1. 針對**映像**，選擇 **`aws/codebuild/amazonlinux2-x86_64-standard:3.0`**。

   1. 針對 **Image version (映像版本)** 和 **Environment type (環境類型)**，請使用預設值。

   1. 選取 **Enable this flag if you want to build Docker images or want your builds to get elevated privileges (若想建置 Docker 影像或讓您的建置提升權限，請啟用此標記)**。

   1. 取消選取 **CloudWatch logs (CloudWatch 日誌)**。您可能需要展開**進階**。

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。

   1. 選擇**下一步**。
**注意**  
精靈會為您的建置專案建立 CodeBuild 服務角色，稱為 **codebuild-*build-project-name*-service-role**。請記下此角色名稱，稍後再新增 Amazon ECR 許可。

1. 在**步驟 5：新增部署階段**頁面上，針對**部署提供者**選擇 **Amazon ECS**。

   1. 針對**叢集名稱**，選擇服務執行所在的 Amazon ECS 叢集。在此教學中，叢集是 **default**。

   1. 針對 **Service name (服務名稱)**，選擇要更新的服務，然後選擇 **Next (下一步)**。在此教學中，服務名稱為 **hello-world**。

1. 在 **Step 6: Review** (步驟 6：檢閱) 頁面上，檢閱您的管道組態，然後選擇 **Create pipeline** (建立管道) 來建立管道。
**注意**  
現在已建立管道，將會嘗試執行不同的管道階段。不過，精靈建立的預設 CodeBuild 角色沒有執行 `buildspec.yml` 檔案中包含之所有命令的許可，因此建置階段會失敗。下節會新增建置階段的許可。

## 步驟 3：將 Amazon ECR 許可新增至 CodeBuild 角色
<a name="code-build-perms"></a>

CodePipeline 精靈為 CodeBuild 組建專案建立 IAM 角色，稱為 **codebuild-*build-project-name*-service-role**。在本教學課程中，名稱為 **codebuild-hello-world-service-role**。由於 `buildspec.yml` 檔案會呼叫 Amazon ECR API 操作，因此該角色必須具有允許進行這些 Amazon ECR 呼叫許可的政策。下列程序可協助您將適當的許可連接至角色。

**將 Amazon ECR 許可新增至 CodeBuild 角色**

1. 前往 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 開啟 IAM 主控台。

1. 在左側導覽窗格中，選擇 **Roles** (角色)。

1. 在搜尋方塊中，輸入 **codebuild-**，然後選擇 CodePipeline 精靈建立的角色。在此教學中，角色名稱為 **codebuild-hello-world-service-role**。

1. 在 **Summary (摘要)** 頁面上，選擇 **Attach policies (連接政策)**。

1. 選取 **AmazonEC2ContainerRegistryPowerUser** 政策左側的方塊，然後選擇 **Attach policy** (連接政策)。

## 步驟 4：測試管道
<a name="commit-change"></a>

您的管道應具備執行end-to-end原生 AWS 持續部署所需的一切。現在，將程式碼變更推送至來源儲存庫，以測試其功能。

**測試管道**

1. 對設定的來源儲存庫進行程式碼變更、遞交並推送變更。

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 從清單中選擇管道。

1. 觀看管道階段的管道進度。您的管道應該完成，Amazon ECS 服務會執行從程式碼變更建立的 Docker 映像。

# 教學課程：使用 Amazon ECR 來源和 ECS-to-CodeDeploy 部署建立管道
<a name="tutorials-ecs-ecr-codedeploy"></a>

在本教學課程中，您會在 中設定管道 AWS CodePipeline ，使用支援 Docker 映像的藍/綠部署來部署容器應用程式。在藍/綠部署中，您可以同時啟動新舊版本的應用程式，並在重新路由流量之前測試新版本。您也可以監控部署程序，並在發生問題時快速轉返。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
本教學課程適用於 CodePipeline 的 Amazon ECS 到 CodeDeploy 藍/綠部署動作。如需在 CodePipeline 中使用 Amazon ECS 標準部署動作的教學課程，請參閱 [教學課程：使用 CodePipeline 進行 Amazon ECS 標準部署](ecs-cd-pipeline.md)。

已完成的管道會偵測儲存在 Amazon ECR 等映像儲存庫中的映像變更，並使用 CodeDeploy 將流量路由和部署到 Amazon ECS 叢集和負載平衡器。CodeDeploy 使用接聽程式將流量重新路由到 AppSpec 檔案中指定之已更新容器的連接埠。如需如何在藍/綠部署中使用負載平衡器、生產接聽程式、目標群組和 Amazon ECS 應用程式的詳細資訊，請參閱[教學課程：部署 Amazon ECS 服務](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html)。

管道也會設定為使用來源位置，例如 CodeCommit，其中存放您的 Amazon ECS 任務定義。在本教學課程中，您會設定每個 AWS 資源，然後使用包含每個資源動作的階段來建立管道。

每當原始碼變更或將新的基礎映像上傳至 Amazon ECR 時，您的持續交付管道會自動建置和部署容器映像。

此流程使用以下成品：
+ 指定 Amazon ECR 映像儲存庫容器名稱和儲存庫 URI 的 Docker 映像檔案。
+ 列出 Docker 映像名稱、容器名稱、Amazon ECS 服務名稱和負載平衡器組態的 Amazon ECS 任務定義。
+ CodeDeploy AppSpec 檔案，指定 Amazon ECS 任務定義檔案的名稱、更新應用程式容器的名稱，以及 CodeDeploy 重新路由生產流量的容器連接埠。它也可以指定選用的網路組態和 Lambda 函數，您可以在部署生命週期事件勾點中執行它們。

**注意**  
當您將變更遞交至 Amazon ECR 映像儲存庫時，管道來源動作會為該遞交建立 `imageDetail.json` 檔案。如需 `imageDetail.json` 詳細資訊，請參閱 [Amazon ECS 藍/綠部署動作的 imageDetail.json 檔案](file-reference.md#file-reference-ecs-bluegreen)。

當您建立或編輯管道，以及更新或指定部署階段的來源成品時，請確保指向的來源成品具有您想要使用的最新名稱和版本。在您設定管道之後，若您變更映像或任務定義檔案，則您可能需要在儲存庫中更新來源成品，然後在管道中編輯部署階段。

**Topics**
+ [

## 先決條件
](#tutorials-ecs-ecr-codedeploy-prereq)
+ [

## 步驟 1：建立映像並推送至 Amazon ECR 儲存庫
](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [

## 步驟 2：建立任務定義和 AppSpec 來源檔案，並推送至 CodeCommit 儲存庫
](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [

## 步驟 3：建立 Application Load Balancer 和目標群組
](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [

## 步驟 4：建立 Amazon ECS 叢集和服務
](#tutorials-ecs-ecr-codedeploy-cluster)
+ [

## 步驟 5：建立 CodeDeploy 應用程式和部署群組 (ECS 運算平台）
](#tutorials-ecs-ecr-codedeploy-deployment)
+ [

## 步驟 6：建立管道
](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [

## 步驟 7：變更您的管道並驗證部署
](#tutorials-ecs-ecr-codedeploy-update)

## 先決條件
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

您必須已建立以下資源：
+ CodeCommit 儲存庫。您可以使用您在 中建立的 AWS CodeCommit 儲存庫[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ 啟動 Amazon EC2 Linux 執行個體並安裝 Docker 以建立映像，如本教學課程所示。如果您已擁有想要使用的映像，則可略過此先先決條件。

## 步驟 1：建立映像並推送至 Amazon ECR 儲存庫
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

在本節中，您會使用 Docker 來建立映像，然後使用 AWS CLI 來建立 Amazon ECR 儲存庫，並將映像推送至儲存庫。

**注意**  
如果您已擁有想要使用的映像，則可略過此先步驟。

**建立映像**

1. 登入您已在其中安裝 Docker 安裝的 Linux 執行個體。

   拉下 `nginx` 的映像。此命令提供`nginx:latest`映像：

   ```
   docker pull nginx
   ```

1. 執行 **docker images**。您應該會在清單中看到映像。

   ```
   docker images
   ```

**建立 Amazon ECR 儲存庫並推送映像**

1. 建立 Amazon ECR 儲存庫，以便存放 映像。記下輸出中的 `repositoryUri`。

   ```
   aws ecr create-repository --repository-name nginx
   ```

   輸出：

   ```
   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }
   ```

1. 為映像標記上一步中的 `repositoryUri` 值。

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. 執行 **aws ecr get-login-password**命令，如 `us-west-2`區域和 111122223333 帳戶 ID 的範例所示。

   ```
   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx
   ```

1. 使用先前步驟`repositoryUri`中的 ，將映像推送至 Amazon ECR。

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

## 步驟 2：建立任務定義和 AppSpec 來源檔案，並推送至 CodeCommit 儲存庫
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

在本節中，您會建立任務定義 JSON 檔案，並將其註冊至 Amazon ECS。然後，為 CodeDeploy 建立 AppSpec 檔案，並使用 Git 用戶端將檔案推送至 CodeCommit 儲存庫。

**針對您的映像建立任務定義**

1. 使用下列內容建立名為 `taskdef.json` 的檔案。對於 `image`，輸入您的映像名稱，例如 nginx。當您的管道執行時，此值即會更新。
**注意**  
請確定任務定義中指定的執行角色包含 `AmazonECSTaskExecutionRolePolicy`。如需詳細資訊，請參閱《[Amazon ECS 開發人員指南》中的 Amazon ECS 任務執行 IAM 角色](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html)。 **

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

1. 註冊具有 `taskdef.json` 檔案的任務定義。

   ```
   aws ecs register-task-definition --cli-input-json file://taskdef.json
   ```

1. 在註冊任務定義之後，請編輯您的檔案以移除映像名稱，並在映像欄位中包含 `<IMAGE1_NAME>` 預留位置文字。

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }
   ```

**建立 AppSpec 檔案**
+ AppSpec 檔案用於 CodeDeploy 部署。此檔案會使用下列格式，其中包含選用欄位：

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"
  ```

  如需 AppSpec 檔案的詳細資訊，包括範例，請參閱 [CodeDeploy AppSpec 檔案參考](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)。

  使用下列內容建立名為 `appspec.yaml` 的檔案。對於 `TaskDefinition`，不要變更 `<TASK_DEFINITION>` 預留位置文字。當您的管道執行時，此值即會更新。

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80
  ```

**將檔案推送至 CodeCommit 儲存庫**

1. 將檔案推送或上傳至 CodeCommit 儲存庫。這些檔案是由**建立管道**精靈為 CodePipeline 中的部署動作建立的來源成品。在本機目錄中，您的檔案應該如下所示：

   ```
   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json
   ```

1. 選擇您要用來上傳檔案的方法：

   1. 若要在您的本機電腦上從複製的儲存庫中使用 Git 命令列：

      1. 將目錄變更為您的本機儲存庫：

         ```
         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo
         ```

      1. 請執行下列命令來同時將所有檔案放入階段：

         ```
         git add -A
         ```

      1. 請執行下列命令來確認檔案並附加確認訊息：

         ```
         git commit -m "Added task definition files"
         ```

      1. 執行下列命令，將檔案從本機儲存庫推送至 CodeCommit 儲存庫：

         ```
         git push
         ```

   1. 若要使用 CodeCommit 主控台上傳您的檔案：

      1. 開啟 CodeCommit 主控台，然後從儲存庫清單中選擇您的**儲存庫**。

      1. 選擇 **Add file (新增檔案)**，然後選擇 **Upload file (上傳檔案)**。

      1. 選擇 **Choose file (選擇檔案)**，然後瀏覽您的檔案。輸入您的使用者名稱和電子郵件地址來確定變更。選擇 **Commit changes (遞交變更)**。

      1. 對於您要上傳的每個檔案重複此步驟。

## 步驟 3：建立 Application Load Balancer 和目標群組
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

在本節中，您會建立 Amazon EC2 Application Load Balancer。您稍後在建立 Amazon ECS 服務時，使用透過負載平衡器建立的子網路名稱和目標群組值。您可以建立應用程式負載平衡器或網路負載平衡器。負載平衡器必須使用 VPC 搭配不同可用區域中的兩個子網路。在這些步驟中，您確認預設 VPC、建立一個負載平衡器，然後為您的負載平衡器建立兩個目標群組。如需詳細資訊，請參閱「[網路負載平衡器的目標群組](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html)」。

**驗證您的預設 VPC 和公有子網路**

1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)：// 開啟 Amazon VPC 主控台。

1. 驗證要使用的預設 VPC。在導覽窗格中，選擇 **Your VPCs** (您的 VPC)。請注意，哪個 VPC 在 **Default VPC (預設 VPC)** 欄中顯示 **Yes (是)**。這是預設 VPC。它包含供您選取的預設子網路。

1. 選擇 **Subnets (子網路)**。選擇兩個在 **Default subnet (預設子網路)** 欄中顯示 **Yes (是)** 的子網路。
**注意**  
記下您的子網路 ID。本教學的稍後部分將需要這些資訊。

1. 選擇子網路，然後選擇 **Description (描述)** 標籤。驗證您想要使用的子網路是否位於不同的可用區域中。

1. 選擇子網路，然後選擇 **Route Table (路由表)** 標籤。若要驗證您想要使用的每個子網路是否為公有子網路，請確認閘道資料列包含在路由表中。

**建立 Amazon EC2 Application Load Balancer**

1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)：// 開啟 Amazon EC2 主控台。

1. 在導覽窗格中，選擇 **Load Balancers (負載平衡器)**。

1. 選擇 **Create Load Balancer (建立負載平衡器)**。

1. 選擇 **Application Load Balancer (應用程式負載平衡器)**，然後選擇 **Create (建立)**。

1. 在 **Name (名稱)** 中，輸入負載平衡器的名稱。

1. 在 **Scheme (結構描述)** 中，選擇 **internet-facing (面向網際網路)**。

1. 在 **IP address type (IP 地址)** 中，選擇 **ipv4**。

1. 為您的負載平衡器設定兩個接聽程式連接埠：

   1. 在 **Load Balancer Protocol (負載平衡器通訊協定)** 下，選擇 **HTTP**。在 **Load Balancer Port (負載平衡器連接埠)** 下，輸入 **80**。

   1. 選擇 **Add listener (新增接聽程式)**。

   1. 在第二個接聽程式的 **Load Balancer Protocol (負載平衡器通訊協定)** 下，選擇 **HTTP**。在 **Load Balancer Port (負載平衡器連接埠)** 下，輸入 **8080**。

1. 在 **Availability Zones (可用區域)** 下，於 **VPC** 中，選擇預設 VPC。接著，選擇您想要使用的兩個預設子網路。

1. 選擇 **Next: Configure Security Settings (下一步：設定安全設定)**。

1. 選擇 **Next: Configure Security Groups (下一步：設定安全群組)**。

1. 選擇 **Select an existing security group (選取現有的安全群組)**，並記下安全群組 ID。

1. 選擇 **Next: Configure Routing (下一步：設定路由)**。

1. 在 **Target group (目標群組)** 中，選擇 **New target group (新增目標群組)**，然後設定您的第一個目標群組：

   1. 在 **Name (名稱)** 中，輸入目標群組名稱 (例如，**target-group-1**)。

   1. 在 **Target type (目標類型)** 中，選擇 **IP**。

   1. 在 **Protocol (通訊協定)** 中，選擇 **HTTP**。在 **Port (連接埠)** 中，輸入 **80**。

   1. 選擇 **Next: Register Targets (下一步：註冊目標)**。

1. 選擇 **Next: Review (下一步：檢視)**，然後選擇 **Create (建立)**。

**為您的負載平衡器建立第二個目標群組**

1. 佈建負載平衡器之後，請開啟 Amazon EC2 主控台。在導覽窗格中，選擇 **Target Groups (目標群組)**。

1. 選擇 **Create target group (建立目標群組)**。

1. 在 **Name (名稱)** 中，輸入目標群組名稱 (例如，**target-group-2**)。

1. 在 **Target type (目標類型)** 中，選擇 **IP**。

1. 在 **Protocol (通訊協定)** 中，選擇 **HTTP**。在 **Port (連接埠)** 中，輸入 **8080**。

1. 在 **VPC** 中，選擇預設 VPC。

1. 選擇**建立**。
**注意**  
您必須具有兩個針對負載平衡器建立的目標群組，才能執行部署。您只需要記下第一個目標群組的 ARN。在下一個步驟中，此 ARN 會用於 `create-service` JSON 檔案中。

**更新您的負載平衡器以包含您的第二個目標群組**

1. 開啟 Amazon EC2 主控台。在導覽窗格中，選擇 **Load Balancers (負載平衡器)**。

1. 選擇您的負載平衡器，然後選擇 **Listeners (接聽程式)** 標籤。選擇使用連接埠 8080 的接聽程式，然後選擇 **Edit (編輯)**。

1. 選擇 **Forward to (轉寄至)** 旁邊的鉛筆圖示。選擇您的第二個目標群組，然後選擇核取記號。選擇 **Update (更新)** 來儲存更新。

## 步驟 4：建立 Amazon ECS 叢集和服務
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

在本節中，您會建立 Amazon ECS 叢集和服務，其中 CodeDeploy 會在部署期間路由流量 （至 Amazon ECS 叢集，而非 EC2 執行個體）。若要建立 Amazon ECS 服務，您必須使用透過負載平衡器建立的子網路名稱、安全群組和目標群組值來建立服務。

**注意**  
當您使用這些步驟建立 Amazon ECS 叢集時，您可以使用**僅限聯網**叢集範本，以佈建 AWS Fargate 容器。 AWS Fargate 是一種技術，可為您管理容器執行個體基礎設施。您不需要為 Amazon ECS 叢集選擇或手動建立 Amazon EC2 執行個體。

**建立 Amazon ECS 叢集**

1. 開啟 Amazon ECS 傳統主控台，網址為 [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/)。

1. 在導覽窗格中，選擇**叢集**。

1. 選擇 **Create Cluster** (建立叢集)。

1. 選擇**僅限聯網**且使用 AWS Fargate 的叢集範本，然後選擇**下一步**。

1. 在 **Configure cluster (設定叢集)** 頁面上輸入叢集名稱。您可以為您的資源新增選用的標籤。選擇**建立**。

**建立 Amazon ECS 服務**

使用 AWS CLI 在 Amazon ECS 中建立您的服務。

1. 建立 JSON 檔案，並將其命名為 `create-service.json`。將下列內容貼入 JSON 檔案中。

   對於 `taskDefinition` 欄位，當您在 Amazon ECS 中註冊任務定義時，您會為其提供一個系列。這類似用於多個任務定義版本的名稱，以修訂版號碼指定。在此範例中，請將「`ecs-demo:1`」用於您檔案中的系列和修訂版號碼。在 [步驟 3：建立 Application Load Balancer 和目標群組](#tutorials-ecs-ecr-codedeploy-loadbal) 中使用您建立的子網路名稱、安全群組和目標群組值，以及您的負載平衡器。
**注意**  
您需要在這個檔案包含您的目標群組 ARN。開啟 Amazon EC2 主控台，然後從導覽窗格的 **LOAD BALANCING** 下，選擇**目標群組**。選擇您的第一個目標群組。從 **Description (描述)** 標籤複製您的 ARN。

   ```
   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }
   ```

1. 執行 **create-service** 命令，指定 JSON 檔案：
**重要**  
請確認在檔案名稱之前包含 `file://`。這是此命令必要項目。

   此範例會建立名為 `my-service` 的服務。
**注意**  
此範例命令會建立名為 my-service 的服務。如果您已經有使用此名稱的服務，此命令會傳回錯誤。

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   輸出會傳回您服務的描述欄位。

1. 執行 **describe-services** 命令，以驗證是否已建立您的服務。

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## 步驟 5：建立 CodeDeploy 應用程式和部署群組 (ECS 運算平台）
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

當您為 Amazon ECS 運算平台建立 CodeDeploy 應用程式和部署群組時，應用程式會在部署期間用來參考正確的部署群組、目標群組、接聽程式和流量重新路由行為。

**建立 CodeDeploy 應用程式**

1. 開啟 CodeDeploy 主控台，然後選擇**建立應用程式**。

1. 在 **Application name (應用程式名稱)** 中，輸入您想要使用的名稱。

1. 在 **Compute Platform (運算平台)** 中，選擇 **Amazon ECS**。

1. 選擇**建立應用程式**。

**建立 CodeDeploy 部署群組**

1. 在您應用程式頁面的 **Deployment groups (部署群組)** 標籤上，選擇 **Create deployment group (建立部署群組)**。

1. 在 **Deployment group name (部署群組名稱)** 中，輸入描述部署群組的名稱。

1. 在**服務角色**中，選擇授予 CodeDeploy 存取 Amazon ECS 的服務角色。若要建立新的服務角色，請遵循下列步驟：

   1. 開啟 IAM 主控台，網址為 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/))。

   1. 從主控台儀表板，選擇 **Roles (角色)**。

   1. 選擇建**立角色**。

   1. 在**選取信任實體類型**下，選取 **AWS 服務**。在 **Choose a use case (選擇使用案例)** 下，選取 **CodeDeploy**。在 **Select your use case (選取您的使用案例)** 下，選取 **CodeDeploy - ECS**。選擇**下一步：許可**。`AWSCodeDeployRoleForECS` 受管政策已連接至角色。

   1. 選擇 **Next: Tags (下一步：標籤)**，然後選擇 **Next: Review (下一步：檢閱)**。

   1. 輸入角色的名稱 (例如 **CodeDeployECSRole**)，然後選擇 **Create role (建立角色)**。

1. 在**環境組態**中，選擇您的 Amazon ECS 叢集名稱和服務名稱。

1. 從**負載平衡器**中，選擇為 Amazon ECS 服務提供流量的負載平衡器名稱。

1. 從 **Production listener port (生產接聽程式連接埠)** 中，為接聽程式選擇連接埠和通訊協定，而此接聽程式會對 Amazon ECS 服務提供生產流量。從 **Test listener port (測試接聽程式連接埠)**，為測試接聽程式選擇連接埠和通訊協定。

1. 從 **Target group 1 name (目標群組 1 名稱)** 和 **Target group 2 name (目標群組 2 名稱)** 中，選擇在部署期間用來路由流量的目標群組。確定這些是您為負載平衡器建立的目標群組。

1. 選擇**立即重新路由流量**，以判斷成功部署後將流量重新路由到更新後的 Amazon ECS 任務的時間長度。

1. 選擇 **Create deployment group (建立部署群組)**。

## 步驟 6：建立管道
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ CodeCommit 動作，其中來源成品是任務定義和 AppSpec 檔案。
+ 具有 Amazon ECR 來源動作的來源階段，其中來源成品是映像檔案。
+ 具有 Amazon ECS 部署動作的部署階段，其中部署使用 CodeDeploy 應用程式和部署群組執行。

**使用精靈建立兩階段管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyImagePipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**的**來源提供者**中，選擇 **AWS CodeCommit**。在**儲存庫名稱**中，選擇您在 中建立的 CodeCommit 儲存庫名稱[步驟 1：建立 CodeCommit 儲存庫](tutorials-simple-codecommit.md#codecommit-create-repository)。在 **Branch name (分支名稱)** 中，選擇包含最新程式碼更新的分支名稱。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**：

   1. 在 **Deploy provider (部署提供者)** 中，選擇 **Amazon ECS (Blue/Green) (Amazon ECS (藍/綠))**。在 **Application name (應用程式名稱)** 中，輸入應用程式名稱或從清單中選擇應用程式名稱，例如，`codedeployapp`。在 **Deployment group (部署群組)** 中，輸入部署群組名稱或從清單中選擇部署群組名稱，例如，`codedeploydeplgroup`。

       
**注意**  
名稱「Deploy」(部署)，是預設指定給在 **Step 4: Deploy (步驟 4：部署)** 步驟中建立的階段名稱，如同「Source」(來源) 是管道的第一階段所指定的名稱。

   1. 在 **Amazon ECS task definition (Amazon ECS 任務定義)** 下，選擇 **SourceArtifact**。在欄位中，輸入 **taskdef.json**。

   1. 在 **AWS CodeDeploy AppSpec 檔案**下，選擇 **SourceArtifact**。在欄位中，輸入 **appspec.yaml**。
**注意**  
此時，不要在 **Dynamically update task definition image (動態更新任務定義映像)** 下填寫任何資訊。

   1. 選擇**下一步**。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

**將 Amazon ECR 來源動作新增至管道**

檢視您的管道，並將 Amazon ECR 來源動作新增至您的管道。

1. 選擇您的管道。在左上角，選擇 **Edit (編輯)**。

1. 在來源階段中，選擇 **Edit stage (編輯階段)**。

1. 選擇 CodeCommit 來源動作旁的 **\$1 新增動作**，以新增平行動作。

1. 在 **Action name (動作名稱)** 中，輸入名稱 (例如，**Image**)。

1. 在**Action provider (動作提供者)**中，選擇 **Amazon ECR**。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/ECR-source-action.png)

1. 在**儲存庫名稱**中，選擇 Amazon ECR 儲存庫的名稱。

1. 在 **Image tag (映像標籤)** 中，指定映像名稱和版本，如果與最新不同的話。

1. 在 **Output artifacts (輸出成品)** 中，選擇輸出成品預設值 (例如 `MyImage`)，其中包含您要下一個階段使用的映像名稱和儲存庫 URI 資訊。

1. 在動作畫面上選擇 **Save (儲存)**。在階段畫面上選擇 **Done (完成)**。在管道上選擇 **Save (儲存)**。訊息顯示要為 Amazon ECR 來源動作建立的 Amazon CloudWatch Events 規則。

**將您的來源成品連線至部署動作**

1. 在部署階段選擇**編輯**，然後選擇 圖示來編輯 **Amazon ECS （藍/綠）** 動作。

1. 捲動到窗格底部。在 **Input artifacts (輸入成品)** 中，選擇 **Add (新增)**。從新的 Amazon ECR 儲存庫新增來源成品 （例如 `MyImage`)。

1. 在 **Task Definition (任務定義)** 中，選擇 **SourceArtifact**，然後確認已輸入 **taskdef.json**。

1. 在 **AWS CodeDeploy AppSpec 檔案中**，選擇 **SourceArtifact**，然後**appspec.yaml**輸入驗證。

1. 在 **Dynamically update task definition image (動態更新任務定義映像)** 的 **Input Artifact with Image URI (輸入成品與映像 URI)** 中，選擇 **MyImage**，然後輸入 `taskdef.json` 檔案中使用的預留位置文字：** IMAGE1\$1NAME**。選擇**儲存**。

1. 在 AWS CodePipeline 窗格中，選擇**儲存管道變更**，然後選擇**儲存變更**。檢視已更新的管道。

   建立此範例管道後，主控台項目的動作組態會顯示在管道結構中，如下所示：

   ```
   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   ```

1. 若要提交您的變更並啟動管道建置，請選擇 **​Release change (發行變更)**，然後選擇 **​Release (發行)**。

1. 選擇部署動作以在 CodeDeploy 中檢視，並查看流量轉移的進度。
**注意**  
您可以查看顯示選用等待時間的部署步驟。根據預設，CodeDeploy 會在成功部署後等待一小時，再終止原始任務集。您可以利用這段時間復原或終止任務，但在任務集終止時，您的部署任務會以別的方式完成。

## 步驟 7：變更您的管道並驗證部署
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

對您的映像進行變更，然後將變更推送到您的 Amazon ECR 儲存庫。這會觸發您的管道執行。驗證是否已部署您的映像來源。

# 教學：建立部署 Amazon Alexa 技能的管道
<a name="tutorials-alexa-skills-kit"></a>

在此教學課程中，您會設定管道在您的部署階段中，將 Alexa Skills Kit 做為部署提供者，來持續交付您的 Alexa 技能。當您變更來源儲存庫中的來源檔案時，完整的管道便會偵測到您的技能變更。管道稍後會使用 Alexa Skills Kit 來部署至 Alexa 技能開發階段。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
此功能不適用於亞太區域 （香港） 或歐洲 （米蘭） 區域。若要使用該區域中可用的其他部署動作，請參閱 [部署動作整合](integrations-action-type.md#integrations-deploy)。

若要將自訂技能建立為 Lambda 函數，請參閱[將自訂技能託管為 AWS Lambda 函數](https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html)。您也可以建立使用 Lambda 來源檔案和 CodeBuild 專案的管道，以針對您的技能將變更部署至 Lambda。

## 先決條件
<a name="tutorials-alexa-skills-kit-prereq"></a>

您必須已擁有下列各項目：
+ CodeCommit 儲存庫。您可以使用您在 中建立的 AWS CodeCommit 儲存庫[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ Amazon 開發人員帳戶。這是擁有您 Alexa 技能的帳戶。您可以在 [Alexa Skills Kit](https://developer.amazon.com/alexa-skills-kit) 免費建立帳戶。
+ Alexa 技能。您可以依據[取得自訂技能範本程式碼](https://developer.amazon.com/docs/custom-skills/use-the-alexa-skills-kit-samples.html)教學課程建立範例技能。
+ 安裝 ASK CLI，並使用 `ask init` 搭配您的 AWS 登入資料進行設定。請參閱[安裝並初始化 ASK CLI](https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize)。

## 步驟 1：建立 Alexa 開發人員服務 LWA 安全性描述檔
<a name="tutorials-alexa-skills-kit-profile"></a>

在本節，您會建立安全性描述檔，來搭配 Login with Amazon (LWA) 使用。如果您已有描述檔，則可以略過此步驟。
+ 使用 [generate-lwa-tokens](https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens) 中的步驟建立安全性描述檔。
+ 建立描述檔後，請記下 **Client ID (用戶端 ID)** 和 **Client Secret (用戶端密碼)**。
+ 請確定您如說明所述輸入 **Allowed Return URLs (允許的傳回 URL)**。URL 允許 ASK CLI 命令重新導向重新整理字符請求。

## 步驟 2：建立 Alexa 技能來源檔案並推送到您的 CodeCommit 儲存庫
<a name="tutorials-alexa-skills-kit-push"></a>

在本節，您會建立並推送 Alexa 技能來源檔案到管道用於來源階段的儲存庫。對於您已在 Amazon 開發人員主控台中建立的技能，您會產生和推送下列項目：
+ `skill.json` 檔案。
+ `interactionModel/custom` 資料夾。
**注意**  
此目錄結構符合 Alexa Skills Kit 技能套件格式要求，如[技能套件格式](https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format)中所述。如果目錄結構未使用正確的技能套件格式，變更不會順利部署到 Alexa Skills Kit 主控台。

**為您的技能建立來源檔案**

1. 從 Alexa Skills Kit 開發人員主控台擷取您的技能 ID。使用此命令：

   ```
   ask api list-skills
   ```

   依名稱找出您的技能，然後複製 `skillId` 欄位中已關聯的 ID。

1. 產生包含您的技能詳細資訊的 `skill.json` 檔案。使用此命令：

   ```
   ask api get-skill -s skill-ID > skill.json
   ```

1. (選用) 建立 `interactionModel/custom` 資料夾。

   使用此命令產生資料夾內的互動模型檔案。在地區設定上，此教學使用 en-US 做為檔案名稱中的地區設定。

   ```
   ask api get-model --skill-id skill-ID --locale locale >
       ./interactionModel/custom/locale.json
   ```

**將檔案推送至 CodeCommit 儲存庫**

1. 將檔案推送或上傳至 CodeCommit 儲存庫。這些檔案是 **Create Pipeline (建立管道)** 精靈針對 AWS CodePipeline中的部署動作所建立的來源成品。在本機目錄中，您的檔案應該如下所示：

   ```
   skill.json
   /interactionModel
     /custom
       |en-US.json
   ```

1. 選擇您要用來上傳檔案的方法：

   1. 若要在您的本機電腦上從複製的儲存庫中使用 Git 命令列：

      1. 請執行下列命令來同時將所有檔案放入階段：

         ```
         git add -A
         ```

      1. 請執行下列命令來確認檔案並附加確認訊息：

         ```
         git commit -m "Added Alexa skill files"
         ```

      1. 執行下列命令，將檔案從本機儲存庫推送至 CodeCommit 儲存庫：

         ```
         git push
         ```

   1. 若要使用 CodeCommit 主控台上傳您的檔案：

      1. 開啟 CodeCommit 主控台，然後從儲存庫清單中選擇您的**儲存庫**。

      1. 選擇 **Add file (新增檔案)**，然後選擇 **Upload file (上傳檔案)**。

      1. 選擇 **Choose file (選擇檔案)**，然後瀏覽您的檔案。輸入您的使用者名稱和電子郵件地址來確定變更。選擇 **Commit changes (遞交變更)**。

      1. 對於您要上傳的每個檔案重複此步驟。

## 步驟 3：使用 ASK CLI 命令建立重新整理字符
<a name="tutorials-alexa-skills-kit-token"></a>

CodePipeline 會根據 Amazon 開發人員帳戶中的用戶端 ID 和秘密，使用重新整理權杖來授權其代表您執行的動作。在本節中，您可以使用 ASK CLI 來建立字符。當您使用 **Create Pipeline (建立管道)** 精靈時，您會使用這些登入資料。

**使用您的 Amazon 開發人員帳戶登入資料建立重新整理字符**

1. 使用下列命令：

   ```
   ask util generate-lwa-tokens
   ```

1. 出現提示時，如此範例所示，輸入您的用戶端 ID 和密碼：

   ```
   ? Please type in the client ID: 
   amzn1.application-client.example112233445566
   ? Please type in the client secret:
   example112233445566
   ```

1. 登入瀏覽器頁面隨即顯示。使用您的 Amazon 開發人員帳戶登入資料登入。

1. 返回命令列畫面。存取字符和重新整理字符會在輸出中產生。複製輸出中傳回的重新整理字符。

## 步驟 4：建立管道
<a name="tutorials-alexa-skills-kit-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 具有 CodeCommit 動作的來源階段，其中來源成品是支援您技能的 Alexa 技能檔案。
+ 具有 Alexa Skills Kit 部署動作的部署階段。

**使用精靈建立管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 選擇您要建立專案及其資源 AWS 的區域。下列區域才能取得 Alexa 技能執行時間：
   + 亞太地區 (東京)
   + 歐洲 (愛爾蘭)
   + 美國東部 (維吉尼亞北部)
   + 美國西部 (奧勒岡)

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyAlexaPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**的**來源提供者**中，選擇 **AWS CodeCommit**。在**儲存庫名稱**中，選擇您在 中建立的 CodeCommit 儲存庫名稱[步驟 1：建立 CodeCommit 儲存庫](tutorials-simple-codecommit.md#codecommit-create-repository)。在 **Branch name (分支名稱)** 中，選擇包含最新程式碼更新的分支名稱。

   選取儲存庫名稱和分支之後，會出現一則訊息，顯示要為此管道建立的 Amazon CloudWatch Events 規則。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**：

   1. 在 **Deploy provider (部署提供者)** 中，選擇 **Alexa Skills Kit**。

   1. 在 **Alexa skill ID (Alexa 技能 ID)** 中，輸入指派給您在 Alexa Skills Kit 開發人員主控台中技能的技能 ID。

   1. 在 **Client ID (用戶端 ID)** 中，輸入您註冊之應用程式的 ID。

   1. 在 **Client secret (用戶端密碼)** 中，輸入您在註冊時選擇的密碼。

   1. 在 **Refresh token (重新整理字符)** 中，輸入您在步驟 3 產生的字符。  
![\[Alexa Skills Kit 動作的步驟 6：部署頁面\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/alexa-deploy.png)

   1. 選擇**下一步**。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

## 步驟 5：變更任一來源檔案並驗證部署
<a name="tutorials-alexa-skills-kit-update"></a>

變更您的技能，然後將變更推送至您的儲存庫。這會觸發您的管道執行。驗證您的技能已在 [Alexa Skills Kit 開發人員主控台](https://developer.amazon.com/alexa/console/ask)中更新。

# 教學課程：建立使用 Amazon S3 做為部署提供者的管道
<a name="tutorials-s3deploy"></a>

在本教學課程中，您會設定管道，以使用 Amazon S3 做為部署階段中的部署動作提供者來持續交付檔案。當您變更來源儲存庫中的來源檔案時，完整的管道便會偵測到變更。然後，管道會使用 Amazon S3 將檔案部署到您的儲存貯體。每次在來源位置修改或新增網站檔案時，部署都會使用最新的檔案建立網站。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
即使您從來源儲存庫刪除檔案，S3 部署動作也不會刪除與已刪除檔案對應的 S3 物件。

本教學課程提供兩種選項：
+ 建立將靜態網站部署到您的 S3 公有儲存貯體的管道。此範例會建立具有 AWS CodeCommit 來源動作和 Amazon S3 部署動作的管道。請參閱 [選項 1：將靜態網站檔案部署至 Amazon S3](#tutorials-s3deploy-acc)。
+ 建立將範例 TypeScript 程式碼編譯為 JavaScript 的管道，並將 CodeBuild 輸出成品部署至 S3 儲存貯體以供封存。此範例會建立具有 Amazon S3 來源動作、CodeBuild 建置動作和 Amazon S3 部署動作的管道。請參閱 [選項 2：從 Amazon S3 S3](#tutorials-s3deploy-s3source)。

**重要**  
您在此程序中新增至管道的許多動作都涉及您在建立管道之前需要建立 AWS 的資源。來源動作 AWS 的資源一律必須在您建立管道 AWS 的相同區域中建立。例如，如果您在美國東部 （俄亥俄） 區域建立管道，則 CodeCommit 儲存庫必須位於美國東部 （俄亥俄） 區域。  
您可以在建立管道時新增跨區域動作。跨區域動作 AWS 的資源必須位於您計劃執行動作的相同 AWS 區域中。如需詳細資訊，請參閱[在 CodePipeline 中新增跨區域動作](actions-create-cross-region.md)。

## 選項 1：將靜態網站檔案部署至 Amazon S3
<a name="tutorials-s3deploy-acc"></a>

在此範例中，您會下載範例靜態網站範本檔案、將檔案上傳至您的 AWS CodeCommit 儲存庫、建立儲存貯體，以及將其設定為託管。接著，您可以使用 AWS CodePipeline 主控台來建立管道，並指定 Amazon S3 部署組態。

### 先決條件
<a name="tutorials-s3deploy-acc-prereq"></a>

您必須已擁有下列各項目：
+ CodeCommit 儲存庫。您可以使用您在 中建立的 AWS CodeCommit 儲存庫[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ 您靜態網站的來源檔案。使用此連結來下載 [範例靜態網站](samples/sample-website.zip)。sample-website.zip 下載會產生下列檔案：
  + `index.html` 檔案
  + `main.css` 檔案
  + `graphic.jpg` 檔案
+ 處理網站託管的 S3 儲存貯體。請參閱[託管於 Amazon S3 的靜態網站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)。確定您建立的儲存貯體與管道位於同一個區域。
**注意**  
為託管網站，儲存貯體必擁有公有讀取存取權，藉此授予每個人讀取存取權。除了網站託管以外，您應該保留封鎖公有存取 S3 儲存貯體的預設存取設定。

### 步驟 1：將來源檔案推送到您的 CodeCommit 儲存庫
<a name="tutorials-s3deploy-acc-push"></a>

在本節，請推送來源檔案到管道用於來源階段的儲存庫。

**將檔案推送至 CodeCommit 儲存庫**

1. 將下載的範例檔案解壓縮。請勿將 ZIP 檔案上傳到您的儲存庫。

1. 將檔案推送或上傳至 CodeCommit 儲存庫。這些檔案是由**建立管道**精靈為 CodePipeline 中的部署動作建立的來源成品。在本機目錄中，您的檔案應該如下所示：

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. 您可以使用 Git 或 CodeCommit 主控台上傳您的檔案：

   1. 若要在您的本機電腦上從複製的儲存庫中使用 Git 命令列：

      1. 請執行下列命令來同時將所有檔案放入階段：

         ```
         git add -A
         ```

      1. 請執行下列命令來確認檔案並附加確認訊息：

         ```
         git commit -m "Added static website files"
         ```

      1. 執行下列命令，將檔案從本機儲存庫推送至 CodeCommit 儲存庫：

         ```
         git push
         ```

   1. 若要使用 CodeCommit 主控台上傳您的檔案：

      1. 開啟 CodeCommit 主控台，然後從儲存庫清單中選擇您的**儲存庫**。

      1. 選擇 **Add file (新增檔案)**，然後選擇 **Upload file (上傳檔案)**。

      1. 選取 **Choose file (選擇檔案)**，然後瀏覽您的檔案。輸入您的使用者名稱和電子郵件地址來確定變更。選擇 **Commit changes (遞交變更)**。

      1. 對於您要上傳的每個檔案重複此步驟。

### 步驟 2：建立管道
<a name="tutorials-s3deploy-acc-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 具有 CodeCommit 動作的來源階段，其中來源成品是您網站的檔案。
+ 具有 Amazon S3 部署動作的部署階段。

**使用精靈建立管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyS3DeployPipeline**。

1. 在**管道類型**中，選擇 **V2**。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。選擇**下一步**。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**的**來源提供者**中，選擇 **AWS CodeCommit**。在**儲存庫名稱**中，選擇您在 中建立的 CodeCommit 儲存庫名稱[步驟 1：建立 CodeCommit 儲存庫](tutorials-simple-codecommit.md#codecommit-create-repository)。在 **Branch name (分支名稱)** 中，選擇包含最新程式碼更新的分支名稱。除非您自己建立不同分支，否則僅能使用 `main`。

   選取儲存庫名稱和分支之後，即會顯示要為此管道建立的 Amazon CloudWatch Events 規則。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**：

   1. 在**Deploy provider (部署提供者)**中，選擇 **Amazon S3**。

   1. 在 **Bucket (儲存貯體)** 中，輸入您公有儲存貯體的名稱。

   1. 選取 **Extract file before deploy (部署前解壓縮檔案)**。
**注意**  
如果您沒有選取 **Extract file before deploy (部署前解壓縮檔案)**，部署則會失敗。這是因為管道中的 AWS CodeCommit 動作壓縮來源成品，而您的 檔案是 ZIP 檔案。

      選取 **Extract file before deploy (部署前解壓縮檔案)** 時，則會顯示 **Deployment path (部署路徑)**。請輸入您要使用的路徑的名稱。這會在 Amazon S3 中建立資料夾結構，將檔案解壓縮至其中。在本教學課程中，請將此欄位保留空白。  
![\[步驟 6：使用 來源新增 S3 部署動作的部署階段頁面 S3 AWS CodeCommit\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-codecommit.png)

   1. (選用) 在 **Canned ACL (固定的 ACL)** 中，您可以將一組預先定義的授與 (稱為[固定的 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl)) 套用至上傳的成品。

   1. (選用) 在 **Cache control (快取控制)** 中，輸入快取參數。您可以將此設為控制請求/回應的快取行為。如需有效值，請參閱 HTTP 操作的 [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) 標頭欄位。

   1. 選擇**下一步**。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

1. 管道成功執行後，請開啟 Amazon S3 主控台，並確認您的檔案出現在您的公有儲存貯體中，如下所示：

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. 存取您的端點，以測試網站。您的端點遵循此格式：`http://bucket-name.s3-website-region.amazonaws.com/`。

   範例端點：`http://my-bucket.s3-website-us-west-2.amazonaws.com/`。

   範例網頁隨即出現。

### 步驟 3：變更任一來源檔案並驗證部署
<a name="tutorials-s3deploy-acc-update"></a>

變更您的來源檔案，然後將變更推送至您的儲存庫。這會觸發您的管道執行。驗證您的網站已更新。

## 選項 2：從 Amazon S3 S3
<a name="tutorials-s3deploy-s3source"></a>

在此選項中，您建置階段中的建置命令會將 TypeScript 程式碼編譯至 JavaScript 程式碼，並將輸出部署到加上個別時間戳記之資料夾下的 S3 目標儲存貯體。您先要建立 TypeScript 程式碼和 buildspec.yml 檔案。在 ZIP 檔案中合併來源檔案後，您可以將來源 ZIP 檔案上傳到 S3 來源儲存貯體，並使用 CodeBuild 階段將建置的應用程式 ZIP 檔案部署到 S3 目標儲存貯體。經過編譯的程式碼會在您的目標儲存貯體中做為存檔保留。

### 先決條件
<a name="tutorials-s3deploy-s3source-prereq"></a>

您必須已擁有下列各項目：
+ S3 來源儲存貯體。您可以使用您在 [教學：建立簡易管道 (S3 儲存貯體)](tutorials-simple-s3.md) 中建立的儲存貯體。
+ S3 目標儲存貯體。請參閱[託管於 Amazon S3 的靜態網站](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)。請務必在與要建立 AWS 區域 的管道相同的 中建立儲存貯體。
**注意**  
此範例示範部署檔案到私有儲存貯體。請勿啟用用於網站託管的目標儲存貯體，或連接使儲存貯體公開的任何政策。

### 步驟 1：建立和上傳來源檔案到您的 S3 來源儲存貯體
<a name="tutorials-s3deploy-s3source-upload"></a>

在本節，您會建立並上傳來源檔案到管道用於來源階段的儲存貯體。本節提供建立下列來源檔案的說明：
+ `buildspec.yml` 檔案，用於 CodeBuild 組建專案。
+ `index.ts` 檔案。

**建立 buildspec.yml 檔案**
+ 使用下列內容建立名為 `buildspec.yml` 的檔案。這些建置命令會安裝 TypeScript 並使用 TypeScript 編譯器將 `index.ts` 中的程式碼重寫成 JavaScript 程式碼。

  ```
  version: 0.2
  
  phases:
    install:
      commands:
        - npm install -g typescript
    build:
      commands:
        - tsc index.ts
  artifacts:
    files:
      - index.js
  ```

**建立 index.ts 檔案**
+ 使用下列內容建立名為 `index.ts` 的檔案。

  ```
  interface Greeting {
      message: string;
  }
  
  class HelloGreeting implements Greeting {
      message = "Hello!";
  }
  
  function greet(greeting: Greeting) {
      console.log(greeting.message);
  }
  
  let greeting = new HelloGreeting();
  
  greet(greeting);
  ```

**上傳檔案到您的 S3 來源儲存貯體**

1. 在本機目錄中，您的檔案應該如下所示：

   ```
   buildspec.yml
   index.ts
   ```

   壓縮檔案，然後命名檔案為 `source.zip`。

1. 在 Amazon S3 主控台中，針對來源儲存貯體選擇**上傳**。選擇 **Add files (新增檔案)**，然後瀏覽您建立的 ZIP 檔案。

1.  選擇**上傳**。這些檔案是由**建立管道**精靈為 CodePipeline 中的部署動作建立的來源成品。您的檔案在您的儲存貯體中應該如下所示：

   ```
   source.zip
   ```

### 步驟 2：建立管道
<a name="tutorials-s3deploy-s3source-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 具有 Amazon S3 動作的來源階段，其中來源成品是可下載應用程式的檔案。
+ 具有 Amazon S3 部署動作的部署階段。

**使用精靈建立管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyS3DeployPipeline**。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**的**來源提供者**中，選擇 **Amazon S3**。在 **Bucket (儲存貯體)** 中，輸入您來源儲存貯體的名稱。在 **S3 object key (S3 物件金鑰)** 中，輸入您的來源 ZIP 檔案名稱。請確保您加入 .zip 副檔名。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**：

   1. 在**建置提供者**中，選擇 **CodeBuild**。

   1. 選擇 **Create build project (建立建置專案)**。在 **Create project (建立專案)** 頁面：

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment (環境)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。針對 **Runtime version (執行時間版本)**，選擇 **aws/codebuild/standard:1.0**。

   1. 在 **Image version (映像版本)** 中，選擇 **Always use the latest image for this runtime version (總是將最新的映像用於此執行時間版本)**。

   1. 針對**服務角色**，選擇您的 CodeBuild 服務角色，或建立一個。

   1. 對於 **Build specifications (建置規格)**，選擇 **Use a buildspec file (使用 buildspec 檔案)**。

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。如果已成功建立專案，則會顯示訊息。

   1. 選擇**下一步**。

1. 在**步驟 5：新增部署階段**：

   1. 在**Deploy provider (部署提供者)**中，選擇 **Amazon S3**。

   1. 在 **Bucket (儲存貯體)** 中，輸入您 S3 目標儲存貯體的名稱。

   1. 請確定已清除 **Extract file before deploy (部署前解壓縮檔案)**。

      清除 **Extract file before deploy (部署前解壓縮檔案)** 時，則會顯示 **S3 object key (S3 物件金鑰)**。請輸入您要使用的路徑名稱：`js-application/{datetime}.zip`

      這會在 Amazon S3 中建立`js-application`資料夾，將檔案解壓縮至其中。在此資料夾中，`{datetime}` 變數會在管道執行時在每個輸出檔案上建立時間戳記。  
![\[步驟 5：使用 Amazon S3 來源部署動作的部署頁面\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-s3source.png)

   1. (選用) 在 **Canned ACL (固定的 ACL)** 中，您可以將一組預先定義的授與 (稱為[固定的 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl)) 套用至上傳的成品。

   1. (選用) 在 **Cache control (快取控制)** 中，輸入快取參數。您可以將此設為控制請求/回應的快取行為。如需有效值，請參閱 HTTP 操作的 [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) 標頭欄位。

   1. 選擇**下一步**。

1. 在**步驟 6：檢閱**中檢閱資訊，然後選擇**建立管道**。

1. 管道成功執行後，請在 Amazon S3 主控台中檢視儲存貯體。驗證您部署的 ZIP 檔案在 `js-application` 資料夾下的目標儲存貯體中顯示。包含在 ZIP 檔案中的 JavaScript 檔案應為 `index.js`。`index.js` 檔案包含下列輸出：

   ```
   var HelloGreeting = /** @class */ (function () {
       function HelloGreeting() {
           this.message = "Hello!";
       }
       return HelloGreeting;
   }());
   function greet(greeting) {
       console.log(greeting.message);
   }
   var greeting = new HelloGreeting();
   greet(greeting);
   ```

### 步驟 3：變更任一來源檔案並驗證部署
<a name="tutorials-s3deploy-s3source-update"></a>

變更您的來源檔案，然後將它們推送至您的來源儲存貯體。這會觸發您的管道執行。檢視您的目標儲存貯體，並驗證部署的輸出檔案可在 `js-application` 資料夾中使用，如下所示：

![\[範例 ZIP 下載\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/tutorial-s3deploy-pipeline-appzip.png)


# 教學課程：建立將無伺服器應用程式發佈至 的管道 AWS Serverless Application Repository
<a name="tutorials-serverlessrepo-auto-publish"></a>

您可以使用 AWS CodePipeline 持續將無 AWS SAM 伺服器應用程式交付至 AWS Serverless Application Repository。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

本教學課程說明如何建立和設定管道，以建置 GitHub 中託管的無伺服器應用程式，並將其 AWS Serverless Application Repository 自動發佈至 。管道使用 GitHub 做為來源提供者，並使用 CodeBuild 做為建置提供者。若要將無伺服器應用程式發佈至 AWS Serverless Application Repository，您可以部署[應用程式](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish ) （從 AWS Serverless Application Repository)，並將該應用程式建立的 Lambda 函數關聯為管道中的調用動作提供者。然後，您可以持續將應用程式更新交付至 AWS Serverless Application Repository，而無需撰寫任何程式碼。

**重要**  
您在此程序中新增至管道的許多動作都涉及您在建立管道之前需要建立 AWS 的資源。來源動作 AWS 的資源一律必須在您建立管道 AWS 的相同區域中建立。例如，如果您在美國東部 （俄亥俄） 區域建立管道，則 CodeCommit 儲存庫必須位於美國東部 （俄亥俄） 區域。  
您可以在建立管道時新增跨區域動作。跨區域動作 AWS 的資源必須位於您計劃執行動作的相同 AWS 區域中。如需詳細資訊，請參閱[在 CodePipeline 中新增跨區域動作](actions-create-cross-region.md)。

## 開始之前
<a name="tutorials-serverlessrepo-auto-publish-prereq"></a>

在此教學課程中，我們假設以下情況。
+ 您熟悉 [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/) 和 [AWS Serverless Application Repository](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/)。
+ 您在 GitHub 中託管了使用 CLI AWS SAM 發佈到 AWS Serverless Application Repository 的無伺服器應用程式。若要將範例應用程式發佈至 AWS Serverless Application Repository，請參閱《 *AWS Serverless Application Repository 開發人員指南*》中的[快速入門：發佈應用程式](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-quick-start.html)。若要將您自己的應用程式發佈至 AWS Serverless Application Repository，請參閱《 *AWS Serverless Application Model 開發人員指南*》中的[使用 AWS SAM CLI 發佈應用程式](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html)。

## 步驟 1：建立 buildspec.yml 檔案
<a name="serverlessrepo-auto-publish-create-buildspec"></a>

建立 `buildspec.yml` 檔案與以下內容，並新增到您的無伺服器應用程式的 GitHub 儲存庫。將 *template.yml* 取代為應用程式的 AWS SAM 範本，並將*儲存貯體名稱*取代為儲存封裝應用程式的 S3 儲存貯體。

```
version: 0.2
phases:
  install:
    runtime-versions:
        python: 3.8
  build:
    commands:
      - sam package --template-file template.yml --s3-bucket bucketname --output-template-file packaged-template.yml
artifacts:
  files:
    - packaged-template.yml
```

## 步驟 2：建立並設定管道
<a name="serverlessrepo-auto-publish-create-pipeline"></a>

請依照下列步驟，在 AWS 區域 您要發佈無伺服器應用程式的 中建立管道。

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)。

1. 如有必要，請切換到 AWS 區域 您要發佈無伺服器應用程式的 。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 選擇 **Create pipeline (建立管道)**。在**步驟 2：選擇管道設定**頁面上，在**管道名稱**中，輸入管道的名稱。

1. 在**管道類型**中，選擇 **V2**。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。選擇**下一步**。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**頁面的**來源提供者**中，選擇 **GitHub**。

1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

1. 在 **​Repository (儲存庫)** 中，選擇 GitHub 來源儲存庫。

1. 在 **Branch (分支)** 中，選擇您的 GitHub 分支。

1. 保留來源動作的其餘預設值。選擇**下一步**。

1. 在**步驟 4：新增建置階段**頁面上，新增建置階段：

   1. 在 **Build provider (建置供應商)** 中，選擇 **AWS CodeBuild**。對於 **Region (區域)**，請使用管道區域。

   1. 選擇**建立專案**。

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment image (環境映像)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 對於 **Runtime (執行時間)** 和 **Runtime version (執行時間版本)**，選擇無伺服器應用程式所需的執行時間和版本。

   1. 對於 **Service role (服務角色)**，選擇 **New service role (新服務角色)**。

   1. 對於 **Build specifications (建置規格)**，選擇 **Use a buildspec file (使用 buildspec 檔案)**。

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。這會開啟 CodePipeline 主控台，並建立 CodeBuild 專案，使用儲存庫`buildspec.yml`中的 進行組態。建置專案使用服務角色來管理 AWS 服務 許可。此步驟可能需要數分鐘。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。您應該會看到顯示階段的圖表。

1. 授予 CodeBuild 服務角色許可，以存取存放封裝應用程式的 S3 儲存貯體。

   1. 在新管道的**建置**階段中，選擇 **CodeBuild**。

   1. 選擇 **Build details (建置詳細資訊)** 標籤。

   1. 在**環境中**，選擇 CodeBuild 服務角色以開啟 IAM 主控台。

   1. 展開 `CodeBuildBasePolicy` 的選項，然後選擇 **Edit policy (編輯政策)**。

   1. 選擇 **JSON**。

   1. 新增政策陳述式與下列內容。陳述式可讓 CodeBuild 將物件放入存放封裝應用程式的 S3 儲存貯體。以您的 S3 儲存貯體名稱取代 *bucketname*。

      ```
              {
                  "Effect": "Allow",
                  "Resource": [
                      "arn:aws:s3:::bucketname/*"
                  ],
                  "Action": [
                      "s3:PutObject"
                  ]
              }
      ```

   1. 選擇**檢閱政策**。

   1. 選擇**儲存變更**。

## 步驟 3：部署發佈應用程式
<a name="serverlessrepo-auto-publish-deploy-app"></a>

請依照下列步驟部署應用程式，其中包含執行發佈至 的 Lambda 函數 AWS Serverless Application Repository。這個應用程式是 **aws-serverless-codepipeline-serverlessrepo-publish**。

**注意**  
您必須將應用程式部署到與管道 AWS 區域 相同的 。

1. 移至[應用程式](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish )頁面，並選擇 **Deploy (部署)**。

1. 選擇 **I acknowledge that this app creates custom IAM roles (我認可此應用程式建立自訂的 IAM 角色)**。

1. 選擇**部署**。

1. 選擇**檢視 CloudFormation 堆疊**以開啟 CloudFormation 主控台。

1. 展開 **Resources (資源)** 區段。您會看到 **ServerlessRepoPublish**，類型為 **AWS::Lambda::Function**。請記下這個資源的實體 ID，以用於下一個步驟。當您在 CodePipeline 中建立新的發佈動作時，您會使用此實體 ID。

## 步驟 4：建立發佈動作
<a name="serverlessrepo-auto-publish-create-action"></a>

依照以下步驟在管道中建立發佈動作。

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在左側導覽區段中，選擇您欲編輯的管道。

1. 選擇**編輯**。

1. 在目前管道的最後階段之後，選擇 **\$1 Add stage (新增階段)**。在 **Stage name (階段名稱)** 中輸入名稱，例如 **Publish**，然後選擇 **Add stage (新增階段)**。

1. 在新階段中，選擇 **\$1 Add action group (\$1 新增動作群組)**。

1. 輸入動作名稱。從 **Action provider (動作供應商)** 的 **Invoke (呼叫)** 中，選擇 **AWS Lambda**。

1. 從 **Input artifacts (輸入成品)**，選擇 **BuildArtifact**。

1. 從**函數名稱**中，選擇您在上一個步驟中記下的 Lambda 函數的實體 ID。

1. 為動作選擇 **Save (儲存)**。

1. 為階段選擇 **Done (完成)**。

1. 在右上角，選擇 **Save (儲存)**。

1. 若要驗證您的管道，在 GitHub 對您的應用程式進行變更。例如，在 AWS SAM 範本檔案的 `Metadata`區段中變更應用程式的描述。遞交變更並將其推送到您的 GitHub 分支。這會觸發您的管道執行。當管道完成時，在 [AWS Serverless Application Repository](https://console.aws.amazon.com/serverlessrepo/home) 中檢查您的應用程式是否已就您的變更進行更新。

# 教學課程：使用 CodePipeline 進行 Lambda 函數部署
<a name="tutorials-lambda-deploy"></a>

本教學課程可協助您在 CodePipeline 中建立部署動作，將您的程式碼部署到您在 Lambda 中設定的函數。您將建立範例 Lambda 函數，其中您將建立別名和版本、將壓縮的 Lambda 函數新增至來源位置，並在管道中執行 Lambda 動作。

**注意**  
在主控台中建立管道時，CodePipeline 將使用 S3 成品儲存貯體做為成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**注意**  
部署動作僅適用於 V2 `Lambda` 類型管道。

## 先決條件
<a name="tutorials-lambda-deploy-prereqs"></a>

您必須先有幾個資源，才能使用此教學來建立 CD 管道。以下是在開始使用前需準備的事項：

**注意**  
所有這些資源都應在相同區域內建立 AWS 。
+ 來源控制儲存庫，例如 GitHub 或來源 S3 儲存貯體 （本教學課程使用 S3)，您將在其中存放為 Lambda 函數建立`.zip`的檔案。
+ 您必須使用已透過此動作許可更新的現有 CodePipeline 服務角色。若要更新您的服務角色，請參閱 [Lambda 部署動作的服務角色政策許可](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action)。

滿足這些先決條件之後，即可繼續教學並建立 CD 管道。

## 步驟 1：建立範例 Lambda 函數
<a name="tutorials-lambda-deploy-instances"></a>

在此步驟中，您會建立您要部署的 Lambda 函數。

**建立 Lambda 函數**

1. 存取 Lambda 主控台，並依照下列教學課程中的步驟建立範例 Lambda 函數：連結。

1. 從頂端導覽中，選擇**建立**，然後從頁面頂端選取**從頭開始**。

1. 在**名稱**中，輸入 **MyLambdaFunction**。

1. 發佈新版本。這將是別名將指向的版本。

   1. 選取您的 函數。

   1. 選擇**動作**下拉式清單。

   1. 選擇 **Publish new version (發佈新版本)**。

   1. （選用） 將 新增至**描述**中的描述。

   1. 選擇**發布**。

1. 為您的函數建立別名，例如 `aliasV1`。

1. 請確定別名指向您剛建立的版本 （例如 1)。
**注意**  
如果您選擇 \$1LATEST，則無法使用流量轉移功能，因為 Lambda 不支援指向超過 1 個版本的別名 \$1LATEST。

## 步驟 2：將函數檔案上傳至您的儲存庫
<a name="tutorials-lambda-deploy-file"></a>

下載函數並將其儲存為 zip 檔案。使用下列步驟將壓縮檔案上傳至 S3 儲存貯體。

**將 `.zip` 檔案新增至來源儲存庫**

1. 開啟 S3 儲存貯體。

1. 選擇**上傳**。

1. 將包含 檔案的 zip `sample_lambda_source.zip` 檔案上傳至來源儲存貯體。

   記下路徑。

   ```
   object key
   ```

## 步驟 3：建立管道
<a name="tutorials-lambda-deploy-pipeline"></a>

使用 CodePipeline 精靈建立管道階段並連接來源儲存庫。

**建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**使用現有的服務角色**，然後選擇已更新此動作所需許可的 CodePipeline 服務角色。若要為此動作設定 CodePipeline 服務角色，請參閱 [Lambda 部署動作的服務角色政策許可](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action)。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **Amazon S3**。

   1. 在**物件金鑰**中，新增 .zip 檔案的名稱，包括副檔名，例如 `sample_lambda_source.zip`。

      

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**頁面上，選擇**略過**。

1. 在**步驟 5：新增測試階段**頁面上，選擇**略過**。

1. 在**步驟 6：新增部署階段**頁面上，選擇 **Lambda**。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)

   1. 新增您的函數名稱和別名。

   1. 選擇您的部署策略。

   1. 選擇**下一步**。

1. 在**步驟 7：檢閱**頁面上，檢閱管道組態，然後選擇**建立管道**以建立管道。  
![\[\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/lambdadeploy-pipeline-screen.png)

## 步驟 4：測試管道
<a name="tutorials-lambda-deploy-test"></a>

您的管道應具備執行end-to-end原生 AWS 持續部署所需的一切。現在，將程式碼變更推送至來源儲存庫，以測試其功能。

**測試管道**

1. 對設定的來源儲存庫進行程式碼變更、遞交並推送變更。

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 從清單中選擇管道。

1. 觀看管道階段的管道進度。您的管道應該完成，而且您的動作會部署到您的 Lambda 函數。

## 進一步了解
<a name="tutorials-lambda-deploy-learn"></a>

Lambda 部署動作允許兩種部署方法。一種方法是單獨轉移流量，而沒有來源動作的輸入成品。另一種方法是使用來源動作的輸入成品更新函數程式碼，然後根據更新的程式碼發佈新版本。對於第二個方法，如果提供別名，CodePipeline 也會執行流量轉移。本 Lambda 部署動作教學課程示範如何使用來源成品更新函數。

若要進一步了解 動作，請參閱 的動作參考頁面[AWS Lambda 部署動作參考](action-reference-LambdaDeploy.md)。

# 教學課程：搭配 Lambda 叫用動作使用變數
<a name="tutorials-lambda-variables"></a>

Lambda 調用動作可以使用來自另一個動作的變數作為其輸入的一部分，並隨其輸出傳回新變數。如需 CodePipeline 中動作變數的相關資訊，請參閱 [變數參考](reference-variables.md)。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

在本教學結束時，您將擁有：
+ Lambda 叫用動作：
  + 使用 CodeCommit 來源動作中的`CommitId`變數
  + 輸出三個新變數：`dateTime`、`testRunId` 和 `region`
+ 使用 Lambda 調用動作中新變數的手動核准動作，以提供測試 URL 和測試執行 ID
+ 以新動作更新的管道

**Topics**
+ [

## 先決條件
](#lambda-variables-prereqs)
+ [

## 步驟 1：建立 Lambda 函式
](#lambda-variables-function)
+ [

## 步驟 2：將 Lambda 調用動作和手動核准動作新增至您的管道
](#lambda-variables-pipeline)

## 先決條件
<a name="lambda-variables-prereqs"></a>

開始之前，您必須準備好以下項目：
+ 您可以在 中建立或使用管道搭配 CodeCommit 來源[教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md)。
+ 編輯現有的管道，讓 CodeCommit 來源動作具有命名空間。將命名空間指派 `SourceVariables` 給動作。

## 步驟 1：建立 Lambda 函式
<a name="lambda-variables-function"></a>

使用下列步驟來建立 Lambda 函數和 Lambda 執行角色。建立 Lambda 函數後，您可以將 Lambda 動作新增至管道。

**建立 Lambda 函數和執行角色**

1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 開啟 AWS Lambda 主控台。

1. 選擇**建立函數**。將 **Author from scratch (從頭開始編寫)** 維持在選取狀態。

1. 在 **Function name (函數名稱)** 中，輸入您函數的名稱 (例如 **myInvokeFunction**)。在 **Runtime (執行時間)** 中，將預設選項維持在選取狀態。

1. 展開 **Choose or create an execution role (選擇或建立執行角色)**。選擇 **Create a new role with basic Lambda permissions (建立具備基本 Lambda 許可的新角色)**。

1. 選擇**建立函數**。

1. 若要透過另一個動作使用變數，則必須將其傳遞給 Lambda 呼叫動作組態中的 `UserParameters`。您將在稍後教學中在我們的管道中設定動作，但您將新增程式碼，此程式碼會假設此變數將傳遞。

   若要產生新變數，請將輸入上名為 `outputVariables` 的屬性設定為 `putJobSuccessResult`。請注意，您無法產生變數作為 `putJobFailureResult` 的一部分。

   ```
    const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
   ```

   在新函數的**程式碼**索引標籤上，將下列範例程式碼貼到 下`index.mjs`。

   ```
   import { CodePipeline } from '@aws-sdk/client-codepipeline';
   
   export const handler = async (event, context) => {
       const codepipeline = new CodePipeline({});
       
       // Retrieve the Job ID from the Lambda action
       const jobId = event["CodePipeline.job"].id;
       
       // Retrieve UserParameters
       const params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
       
       // The region from where the lambda function is being executed
       const lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           
           try {
               await codepipeline.putJobSuccessResult(params);
               return message;
           } catch (err) {
               throw err;
           }
       };
       
       // Notify CodePipeline of a failed job
       const putJobFailure = async (message) => {
           const params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           
           try {
               await codepipeline.putJobFailureResult(params);
               throw message;
           } catch (err) {
               throw err;
           }
       };
       
       try {
           console.log("Testing commit - " + params);
           
           // Your tests here
           
           // Succeed the job
           return await putJobSuccess("Tests passed.");
       } catch (ex) {
           // If any of the assertions failed then fail the job
           return await putJobFailure(ex);
       }
   };
   ```

1. 允許函數自動儲存。

1. 複製畫面頂端**函數 ARN** 欄位中包含的 Amazon Resource Name (ARN)。

1. 最後一個步驟是開啟位於 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 的 AWS Identity and Access Management (IAM) 主控台。修改 Lambda 執行角色以新增以下政策：[AWSCodePipelineCustomActionAccess](https://console.aws.amazon.com/iam/home?region=us-west-2#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCodePipelineCustomActionAccess)。如需建立 Lambda 執行角色或修改角色政策的步驟，請參閱 [步驟 2：建立 Lambda 函數](actions-invoke-lambda-function.md#actions-invoke-lambda-function-create-function)。

## 步驟 2：將 Lambda 調用動作和手動核准動作新增至您的管道
<a name="lambda-variables-pipeline"></a>

在此步驟中，您會將 Lambda 調用動作新增至管道。您會新增名為 **Test (測試)** 的動作，做為階段的一部分。動作類型是呼叫動作。您接著會在呼叫動作之後新增手動核准動作。

**將 Lambda 動作和手動核准動作新增至管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

   與 AWS 您的帳戶相關聯的所有管道名稱都會顯示。選擇您要新增動作的管道。

1. 將 Lambda 測試動作新增至您的管道。

   1. 若要編輯管道，請選擇 **Edit (編輯)**。在現有管道中於來源動作之後新增階段。輸入階段的名稱，例如 **Test**。

   1. 在新階段中，選擇**新增動作群組**以新增動作。在 **Action name (動作名稱)** 中，輸入呼叫動作的名稱，例如 **Test\$1Commit**。

   1. 在**動作提供者**中，選擇 **AWS Lambda**。

   1. 在 **Input artifacts (輸入成品)** 中，選擇您來源動作輸出成品的名稱，例如 `SourceArtifact`。

   1. 在 **FunctionName** 中，新增您建立之 Lambda 函數的 ARN。

   1. 在 **Variable namespace (變數命名空間)** 中，新增命名空間名稱，例如 **TestVariables**。

   1. 在**輸出成品**中，新增輸出成品名稱，例如 **LambdaArtifact**。

   1. 選擇**完成**。

1. 將手動核准動作新增到您的管道。

   1. 在您的管道仍處於編輯模式中時，於呼叫動作之後新增階段。輸入階段的名稱，例如 **Approval**。

   1. 在新階段中，選擇新增動作的圖示。在 **Action name (動作名稱)** 中，輸入核准動作的名稱，例如 **Change\$1Approval**。

   1. 在 **Action provider (動作提供者)** 中，選擇 **Manual approval (手動核准)**。

   1. 在 **URL for review (檢閱 URL)** 中，透過新增 `region` 變數和 `CommitId` 變數的變數語法來建構 URL。請確定您使用的是指派給提供輸出變數動作的命名空間。

      在此範例中，CodeCommit 動作具有變數語法的 URL 具有預設命名空間 `SourceVariables`。Lambda 區域輸出變數具備 `TestVariables` 命名空間。URL 看起來如下。

      ```
      https://#{TestVariables.region}.console.aws.amazon.com/codesuite/codecommit/repositories/MyDemoRepo/commit/#{SourceVariables.CommitId}
      ```

      在 **Comments (註解)** 中，透過新增 `testRunId` 變數的變數語法來建構核准訊息文字。針對此範例，擁有 Lambda `testRunId` 輸出變數變數語法的 URL 具備 `TestVariables` 命名空間。輸入以下訊息。

      ```
      Make sure to review the code before approving this action. Test Run ID: #{TestVariables.testRunId}
      ```

1. 選擇 **Done (完成)** 來關閉動作的編輯畫面，然後選擇 **Done (完成)** 來關閉階段的編輯畫面。如要儲存管道，請選擇 **Done (完成)**。已完成的管道現在包含結構，其中包含來源、測試、核准和部署階段。

   選擇 **Release change (發行變更)** 來透過管道結構執行最新的變更。

1. 管道到達手動核准階段時，請選擇 **Review (檢閱)**。已解析的變數會做為遞交 ID 的 URL 出現。您的核准者可以選擇 URL 來檢閱遞交。

1. 管道成功執行後，您也可以在 action execution history (動作執行歷史記錄) 頁面上檢視變數值。

# 教學課程：在管道中使用 AWS Step Functions 叫用動作
<a name="tutorials-step-functions"></a>

您可以使用 AWS Step Functions 來建立和設定狀態機器。本教學示範如何將叫用動作新增至管道，從您的管道啟動狀態機執行。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

在本教學中，您將執行下列操作：
+ 在 中建立標準狀態機器 AWS Step Functions。
+ 直接輸入狀態機器輸入 JSON。您也可以將狀態機器輸入檔案上傳至 Amazon Simple Storage Service (Amazon S3) 儲存貯體。
+ 透過新增狀態機器動作來更新您的管道。

**Topics**
+ [

## 先決條件：建立或選擇簡易管道
](#tutorials-step-functions-prereq)
+ [

## 步驟 1：建立範例狀態機器
](#tutorials-step-functions-sample)
+ [

## 步驟 2：將 Step Functions 叫用動作新增至您的管道
](#tutorials-step-functions-pipeline)

## 先決條件：建立或選擇簡易管道
<a name="tutorials-step-functions-prereq"></a>

在本教學中，您會將叫用動作新增至現有管道。您可以使用在 [教學：建立簡易管道 (S3 儲存貯體)](tutorials-simple-s3.md) 或 [教學課程：建立簡單的管道 (CodeCommit 儲存庫）](tutorials-simple-codecommit.md) 中建立的管道。

您可以使用具有來源動作和至少有兩階段結構的現有管道，但在此範例中不使用來源成品。

**注意**  
您可能需要額外許可來更新管道所使用的服務角色，才能執行此動作。若要這樣做，請開啟 AWS Identity and Access Management (IAM) 主控台、尋找角色，然後將許可新增至角色的政策。如需詳細資訊，請參閱[將許可新增至 CodePipeline 服務角色](how-to-custom-role.md#how-to-update-role-new-services)。

## 步驟 1：建立範例狀態機器
<a name="tutorials-step-functions-sample"></a>

在 Step Functions 主控台中，使用`HelloWorld`範例範本建立狀態機器。如需說明，請參閱《 *AWS Step Functions 開發人員指南*》中的[建立狀態機器](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started.html#create-state-machine)。

## 步驟 2：將 Step Functions 叫用動作新增至您的管道
<a name="tutorials-step-functions-pipeline"></a>

將 Step Functions 叫用動作新增至管道，如下所示：

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

   與 AWS 您的帳戶相關聯的所有管道名稱都會顯示。

1. 在 **Name (名稱)** 中，選擇您想編輯的管道名稱。這會開啟管道的詳細檢視，包含管道中各階段的每項動作之每項狀態。

1. 在管道詳細資訊頁面上，選擇 **Edit (編輯)**。

1. 在簡易管道的第二階段，選擇 **Edit stage (編輯階段)**。選擇 **刪除**。這會刪除第二階段，因為您不再需要它。

1. 在圖表的底部，選擇 **\$1 Add stage (\$1 新增階段)**。

1. 在 **Stage name (階段名稱)** 中，輸入階段的名稱，例如 **Invoke**，然後選擇 **Add stage (新增階段)**。

1. 選擇 **\$1 Add action group (\$1 新增動作群組)**。

1. 在 **​Action name (動作名稱)** 中，輸入名稱，例如 **Invoke**。

1. 在**動作提供者**中，選擇**AWS 步驟函數**。允許 **Region (區域)** 預設為管道區域。

1. 在 **Input artifacts (輸入成品)** 中，選擇 `SourceArtifact`。

1. 在 **State machine ARN (狀態機器 ARN)** 中，為您先前建立的狀態機器選擇 Amazon Resource Name (ARN)。

1. (選用) 在 **Execution name prefix (執行名稱前綴)** 中，輸入要新增至狀態機器執行 ID 的前綴。

1. 在 **Input type (輸入類型)** 中，選擇 **Literal (常值)**。

1. 在 **Input (輸入)** 中，輸入 `HelloWorld` 範例狀態機器預期的輸入 JSON。
**注意**  
狀態機器執行的輸入與 CodePipeline 中用於描述動作輸入成品的術語不同。

   在本範例中，輸入下列 JSON：

   ```
   {"IsHelloWorldExample": true}
   ```

1. 選擇**完成**。

1. 在您正在編輯的階段上，選擇 **Done (完成)**。在 AWS CodePipeline 窗格中，選擇 **Save (儲存)**，然後在警告訊息中選擇 **Save (儲存)**。

1. 若要提交您的變更並啟動管道執行，請選擇 **​Release change (發行變更)**，然後選擇 **​Release (發行)**。

1. 在您完成的管道上，選擇叫用動作中的 **AWS Step Functions**。在 AWS Step Functions 主控台中，檢視您的狀態機器執行 ID。該 ID 會顯示您的狀態機器名稱 `HelloWorld` 和帶有前綴 `my-prefix` 的狀態機器執行 ID。

   ```
   arn:aws:states:us-west-2:account-ID:execution:HelloWorld:my-prefix-0d9a0900-3609-4ebc-925e-83d9618fcca1
   ```

# 教學課程：建立使用 AWS AppConfig 做為部署提供者的管道
<a name="tutorials-AppConfig"></a>

在本教學課程中，您會設定管道，以使用 AWS AppConfig 做為部署階段中的部署動作提供者，持續交付組態檔案。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**Topics**
+ [

## 先決條件
](#tutorials-AppConfig-prereq)
+ [

## 步驟 1：建立 your AWS AppConfig 資源
](#tutorials-AppConfig-application)
+ [

## 步驟 2：將檔案上傳至 S3 來源儲存貯體
](#tutorials-AppConfig-bucket)
+ [

## 步驟 3：建立管道
](#tutorials-AppConfig-pipeline)
+ [

## 步驟 4：變更任何來源檔案並驗證部署
](#tutorials-AppConfig-verify)

## 先決條件
<a name="tutorials-AppConfig-prereq"></a>

開始之前，您必須完成以下項目：
+ 此範例使用管道的 S3 來源。建立或使用已啟用版本控制的 Amazon S3 儲存貯體。遵循[步驟 1：為您的應用程式建立 S3 來源儲存貯體](tutorials-simple-s3.md#s3-create-s3-bucket)中的說明，建立 S3 儲存貯體。

## 步驟 1：建立 your AWS AppConfig 資源
<a name="tutorials-AppConfig-application"></a>

在本節中，您會建立下列資源：
+ *應用程式* in AWS AppConfig 是為您的客戶提供功能的邏輯程式碼單位。
+ *環境* in AWS AppConfig 是 AppConfig 目標的邏輯部署群組，例如 Beta 版或生產環境中的應用程式。
+ *組態描述*檔是一組會影響應用程式行為的設定。組態設定檔可讓 AWS AppConfig 在其儲存的位置存取您的組態。
+ （選用） AppConfig 中的 AWS *部署策略*會定義組態部署的行為，例如在部署期間的任何指定時間，應接收新部署組態的用戶端百分比。

**建立應用程式、環境、組態設定檔和部署策略**

1. 登入 AWS 管理主控台。

1. 使用下列主題中的步驟，在 AppConfig 中 AWS 建立您的 資源。
   + [建立應用程式](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-application.html)。
   + [建立環境](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-environment.html)。
   + [建立 AWS CodePipeline 組態設定檔](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-configuration-and-profile.html)。
   + （選用） [選擇預先定義的部署策略或建立您自己的](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-deployment-strategy.html)部署策略。

## 步驟 2：將檔案上傳至 S3 來源儲存貯體
<a name="tutorials-AppConfig-bucket"></a>

在本節中，建立您的組態檔案。然後將來源檔案壓縮並推送至管道用於來源階段的儲存貯體。

**建立組態檔案**

1. 為每個區域中的每個組態建立`configuration.json`檔案。包含下列內容：

   ```
   Hello World!
   ```

1. 使用下列步驟壓縮和上傳您的組態檔案。

**壓縮和上傳來源檔案**

1. 使用 檔案建立 .zip 檔案，並將 .zip 檔案命名為 `configuration-files.zip`。例如，您的 .zip 檔案可以使用下列結構：

   ```
   .
   └── appconfig-configurations
       └── MyConfigurations
           ├── us-east-1
           │   └── configuration.json
           └── us-west-2
               └── configuration.json
   ```

1. 在儲存貯體的 Amazon S3 主控台中，選擇**上傳**，然後依照指示上傳 .zip 檔案。

## 步驟 3：建立管道
<a name="tutorials-AppConfig-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 具有 Amazon S3 動作的來源階段，其中來源成品是您組態的檔案。
+ 具有 AppConfig 部署動作的部署階段。

**使用精靈建立管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyAppConfigPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 將 **Advanced settings (進階設定)** 下的設定保留為預設值，然後選擇 **Next (下一步)**。

1. 在**步驟 3：新增來源階段**的**來源提供者**中，選擇 **Amazon S3**。在**儲存貯**體中，選擇 S3 來源儲存貯體的名稱。

   在 **S3 物件金鑰**中，輸入 .zip 檔案的名稱：`configuration-files.zip`。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**：

   1. 在**部署提供者**中，選擇 **AWS AppConfig**。

   1. 在**應用程式中**，選擇您在 AWS AppConfig 中建立的應用程式名稱。欄位會顯示您應用程式的 ID。

   1. 在**環境中**，選擇您在 AWS AppConfig 中建立的環境名稱。欄位會顯示您環境的 ID。

   1. 在**組態設定檔**中，選擇您在 AWS AppConfig 中建立的組態設定檔名稱。欄位會顯示組態設定檔的 ID。

   1. 在**部署策略**中，選擇部署策略的名稱。這可以是您在 AppConfig 中建立的部署策略，也可以是您在 AppConfig 中選擇的預先定義部署策略。欄位會顯示部署策略的 ID。

   1. 在**輸入成品組態路徑**中，輸入檔案路徑。請確定您的輸入成品組態路徑符合 S3 儲存貯體 .zip 檔案中的目錄結構。在此範例中，輸入下列檔案路徑：`appconfig-configurations/MyConfigurations/us-west-2/configuration.json`。

   1. 選擇**下一步**。

1. 在**步驟 7：檢閱**中，檢閱資訊，然後選擇**建立管道**。

## 步驟 4：變更任何來源檔案並驗證部署
<a name="tutorials-AppConfig-verify"></a>

變更來源檔案，並將變更上傳至儲存貯體。這會觸發您的管道執行。檢視 版本，確認您的組態是否可用。

# 教學課程：搭配 GitHub 管道來源使用完整複製
<a name="tutorials-github-gitclone"></a>

您可以在 CodePipeline 中選擇 GitHub 來源動作的完整複製選項。使用此選項在管道建置動作中執行 Git 中繼資料的 CodeBuild 命令。

**注意**  
此處描述的完整複製選項是指指定 CodePipeline 是否應該複製儲存庫中繼資料，這只能由 CodeBuild 命令使用。若要使用 GitHub [使用者存取權杖](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app)搭配 CodeBuild 專案使用，請依照此處的步驟安裝 AWS Connector for GitHub 應用程式，然後將應用程式安裝欄位保留空白。CodeConnections 將使用使用者存取字符進行連線。



**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

在本教學課程中，您將建立連線至 GitHub 儲存庫的管道、使用來源資料的完整複製選項，以及執行 CodeBuild 組建來複製儲存庫，並為儲存庫執行 Git 命令。

**注意**  
此功能不適用於亞太區域 （香港）、非洲 （開普敦）、中東 （巴林）、歐洲 （蘇黎世） 或 AWS GovCloud （美國西部） 區域。若要參考其他可用的動作，請參閱 [與 CodePipeline 的產品和服務整合](integrations.md)。如需歐洲 （米蘭） 區域中此動作的考量，請參閱 中的備註[適用於 Bitbucket Cloud、GitHub、GitHub Enterprise Server、GitLab.com, 和 GitLab 自我管理動作的 CodeStarSourceConnection](action-reference-CodestarConnectionSource.md)。

**Topics**
+ [

## 先決條件
](#tutorials-github-gitclone-prereq)
+ [

## 步驟 1：建立 README 檔案
](#tutorials-github-gitclone-file)
+ [

## 步驟 2：建立管道和建置專案
](#tutorials-github-gitclone-pipeline)
+ [

## 步驟 3：更新 CodeBuild 服務角色政策以使用連線
](#tutorials-github-gitclone-rolepolicy)
+ [

## 步驟 4：檢視建置輸出中的儲存庫命令
](#tutorials-github-gitclone-view)

## 先決條件
<a name="tutorials-github-gitclone-prereq"></a>

開始之前，您必須執行以下作業：
+ 使用 GitHub 帳戶建立 GitHub 儲存庫。
+ 準備好您的 GitHub 登入資料。當您使用 AWS 管理主控台 設定連線時，系統會要求您使用 GitHub 登入資料登入。

## 步驟 1：建立 README 檔案
<a name="tutorials-github-gitclone-file"></a>

建立 GitHub 儲存庫之後，請使用下列步驟來新增 README 檔案。

1. 登入您的 GitHub 儲存庫，然後選擇您的儲存庫。

1. 若要建立新檔案，請選擇**新增檔案 > 建立新檔案**。命名檔案 `README.md`. 檔案並新增下列文字。

   ```
   This is a GitHub repository!
   ```

1. 選擇 **Commit changes (遞交變更)**。

   確定 `README.md` 檔案位於儲存庫的根層級。

## 步驟 2：建立管道和建置專案
<a name="tutorials-github-gitclone-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 與 GitHub 儲存庫和動作連線的來源階段。
+ 具有建置動作的 AWS CodeBuild 建置階段。

**使用精靈建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 登入 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyGitHubPipeline**。

1. 在**管道類型**中，針對本教學課程的目的選擇 **V1**。您也可以選擇 **V2**；不過請注意，管道類型在特性和價格方面有所不同。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。

1. 在 **Service role (服務角色)** 中，選擇 **New service role (新服務角色)**。
**注意**  
如果您選擇改用現有的 CodePipeline 服務角色，請確定您已將 `codestar-connections:UseConnection` IAM 許可新增至您的服務角色政策。如需 CodePipeline 服務角色的說明，請參閱[為 CodePipeline 服務角色新增許可](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**進階設定**底下，請保留預設值。在**Artifact store (成品存放區)** 中，針對您為管道所選取區域中的管道，選擇 **Default location (預設位置)**，即可使用預設成品存放區 (例如指定為預設值的 ​Amazon S3 成品儲存貯體)。
**注意**  
這不是原始碼的來源儲存貯體。這是管道的成品存放區。每個管道都需要有個別成品存放區，例如 S3 儲存貯體。

   選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

      您可以為您連至特定供應商的所有連線安裝一個應用程式。如果您已安裝 AWS Connector for GitHub 應用程式，請選擇它並略過此步驟。
**注意**  
如果您想要建立[使用者存取權杖](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app)，請確定您已安裝 AWS Connector for GitHub 應用程式，然後將應用程式安裝欄位保留空白。CodeConnections 將使用使用者存取字符進行連線。如需詳細資訊，請參閱 [ CodeBuild 中的存取您的來源提供者](https://docs.aws.amazon.com/codebuild/latest/userguide/access-tokens.html)。

   1. 在**儲存庫名稱**中，選擇 GitHub 儲存庫的名稱。

   1. 在**分支名稱**中，選擇您要使用的儲存庫分支。

   1. 請確認已選取**在原始程式碼變更時啟動管道**選項。

   1. 在**輸出成品格式**下，選擇**完整複製**以啟用來源儲存庫的 Git 複製選項。只有 CodeBuild 提供的動作才能使用 Git 複製選項。在本教學[步驟 3：更新 CodeBuild 服務角色政策以使用連線](#tutorials-github-gitclone-rolepolicy)課程中，您將使用 來更新 CodeBuild 專案服務角色的許可，以使用此選項。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，新增建置階段：

   1. 在 **Build provider (建置供應商)** 中，選擇 **AWS CodeBuild**。允許 **Region (區域)** 預設為管道區域。

   1. 選擇**建立專案**。

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment image (環境映像)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。針對**映像**，選擇 **aws/codebuild/standard:5.0**。

   1. 對於 **Service role (服務角色)**，選擇 **New service role (新服務角色)**。
**注意**  
請記下 CodeBuild 服務角色的名稱。在本教學課程中，您將需要最後一個步驟的角色名稱。

   1. 在 **BuildSpec** 底下，針對 **Build specifications (建置規格)** 選擇 **Insert build commands (插入建置命令)**。選擇**切換到編輯器**，並在**建置命令**下貼上以下內容。
**注意**  
在建置規格的 `env`區段中，請確定 git 命令的登入資料協助程式已啟用，如本範例所示。

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git archive --format=zip HEAD > application.zip
        #post_build:
          #commands:
            # - command
            # - command
      artifacts:
        files:
          - application.zip
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。這會傳回 CodePipeline 主控台，並建立使用您的建置命令進行設定的 CodeBuild 專案。建置專案使用服務角色來管理 AWS 服務 許可。此步驟可能需要數分鐘。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。

## 步驟 3：更新 CodeBuild 服務角色政策以使用連線
<a name="tutorials-github-gitclone-rolepolicy"></a>

初始管道執行會失敗，因為 CodeBuild 服務角色必須更新為具有使用連線的許可。將 `codestar-connections:UseConnection` IAM 許可新增至您的服務角色政策。如需在 IAM 主控台中更新政策的說明，請參閱 [新增連線至 Bitbucket、GitHub、GitHub Enterprise Server 或 GitLab.com 的 CodeBuild GitClone 許可 GitLab.com](troubleshooting.md#codebuild-role-connections)。

## 步驟 4：檢視建置輸出中的儲存庫命令
<a name="tutorials-github-gitclone-view"></a>

1. 當您的服務角色成功更新時，請在失敗的 CodeBuild 階段選擇**重試**。

1. 管道成功執行後，在您成功的建置階段，選擇**檢視詳細資訊**。

   在詳細資訊頁面上，選擇**日誌**索引標籤。檢視 CodeBuild 組建輸出。命令會輸出輸入變數的值。

   命令會輸出`README.md`檔案內容、列出 目錄中的檔案、複製儲存庫、檢視日誌，並將儲存庫封存為 ZIP 檔案。

# 教學課程：搭配 CodeCommit 管道來源使用完整複製
<a name="tutorials-codecommit-gitclone"></a>

您可以在 CodePipeline 中選擇 CodeCommit 來源動作的完整複製選項。 CodePipeline 使用此選項可讓 CodeBuild 存取管道建置動作中的 Git 中繼資料。

在本教學課程中，您會建立管道來存取 CodeCommit 儲存庫、使用完整複製選項進行來源資料，以及執行 CodeBuild 組建來複製您的儲存庫，並為儲存庫執行 Git 命令。

**注意**  
CodeBuild 動作是唯一下游動作支援使用 Git 複製選項提供的 Git 中繼資料。此外，雖然您的管道可以包含跨帳戶動作，但 CodeCommit 動作和 CodeBuild 動作必須位於相同的帳戶中，完整複製選項才能成功。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**Topics**
+ [

## 先決條件
](#tutorials-codecommit-gitclone-prereq)
+ [

## 步驟 1：建立 README 檔案
](#tutorials-codecommit-gitclone-file)
+ [

## 步驟 2：建立管道和建置專案
](#tutorials-codecommit-gitclone-pipeline)
+ [

## 步驟 3：更新 CodeBuild 服務角色政策以複製儲存庫
](#tutorials-codecommit-gitclone-rolepolicy)
+ [

## 步驟 4：檢視建置輸出中的儲存庫命令
](#tutorials-codecommit-gitclone-view)

## 先決條件
<a name="tutorials-codecommit-gitclone-prereq"></a>

開始之前，您必須在與管道相同的 AWS 帳戶和區域中建立 CodeCommit 儲存庫。

## 步驟 1：建立 README 檔案
<a name="tutorials-codecommit-gitclone-file"></a>

使用這些步驟將 README 檔案新增至您的來源儲存庫。README 檔案提供範例來源檔案，供 CodeBuild 下游動作讀取。

**新增 README 檔案**

1. 登入您的儲存庫，然後選擇您的儲存庫。

1. 若要建立新檔案，請選擇**新增檔案 > 建立檔案**。命名檔案 `README.md`. 檔案並新增下列文字。

   ```
   This is a CodeCommit repository!
   ```

1. 選擇 **Commit changes (遞交變更)**。

   確定 `README.md` 檔案位於儲存庫的根層級。

## 步驟 2：建立管道和建置專案
<a name="tutorials-codecommit-gitclone-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 具有 CodeCommit 來源動作的來源階段。
+ 具有建置動作的 AWS CodeBuild 建置階段。

**使用精靈建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 登入 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyCodeCommitPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在 **Service role (服務角色)** 中，執行下列其中一項作業：
   + 選擇 **Existing service role (現有服務角色)**。
   + 選擇您現有的 CodePipeline 服務角色。此角色必須具有服務角色政策的 `codecommit:GetRepository` IAM 許可。請參閱將[許可新增至 CodePipeline 服務角色](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**進階設定**底下，請保留預設值。選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面上，執行下列動作：

   1. 在**來源提供者**中，選擇 **CodeCommit**。

   1. 在**儲存庫名稱**中，選擇儲存庫的名稱。

   1. 在**分支名稱**中，選擇分支名稱。

   1. 請確認已選取**在原始程式碼變更時啟動管道**選項。

   1. 在**輸出成品格式**下，選擇**完整複製**以啟用來源儲存庫的 Git 複製選項。只有 CodeBuild 提供的動作才能使用 Git 複製選項。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，執行下列動作：

   1. 在 **Build provider (建置供應商)** 中，選擇 **AWS CodeBuild**。允許 **Region (區域)** 預設為管道區域。

   1. 選擇**建立專案**。

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment image (環境映像)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。針對**映像**，選擇 **aws/codebuild/standard:5.0**。

   1. 對於 **Service role (服務角色)**，選擇 **New service role (新服務角色)**。
**注意**  
請記下 CodeBuild 服務角色的名稱。在本教學課程中，您將需要最後一個步驟的角色名稱。

   1. 在 **BuildSpec** 底下，針對 **Build specifications (建置規格)** 選擇 **Insert build commands (插入建置命令)**。選擇**切換到編輯器**，然後在**建置命令**下貼上下列程式碼。

      ```
      version: 0.2
      
      env:
        git-credential-helper: yes
      phases:
        install:
          #If you use the Ubuntu standard image 2.0 or later, you must specify runtime-versions.
          #If you specify runtime-versions and use an image other than Ubuntu standard image 2.0, the build fails.
          runtime-versions:
            nodejs: 12
            # name: version
          #commands:
            # - command
            # - command
        pre_build:
          commands:
            - ls -lt
            - cat README.md
        build:
          commands:
            - git log | head -100
            - git status
            - ls
            - git describe --all
        #post_build:
          #commands:
            # - command
            # - command
      #artifacts:
        #files:
          # - location
        #name: $(date +%Y-%m-%d)
        #discard-paths: yes
        #base-directory: location
      #cache:
        #paths:
          # - paths
      ```

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。這會將您傳回 CodePipeline 主控台，並建立 CodeBuild 專案，以使用您的建置命令進行組態。建置專案使用服務角色來管理 AWS 服務 許可。此步驟可能需要數分鐘。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。

## 步驟 3：更新 CodeBuild 服務角色政策以複製儲存庫
<a name="tutorials-codecommit-gitclone-rolepolicy"></a>

初始管道執行將會失敗，因為您需要更新 CodeBuild 服務角色，並具有從儲存庫提取的許可。

將 `codecommit:GitPull` IAM 許可新增至您的服務角色政策。如需在 IAM 主控台中更新政策的說明，請參閱 [為 CodeCommit 來源動作新增 CodeBuild GitClone 許可](troubleshooting.md#codebuild-role-codecommitclone)。

## 步驟 4：檢視建置輸出中的儲存庫命令
<a name="tutorials-codecommit-gitclone-view"></a>

**檢視建置輸出**

1. 當您的服務角色成功更新時，請在失敗的 CodeBuild 階段選擇**重試**。

1. 管道成功執行後，在您成功的建置階段，選擇**檢視詳細資訊**。

   在詳細資訊頁面上，選擇**日誌**索引標籤。檢視 CodeBuild 組建輸出。命令會輸出輸入變數的值。

   命令會輸出`README.md`檔案內容、列出 目錄中的檔案、複製儲存庫、檢視日誌，以及執行 `git describe --all`。

# 教學課程：使用 AWS CloudFormation StackSets 部署動作建立管道
<a name="tutorials-stackset-deployment"></a>

在本教學課程中，您可以使用 AWS CodePipeline 主控台建立具有部署動作的管道，以建立堆疊集和建立堆疊執行個體。當管道執行時，範本會建立堆疊集，並建立和更新部署堆疊集的執行個體。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

有兩種方式可以管理堆疊集的許可：自我管理和受管 AWS IAM 角色。本教學課程提供具有自我管理許可的範例。

若要最有效地在 CodePipeline 中使用 Stacksets，您應該清楚了解 CloudFormation StackSets 背後的概念及其運作方式。請參閱*AWS CloudFormation 《 使用者指南*》中的 [StackSets 概念](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html)。

**Topics**
+ [

## 先決條件
](#tutorials-stackset-deployment-prereq)
+ [

## 步驟 1：上傳範例 AWS CloudFormation 範本和參數檔案
](#tutorials-stackset-deployment-upload)
+ [

## 步驟 2：建立管道
](#tutorials-stackset-action-pipeline)
+ [

## 步驟 3：檢視初始部署
](#tutorials-stackset-action-initial)
+ [

## 步驟 4：新增 CloudFormationStackInstances 動作
](#tutorials-stacksets-instances)
+ [

## 步驟 5：檢視部署的堆疊集資源
](#tutorials-stacksets-view)
+ [

## 步驟 6：更新堆疊集
](#tutorials-stacksets-update)

## 先決條件
<a name="tutorials-stackset-deployment-prereq"></a>

對於堆疊集操作，您可以使用兩個不同的帳戶：管理帳戶和目標帳戶。您可以在管理員帳戶中建立堆疊集。您可以建立屬於目標帳戶中堆疊集的個別堆疊。

**使用管理員帳戶建立管理員角色**
+ 請遵循[設定堆疊集操作的基本許可](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup)中的指示。您的角色必須命名為 **`AWSCloudFormationStackSetAdministrationRole`**。

**在目標帳戶中建立服務角色**
+ 在信任管理員帳戶的目標帳戶中建立服務角色。請遵循[設定堆疊集操作的基本許可](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html#stacksets-prereqs-accountsetup)中的指示。您的角色必須命名為 **`AWSCloudFormationStackSetExecutionRole`**。

## 步驟 1：上傳範例 AWS CloudFormation 範本和參數檔案
<a name="tutorials-stackset-deployment-upload"></a>

為您的堆疊集範本和參數檔案建立來源儲存貯體。下載範例 AWS CloudFormation 範本檔案、設定參數檔案，然後在上傳至 S3 來源儲存貯體之前壓縮檔案。

**注意**  
請務必先壓縮來源檔案，再上傳至 S3 來源儲存貯體，即使唯一的來源檔案是 範本。



**建立 S3 來源儲存貯體**

1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。

1. 選擇**建立儲存貯體**。

1. 在**儲存貯體名稱**中，輸入儲存貯體的名稱。

   在 **區域中**，選擇您要建立管道的區域。選擇**建立儲存貯體**。

1. 建立儲存貯體後，會顯示成功橫幅。選擇 **Go to bucket details (前往儲存貯體詳細資訊)**。

1. 在 **Properties (屬性)** 標籤上，選擇 **Versioning (版本控制)**。選擇 **Enable versioning (啟用版本控制)**，然後選擇 **Save (儲存)**。

**建立 AWS CloudFormation 範本檔案**

1. 下載下列範例範本檔案，以產生堆疊集的 CloudTrail 組態：[https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml](https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml)。

1. 儲存檔案為 `template.yml`。

**建立 parameters.txt 檔案**

1. 建立具有部署參數的檔案。參數是您想要在執行時間更新堆疊中的值。下列範例檔案會更新堆疊集的範本參數，以啟用記錄驗證和全域事件。

   ```
   [
     {
       "ParameterKey": "EnableLogFileValidation",
       "ParameterValue": "true"
     }, 
     {
       "ParameterKey": "IncludeGlobalEvents",
       "ParameterValue": "true"
     }
   ]
   ```

1. 儲存檔案為 `parameters.txt`。

**建立 account.txt 檔案**

1. 使用您要建立執行個體的帳戶建立檔案，如下列範例檔案所示。

   ```
   [
       "111111222222","333333444444"
   ]
   ```

1. 儲存檔案為 `accounts.txt`。

**建立和上傳來源檔案**

1. 將檔案合併為單一 ZIP 檔案。您的檔案在 ZIP 檔案中看起來應該像這樣。

   ```
   template.yml
   parameters.txt
   accounts.txt
   ```

1. 將 ZIP 檔案上傳至 S3 儲存貯體。此檔案是**建立管道**精靈為 CodePipeline 中的部署動作建立的來源成品。

## 步驟 2：建立管道
<a name="tutorials-stackset-action-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 具有 S3 來源動作的來源階段，其中來源成品是您的範本檔案和任何支援的來源檔案。
+ 具有建立 CloudFormation 堆疊集之堆疊集部署動作的部署階段。
+ 具有 CloudFormation 堆疊執行個體部署動作的部署階段，可在目標帳戶中建立堆疊和執行個體。

**使用 CloudFormationStackSet 動作建立管道**

1. 登入 AWS 管理主控台 並開啟 CodePipeline 主控台，網址為 https：//[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home)。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyStackSetsPipeline**。

1. 在**管道類型**中，針對本教學課程的目的選擇 **V1**。您也可以選擇 **V2**；不過請注意，管道類型在特性和價格方面有所不同。如需詳細資訊，請參閱[管道類型](pipeline-types.md)。

1. 在**服務角色**中，選擇**新服務角色**，以允許 CodePipeline 在 IAM 中建立服務角色。

1. 在**成品存放**區中，保留預設值。
**注意**  
這不是原始碼的來源儲存貯體。這是管道的成品存放區。每個管道都需要有個別成品存放區，例如 S3 儲存貯體。當您建立或編輯管道時，您必須在管道區域中擁有一個成品儲存貯體，並在您執行動作的每個 AWS 區域中擁有一個成品儲存貯體。  
如需詳細資訊，請參閱[輸入和輸出成品](welcome-introducing-artifacts.md)及[CodePipeline 管道結構參考](reference-pipeline-structure.md)。

   選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面的**來源提供者**中，選擇 **Amazon S3**。

1. 在**儲存貯**體中，輸入您為此教學課程建立的 S3 來源儲存貯體，例如 `BucketName`。在 **S3 物件金鑰**中，輸入 ZIP 檔案的檔案路徑和檔案名稱，例如 `MyFiles.zip`。

1. 選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，選擇**略過建置階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**：

   1. 在**部署提供者**中，選擇**AWS CloudFormation 堆疊集**。

   1. 在**堆疊集名稱**中，輸入堆疊集的名稱。這是範本建立的堆疊集名稱。
**注意**  
請記下您的堆疊集名稱。當您將第二個 StackSets 部署動作新增至管道時，將使用它。

   1. 在**範本路徑**中，輸入上傳範本檔案的成品名稱和檔案路徑。例如，使用預設來源成品名稱 輸入下列項目`SourceArtifact`。

      ```
      SourceArtifact::template.yml
      ```

   1. 在**部署目標**中，輸入上傳帳戶檔案的成品名稱和檔案路徑。例如，使用預設來源成品名稱 輸入下列項目`SourceArtifact`。

      ```
      SourceArtifact::accounts.txt
      ```

   1. 在**部署目標 AWS 區域**中，輸入一個區域以部署初始堆疊執行個體，例如 `us-east-1`。

   1. 展開**部署選項**。在**參數**中，輸入您上傳參數檔案的成品名稱和檔案路徑。例如，使用預設來源成品名稱 輸入下列項目`SourceArtifact`。

      ```
      SourceArtifact::parameters.txt
      ```

      若要將參數輸入為常值輸入而非檔案路徑，請輸入下列內容：

      ```
      ParameterKey=EnableLogFileValidation,ParameterValue=true
      ParameterKey=IncludeGlobalEvents,ParameterValue=true
      ```

   1. 在**功能**中，選擇 CAPABILITY\$1IAM 和 CAPABILITY\$1NAMED\$1IAM。

   1. 在**許可模型**中，選擇 SELF\$1MANAGED。

   1. 在**容錯能力百分比**中，輸入 `20`。

   1. 在**最大並行百分比**中，輸入 `25`。

   1. 選擇**下一步**。

   1. 在**步驟 7：檢閱**中，選擇**建立管道**。您的管道隨即顯示。

   1. 允許您的管道執行。

## 步驟 3：檢視初始部署
<a name="tutorials-stackset-action-initial"></a>

檢視初始部署的資源和狀態。驗證部署成功建立堆疊集後，您可以將第二個動作新增至**部署**階段。

**檢視資源**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。

1. 在管道的 **CloudFormationStackSet** CloudFormation 動作上選擇動作。堆疊集的範本、資源和事件會顯示在 CloudFormation 主控台中。

1. 在左側導覽面板中，選擇 **StackSets**。在清單中，選擇新的堆疊集。

1. 選擇**堆疊執行個體**索引標籤。確認您提供的每個帳戶有一個堆疊執行個體是在 us-east-1 區域中建立的。確認每個堆疊執行個體的狀態為 `CURRENT`。

## 步驟 4：新增 CloudFormationStackInstances 動作
<a name="tutorials-stacksets-instances"></a>

在管道中建立下一個動作，以允許 CloudFormation StackSets 建立剩餘的堆疊執行個體。

**在管道中建立下一個動作**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

   在 **Pipelines (管道)** 下，選擇您的管道，然後選擇 **View (檢視)**。本圖顯示您的管道來源和部署階段。

1. 選擇編輯管道。管道會以**編輯**模式顯示。

1. 在**部署**階段，選擇**編輯**。

1. 在**AWS CloudFormation 堆疊集**部署動作下，選擇**新增動作群組**。

1. 在**編輯動作**頁面上，新增動作詳細資訊：

   1. 在**動作名稱**中，輸入動作的名稱。

   1. 在**動作提供者**中，選擇**AWS CloudFormation 堆疊執行個體**。

   1. 在**輸入成品**下，選擇 **SourceArtifact**。

   1. 在**堆疊集名稱**中，輸入堆疊集的名稱。這是您在第一個動作中提供的堆疊集名稱。

   1. 在**部署目標**中，輸入上傳帳戶檔案的成品名稱和檔案路徑。例如，使用預設來源成品名稱 輸入下列項目`SourceArtifact`。

      ```
      SourceArtifact::accounts.txt
      ```

   1. 在**部署目標 AWS 區域**中，輸入用於部署剩餘堆疊執行個體的區域，例如 `us-east-2`和 `eu-central-1` ，如下所示：

      ```
      us-east2, eu-central-1
      ```

   1. 在**容錯能力百分比**中，輸入 `20`。

   1. 在**最大並行百分比**中，輸入 `25`。

   1. 選擇**儲存**。

   1. .手動發佈變更。您更新的管道會在部署階段中顯示兩個動作。

## 步驟 5：檢視部署的堆疊集資源
<a name="tutorials-stacksets-view"></a>

您可以檢視堆疊集部署的資源和狀態。

**檢視資源**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在**管道**下，選擇您的管道，然後選擇**檢視**。本圖顯示您的管道來源和部署階段。

1. 選擇管道中**`AWS CloudFormation Stack Instances`**動作 CloudFormation 的動作。堆疊集的範本、資源和事件會顯示在 CloudFormation 主控台中。

1. 在左側導覽面板中，選擇 **StackSets**。在清單中，選擇您的堆疊集。

1. 選擇**堆疊執行個體**索引標籤。驗證您提供的每個帳戶的所有剩餘堆疊執行個體是否已在預期區域中建立或更新。確認每個堆疊執行個體的狀態為 `CURRENT`。

## 步驟 6：更新堆疊集
<a name="tutorials-stacksets-update"></a>

對堆疊集進行更新，並將更新部署到執行個體。在此範例中，您也可以變更要指定用於更新的部署目標。不屬於更新一部分的執行個體會移至過期狀態。

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 開啟 CodePipeline 主控台。

1. 在**管道**下，選擇管道，然後選擇**編輯**。在**部署**階段，選擇**編輯**。

1. 選擇 在管道中編輯**AWS CloudFormation 堆疊集**動作。在**描述**中，使用堆疊集的新描述覆寫現有描述。

1. 選擇 編輯管道中的**AWS CloudFormation 堆疊執行個體**動作。在**部署目標 AWS 區域**中，刪除建立動作時輸入的`us-east-2`值。

1. 儲存變更。選擇**發行變更**以執行您的管道。

1. 在 中開啟您的動作 CloudFormation。選擇 **StackSet 資訊**索引標籤。在 **StackSet 描述**中，確認已顯示新的描述。

1. 選擇**堆疊執行個體**索引標籤。在**狀態**下，確認 us-east-2 中堆疊執行個體的狀態為 `OUTDATED`。

# 教學課程：建立管道的變數檢查規則做為進入條件
<a name="tutorials-varcheckrule"></a>

在本教學課程中，您會設定管道，以使用 GitHub 做為來源階段中的來源動作提供者來持續交付檔案。當您變更來源儲存庫中的來源檔案時，完整的管道便會偵測到變更。管道會執行 ，然後對照 條件中提供的來源儲存庫名稱和分支名稱檢查輸出變數，以進入建置階段。

**重要**  
在建立管道的過程中，CodePipeline 將使用客戶提供的 S3 成品儲存貯體來製作成品。（這與用於 S3 來源動作的 儲存貯體不同。) 如果 S3 成品儲存貯體位於與管道帳戶不同的帳戶中，請確定 S3 成品儲存貯體由 所擁有 AWS 帳戶 ，安全且可靠。

**重要**  
您在此程序中新增至管道的許多動作都涉及您在建立管道之前需要建立 AWS 的資源。來源動作 AWS 的資源一律必須在您建立管道 AWS 的相同區域中建立。例如，如果您在美國東部 （俄亥俄） 區域建立管道，則 CodeCommit 儲存庫必須位於美國東部 （俄亥俄） 區域。  
您可以在建立管道時新增跨區域動作。跨區域動作 AWS 的資源必須位於您計劃執行動作的相同 AWS 區域中。如需詳細資訊，請參閱[在 CodePipeline 中新增跨區域動作](actions-create-cross-region.md)。

此範例使用範例管道搭配 GitHub （第 2 版） 來源動作和 CodeBuild 組建動作，其中組建階段的進入條件將檢查變數。

## 先決條件
<a name="tutorials-varcheckrule-prereq"></a>

開始之前，您必須執行以下作業：
+ 使用 GitHub 帳戶建立 GitHub 儲存庫。
+ 準備好您的 GitHub 登入資料。當您使用 AWS 管理主控台 設定連線時，系統會要求您使用 GitHub 登入資料登入。
+ 將 GitHub （透過 GitHub 應用程式） 設定為管道來源動作的儲存庫連線。若要建立 GitHub 儲存庫的連線，請參閱 [GitHub 連線](connections-github.md)。

## 步驟 1：建立範例來源檔案，並新增至 GitHub 儲存庫
<a name="tutorials-varcheckrule-push"></a>

在本節中，您會建立範例來源檔案，並將其新增至管道用於來源階段的儲存庫。在此範例中，您會產生並新增下列項目：
+ `README.md` 檔案。

建立 GitHub 儲存庫之後，請使用下列步驟來新增您的 README 檔案。

1. 登入您的 GitHub 儲存庫，然後選擇您的儲存庫。

1. 若要建立新檔案，請選擇**新增檔案**，然後選擇**建立新檔案**。命名檔案`README.md`並新增下列文字。

   ```
   This is a GitHub repository!
   ```

1. 選擇 **Commit changes (遞交變更)**。基於本教學的目的，請新增包含大寫單字「更新」的遞交訊息，如下列範例所示：

   ```
   Update to source files
   ```
**注意**  
字串的規則檢查區分大小寫。

   確定 `README.md` 檔案位於儲存庫的根層級。

## 步驟 2：建立管道
<a name="tutorials-varcheckrule-create-pipeline"></a>

在本節中，您可以採取下列動作建立管道：
+ 與 GitHub 儲存庫和動作連線的來源階段。
+ CodeBuild 建置階段，其中階段已針對變數檢查規則設定 On Entry 條件。

**使用精靈建立管道**

1. 前往 [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) 登入 CodePipeline 主控台。

1. 在 **Welcome (歡迎)** 頁面、**Getting started (入門)** 頁面、或者 **Pipelines (管道)** 頁面上，選擇 **Create pipeline (建立管道)**。

1. 在**步驟 1：選擇建立選項**頁面的**建立選項**下，選擇**建置自訂管道**選項。選擇**下一步**。

1. 在**步驟 2：選擇管道設定**中，在**管道名稱**中輸入 **MyVarCheckPipeline**。

1. CodePipeline 提供 V1 和 V2 類型的管道，其特性和價格有所不同。V2 類型是您可以在 主控台中選擇的唯一類型。如需詳細資訊，請參閱[管道類型](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)。如需 CodePipeline 定價的資訊，請參閱 [定價](https://aws.amazon.com/codepipeline/pricing/)。

1. 在 **Service role (服務角色)** 中，選擇 **New service role (新服務角色)**。
**注意**  
如果您選擇改用現有的 CodePipeline 服務角色，請確定您已將 `codeconnections:UseConnection` IAM 許可新增至您的服務角色政策。如需 CodePipeline 服務角色的說明，請參閱[為 CodePipeline 服務角色新增許可](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)。

1. 在**進階設定**底下，請保留預設值。

   選擇**下一步**。

1. 在**步驟 3：新增來源階段**頁面上，新增來源階段：

   1. 在**來源提供者**中，選擇 **GitHub （透過 GitHub 應用程式）**。

   1. 在**連線**下，選擇現有的連線或建立新的連線。若要建立或管理 GitHub 來源動作的連線，請參閱 [GitHub 連線](connections-github.md)。

   1. 在**儲存庫名稱**中，選擇 GitHub 儲存庫的名稱。

   1. 在**分支名稱**中，選擇您要使用的儲存庫分支。

   1. 確定已選取**無觸發**選項。

   選擇**下一步**。

1. 在**步驟 4：新增建置階段**中，新增建置階段：

   1. 在 **Build provider (建置供應商)** 中，選擇 **AWS CodeBuild**。允許 **Region (區域)** 預設為管道區域。

   1. 選擇**建立專案**。

   1. 在 **Project name (專案名稱)** 中，輸入此建置專案的名稱。

   1. 在 **Environment image (環境映像)** 中，選擇 **Managed image (受管映像)**。針對 **Operating system (作業系統)**，選擇 **Ubuntu**。

   1. 針對 **Runtime (執行時間)**，選擇 **Standard (標準)**。針對**映像**，選擇 **aws/codebuild/standard:5.0**。

   1. 對於 **Service role (服務角色)**，選擇 **New service role (新服務角色)**。
**注意**  
請記下 CodeBuild 服務角色的名稱。在本教學課程中，您將需要最後一個步驟的角色名稱。

   1. 在 **BuildSpec** 底下，針對 **Build specifications (建置規格)** 選擇 **Insert build commands (插入建置命令)**。選擇**切換到編輯器**，並在**建置命令**下貼上以下內容。

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

   1. 選擇 **Continue to CodePipeline (繼續 CodePipeline)**。這會傳回 CodePipeline 主控台，並建立使用您的建置命令進行設定的 CodeBuild 專案。建置專案使用服務角色來管理 AWS 服務 許可。此步驟可能需要數分鐘。

   1. 選擇**下一步**。

1. 在**步驟 5：新增測試階段**中，選擇**略過測試階段**，然後再次選擇**略過**以接受警告訊息。

   選擇**下一步**。

1. 在**步驟 6：新增部署階段**頁面上，選擇**略過部署階段**，然後再次選擇**略過**以接受警告訊息。選擇**下一步**。

1. 在**步驟 7：檢閱**中，選擇**建立管道**。

## 步驟 2：編輯建置階段以新增條件和規則
<a name="tutorials-varcheckrule-create-condition"></a>

在此步驟中，您會編輯階段，以新增變數檢查規則的 On Entry 條件。

1. 選擇您的管道，然後選擇**編輯**。選擇在建置階段新增項目規則。

   在**規則提供者**中，選擇 **VariableCheck**。

1. 在**變數**中，輸入您要檢查的變數。在**值**中，輸入要檢查已解析變數的字串值。在下列範例畫面中，會為「等於」檢查建立規則，並為「包含」檢查建立另一個規則。  
![\[「等於」變數檢查的規則建立頁面\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/varcheck-tut-create-rule-equals.png)  
![\[「包含」變數檢查的規則建立頁面\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/varcheck-tut-create-rule-contains.png)

1. 選擇**儲存**。

   選擇**完成**。

## 步驟 3：執行管道並檢視已解析的變數
<a name="tutorials-varcheckrule-run"></a>

在此步驟中，您可以檢視變數檢查規則的解析值和結果。

1. 在規則檢查成功後檢視解析的執行，如下列範例所示。  
![\[成功執行\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/varcheck-tut-run-succeeded.png)

1. 在**時間軸**索引標籤上檢視變數資訊。  
![\[歷史記錄頁面顯示已成功變數的 Timline 標籤\]](http://docs.aws.amazon.com/zh_tw/codepipeline/latest/userguide/images/varcheck-tut-history.png)