翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# 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)
+ [

# チュートリアル: 4 ステージのパイプラインを作成する
](tutorials-four-stage-pipeline.md)
+ [

# チュートリアル: CloudWatch Events ルールをセットアップし、パイプラインの状態の変更の E メール通知を送信します。
](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 - CodeDeploy 間のデプロイでパイプラインを作成する
](tutorials-ecs-ecr-codedeploy.md)
+ [

# チュートリアル: Amazon Alexa Skill をデプロイするパイプラインを作成する
](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)
+ [

# チュートリアル: CodeCommit パイプラインソースで完全なクローンを使用する
](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>

このチュートリアルは、Amazon EC2 で設定したインスタンスにコードをデプロイするデプロイアクションを CodePipeline で作成する方法について説明します。

**注記**  
コンソールでのパイプライン作成の一環として、CodePipeline は S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**注記**  
`EC2` デプロイアクションは V2 タイプのパイプラインでのみ使用できます。

## 前提条件
<a name="tutorials-ec2-deploy-prereqs"></a>

このチュートリアルで CD パイプラインを作成する前に、いつくかのリソースを用意する必要があります。使用を開始するために必要なものは以下のとおりです。

**注記**  
これらのリソースはすべて、同じ AWS リージョン内に作成する必要があります。
+ サンプル `script.sh` ファイルを追加するソースコントロールリポジトリ (このチュートリアルでは GitHub を使用します）。
+ このアクションのアクセス許可で更新された既存の 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. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソール を開きます。

1. コンソールダッシュボードで [**ロール**] を選択します。

1. [**ロールの作成**] を選択してください。

1. [**信頼されたエンティティのタイプを選択**] で、[**AWS のサービス** ] を選択します。**[ユースケースの選択]** で、**[EC2]** を選択します。[**Select your use case (ユースケースを選択)**] で、[**EC2**] を選択します。[**次へ**] を選択します。

1. **`AmazonSSMManagedEC2InstanceDefaultPolicy`** という名前のマネージドポリシーを検索して選択します。

1. **`AmazonSSMManagedInstanceCore`** という名前のマネージドポリシーを検索して選択します。[**Next: Tags (次へ: タグ)**] を選択します。

1. **[次へ: レビュー]** を選択します。ロールの名前を入力します (例: **EC2InstanceRole**)。
**注記**  
次のステップのロール名をメモしておきます。このロールは、インスタンスの作成時に選択します。
**注記**  
このロールにアクセス許可を追加して、パイプラインの作成後にパイプラインの S3 アーティファクトバケットへのアクセスを許可します。

   [**ロールの作成**] を選択してください。

**インスタンスを起動するには**

1. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) を開いてください。

1. サイドナビゲーションから [**インスタンス**] を選択し、ページの上部から [**インスタンスの起動**] を選択します。

1. [**名前**] に「**MyInstances**」と入力します。これにより、インスタンスには**キー**が **Name** で、**値**が **MyInstances** というタグがが割り当てられます。

1. **アプリケーションイメージと OS イメージ (Amazon マシンイメージ)** で、 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. [**インスタンス**] ページで、起動のステータスを表示できます。インスタンスを起動すると、その初期状態は `pending` です。インスタンスを起動した後は、状態が `running` に変わり、パブリック DNS 名を受け取ります ([**パブリック DNS**] 列が表示されていない場合は、[**表示/非表示**] アイコンを選択してから、[**パブリック DNS**] を選択します)。

## ステップ 2: EC2 インスタンスロールにアーティファクトバケットのアクセス許可を追加する
<a name="tutorials-ec2-deploy-role-s3"></a>

パイプラインのアーティファクトバケットへのアクセスを許可するには、インスタンス用に作成した EC2 インスタンスロールを更新する必要があります。

**注記**  
インスタンスを作成する際は、既存の EC2 インスタンスロールを作成または使用します。`Access Denied` エラーを回避するには、インスタンスロールに S3 バケットアクセス許可を追加して、CodePipeline アーティファクトバケットにインスタンスアクセス許可を付与する必要があります。デフォルトのロールを作成するか、パイプラインのリージョンのアーティファクトバケットにスコープダウンされた `s3:GetObject` アクセス許可で既存のロールを更新します。

1. CodePipeline コンソールでパイプラインに移動します。**[設定]** を選択します。既存のパイプラインのアーティファクト保存場所の名前を確認します。アーティファクトバケットの Amazon リソースネーム (ARN) をメモしてコピーします。

1. IAM コンソールに移動し、[**ロール**] を選択します。このチュートリアルのステップ 1 で作成したインスタンスロールを選択します。

1. **[Permissions]** (アクセス許可) タブで **[Add inline policy]** (インラインポリシーの追加) を選択します。

1. 次の JSON をポリシードキュメントに追加し、`Resource` フィールドの値をバケット ARN に置き換えます。

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

1. **[更新]** を選択します。

## ステップ 3: リポジトリにスクリプトファイルを追加する
<a name="tutorials-ec2-deploy-file"></a>

このサンプルテキストを貼り付けて、デプロイのスクリプト後のステップ用の `script.sh` ファイルを作成します。

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

**ソースリポジトリに `script.sh` ファイルを追加するには**

1. テキストエディタを開き、上記のファイルをコピーして新しいファイルに貼り付けます。

1. ソースリポジトリに `script.sh` ファイルをコミットし、プッシュします。

   1. ファイルを追加します。

      ```
      git add .
      ```

   1. 変更をコミットします。

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

   1. コミットをプッシュします。

      ```
      git push
      ```

   リポジトリ内のパスを書き留めます。

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

## ステップ 4: パイプラインを作成する
<a name="tutorials-ec2-deploy-pipeline"></a>

CodePipeline ウィザードを使用してパイプラインステージを作成し、ソースリポジトリを接続します。

**パイプラインを作成するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **[サービスロール]** で、**[既存サービスロールの使用]** を選択し、このアクションに必要なアクセス許可で更新された CodePipeline サービスロールを選択します。このアクション用に CodePipeline サービスロールを設定するには、「[EC2 デプロイアクションのサービスロールポリシーのアクセス許可](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action)」を参照してください。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページで、ソースステージを追加します。

   1. **[ソースプロバイダー]** で、**[GitHub (GitHub アプリ経由)]** を選択します。

   1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理する方法については、[GitHub コネクション](connections-github.md) を参照してください。

   1. **リポジトリ名** で、GitHub リポジトリの名前を選択します。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** ページで、**[スキップ]** を選択します。

1. **[ステップ 5: デプロイステージの追加]** ページで、**[EC2]** を選択します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ec2deploy-action.png)

   1. **[ターゲットディレクトリ]** で、`/home/ec2-user/testhelloworld` などのデプロイ先のインスタンスのディレクトリを入力します。
**注記**  
アクションがインスタンスで使用するデプロイディレクトリを指定します。アクションは、デプロイの一部としてインスタンスに指定されたディレクトリの作成を自動化します。

   1. **[PostScript]** で、`test/script.sh` などのスクリプトのパスとファイル名を入力します。

   1. [**次へ**] を選択します。

1. [**Step 6: Review**] ページで、パイプラインの設定を確認し、[**Create pipeline**] を選択してパイプラインを作成します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ec2deploy-pipeline.png)

1. パイプラインが正常に実行されたら、**[詳細を表示]** を選択してアクションのログを表示し、マネージドコンピューティングアクション出力を表示します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ec2deploy-logs.png)  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ec2deploy-logs2.png)

## ステップ 5: パイプラインをテストする
<a name="tutorials-ec2-deploy-test"></a>

パイプラインには、end-to-endのネイティブ AWS 継続的デプロイを実行するためのすべてが必要です。次は、コードの変更をソースリポジトリにプッシュすることで機能をテストします。

**パイプラインをテストするには**

1. 設定済みソースリポジトリにコード変更を行い、変更をコミットしてプッシュします。

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. リストからパイプラインを選択します。

1. ステージを通してパイプラインの進行状況を監視します。パイプラインが完了し、アクションによってスクリプトがインスタンスにデプロイされます。

1. トラブルシューティングの詳細については、「[EC2 デプロイアクションがエラーメッセージ `No such file` で失敗する](troubleshooting.md#troubleshooting-ec2-deploy)」を参照してください。

# チュートリアル: CodePipeline (V2 タイプ) を使用して Docker イメージを構築し Amazon ECR にプッシュする
<a name="tutorials-ecr-build-publish"></a>

このチュートリアルは、ソースコードの変更後に Docker イメージを実行して Amazon ECR にプッシュする CodePipeline のビルドアクションの作成について説明します。このチュートリアルでは、プッシュされたイメージをデプロイする Amazon ECS デプロイアクションを追加する方法についても説明します。

**重要**  
コンソールでのパイプライン作成の一環として、CodePipeline は S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**注記**  
このチュートリアルでは、GitHub ソースリポジトリと Amazon ECS クラスターにデプロイするための Amazon ECS 標準アクションを備えた CodePipeline パイプラインの ECRBuildAndPublish ビルドアクションについて説明します。Amazon ECS のソースとして ECR イメージリポジトリを含むパイプラインを使用する CodePipeline での CodeDeploy のブルー/グリーンデプロイアクションに関するチュートリアルについては、「[チュートリアル: Amazon ECR ソース、ECS - CodeDeploy 間のデプロイでパイプラインを作成する](tutorials-ecs-ecr-codedeploy.md)」を参照してください。

**重要**  
このアクションでは、CodePipeline マネージド CodeBuild コンピューティングを使用して、ビルド環境でコマンドを実行します。コマンドアクションを実行すると、 AWS CodeBuildで別途料金が発生します。

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

このチュートリアルで CD パイプラインを作成する前に、いつくかのリソースを用意する必要があります。使用を開始するために必要なものは以下のとおりです。

**注記**  
これらのリソースはすべて、同じ AWS リージョン内に作成する必要があります。
+ ソースコントロールリポジトリ (このチュートリアルでは GitHub を使用します）。このチュートリアルでは、以下を追加します。
  + ステップ 1 では、CodePipeline の ECRBuildAndPublish ビルドアクションの入力アーティファクトとしてソースリポジトリにサンプル Dockerfile を追加します。
  + ステップ 2 では、CodePipeline の Amazon ECS 標準デプロイアクションの要件として、ソースリポジトリにサンプル imagedefinitions.json ファイルを追加します。
+ Dockerfile から構築したイメージを含む Amazon ECR イメージリポジトリ。詳細については、*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 Simple Queue Service デベロッパーガイド*」の「[クラスターの作成](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service.html)」と「[サービスの作成](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.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 で Amazon ECS 標準デプロイアクションを使用して、コンテナを Amazon ECS クラスターにデプロイします。Amazon ECS 標準デプロイアクションには、イメージ名と URI を含む imagedefinitions.json ファイルが必要です。imagedefinitions.json ファイルの詳細については、「[Amazon ECS 標準デプロイアクション用の imagedefinitions.json ファイル](file-reference.md#pipelines-create-image-definitions)」を参照してください。

このサンプルテキストを貼り付けて `imagedefinitions.json` ファイルを作成します。`hello-world` などの Dockerfile の名前を使用し、イメージが保存されている Amazon ECR リポジトリの URI を使用します。

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

**ソースリポジトリに `imagedefinitions.json` ファイルを追加するには**

1. テキストエディタを開き、上記の例をコピーして新しいファイルに貼り付けます。

1. ソースリポジトリに `imagedefinitions.json` ファイルをコミットし、プッシュします。

   1. ファイルを追加します。

      ```
      git add .
      ```

   1. 変更をコミットします。

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

   1. コミットをプッシュします。

      ```
      git push
      ```

   ファイルは、必ずリポジトリのルートレベルに配置してください。

   ```
   / imagedefinitions.json
   ```

## ステップ 3: パイプラインを作成する
<a name="tutorials-ecr-build-publish-pipeline"></a>

CodePipeline ウィザードを使用してパイプラインステージを作成し、ソースリポジトリを接続します。

**パイプラインを作成するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページで、ソースステージを追加します。

   1. **[ソースプロバイダー]** で、**[GitHub (GitHub アプリ経由)]** を選択します。

   1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理する方法については、[GitHub コネクション](connections-github.md) を参照してください。

   1. **リポジトリ名** で、GitHub リポジトリの名前を選択します。

   1. [**デフォルトブランチ**] で、パイプラインを手動で開始する場合、または Git タグではないソースイベントで開始する場合に指定するブランチを選択します。変更元がトリガーでない場合やパイプラインの実行が手動で開始された場合は、デフォルトブランチの HEAD コミットが変更として使用されます。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** ページで、**[その他のビルドプロバイダー]**で、**[ECRBuildAndPublish]** を選択します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ecrbuild-wizard.png)

   1. **[リポジトリ名]** でリポジトリ名を選択します。

   1. [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 6: デプロイステージの追加]** ページで、**[導入段階をスキップ]** を選択します。以下の手順を使用して、ECS アクションを追加します。

1. **ステップ 7: 確認**ページで、パイプライン設定を確認し、**パイプラインの作成**を選択してパイプラインを作成します。

1. パイプラインを編集して、Amazon ECS デプロイアクションをパイプラインに追加します。

   1. 右上の [**編集**] を選択します。

   1. 図の最下部で [**\$1 Add stage]** (\$1 ステージの追加) を選択します。[**ステージ名**] に名前 (**Deploy** など) を入力します。

   1. [**\$1 Add action group (\$1 アクションの追加)**] を選択します。

   1. **[アクション名]** に名前を入力します。

   1. **[アクションプロバイダ]** で [Amazon ECS] を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. **[入力アーティファクト]** で、`SourceArtifact` などのソースアクションからの入力アーティファクトを選択します。

   1. [**Cluster name (クラスター名)**] で、サービスが実行されている Amazon ECS クラスターを選択します。

   1. **[サービス名]** で更新するサービスを選択します。

   1. **[保存]** を選択します。

   1. 編集中のステージで、[**完了**] を選択します。 AWS CodePipeline のペインで [**保存**] を選択し、警告メッセージで [**保存**] を選択します。

   1. 変更を送信してパイプラインのビルドを開始するには、**[変更をリリース]**、**[リリース]** の順に選択します。

1. パイプラインが実行されたら、パイプラインの構造とステータスを確認します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ecrbuild-ecsaction.png)

1. パイプラインが正常に実行されたら、**[詳細を表示]** を選択してアクションのログを表示し、マネージドコンピューティングアクション出力を表示します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ecrbuild-logs.png)

1. 失敗したアクションのトラブルシューティングを行います。例えば、imagedefinitions.json ファイルがソースリポジトリにない場合、ECS デプロイアクションは失敗する可能性があります。以下は、imagedefinitions.json ファイルがない場合に表示されるエラーメッセージの例です。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ecrbuild-ecsdebug.png)

## ステップ 4: パイプラインのテスト
<a name="tutorials-ecr-build-publish-test"></a>

パイプラインには、end-to-endのネイティブ AWS 継続的デプロイを実行するためのすべてが必要です。次は、コードの変更をソースリポジトリにプッシュすることで機能をテストします。

**パイプラインをテストするには**

1. 設定済みソースリポジトリにコード変更を行い、変更をコミットしてプッシュします。

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. リストからパイプラインを選択します。

1. ステージを通してパイプラインの進行状況を監視します。パイプラインが終了し、アクションが Docker イメージをコードの変更で作成された ECR にプッシュすることを確認します。

# チュートリアル: CodePipeline を使用して Amazon EKS にデプロイする
<a name="tutorials-eks-deploy"></a>

このチュートリアルは、Amazon EKS で設定したクラスターにコードをデプロイするデプロイアクションを CodePipeline で作成する方法について説明します。

EKS アクションは、パブリック EKS クラスターとプライベート EKS クラスターの両方をサポートします。プライベートクラスターは EKS で推奨されるタイプですが、どちらのタイプもサポートされています。

**注記**  
コンソールでのパイプライン作成の一環として、CodePipeline は S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**注記**  
このアクションでは、CodePipeline マネージド CodeBuild コンピューティングを使用して、ビルド環境でコマンドを実行します。コマンドアクションを実行すると、 AWS CodeBuildで別途料金が発生します。

**注記**  
`EKS` デプロイアクションは V2 タイプのパイプラインでのみ使用できます。

## 前提条件
<a name="tutorials-eks-deploy-prereqs"></a>

このチュートリアルで CD パイプラインを作成する前に、いつくかのリソースを用意する必要があります。使用を開始するために必要なものは以下のとおりです。

**注記**  
これらのリソースはすべて、同じ AWS リージョン内に作成する必要があります。
+ サンプル `deployment.yaml` ファイルを追加するソースコントロールリポジトリ (このチュートリアルでは GitHub を使用します）。
+ 以下の [ステップ 3: IAM の CodePipeline サービスロールポリシーを更新する](#tutorials-eks-deploy-role) を使用してこのアクションのアクセス許可で更新された、既存の CodePipeline サービスロールを使用する必要があります。必要なアクセス許可は、作成するクラスターのタイプに基づきます。詳細については、「[サービスロールのポリシーのアクセス許可](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>

プライベートエンドポイントを使用してクラスターを作成する場合は、プライベートサブネットのみをアタッチし、それらにインターネット接続があることを確認してください。

プライベートエンドポイントを使用してクラスターを作成するには、次の 5 つのサブステップに従います。

**コンソールで VPC を作成します。**

1. VPC コンソールを開いて **[VPC の作成]** を選択します。

1. **[VPC 設定]** で、**[VPC など]** を選択します。

1. 1 つのパブリックサブネットと 4 つのプライベートサブネットを作成することを選択します。**[Create VPC（VPC の作成）]** を選択します。

1. サブネットページで、**[プライベート]** を選択します。

**VPC 内のプライベートサブネットを確認する**

1. VPC に移動し、VPC ID を選択して VPC の詳細ページを開きます。

1. VPC の詳細ページで、**[リソースマップ]** タブを選択します。

1. 図を確認して、プライベートサブネットを書き留めます。サブネットにはパブリックまたはプライベートのステータスを示すラベルが表示され、各サブネットはルートテーブルにマッピングされます。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/eks-deploy-subnets.png)

   プライベートクラスターにはすべてのプライベートサブネットがあることに注意してください。

1. NAT ゲートウェイをホストするパブリックサブネットを作成します。一度に VPC にアタッチできるインターネットゲートウェイは 1 つだけです。

**パブリックサブネット内に NAT ゲートウェイを作成する**

1. パブリックサブネットで、NAT ゲートウェイを作成します。VPC コンソールに移動し、**[インターネットゲートウェイ]**を選択します。[**インターネットゲートウェイの作成**] を選択します。

1. [名前] にインターネットゲートウェイの名前を入力します。[**インターネットゲートウェイの作成**] を選択します。

プライベートサブネットのルートテーブルを更新して、トラフィックを NAT ゲートウェイに転送します。

**プライベートサブネットのルートテーブルに NAT ゲートウェイを追加する**

1. VPC コンソールに移動し、**[サブネット]** を選択します。

1. 各プライベートサブネットで選択して、詳細ページでそのサブネットのルートテーブルを選択し、**[ルートテーブルの編集]** を選択します。

1. プライベートサブネットのルートテーブルを更新して、インターネットトラフィックを NAT ゲートウェイに転送します。**[Add Rule]** (ルートの追加) を選択します。追加するオプションから **[NAT ゲートウェイ]** を選択します。作成したインターネットゲートウェイを選択します。

1. パブリックサブネットのカスタムルートテーブルを作成します。パブリックサブネットのネットワークアクセスコントロールリスト (ACL) で、プライベートサブネットからのインバウンドトラフィックが許可されていることを確認します。

1. **[Save changes]** (変更の保存) をクリックします。

このステップでは、EKS にクラスターを作成します。

**プライベートクラスターを作成する**

1. EKS コンソールを開いて **[クラスターの作成]** を選択します。

1. **[名前]** で、クラスターに名前を付けます。[**次へ**] を選択します。

1. VPC およびその他の設定情報を指定します。**[作成]** を選択します。

EKS クラスターは、パブリッククラスターでもプライベートクラスターでもかまいません。このステップは、プライベートエンドポイントのみを持つクラスター用です。クラスターがプライベートであることを確認してください。

## ステップ 2: Amazon EKS でプライベートクラスターを設定する
<a name="tutorials-eks-deploy-cluster-private-configure"></a>

このステップは、プライベートクラスターを作成している場合にのみ適用されます。このステップは、プライベートエンドポイントのみを持つクラスター用です。

**クラスターを設定する**

1. **[ネットワーク]** タブの EKS クラスターにのみプライベートサブネットをアタッチします。[ステップ 1: (オプション) Amazon EKS でクラスターを作成する](#tutorials-eks-deploy-cluster) の「**VPC 内のプライベートサブネットを確認する**」セクションでキャプチャされたプライベートサブネットをアタッチします。

1. CodePipeline はパイプラインの S3 アーティファクトバケットからアーティファクトを保存および取得するため、プライベートサブネットがインターネットにアクセスできることを確認します。

## ステップ 3: IAM の CodePipeline サービスロールポリシーを更新する
<a name="tutorials-eks-deploy-role"></a>

このステップでは、`cp-service-role` などの既存の CodePipeline サービスロールを CodePipeline がクラスターに接続するために必要なアクセス許可で更新します。既存のロールがない場合は、新しいロールを作成します。

CodePipeline サービスロールを次の手順で更新します。

**CodePipeline サービスロールポリシーを更新するには**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソール を開きます。

1. コンソールダッシュボードで [**ロール**] を選択します。

1. `cp-service-role` などの CodePipeline サービスロールを検索します。

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 チャート) を作成し、その設定ファイルをソースリポジトリに保存します。設定に適したファイルを使用します。詳細については、[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 チャートを使用します。

1. GitHub リポジトリを作成するか、既存のものを使用します。

1. 以下の例に示すように、Helm チャートファイルのリポジトリに新しい構造を作成します。

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

1. ファイルをリポジトリのルートレベルに追加します。

## ステップ 6: パイプラインを作成する
<a name="tutorials-eks-deploy-pipeline"></a>

CodePipeline ウィザードを使用してパイプラインステージを作成し、ソースリポジトリを接続します。

**パイプラインを作成するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyEKSPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **[サービスロール]** で、ステップ 3 で更新したサービスロールを選択します。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページの **[ソースプロバイダー]** で、**[GitHub リポジトリへの接続を作成すること]** を選択します。

1. **[ステップ 4: ビルドステージの追加]** ページで、**[スキップ]** を選択します。

1. **[ステップ 5: デプロイステージの追加]** ページで、**[Amazon EKS]** を選択します。  
![\[Deploy configuration form with Helm selected, showing fields for release name and chart location.\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/eks-action-example.png)

   1. **[デプロイ設定タイプ]** で、**[Helm]** を選択します。

   1. **[Helm チャートの場所]** で、`my-release` などのリリース名を入力します。**[Helm チャートの場所]** で、`mychart` などの Helm チャートファイルのパスを入力します。

   1. [**次へ**] を選択します。

1. [**Step 6: Review**] ページで、パイプラインの設定を確認し、[**Create pipeline**] を選択してパイプラインを作成します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/eks-deploy-pipeline.png)

1. パイプラインが正常に実行されたら、**[詳細を表示]** を選択してアクションのログを表示し、アクション出力を表示します。

# チュートリアル: コンピューティングを使用してコマンドを実行するパイプラインを作成する (V2 タイプ)
<a name="tutorials-commands"></a>

このチュートリアルでは、ビルドステージでコマンドアクションを使用して、指定したビルドコマンドを継続的に実行するパイプラインを設定します。コマンドアクションの詳細については、「[コマンドアクションリファレンス](action-reference-Commands.md)」を参照してください。

**重要**  
パイプライン作成の一環として、CodePipeline は、ユーザーが指定した S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

## 前提条件
<a name="tutorials-commands-prereq"></a>

以下のものを用意しておく必要があります。
+ GitHub リポジトリ。「[チュートリアル: CodeCommit パイプラインソースで完全なクローンを使用する](tutorials-github-gitclone.md)」で作成した GitHub リポジトリを使用できます。

## ステップ 1: ソースファイルを作成して GitHub リポジトリにプッシュする
<a name="tutorials-commands-push"></a>

このセクションでは、サンプルのソースファイルを作成して、パイプラインがソースステージで使用するリポジトリにプッシュします。この例では、以下を作成してプッシュします。
+ `README.txt` ファイル。

**ソースファイルを作成するには**

1. 次のテキストを含むファイルを作成します。

   ```
   Sample readme file
   ```

1. `README.txt` という名前でファイルを保存します。

**ファイルを GitHub リポジトリにプッシュするには**

1. ファイルを リポジトリにプッシュまたはアップロードします。これらのファイルは、 AWS CodePipelineでのデプロイアクションのために **パイプライン作成** ウィザードによって作成されたソースアーティファクトです。ファイルは、ローカルディレクトリに次のように表示されます。

   ```
   README.txt
   ```

1. ローカルコンピュータで複製されたリポジトリから Git コマンドラインを使用するには:

   1. 以下のコマンドを実行して、すべてのファイルを一度にステージングします。

      ```
      git add -A
      ```

   1. 以下のコマンドを実行して、コミットメッセージによりファイルをコミットします。

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

   1. 以下のコマンドを実行して、ローカルリポジトリから リポジトリにファイルをプッシュします。

      ```
      git push
      ```

## ステップ 2: パイプラインを作成する
<a name="tutorials-commands-pipeline"></a>

このセクションでは、次のアクションを使用してパイプラインを作成します。
+ ソースファイルが保存されているリポジトリの GitHub (GitHub アプリ経由) アクションを含むソースステージ。
+ コマンドアクションを含むビルドステージ。

**ウィザードを使用してパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyCommandsPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. [**サービスロール**] で、[**新しいサービスロール**] を選択し、CodePipeline に IAM でのサービスロールの作成を許可します。
**注記**  
既存のサービスロールを使用している場合、コマンドアクションを使用するには、サービスロールに以下のアクセス許可を追加する必要があります。サービスロールポリシーステートメントでリソースベースのアクセス許可を使用して、アクセス許可の範囲をパイプラインリソースレベルに絞り込みます。詳細については、「[サービスロールのポリシーのアクセス許可](action-reference-Commands.md#action-reference-Commands-policy)」のポリシー例を参照してください。  
logs:CreateLogGroup
logs:CreateLogStream
logs:PutLogEvents

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページで、ソースステージを追加します。

   1. **[ソースプロバイダー]** で、**[GitHub (GitHub アプリ経由)]** を選択します。

   1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理するには、「[GitHub コネクション](connections-github.md)」を参照してください。

   1. **[リポジトリ名]** で、GitHub.com リポジトリの名前を選択します。

   1. [**デフォルトブランチ**] で、パイプラインを手動で開始する場合、または Git タグではないソースイベントで開始する場合に指定するブランチを選択します。変更元がトリガーでない場合やパイプラインの実行が手動で開始された場合は、デフォルトブランチの HEAD コミットが変更として使用されます。必要に応じて、フィルタリング (トリガー) を使用してウェブフックを指定することもできます。詳細については、「[トリガーとフィルタリングを使用してパイプラインを自動的に開始する](pipelines-triggers.md)」を参照してください。

   **[Next]** (次へ) を選択します。

1. **[ステップ 4: ビルドステージ を追加する]** で、**[コマンド]** を選択します。
**注記**  
コマンドアクションを実行すると、 AWS CodeBuildで別途料金が発生します。

   以下のコマンドを入力します。

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

   [**次へ**] を選択します。  
![\[コマンドアクションを使用した新しいパイプラインの [ステップ 4: ビルドステージの追加] ページ\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/codepipeline/latest/userguide/images/commands-output-edit-var.png)

## ステップ 3: パイプラインを実行してビルドコマンドを検証する
<a name="tutorials-commands-update"></a>

変更をリリースして、パイプラインを実行します。実行履歴、ビルドログ、出力変数を表示して、ビルドコマンドが実行したことを確認します。

**アクションのログと出力変数を表示するには**

1. パイプラインが正常に実行したら、アクションのログと出力を表示できます。

1. アクションの出力変数を表示するには、**[履歴]**し、**[タイムライン]** の順に選択します。

   アクションに追加した出力変数を表示します。コマンドアクションの出力に、アクション Region に解決された出力変数が表示されます。  
![\[アクション Region に解決された出力変数を示すコマンドアクションの出力\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/commands-output-variable.png)

1. アクションのログを表示するには、成功したコマンドアクションの **[詳細を表示]** を選択します。コマンドアクションのログを表示します。  
![\[コマンドアクションのログ例\]](http://docs.aws.amazon.com/ja_jp/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)」を参照してください。欧州 (ミラノ) リージョンでのこのアクションに関する考慮事項については、「[CodeStarSourceConnection (Bitbucket Cloud、GitHub、GitHub Enterprise Server、GitLab.com、および GitLab セルフマネージドアクションの場合)](action-reference-CodestarConnectionSource.md)」の注意を参照してください。

**Topics**
+ [

## 前提条件
](#tutorials-github-tags-prereq)
+ [

## ステップ 1: CloudShell を開いてリポジトリを複製する
](#w2aac13c16c15)
+ [

## ステップ 2: Git タグでトリガーするパイプラインを作成する
](#tutorials-github-tags-pipeline)
+ [

## ステップ 3: リリースに対するコミットにタグを付ける
](#w2aac13c16c19)
+ [

## ステップ 4: 変更をリリースしてログを表示する
](#tutorials-github-tags-view)

## 前提条件
<a name="tutorials-github-tags-prereq"></a>

開始する前に、以下を実行する必要があります。
+ GitHub アカウントで GitHub リポジトリを作成します。
+ GitHub の認証情報を準備してください。を使用して接続 AWS マネジメントコンソール を設定すると、GitHub 認証情報を使用してサインインするように求められます。

## ステップ 1: CloudShell を開いてリポジトリを複製する
<a name="w2aac13c16c15"></a>

コマンドラインインターフェイスを使用して、リポジトリの複製、コミット、タグの追加を行うことができます。このチュートリアルでは、コマンドラインインターフェイス用に CloudShell インスタンスを起動します。

1.  AWS マネジメントコンソールにサインインします。

1. 上部のナビゲーションバーで、 AWS アイコンを選択します。 AWS マネジメントコンソール のメインページが表示されます。

1. 上部のナビゲーションバーで、 AWS CloudShell アイコンを選択します。CloudShell が開きます。CloudShell 環境が作成されるまで待ちます。
**注記**  
CloudShell アイコンが表示されない場合は、[CloudShell でサポートされているリージョン](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available)にいることを確認してください。このチュートリアルは、米国西部 (オレゴン) リージョンにいることを前提としています。

1. GitHub で、目的のリポジトリに移動します。[**コード**] を選択してから、[**HTTPS**] を選択します。パスをコピーします。Git リポジトリのクローンを作成するアドレスがクリップボードにコピーされます。

1. 次のコマンドを実行してリポジトリを複製します。

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

1. プロンプトが表示されたら、GitHub アカウントの `Username` と `Password` を入力します。`Password` エントリには、アカウントのパスワードではなく、ユーザーが作成したトークンを使用する必要があります。

## ステップ 2: Git タグでトリガーするパイプラインを作成する
<a name="tutorials-github-tags-pipeline"></a>

このセクションでは、以下のアクションを使用してパイプラインを作成します。
+ Bitbucket リポジトリとアクションへの接続を持つソースステージ。
+ ビルドアクションを含む AWS CodeBuild ビルドステージ。

**ウィザードを使用してパイプラインを作成するには**

1. CodePipeline コンソール ([http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codepipeline/)) にサインインします。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyGitHubTagsPipeline**」と入力します。

1. [**パイプラインのタイプ**] で、デフォルトの選択を [**V2**] のままにします。パイプラインのタイプによって特徴および価格が異なります。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。

1. [**サービスロール**] で、[**New service role (新しいサービスロール)**] を選択します。
**注記**  
既存の CodePipeline サービスロールを代わりに使用する場合は、サービスロールポリシーに対する `codestar-connections:UseConnection` IAM アクセス許可を追加したことを確認してください。CodePipeline サービスロールの手順については、「[Add permissions to the the CodePipeline service role](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)」を参照してください。

1. **[詳細設定]** では、デフォルト値のままにします。**アーティファクトストア**で、[**Default location**] (デフォルトの場所)を選択し、パイプライン用に選択したリージョン内のパイプラインのデフォルトのアーティファクトストア (デフォルトとして指定された Amazon S3 アーティファクトバケットなど) を使用します。
**注記**  
これはソースコードのソースバケットではありません。パイプラインのアーティファクトストアです。パイプラインごとに S3 バケットなどの個別のアーティファクトストアが必要です。

   [**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページで、ソースステージを追加します。

   1. **[ソースプロバイダー]** で、**[GitHub (GitHub アプリ経由)]** を選択します。

   1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理する方法については、[GitHub コネクション](connections-github.md) を参照してください。

   1. **リポジトリ名** で、GitHub リポジトリの名前を選択します。

   1. [**デフォルトブランチ**] で、パイプラインを手動で開始する場合、または Git タグではないソースイベントで開始する場合に指定するブランチを選択します。変更元がトリガーでない場合やパイプラインの実行が手動で開始された場合は、デフォルトブランチの HEAD コミットが変更として使用されます。

   1. **[ウェブフックイベント]** の **[フィルタータイプ]** で、**[タグ]** を選択します。

      **[タグまたはパターン]** フィールドに、`release*` と入力します。
**重要**  
Git タグのトリガータイプで開始されるパイプラインは、WebhookV2 イベントに対して設定されます。パイプラインの開始に Webhook イベント (すべてのプッシュイベントに対して変更検出を行う) は使用されません。

   [**次へ**] を選択します。

1. [**Add build stage (ビルドステージの追加)**] で、ビルドステージを追加します。

   1. [**ビルドプロバイダ**] で、[**AWS CodeBuild**] を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. **[プロジェクトを作成]** を選択します。

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。[**イメージ**] で、[**aws/codebuild/standard:5.0**] を選択します。

   1. [**サービスロール**] で、[**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 タグが必要です。コミットを選択してタグを付けると、さまざまなブランチからの変更をパイプラインのデプロイに組み込むことができます。release というタグ名は、GitHub のリリースの概念には当てはまりません。

1. コピーしたコミット ID のうち、タグを付けるものを参照します。各ブランチのコミットを表示するには、CloudShell ターミナルで以下のコマンドを入力して、タグを付けるコミット ID を取得します。

   ```
   git log
   ```

1. CloudShell ターミナルで、コミットにタグを付け、元のリポジトリにプッシュするコマンドを入力します。コミットにタグを付けた後、git Push コマンドを使用してタグを元のリポジトリにプッシュします。以下の例では、次のコマンドを入力して、ID `49366bd` の 2 番目のコミットに `release-1` タグを使用しています。このタグはパイプラインの `release*` タグフィルタによって処理されて、パイプラインの実行が開始されます。

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

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

## ステップ 4: 変更をリリースしてログを表示する
<a name="tutorials-github-tags-view"></a>

1. パイプラインが正常に実行されたら、デプロイステージで [**ログの表示**] を選択します。

   [**ログ**] で、CodeBuild のビルド出力を表示します。このコマンドは、入力された変数の値を出力します。

1. [**履歴**] ページで、[**トリガー**] 列を表示します。トリガータイプ **GitTag : release-1** を表示します。

# チュートリアル: プルリクエストのブランチ名をフィルタリングしてパイプラインを開始する (V2 タイプ)
<a name="tutorials-github-featurebranches"></a>

このチュートリアルでは、GitHub.com リポジトリに接続するパイプラインを作成します。このリポジトリでは、プルリクエストをフィルタリングするトリガー設定でパイプラインを開始するようにソースアクションを設定します。指定したブランチに対して指定したプルリクエストイベントが発生すると、パイプラインが開始します。この例では、ブランチ名のフィルタリングを許可するパイプラインの作成方法を示します。トリガーの操作の詳細については、「[プッシュリクエストイベントタイプとプルリクエストイベントタイプのフィルターを追加する (CLI)](pipelines-filter.md#pipelines-filter-cli)」を参照してください。glob 形式の正規表現パターンを使用したフィルタリングの詳細については、「[構文での glob パターンの使用](syntax-glob.md)」を参照してください。

**重要**  
パイプライン作成の一環として、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. CodePipeline コンソール ([http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codepipeline/)) にサインインします。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyFilterBranchesPipeline**」と入力します。

1. [**パイプラインのタイプ**] で、デフォルトの選択を [**V2**] のままにします。パイプラインのタイプによって特徴および価格が異なります。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。

1. [**サービスロール**] で、[**New service role (新しいサービスロール)**] を選択します。
**注記**  
既存の CodePipeline サービスロールを代わりに使用する場合は、サービスロールポリシーに対する `codeconnections:UseConnection` IAM アクセス許可を追加したことを確認してください。CodePipeline サービスロールの手順については、「[Add permissions to the the CodePipeline service role](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)」を参照してください。

1. **[詳細設定]** では、デフォルト値のままにします。**アーティファクトストア**で、[**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/ja_jp/codepipeline/latest/userguide/images/pullreq-example-triggers-edit.png)
**重要**  
このトリガータイプで開始するパイプラインは、WebhookV2 イベントに対して設定します。パイプラインの開始には Webhook イベント (すべてのプッシュイベントでの変更検出) を使用しません。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** の **[ビルドプロバイダー]** で、**[AWS CodeBuild]** を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。「[チュートリアル: Git タグを使用してパイプラインを開始する](tutorials-github-tags.md)」の指示に従って、ビルドプロジェクトを選択または作成します。このアクションは、パイプラインの作成に必要な 2 番目のステージとして、このチュートリアルでのみ使用します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 6: デプロイステージの追加]** ページで、**[デプロイステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。[**次へ**] を選択します。

1. **ステップ 7: 確認**で、**パイプラインの作成**を選択します。

## ステップ 2: GitHub.com でプルリクエストを作成してマージし、パイプライン実行を開始する
<a name="tutorials-github-featurebranches-pullrequest"></a>

このセクションでは、プルリクエストを作成してマージします。これにより、プルリクエストを開く 1 つの実行と、プルリクエストを閉じる 1 つの実行でパイプラインが開始します。

**プルリクエストを作成してパイプラインを開始するには**

1. GitHub.com で、機能ブランチの README.md に変更を加え、`main` ブランチにプルリクエストを送信することで、プルリクエストを作成します。`Update README.md for PR` のようなメッセージを付けて変更をコミットします。

1. パイプラインは、プルリクエストの**ソース**メッセージとして **Update README.md for PR** を示すソースリビジョンで開始します。  
![\[プルリクエストのソースメッセージとしてテキスト「Update README.md for PR」を示す画像\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/pullreq-example.png)

1. **[履歴]** を選択します。パイプライン実行履歴で、パイプライン実行を開始した CREATED および MERGED プルリクエストのステータスイベントを表示します。  
![\[パイプライン実行を開始した CREATED および MERGED プルリクエストのステータスイベントを表示するパイプライン実行履歴を示す画像\]](http://docs.aws.amazon.com/ja_jp/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. CodePipeline コンソール ([http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codepipeline/)) にサインインします。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyVariablesPipeline**」と入力します。

1. [**パイプラインのタイプ**] で、デフォルトの選択を [**V2**] のままにします。パイプラインのタイプによって特徴および価格が異なります。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。

1. [**サービスロール**] で、[**New service role (新しいサービスロール)**] を選択します。
**注記**  
既存の CodePipeline サービスロールを代わりに使用する場合は、サービスロールポリシーに対する `codeconnections:UseConnection` IAM アクセス許可を追加したことを確認してください。CodePipeline サービスロールの手順については、「[Add permissions to the the CodePipeline service role](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. **[詳細設定]** では、デフォルト値のままにします。**アーティファクトストア**で、[**Default location**] (デフォルトの場所)を選択し、パイプライン用に選択したリージョン内のパイプラインのデフォルトのアーティファクトストア (デフォルトとして指定された Amazon S3 アーティファクトバケットなど) を使用します。
**注記**  
これはソースコードのソースバケットではありません。パイプラインのアーティファクトストアです。パイプラインごとに S3 バケットなどの個別のアーティファクトストアが必要です。

   [**次へ**] を選択します。

1. **[ステップ 3: ソースステージを追加する]** ページでソースステージを追加します。

   1. [**ソースプロバイダ**] で、**AWS CodeCommit** を選択します。

   1. [**リポジトリ名**] と [**ブランチ名**] で、リポジトリとブランチを選択します。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、ビルドステージを追加します。

   1. [**ビルドプロバイダ**] で、[**AWS CodeBuild**] を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. **[プロジェクトを作成]** を選択します。

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。[**イメージ**] で、[**aws/codebuild/standard:5.0**] を選択します。

   1. [**サービスロール**] で、[**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`」と入力します。**[値]** には「`#{variables.timeout}`」と入力します。[**タイプ**] で、[`Plaintext`] を選択します。

      環境変数の`#{variables.timeout}`値は、パイプラインレベルの変数名前空間`variables`と、ステップ 7 でパイプライン用に`timeout`作成されたパイプラインレベルの変数に基づいています。

   1. [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 6: デプロイステージの追加]** ページで、**[デプロイステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。[**次へ**] を選択します。

1. **ステップ 7: 確認**で、**パイプラインの作成**を選択します。

## ステップ 2: 変更をリリースしてログを表示する
<a name="tutorials-pipeline-variables-view"></a>

1. パイプラインが正常に実行されたら、成功したビルドステージで **[詳細を表示]** を選択します。

   詳細ページで、**[ログ]** タブを選択します。CodeBuild ビルド出力を表示します。このコマンドは、入力された変数の値を出力します。

1. 左側のナビゲーションで、[**履歴**] を選択します。

   最近の実行を選択し、[**変数**] タブを選択します。パイプライン変数の解決された値を表示します。

# チュートリアル: シンプルなパイプラインを作成する (S3 バケット)
<a name="tutorials-simple-s3"></a>

パイプラインを作成する最も簡単な方法は、 AWS CodePipeline コンソールで**パイプラインの作成**ウィザードを使用することです。

このチュートリアルでは、バージョン管理された S3 ソースバケットおよび CodeDeploy を使用してサンプルアプリケーションをリリースする 2 ステージのパイプラインを作成します。

**注記**  
Amazon S3 がパイプラインのソースプロバイダーである場合、ソースファイルを 1 つの .zip に圧縮し、その .zip をソースバケットにアップロードできます。解凍されたファイルを 1 つアップロードすることもできます。ただし、.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. [**バケット名**] に、バケットの名前 (**awscodepipeline-demobucket-example-date** など) を入力します。
**注記**  
Amazon S3 内のすべてのバケット名は一意になる必要があるため、例に示す名前ではなく、独自のバケット名を使用してください。例に示す名前は、日付を追加するだけでも変更できます。このチュートリアルの残りの部分で必要となるため、この名前を書き留めます。

   [**リージョン**] で、パイプラインを作成するリージョン [**米国西部 (オレゴン)**] などを選択し、[**バケットの作成**] を選択します。

1. バケットが作成されると、成功バナーが表示されます。[**バケットの詳細に移動**] を選択します。

1. [**プロパティ**] タブで、[**バージョニング**] を選択します。[**バージョニングの有効化**] を選択し、[**保存**] を選択します。

   バージョニングが有効になったら、Amazon S3 によって各オブジェクトのすべてのバージョンがバケットに保存されます。

1. [**アクセス許可**] タブは、デフォルト設定のままにします。S3 バケットおよびオブジェクトへのアクセス許可に関する詳細については、「[ポリシーでのアクセス許可の指定](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html)」を参照してください。

1. 次に、サンプル をダウンロードし、ローカルコンピュータのフォルダまたはディレクトリに保存します。

   1.  次のいずれかを選択します 。Windows Server インスタンスについて、このチュートリアルのステップに従う場合は、`SampleApp_Windows.zip` を選択します。
      + 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 デプロイライフサイクルイベントごとに 1 つのファイルが書き込まれます。
        + (Linux サンプルのみ) `scripts` フォルダ - このフォルダに入っているのはシェルスクリプト `install_dependencies`、`start_server`、`stop_server` です。依存関係をインストールし、自動デプロイのサンプルアプリケーションを起動および停止するために使用されます。
        + (Windows サンプルのみ) `before-install.bat` - `BeforeInstall` デプロイライフサイクルイベントのバッチスクリプトです。このサンプルの前のデプロイ中に書き込まれた古いファイルを削除し、新しいファイルを書き込む場所をインスタンス上に作成するために実行されます。

   1. 圧縮 (zip) ファイルをダウンロードします。このファイルを解凍しないでください。

1. Amazon S3 コンソールで、バケットに次のファイルをアップロードします。

   1. **アップロード** を選択します。

   1. ファイルをドラッグアンドドロップするか、[**ファイルを追加**] を選択してファイルを参照します。

   1. **アップロード** を選択します。

## ステップ 2: Amazon EC2 Windows インスタンスを作成し、CodeDeploy エージェントをインストールします。
<a name="S3-create-instances"></a>

**注記**  
このチュートリアルでは、Amazon EC2 Windows インスタンスを作成するサンプル手順を示します。Amazon EC2 Linux インスタンスを作成するサンプルステップについては、「[ステップ 3: Amazon EC2 Linux インスタンスを作成して CodeDeploy エージェントをインストールする](tutorials-simple-codecommit.md#codecommit-create-deployment) 」を参照してください。作成するインスタンスの数の入力を求められたら、**2** つのインスタンスを指定します。

このステップでは、サンプルアプリケーションをデプロイする Windows Server Amazon EC2 インスタンスを作成します。このプロセスの一環として、インスタンス上で CodeDeploy エージェントのインストールと管理を許可するポリシーを関連付けたインスタンスロールを作成します。CodeDeploy エージェントは、CodeDeploy デプロイでインスタンスを使用できるようにするソフトウェアパッケージです。また、CodeDeploy エージェントによってアプリケーションのデプロイに使用されるファイルを取得すること、SSM によって管理されることを、インスタンスに許可するポリシーをアタッチします。

**インスタンスロールを作成するには**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソール を開きます。

1. コンソールダッシュボードで [**ロール**] を選択します。

1. [**ロールの作成**] を選択してください。

1. [**信頼されたエンティティのタイプを選択**] で、[**AWS のサービス** ] を選択します。[**ユースケースの選択**] で [**EC2**] を選択し、[**次の手順: アクセス許可**] を選択します。

1. **`AmazonEC2RoleforAWSCodeDeploy`** という名前のマネージドポリシーを検索して選択します。

1. **`AmazonSSMManagedInstanceCore`** という名前のマネージドポリシーを検索して選択します。[**Next: Tags (次へ: タグ)**] を選択します。

1. **[次へ: レビュー]** を選択します。ロールの名前を入力します (例: **EC2InstanceRole**)。
**注記**  
次のステップのロール名をメモしておきます。このロールは、インスタンスの作成時に選択します。

   [**ロールの作成**] を選択してください。

**インスタンスを起動するには**

1. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) を開いてください。

1. サイドナビゲーションから [**インスタンス**] を選択し、ページの上部から [**インスタンスの起動**] を選択します。

1. [**名前とタグ**] で、[**名前**] に「**MyCodePipelineDemo**」と入力します。これにより、インスタンスには**キー**が **Name** で、**値**が **MyCodePipelineDemo** というタグがが割り当てられます。後で、そのインスタンスにサンプルアプリケーションをデプロイする CodeDeploy アプリケーションを作成します。CodeDeploy は、タグに基づいてデプロイするインスタンスを選択します。

1. [**アプリケーションと OS イメージ (Amazon マシンイメージ)**] で、[**Windows**] オプションを選択します。(この AMI は **Microsoft Windows Server 2019 Base** として説明され、「無料利用枠対象」というラベルが付いており、[**クイックスタート**] の下にあります。)

1. [**インスタンスタイプ**] で、インスタンスのハードウェア構成として無料利用枠対象となる `t2.micro` タイプを選択します。

1. [**キーペア (ログイン)**] で、キーペアを選択するか作成します。

   [**キーペアなしで続行**] を選択することもできます。
**注記**  
このチュートリアルでは、キーペアを使用せずに続行できます。SSH を使用してインスタンスに接続するには、キーペアを作成または使用します。

1. [**ネットワーク設定**] で、次の操作を行います。

   [**パブリック IP の自動割り当て**] で、ステータスが [**有効**] になっていることを確認します。
   + [**セキュリティグループの割り当て**] の横にある [**新規セキュリティグループを作成**] を選択します。
   + [**SSH**] の行で、[**ソースタイプ**] の [**マイ IP**] を選択します。
   + [**セキュリティグループの追加**]、[**HTTP**] の順に選択し、[**ソースタイプ**] で [**マイ IP**] を選択します。

1. **[Advanced Details]** (高度な詳細) を展開します。[**IAM インスタンスプロファイル**] で、前の手順で作成した IAM ロール (**EC2InstanceRole** など) を選択します。

1. [**概要**] の [**インスタンス数**] に「`2`」と入力します。

1. **[インスタンスを起動]** を選択します。

1. **[View all instances]** (すべてのインスタンスの表示) を選択して確認ページを閉じ、コンソールに戻ります。

1. [**インスタンス**] ページで、起動のステータスを表示できます。インスタンスを起動すると、その初期状態は `pending` です。インスタンスを起動した後は、状態が `running` に変わり、パブリック DNS 名を受け取ります ([**パブリック DNS**] 列が表示されていない場合は、[**表示/非表示**] アイコンを選択してから、[**パブリック DNS**] を選択します)。

1. インスタンスに接続可能になるまでには、数分かかることがあります。インスタンスのステータスチェックが成功していることを確認します。この情報は、[**ステータスチェック**] 列で確認できます。

## ステップ 3: CodeDeploy でアプリケーションを作成する
<a name="S3-create-deployment"></a>

CodeDeploy では*アプリケーション*は、デプロイするコードの識別子で、名前の形式です。 CodeDeploy はこの名前を使用して、デプロイ中にリビジョン、デプロイ設定、およびデプロイグループの正しい組み合わせが参照されるようにします。このチュートリアルの後半でパイプラインを作成する際、このステップで作成した CodeDeploy アプリケーションの名前を選択します。

まず、CodeDeploy が使用するサービスロールを作成します。既にサービスロールを作成している場合は、別のサービスロールを作成する必要はありません。

**CodeDeploy サービスロールの作成するために**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソール を開きます。

1. コンソールダッシュボードで [**ロール**] を選択します。

1. [**ロールの作成**] を選択してください。

1. [**信頼されたエンティティを選択**] で、[**AWS のサービス**] を選択します。[**ユースケース**] で、[**CodeDeploy**] を選択します。示されたオプションから [**CodeDeploy**] を選択します。[**次へ**] を選択します。`AWSCodeDeployRole` マネージドポリシーはロールにアタッチ済みです。

1. [**次へ**] を選択します。

1. ロールの名前 (例: **CodeDeployRole**) を入力し、[**ロールの作成**] を選択します。

**CodeDeploy でアプリケーションを作成するには**

1. [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) で、CodeDeploy コンソールを開きます。

1. **アプリケーション**ページが表示されない場合は、 AWS CodeDeploy メニューで**アプリケーション**を選択します。

1. [**アプリケーションを作成**] を選択します。

1. [**アプリケーション名**] に、「`MyDemoApplication`」と入力します。

1. [**コンピューティングプラットフォーム**] で [**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. [**環境設定**] で、[**Amazon EC2 インスタンス**] を選択します。[**名前**] を [**キー**] フィールドに入力し、[**値**] フィールドに **MyCodePipelineDemo** を入力します。
**重要**  
[**Name (名前)**] キーには、EC2 インスタンスの作成時にインスタンスに割り当てたのと同じ値を選択する必要があります。インスタンスに **MyCodePipelineDemo** 以外のタグを付けた場合は、ここでもそのタグを使用してください。

1. ** AWS Systems Manager を使用したエージェント設定**で、**今すぐ を選択し、更新をスケジュール**します。これにより、インスタンスにエージェントがインストールされます。Windows インスタンスは既に SSM エージェントで設定されており、これから CodeDeploy エージェントで更新されます。

1. [**デプロイ設定**] で `CodeDeployDefault.OneAtaTime` を選択します。

1. [**ロードバランサー**] で、[**ロードバランシングの有効化**] ボックスが選択されていないことを確認してください。この例では、ロードバランサーを設定したり、ターゲットグループを選択したりする必要はありません。チェックボックスの選択を解除すると、ロードバランサーのオプションが表示されません。

1. [**詳細設定**] セクションでは、既定のままにしておきます。

1. **デプロイグループの作成** を選択します。

## ステップ 4: CodePipeline で最初のパイプラインを作成する
<a name="s3-create-pipeline"></a>

チュートリアルのこの部分では、パイプラインを作成します。サンプルは、パイプラインを通して自動的に実行されます。

**CodePipeline 自動リリースプロセスを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyFirstPipeline**」と入力します。
**注記**  
パイプラインに別の名前を選択した場合は、このチュートリアルの残りの部分で **MyFirstPipeline** の代わりにその名前を使用してください。パイプラインを作成したら、その名前を変更することはできません。パイプラインの名前にはいくつかの制限がある場合があります。詳細については、「[AWS の CodePipeline 中のクォータ](limits.md)」を参照してください。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. [**Service role (サービスロール)**] で、次のいずれかの操作を行います。
   + **New service role** を選択して、CodePipeline に IAM での新しいサービスロールの作成を許可します。
   + IAM で作成済みのサービスロールを使用するには、[**Existing service role (既存のサービスロール)**] を選択します。[**ロール名**] で、リストからサービスロールを選択します。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** の **[ソースプロバイダー]** で、**[Amazon S3]** を選択します。[**バケット**] に、「[ステップ 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 リージョン と同じです。[**アプリケーション名**] に `MyDemoApplication` を入力するか、**更新**ボタンを選択してリストからそのアプリケーション名を選択します。[**デプロイグループ**] に「**MyDemoDeploymentGroup**」と入力するか、リストからデプロイグループを選択して [**次へ**] を選択します。
**注記**  
「Deploy」は、[**ステップ 4: デプロイステージの追加**] ステップで作成したステージにデフォルトで付けられる名前です。パイプラインの最初のステージに付けられる「Source」という名前も同様です。

1. **ステップ 7: **情報を確認してから、**パイプラインの作成**を選択します。

1. パイプラインの実行が開始されます。CodePipeline サンプルがウェブページを CodeDeploy デプロイの各 Amazon EC2 インスタンスにデプロイしている間、進行状況と成功/失敗メッセージを表示できます。

お疲れ様でした。シンプルなパイプラインが CodePipeline に作成されました。パイプラインには 2 つのステージがあります。
+ [**Source**] という名前のソースステージ。このステージでは、S3 バケットに保存したバージョニング済みのサンプルアプリケーションの変更を検出し、これらの変更をパイプライン内にプルします。
+ **デプロイ** ステージでは、CodeDeploy を使用して、これらの変更を EC2 インスタンスにデプロイします。

ここで、結果を確認します。

**パイプラインが正常に実行されたことを確認するには**

1. パイプラインの最初の進行状況を表示します。各ステージのステータスは、[**まだ実行はありません**] から [**進行中**] に変わり、その後、[**Succeeded** (成功)] または [**Failed** (失敗)] のいずれかに変わります。パイプラインの最初の実行は数分で完了します。

1. アクションのステータスに [**Succeeded (成功)**] が表示されたら、[** Deploy (デプロイ)**] ステージのステータス領域で [**Details (詳細)**] を選択します。これにより、CodeDeploy コンソールが開きます。

1. [**デプロイグループ**] タブの [**Deployment lifecycle events (デプロイライフサイクルイベント)**] の下で、インスタンス ID を選択します。これにより、EC2 コンソールが開きます。

1. [**Description**] タブの [**Public DNS**] でアドレスをコピーし、ウェブブラウザーのアドレスバーに貼り付けます。S3 バケットにアップロードしたサンプルアプリケーションのインデックスページを表示します。

   S3 バケットにアップロードしたサンプルアプリケーションのウェブページが表示されます。

ステージ、アクション、パイプラインの仕組みの詳細については、「[CodePipeline の概念 ](concepts.md)」を参照してください。

## (オプション) ステップ 5: 別のステージをパイプラインに追加する
<a name="s3-add-stage"></a>

次に、別のステージをパイプラインに追加し、CodeDeploy を使用してステージングサーバーから本稼働サーバーにデプロイできるようにします。まず、CodeDeploy の CodePipelineDemoApplication に別のデプロイグループを作成します。その後、このデプロイグループを使用するアクションを含むステージを追加します。別のステージを追加するには、CodePipeline コンソールまたは AWS CLI を使用して、JSON ファイル内のパイプラインの構造を取得して手動で編集し、 **update-pipeline** コマンドを実行してパイプラインを変更で更新します。

**Topics**
+ [

### CodeDeploy で 2 番目のデプロイグループを作成するには
](#s3-add-stage-part-1)
+ [

### パイプラインの別のステージとしてデプロイグループを追加する
](#s3-add-stage-part-2)

### CodeDeploy で 2 番目のデプロイグループを作成するには
<a name="s3-add-stage-part-1"></a>

**注記**  
チュートリアルのこの部分では、2 番目のデプロイグループを作成しますが、以前と同じ Amazon EC2 インスタンスにデプロイします。このウォークスルーは、デモンストレーションのみを目的としています。CodePipeline でエラーを表示する方法を示すために、意図的に失敗するように設計されています。

**CodeDeploy で 2 番目のデプロイグループを作成するには**

1. [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) で、CodeDeploy コンソールを開きます。

1. [**アプリケーション**] を選択し、アプリケーションのリストで [`MyDemoApplication`] を選択します。

1. [**デプロイグループ**] タブを選択して、[**Create deployment group (デプロイグループの作成)**] を選びます。

1. [**Create deployment group (デプロイグループの作成)**] ページの [**Deployment group name (デプロイグループ名)**] に、2 番目のデプロイグループの名前 (たとえば、**CodePipelineProductionFleet**) を入力します。

1. [**サービスロール**] で、最初のデプロイに使用したのと同じ CodeDeploy サービスロール (CodePipeline サービスロールではない) を選択します。

1. **[Deployment type]** (デプロイタイプ) で、**[In-place]** (インプレース) を選択します。

1. [**環境設定**] で、[**Amazon EC2 インスタンス**] を選択します。**[名前]** を **[キー]** ボックスから選択し、**[値]** ボックスで `MyCodePipelineDemo` をリストから選択します。[**デプロイ設定**] のデフォルト設定をそのままにします。

1. [**デプロイ設定**] で、[`CodeDeployDefault.OneAtaTime`] を選択します。

1. [**Load Balancer (ロードバランサー)**] で、[**Enable load balancing (ロードバランシングの有効化)**] をオフにします。

1.  **デプロイグループの作成** を選択します。

### パイプラインの別のステージとしてデプロイグループを追加する
<a name="s3-add-stage-part-2"></a>

別のデプロイグループが追加されたため、このデプロイグループを使用するステージを追加して、前に使用したのと同じ EC2 インスタンスにデプロイできます。CodePipeline コンソールまたは を使用して AWS CLI 、このステージを追加できます。

**Topics**
+ [

#### 3 番目のステージを追加する (コンソール)
](#s3-add-stage-part-2-console)
+ [

#### 3 番目のステージを追加する (CLI)
](#s3-add-stage-part-2-cli)

#### 3 番目のステージを追加する (コンソール)
<a name="s3-add-stage-part-2-console"></a>

CodePipeline コンソールを使用して、新しいデプロイグループを使用する新しいステージを追加できます。このデプロイグループのデプロイ先は、すでに使用した EC2 インスタンスであるため、このステージのデプロイアクションは失敗します。

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**名前**] で、作成したパイプラインの名前 MyFirstPipeline を選択します。

1. パイプライン詳細ページで、[**編集**] を選択します。

1. [**Edit (編集)**] ページで [**\$1 Add stage (\$1 ステージの追加)**] を選択して、[Deploy] ステージの直後にステージを追加します。  
![\[編集画面の [+ ステージの追加] ボタンを示す画像\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/edit-pipeline-console-pol.png)

1. [**Add stage (ステージの追加)**] で、[**Stage name (ステージ名)**] に、**Production**​ を入力します。[**Add stage (ステージの追加)**] を選択します。

1. 新しいステージで、[**\$1 Add action group (\$1 アクショングループの追加)**] を選択します。

1. [**アクションの編集**] の、[**アクション名**] に、**Deploy-Second-Deployment** を入力します。​ [**アクションプロバイダー]** の [**デプロイ**] で、[**CodeDeploy**] を選択します。

1. CodeDeploy セクションの [**アプリケーション名**] で、パイプラインの作成時と同様に、ドロップダウンリストから `MyDemoApplication` を選択します。[**デプロイグループ**] で、先ほど作成したデプロイグループ **CodePipelineProductionFleet** を選択します。[**入力アーティファクト**] で、ソースアクションから入力アーティファクトを選択します。**[保存]** を選択します。

1. [**Edit (編集)**] ページで [**Save (保存)**] を選択します。[**パイプラインの変更を保存**] で、[**Save (保存)**] を選択します。

1. 新しいステージがパイプラインに追加されていますが、パイプラインの別の実行をトリガーした変更がないため、[**まだ実行はありません**] というステータスが表示されます。最新のリビジョンを手動で再度実行して、編集されたパイプラインの実行度を確認する必要があります。パイプラインの詳細ページで、[**Release change (リリースの変更)**] を選択し、プロンプトが表示されたら [**Release (リリース)**] を選択します。これにより、ソースアクションで指定した各ソース場所における最新のリビジョンがパイプラインで実行されます。

   または、 AWS CLI を使用してパイプラインを再実行するには、ローカル Linux、macOS、Unix マシンのターミナル、またはローカル Windows マシンのコマンドプロンプトから、パイプラインの名前を指定して **start-pipeline-execution** コマンドを実行します。これにより、ソースバケット内のアプリケーションの 2 回目の実行がパイプラインで実行されます。

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

   このコマンドは `pipelineExecutionId` オブジェクトを返します。

1. CodePipeline コンソールに戻り、パイプラインのリストで [**MyFirstPipeline**] を選択してビューページを開きます。

   パイプラインには、3 つのステージがあり、それらの各ステージのアーティファクトの状態が示されます。パイプラインがすべてのステージを実行するまでに最大 5 分かかることがあります。前回と同じように、最初の 2 つのステージではデプロイが成功しますが、[**Production (本番稼働用)**] ステージでは [**Deploy-Second-Deployment (2 番目のデプロイをデプロイ)**] アクションが失敗したことが示されます。

1. [**Deploy-Second-Deployment**] アクションで、[**Details**] を選択します。CodeDeploy デプロイのページにリダイレクトされます。この場合、最初のインスタンスグループがすべての EC2 インスタンスにデプロイされ、2 番目のデプロイグループ用のインスタンスが残っていないために失敗しています。
**注記**  
この失敗は、パイプラインのステージにエラーがある場合にどうなるかを示すために、意図的に起こしたものです。

#### 3 番目のステージを追加する (CLI)
<a name="s3-add-stage-part-2-cli"></a>

を使用してパイプラインにステージ AWS CLI を追加するのは、 コンソールを使用するよりも複雑ですが、パイプラインの構造をより可視化できます。

**パイプラインの 3 番目のステージを作成するには**

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 (デプロイ)**] ステージセクションをコピーし、最初の 2 つのステージの後に貼り付けます。これはデプロイステージであるため、[** Deploy (デプロイ)**] ステージと同様に、3 番目のステージのテンプレートとして使用します。

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. 以下のようにパイプライン JSON ファイルを指定して、**update-pipeline** コマンドを実行します。

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

   このコマンドは、更新されたパイプラインの構造全体を返します。
**重要**  
ファイル名の前に必ず `file://` を含めてください。このコマンドでは必須です。

1.  パイプラインの名前を指定して、**start-pipeline-execution** コマンドを実行します。これにより、ソースバケット内のアプリケーションの 2 回目の実行がパイプラインで実行されます。

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

   このコマンドは `pipelineExecutionId` オブジェクトを返します。

1. CodePipeline コンソールを開き、パイプラインのリストから [**MyFirstPipeline**] を選択します。

   パイプラインには、3 つのステージがあり、それらの各ステージのアーティファクトの状態が示されます。パイプラインがすべてのステージを実行するまでに最大 5 分かかることがあります。前回と同じように、最初の 2 つのステージではデプロイが成功しますが、[**Production**] ステージでは [**Deploy-Second-Deployment**] アクションが失敗したことが示されます。

1. [**Deploy-Second-Deployment**] アクションで、[**Details**] を選択すると、その失敗の詳細が表示されます。CodeDeploy デプロイの詳細ページにリダイレクトされます。この場合、最初のインスタンスグループがすべての EC2 インスタンスにデプロイされ、2 番目のデプロイグループ用のインスタンスが残っていないために失敗しています。
**注記**  
この失敗は、パイプラインのステージにエラーがある場合にどうなるかを示すために、意図的に起こしたものです。

## (オプション) ステップ 6: CodePipeline でステージ間の移行を有効または無効にする
<a name="s3-configure-transitions"></a>

パイプラインのステージ間の移行を有効化または無効化することができます。ステージ間の移行を無効にすると、ステージ間の移行を手動で制御できるようになります。たとえば、パイプラインの最初の 2 つのステージを実行するが、本番環境にデプロイする準備ができるまで、または問題のトラブルシューティング中か、そのステージが失敗するまで、3 番目のステージへの移行を無効化します。

**CodePipeline パイプラインのステージ間の移行を無効/有効にするには**

1. CodePipeline コンソールを開き、パイプラインのリストから [**MyFirstPipeline**] を選択します。

1. パイプラインの詳細ページで、2 番目のステージ (**Deploy**) と前のセクションで追加した 3 番目のステージ (**Production**) との間で [**移行を無効にする**] ボタンを選択します。

1. [**移行を無効にする**] で、ステージ間の移行を無効にする理由を入力し、[**無効化**] を選択します。

   ステージ間の矢印では、アイコンと色の変化、および、[**移行を有効にする**] ボタンが表示されます。  
![\[移行を無効にする理由として「障害のトラブルシューティング中に移行を無効にする」と入力した画像\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/codepipeline-disabled-transition-pol.png)

1. サンプルをもう一度 S3 バケットにアップロードします。バケットのバージョニングが有効になっているため、この変更によってパイプラインが開始します。

1. パイプラインの詳細ページに戻り、ステージの状態を監視します。パイプラインビューでは、最初の 2 つのステージで進行状況が示されて成功に変わりますが、3 番目のステージで変更はありません。このプロセスには数分かかることがあります。

1. 2 つのステージの間の [**移行を有効にする**] ボタンを選択して、遷移を有効にします。[**Enable transition**] ダイアログボックスで、[**Enable**] を選択します。3 番目のステージの実行は数分で開始し、パイプラインの最初の 2 つのステージですでに実行されているアーティファクトの処理を試みます。
**注記**  
この 3 番目のステージを成功させるには、遷移を有効にする前に 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>

[チュートリアル: 4 ステージのパイプラインを作成する](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 リポジトリに保持されているコードを 1 つの Amazon EC2 インスタンスにデプロイします。CodeCommit リポジトリに変更をプッシュすると、パイプラインがトリガーされます。パイプラインは、デプロイサービスとして CodeDeploy を使用して Amazon EC2 インスタンスに変更をデプロイします。

**重要**  
パイプライン作成の一環として、CodePipeline は、ユーザーが指定した S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

パイプラインには 2 つのステージがあります。
+ ソースステージ (**ソース**) を CodeCommit ソースアクションに指定します。
+ デプロイステージ (**デプロイ**) を CodeDeploy デプロイアクションで指定します。

の使用を開始する最も簡単な方法は、CodePipeline **コンソールでパイプラインの作成**ウィザードを使用すること AWS CodePipeline です。

**注記**  
開始する前に、CodeCommit で Git クライアントを使用するようにセットアップされていることを確認します。手順については、[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. [**リポジトリの作成**] ページの [**リポジトリ名**] に、新しいリポジトリの名前を入力します (例: **MyDemoRepo**)。

1. [**作成**] を選択します。

**注記**  
このチュートリアルの残りのステップでは、CodeCommit リポジトリの名前として **MyDemoRepo** を使用します。別の名前を選択した場合は、このチュートリアル全体でそれを使用してください。

**ローカルリポジトリをセットアップするには**

このステップでは、ローカルリポジトリをセットアップしてリモート CodeCommit リポジトリに接続します。
**注記**  
ローカルリポジトリを設定する必要はありません。[ステップ 2: CodeCommit リポジトリにサンプルコードを追加する](#codecommit-add-code) の説明に従って、コンソールを使用してファイルをアップロードすることもできます。

1. コンソールで新しいリポジトリを開き、ページの右上にある [**URL のクローンを作成**] を選択してから、[**SSH のクローンを作成**] を選択します。Git リポジトリのクローンを作成するアドレスがクリップボードにコピーされます。

1. ターミナルまたはコマンドラインで、ローカルリポジトリを保存するローカルディレクトリに移動します。このチュートリアルでは、`/tmp` を使用します。

1. 次のコマンドを実行してリポジトリをクローンし、SSH アドレスを前のステップでコピーしたものに置き換えます。このコマンドは、`MyDemoRepo` という名前のディレクトリを作成します。サンプルアプリケーションをこのディレクトリにコピーします。

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

## ステップ 2: CodeCommit リポジトリにサンプルコードを追加する
<a name="codecommit-add-code"></a>

このステップでは、CodeDeploy サンプルチュートリアル用に作成したサンプルアプリケーションのコードをダウンロードし、CodeCommit リポジトリに追加します。



1. 次に、サンプル をダウンロードし、ローカルコンピュータのフォルダまたはディレクトリに保存します。

   1.  次のいずれかを選択します 。Linux インスタンスについて、このチュートリアルのステップに従う場合は、`SampleApp_Linux.zip` を選択します。
      + 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 デプロイライフサイクルイベントごとに 1 つのファイルが書き込まれます。
        + (Linux サンプルのみ) `scripts` フォルダ - このフォルダに入っているのはシェルスクリプト `install_dependencies`、`start_server`、`stop_server` です。依存関係をインストールし、自動デプロイのサンプルアプリケーションを起動および停止するために使用されます。
        + (Windows サンプルのみ) `before-install.bat` - `BeforeInstall` デプロイライフサイクルイベントのバッチスクリプトです。このサンプルの前のデプロイ中に書き込まれた古いファイルを削除し、新しいファイルを書き込む場所をインスタンス上に作成するために実行されます。

   1. 圧縮 (zip) ファイルをダウンロードします。

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. [**ファイルの選択**] を選択し、ファイルを参照します。フォルダにファイルを追加するには、**ファイルの作成** を選択してから、`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 `main` リポジトリの `MyDemoRepo` ブランチに追加され、パイプラインに含める準備ができています。

## ステップ 3: Amazon EC2 Linux インスタンスを作成して CodeDeploy エージェントをインストールする
<a name="codecommit-create-deployment"></a>

このステップでは、サンプルアプリケーションをデプロイする先の Amazon EC2 インスタンスを作成します。このプロセスの一環として、インスタンス上での CodeDeploy エージェントのインストールと管理を許可するインスタンスロールを作成します。CodeDeploy エージェントは、CodeDeploy デプロイでインスタンスを使用できるようにするソフトウェアパッケージです。また、CodeDeploy エージェントによってアプリケーションのデプロイに使用されるファイルを取得すること、SSM によって管理されることを、インスタンスに許可するポリシーをアタッチします。

**インスタンスロールを作成するには**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソール を開きます。

1. コンソールダッシュボードで [**ロール**] を選択します。

1. [**ロールの作成**] を選択してください。

1. [**信頼されたエンティティのタイプを選択**] で、[**AWS のサービス** ] を選択します。**[ユースケースの選択]** で、**[EC2]** を選択します。[**Select your use case (ユースケースを選択)**] で、[**EC2**] を選択します。**[Next: Permissions]** (次のステップ: 許可) を選択します。

1. **`AmazonEC2RoleforAWSCodeDeploy`** という名前のマネージドポリシーを検索して選択します。

1. **`AmazonSSMManagedInstanceCore`** という名前のマネージドポリシーを検索して選択します。[**Next: Tags (次へ: タグ)**] を選択します。

1. **[次へ: レビュー]** を選択します。ロールの名前を入力します (例: **EC2InstanceRole**)。
**注記**  
次のステップのロール名をメモしておきます。このロールは、インスタンスの作成時に選択します。

   [**ロールの作成**] を選択してください。

**インスタンスを起動するには**

1. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) を開いてください。

1. サイドナビゲーションから [**インスタンス**] を選択し、ページの上部から [**インスタンスの起動**] を選択します。

1. [**名前**] に「**MyCodePipelineDemo**」と入力します。これにより、インスタンスには**キー**が **Name** で、**値**が **MyCodePipelineDemo** というタグがが割り当てられます。後で、このインスタンスにサンプルアプリケーションをデプロイする CodeDeploy アプリケーションを作成します。CodeDeploy は、タグに基づいてデプロイするインスタンスを選択します。

1. **アプリケーションイメージと OS イメージ (Amazon マシンイメージ)** で、 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. [**インスタンス**] ページで、起動のステータスを表示できます。インスタンスを起動すると、その初期状態は `pending` です。インスタンスを起動した後は、状態が `running` に変わり、パブリック DNS 名を受け取ります ([**パブリック DNS**] 列が表示されていない場合は、[**表示/非表示**] アイコンを選択してから、[**パブリック DNS**] を選択します)。

## ステップ 4: CodeDeploy でアプリケーションを作成する
<a name="codecommit-create-codedeploy-app"></a>

CodeDeploy では、[https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) は、デプロイするソフトウェアアプリケーションを含むリソースです。後で、このアプリケーションを CodePipeline とともに使用して、サンプルアプリケーションの Amazon EC2 インスタンスへのデプロイを自動化します。

最初に、CodeDeploy がデプロイを実行できるようにするロールを作成します。次に、CodeDeploy アプリケーションを作成します。

**CodeDeploy サービスロールの作成するために**

1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソール を開きます。

1. コンソールダッシュボードで [**ロール**] を選択します。

1. [**ロールの作成**] を選択してください。

1. [**信頼されたエンティティを選択**] で、[**AWS のサービス**] を選択します。[**ユースケース**] で、[**CodeDeploy**] を選択します。示されたオプションから [**CodeDeploy**] を選択します。[**次へ**] を選択します。`AWSCodeDeployRole` マネージドポリシーはロールにアタッチ済みです。

1. [**次へ**] を選択します。

1. ロールの名前 (例: **CodeDeployRole**) を入力し、[**ロールの作成**] を選択します。

**CodeDeploy でアプリケーションを作成するには**

1. [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy) で、CodeDeploy コンソールを開きます。

1. [**アプリケーション**] ページが表示されない場合は、メニューで [**アプリケーション**] を選択します。

1. [**アプリケーションを作成**] を選択します。

1. [**アプリケーション名**] に、「**MyDemoApplication**」と入力します。

1. [**コンピューティングプラットフォーム**] で [**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. [**環境設定**] で、[**Amazon EC2 インスタンス**] を選択します。**キー** フィールドに **Name** と入力します。**値** フィールドに、(**MyCodePipelineDemo** のような) インスタンスのタグ付けに使用した名前を入力します。

1. ** AWS Systems Manager を使用したエージェント設定**で、**今すぐ を選択し、更新をスケジュール**します。これにより、インスタンスにエージェントがインストールされます。Linux インスタンスは既に SSM エージェントで設定されており、これから CodeDeploy エージェントで更新されます。

1. [**デプロイ設定**] で、[`CodeDeployDefault.OneAtaTime`] を選択します。

1. **ロードバランサー** で、**ロードバランシングの有効化** が選択されていないことを確認します。この例では、ロードバランサーを設定したり、ターゲットグループを選択したりする必要はありません。

1. **デプロイグループの作成** を選択します。

## ステップ 5: CodePipeline で最初のパイプラインを作成する
<a name="codecommit-create-pipeline"></a>

これで、最初のパイプラインを作成および実行する準備ができました。このステップでは、コードが CodeCommit リポジトリにプッシュされたときに自動的に実行されるパイプラインを作成します。

**CodePipeline でパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

   CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyFirstPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** の **[ソースプロバイダー]** で、**[CodeCommit]** を選択します。**リポジトリ名** で、[ステップ 1: CodeCommit リポジトリを作成する](#codecommit-create-repository) で作成した CodeCommit リポジトリの名前を選択します。[**ブランチ名**] で、[`main`] を選択し、[**次のステップ**] を選択します。

   リポジトリ名とブランチを選択すると、このパイプライン用に作成される Amazon CloudWatch Events ルールがメッセージに表示されます。

   [**Change detection options**] で、デフォルト値のままにします。これにより、CodePipelineはAmazon CloudWatch Events を使用して、ソースリポジトリの変更を検出できます。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、**[ビルドステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。[**次へ**] を選択します。
**注記**  
このチュートリアルでは、ビルドサービスを必要としないコードをデプロイするため、このステップは省略できます。ただし、インスタンスにデプロイする前にソースコードを構築する必要がある場合は、このステップで [CodeBuild](https://aws.amazon.com/codebuild/) を設定できます。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 6: デプロイステージの追加]** の **[デプロイプロバイダー]** で、**[CodeDeploy]** を選択します。[**アプリケーション名**] に、「**MyDemoApplication**」を選択します。[**デプロイグループ**] で、[**MyDemoDeploymentGroup**]、[**次のステップ**] の順に選択します。

1. **ステップ 7: **情報を確認してから、**パイプラインの作成**を選択します。

1. パイプラインは、作成後に実行を開始します。CodeCommit リポジトリからコードをダウンロードし、EC2 インスタンスへの CodeDeploy デプロイを作成します。CodePipeline サンプルが CodeDeploy デプロイで Amazon EC2 インスタンスにウェブページをデプロイするときに、進行状況と成功および失敗のメッセージを表示できます。  
![\[CodePipeline コンソールでの実行を開始したパイプラインのビュー\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/codepipeline-firstpipeline-codecommit-pol.png)

お疲れ様でした。CodePipeline で単純なパイプラインを作成しました。

次に、結果を確認します。

**パイプラインが正常に実行されたことを確認するには**

1. パイプラインの最初の進行状況を表示します。各ステージのステータスは、[**まだ実行はありません**] から [**進行中**] に変わり、その後、[**Succeeded** (成功)] または [**Failed** (失敗)] のいずれかに変わります。パイプラインの最初の実行は数分で完了します。

1. パイプラインのステータスが [**成功**] と表示されたら、[** デプロイ**] ステージのステータス領域で [**CodeDeploy **] を選択します。これにより、CodeDeploy コンソールが開きます。[**成功**] が表示されない場合は、「[CodePipeline のトラブルシューティング](troubleshooting.md)」を参照してください。

1.  [**Deployments (デプロイ)**] タブで、デプロイ ID を選択します。デプロイのページの [**Deployment lifecycle events (デプロイライフサイクルイベント)**] で、インスタンス ID を選択します。これにより、EC2 コンソールが開きます。

1. [**説明**] タブの [**パブリック DNS**] でアドレス (例: `ec2-192-0-2-1.us-west-2.compute.amazonaws.com`) をコピーし、ウェブブラウザのアドレスバーに貼り付けます。

   ダウンロードして CodeCommit リポジトリにプッシュしたサンプルアプリケーションのウェブページが表示されます。

ステージ、アクション、パイプラインの仕組みの詳細については、「[CodePipeline の概念 ](concepts.md)」を参照してください。

## ステップ 6: CodeCommit リポジトリ内のコードを変更する
<a name="codecommit-push-code"></a>

CodeCommit リポジトリのコードが変更されるとパイプラインが実行されるように設定されています。このステップでは、CodeCommit リポジトリ内のサンプル CodeDeploy アプリケーションのパートである HTML ファイルに変更を加えます。これらの変更をプッシュすると、パイプラインが再度実行され、変更内容は先ほどアクセスしたウェブアドレスに表示されます。

1. ディレクトリをローカルリポジトリに変更する:

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

1. テキストエディタを使用して、`index.html` ファイルを変更します。

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

1. `index.html` ファイルのコンテンツを変更して、背景色およびウェブページのテキストの一部を変更してから、ファイルを保存します。

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

1. 次のコマンドを一度に 1 つずつ実行して、変更をコミットして CodeCommit リポジトリにプッシュします。

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

   ```
   git push
   ```

**パイプラインが正常に実行されたことを確認するには**

1. パイプラインの最初の進行状況を表示します。各ステージのステータスは、[**まだ実行はありません**] から [**進行中**] に変わり、その後、[**Succeeded** (成功)] または [**Failed** (失敗)] のいずれかに変わります。パイプラインの実行は数分以内に完了します。

1. アクションステータスが [**成功**] と表示されたら、ブラウザで先ほどアクセスしたデモページを更新します。

   更新されたウェブページが表示されます。

## ステップ 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) を参照してください。
+ この詳細なチュートリアル「[チュートリアル: 4 ステージのパイプラインを作成する](tutorials-four-stage-pipeline.md)」をお試しください。デプロイ前にコードをビルドする手順を含むマルチステージパイプラインが作成されます。

# チュートリアル: 4 ステージのパイプラインを作成する
<a name="tutorials-four-stage-pipeline"></a>

これで、「[チュートリアル: シンプルなパイプラインを作成する (S3 バケット)](tutorials-simple-s3.md)」または「[チュートリアル: シンプルなパイプラインを作成する (CodeCommit リポジトリ)](tutorials-simple-codecommit.md)」に最初のパイプラインが作成されたため、より複雑なパイプラインを作成できるようになりました。このチュートリアルでは、4 ステージパイプラインを作成する方法について説明します。このパイプラインでは、ソースとして GitHub リポジトリを使用し、プロジェクトをビルドするための Jenkins ビルドサーバーおよびビルドしたコードをステージングサーバーにデプロイするための CodeDeploy アプリケーションを使用します。以下の図は初期の 3 ステージのパイプラインを示しています。

![\[ソースアクションを含むソースステージ、Jenkins アクションを含むビルドステージ、デプロイアクションを含むデプロイステージを示す図。\]](http://docs.aws.amazon.com/ja_jp/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 と統合するには、CodePipeline で使用する Jenkins のインスタンスに CodePipeline Plugin for Jenkins をインストール AWS CodePipeline する必要があります。また、専用の IAM ユーザーまたはロールを設定して、Jenkins プロジェクトと CodePipeline の間でアクセス許可を使用する必要があります。Jenkins と CodePipeline を統合する最も簡単な方法としては、Jenkins の統合用に作成した IAM インスタンスロールを使用する EC2 インスタンスに Jenkins をインストールします。Jenkins アクション用のパイプラインのリンクを正常に接続するには、Jenkins プロジェクトで使用するポートへのインバウンド接続を許可するように、サーバーまたは EC2 インスタンスのプロキシおよびファイアウォール設定を構成する必要があります。これらのポートに接続する前に、Jenkins でユーザーを認証してアクセス制御するように設定されていることを確認します (HTTPS 接続のみ使用できるように Jenkins のセキュリティを確保するには 443 および 8443、HTTP 接続できるようにするには 80 および 8080)。詳細については、「[Jenkins のセキュリティ確保](https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins)」を参照してください。

**注記**  
このチュートリアルでは、コードサンプルを使用して、Haml から HTML に変換するビルドステップを設定します。GitHub リポジトリからオープンソースのサンプルコードをダウンロードするには、「[サンプルのコピーまたはクローンを GitHub リポジトリに作成する](#tutorials-four-stage-pipeline-prerequisites-github)」のステップに従います。GitHub リポジトリ内の .zip ファイルだけではなく、sample 全体が必要です。  
このチュートリアルでは、以下を前提としています。  
Jenkins のインストールと管理および Jenkins プロジェクトの作成に慣れている
Ruby の Rake と Haml gem が、同一コンピュータ、または Jenkins プロジェクトをホストするインスタンス上にインストールされていること。
Rake コマンドを端末またはコマンドラインから実行できるように、必要なシステム環境変数が設定されていること (例えば、Windows システムで、Rake をインストールしたディレクトリが追加されるように PATH 変数を変更する)。

**Topics**
+ [

### サンプルのコピーまたはクローンを GitHub リポジトリに作成する
](#tutorials-four-stage-pipeline-prerequisites-github)
+ [

### Jenkins 統合に使用する IAM ロールを作成する
](#tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role)
+ [

### Jenkins および Jenkins 用 CodePipeline プラグインのインストールと設定
](#tutorials-four-stage-pipeline-prerequisites-jenkins-configure)

### サンプルのコピーまたはクローンを GitHub リポジトリに作成する
<a name="tutorials-four-stage-pipeline-prerequisites-github"></a>

**サンプルを複製して GitHub リポジトリにプッシュするには**

1. サンプルコードを GitHub リポジトリからダウンロードするか、リポジトリをローカルコンピュータに複製します。2 つのサンプルパッケージがあります。
   + サンプルを 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://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. **[Next: Permissions]** (次のステップ: 許可) を選択します。[**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)」、「[Amazon EC2 インスタンスで実行されるアプリケーションに IAM ロールを使用してアクセス許可を付与する](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html)」、「[AWS のサービスにアクセス許可を委任するロールの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html)」を参照してください。

### Jenkins および Jenkins 用 CodePipeline プラグインのインストールと設定
<a name="tutorials-four-stage-pipeline-prerequisites-jenkins-configure"></a>

**Jenkins および Jenkins 用 CodePipeline プラグインのインストールをするには、**

1. Jenkins をインストールする先の EC2 インスタンスを作成し、「**ステップ 3: インスタンスの詳細を設定する**」で、作成したインスタンスロール (*JenkinsAccess*など) を必ず選択します。EC2 インスタンス作成の詳細については、「[Amazon EC2 ユーザーガイド](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html)」の 「*Amazon EC2 インスタンスの起動*」を参照してください。
**注記**  
使用する Jenkins リソースがすでにある場合は、特別な IAM ユーザーを作成し、そのユーザーに `AWSCodePipelineCustomActionAccess` 管理ポリシーを適用してから、Jenkins リソースに対してそのユーザーのアクセス認証情報を設定して使用する必要があります。Jenkins UI を使用して認証情報を指定する場合は、HTTPS のみを許可するように Jenkins を設定します。詳細については、「[CodePipeline のトラブルシューティング](troubleshooting.md)」を参照してください。

1. EC2 インスタンスに Jenkins をインストールします。詳細については、Jenkins のドキュメントの「[Jenkins のインストール](https://www.jenkins.io/doc/book/installing/linux/)」と「[Jenkins の開始とアクセス](https://wiki.jenkins.io/JENKINS/Starting-and-Accessing-Jenkins.html)」のほか、「[CodePipeline との製品とサービスの統合](integrations.md)」の「[details of integration with Jenkins](integrations-action-type.md#JenkinsInt_2)」を参照してください。

1. Jenkins を起動し、ホーム ページで [**Manage Jenkins**] (Jenkins の管理) を選択します。

1. [**Jenkins の管理**] ページで、[**プラグインの管理**] を選択します。

1. [**Available**] タブを選択し、[**Filter**] 検索ボックスに「**AWS CodePipeline**」と入力します。リストから [**CodePipeline Plugin for Jenkins**] を選択し、次に [**ダウンロードして再起動後にインストール**] を選択します。

1. [**プラグイン/アップグレードのインストール**] ページで、[**インストール完了後、実行中のジョブがなければ Jenkins を再起動する**] を選択します。

1. [**ダッシュボードに戻る**] を選択します。

1. メインページで、[**New Item**] (新しい項目) を選択します。

1. [**Item Name**] に、Jenkins プロジェクトの名前 (*MyDemoProject* など) を入力します。[**Freestyle project**] (フリースタイルプロジェクト)、[**OK**] の順に選択します。
**注記**  
プロジェクトの名前が CodePipeline の要件を満たしていることを確認します。詳細については、「[AWS の CodePipeline 中のクォータ](limits.md)」を参照してください。

1. プロジェクトの設定ページで、[**Execute concurrent builds if necessary**] (必要な場合に複数のビルドを並列実行する) チェックボックスをオンにします。[**ソースコードの管理**] で、[**AWS CodePipeline**] を選択します。EC2 インスタンスに Jenkins をインストールし、CodePipeline と Jenkins の統合用に作成した IAM ユーザーのプロファイル AWS CLI で を設定した場合は、他のすべてのフィールドを空のままにします。

1. [**Advanced (詳細)**] を選択し、[**プロバイダ**] に、CodePipeline に表示されるアクションのプロバイダーの名前 (*MyJenkinsProviderName*など) を入力します。この名前が一意で覚えやすいものであることを確認します。このチュートリアルの後半でパイプラインにビルドアクションを追加するときと、テストアクションを追加するときに使用します。
**注記**  
このアクション名は、CodePipeline のアクションの命名要件を満たしている必要があります。詳細については、「[AWS の CodePipeline 中のクォータ](limits.md)」を参照してください。

1. [**Build Triggers**] (トリガーのビルド) で、チェックボックスをすべてオフにし、[**Poll SCM**] (SCM のポーリング) を選択します。[**Schedule**] に、以下のようにスペースで区切ってアスタリスクを 5 つ入力します。

   ```
   * * * * *
   ```

   これは 1 分ごとに CodePipeline をポーリングします。

1. [**ビルド**] で、[**Add build step**] (ビルドステップの追加) を選択します。[**シェルの実行**] (Amazon Linux、RHEL、または Ubuntu Server) [**バッチコマンドの実行**] (Windows Server) を選択し、次のように入力します。

   ```
   rake
   ```
**注記**  
rake の実行に必要な変数と設定が環境で定義されていることを確認します。定義されていないと、ビルドは失敗します。

1. [**Add post-build action**]、[**AWS CodePipeline Publisher**] の順に選択します。[**Add**] を選択し、[**Build Output Locations**] でこの場所は空白のままにします。この設定はデフォルトです。ビルドプロセスの最後に圧縮ファイルが作成されます。

1. [**保存**] を選択して、Jenkins プロジェクトを保存します。

## ステップ 2: CodePipeline でパイプラインを作成する
<a name="tutorials-four-stage-pipeline-pipeline-create"></a>

チュートリアルのこの部分では、[**Create Pipeline**] ウィザードを使用してパイプラインを作成します。

**CodePipeline 自動リリースプロセスを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. 必要に応じて、リージョンセレクターを使用し、パイプラインリソースの配置先のリージョンに切り替えます。例えば、前のチュートリアルでリソースを `us-east-2` に作成した場合は、リージョンセレクターを必ず米国東部 (オハイオ) に設定します。

   CodePipeline で使用できるリージョンとエンドポイントの詳細については、「[AWS CodePipeline エンドポイントとクォータ](https://docs.aws.amazon.com/general/latest/gr/codepipeline.html)」を参照してください。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。[**次へ**] を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** ページで、**[パイプライン名]** にパイプラインの名前を入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. [**サービスロール**] で、[**新しいサービスロール**] を選択して、CodePipeline の IAM でのサービスロールの作成を許可します。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページの **[ソースプロバイダー]** で、**[GitHub]** を選択します。

1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理するには、「[GitHub コネクション](connections-github.md)」を参照してください。

1. **[ステップ 4: ビルドステージ を追加する]** で、**[Jenkins の追加]** を選択します。[**プロバイダー名**]で、Jenkins の CodePipeline プラグインで指定したアクションの名前 (*MyJenkinsProviderName*など) を入力します。この名前は、Jenkins用の CodePipeline プラグインの名前と正確に一致する必要があります。[**サーバー URL**] に、Jenkins がインストールされている EC2 インスタンスの URL を入力します。[**プロジェクト名**] に、Jenkins で作成したプロジェクトの名前 (*MyDemoProject* など) を入力し、[**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. [**ステップ 6: デプロイステージの追加**] では、[チュートリアル: シンプルなパイプラインを作成する (S3 バケット)](tutorials-simple-s3.md) で作成した CodeDeploy アプリケーションおよびデプロイグループを再利用します。[**プロバイダをデプロイする**]で、[**CodeDeploy**] を選択します。[**アプリケーション名**] に「**CodePipelineDemoApplication**」と入力するか、更新ボタンを選択してリストからアプリケーション名を選択します。[**デプロイグループ**] に「**CodePipelineDemoFleet**」と入力するか、リストからデプロイグループを選択して [**次へ**] を選択します。
**注記**  
独自の 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)
+ [

#### 4 番目のステージを作成する
](#tutorials-four-stage-pipeline-create-fourth-stage)

#### インスタンスの IP アドレスを検索する
<a name="tutorials-four-stage-pipeline-instance-ip-lookup"></a>

**コードをデプロイしたインスタンスの IP アドレスを確認するには**

1. パイプラインのステータスが "**Succeeded**" と表示されたら、[Staging] ステージのステータス領域で [**詳細**] を選択します。

1. [**デプロイの詳細**] (デプロイの詳細) セクションの [**インスタンス ID**] で、正常にデプロイされたいずれかのインスタンスの ID を選択します。

1. インスタンスの IP アドレス (*192.168.0.4* など) をコピーします。この IP アドレスは Jenkins テストで使用します。

#### デプロイのテスト用に 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**] (必要な場合に複数のビルドを並列実行する) チェックボックスをオンにします。[**ソースコードの管理**] で、[**AWS CodePipeline**] を選択します。EC2 インスタンスに Jenkins をインストールし、CodePipeline と Jenkins の統合用に作成した IAM ユーザーのプロファイル AWS CLI で を設定した場合は、他のすべてのフィールドを空のままにします。
**重要**  
Jenkins プロジェクトを設定していて、それが Amazon EC2 インスタンスにインストールされていないか、Windows オペレーティングシステムを実行している EC2 インスタンスにインストールされている場合は、プロキシホストとポートの設定に従ってフィールドに入力し、Jenkins と CodePipeline の統合用に設定した IAM ユーザーまたはロールの認証情報を指定します。

1. [**詳細設定**] を選択してから、[**カテゴリ**] で [**テスト**] を選択します。

1. [**プロバイダ**] に、ビルドプロジェクトで使用したのと同じ名前 (*MyJenkinsProviderName* など) を入力します。この名前は、このチュートリアルの後半でパイプラインにテストアクションを追加するときに使用します。
**注記**  
この名前は、CodePipeline のアクションの命名要件を満たしている必要があります。詳細については、「[AWS の CodePipeline 中のクォータ](limits.md)」を参照してください。

1. [**Build Triggers**] (トリガーのビルド) で、チェックボックスをすべてオフにし、[**Poll SCM**] (SCM のポーリング) を選択します。[**Schedule**] に、以下のようにスペースで区切ってアスタリスクを 5 つ入力します。

   ```
   * * * * *
   ```

   これは 1 分ごとに CodePipeline をポーリングします。

1. [**ビルド**] で、[**Add build step**] (ビルドステップの追加) を選択します。Amazon Linux、RHEL、または Ubuntu Server インスタンスにデプロイする場合は、[**シェルの実行**] を選択します。次に、以下のように入力します。IP アドレスは、先ほどコピーした EC2 インスタンスのアドレスです。

   ```
   TEST_IP_ADDRESS=192.168.0.4 rake test
   ```

   Windows Server インスタンスにデプロイする場合は、[**Execute batch command (バッチコマンドの実行)**] を選択し、以下のように入力します。ここで、IP アドレスは、先ほどコピーした EC2 インスタンスのアドレスです。

   ```
   set TEST_IP_ADDRESS=192.168.0.4 rake test
   ```
**注記**  
このテストでは、デフォルトのポート 80 を想定しています。別のポートを指定する場合は、以下のように test port ステートメントを追加します。  

   ```
   TEST_IP_ADDRESS=192.168.0.4 TEST_PORT=8000 rake test
   ```

1. [**Add post-build action**]、[**AWS CodePipeline Publisher**] の順に選択します。[**追加**] は選択しないでください。

1. [**保存**] を選択して、Jenkins プロジェクトを保存します。

#### 4 番目のステージを作成する
<a name="tutorials-four-stage-pipeline-create-fourth-stage"></a>

**Jenkins テストアクションを含むステージをパイプラインに追加するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**名前**] で、作成したパイプラインの名前を選択します。

1. パイプライン詳細ページで、[**編集**] を選択します。

1. [**編集**] ページで [**\$1 Stage (\$1 ステージの追加)**] を選択して、ビルドステージの直後にステージを追加します。

1. 新しいステージの名前フィールドに名前 (**Testing** など) を入力し、[**\$1 Add action group (\$1 アクショングループの追加)**] を選択します。

1. [**アクション名**] に「*MyJenkinsTest-Action*」と入力します。[**テストプロバイダ**] で、Jenkins で指定したプロバイダ名 (*MyJenkinsProviderName* など) を選択します。[**プロジェクト名**] に、Jenkins で作成したプロジェクトの名前 (*MyTestProject* など) を入力します。[**入力アーティファクト**] で、デフォルト名が *BuildArtifact* の Jenkins ビルドからアーティファクトを選択し、[**完了**] を選択します。
**注記**  
Jenkins テストアクションは Jenkins ビルドステップで構築されたアプリケーションで動作するため、テストアクションへの入力アーティファクトのビルドアーティファクトを使用します。

   入力アーティファクトと出力アーティファクト、およびパイプラインの構造の詳細については、「[CodePipeline パイプライン構造リファレンス](reference-pipeline-structure.md)」を参照してください。

1. [**編集**] ページで、[**パイプラインの変更を保存**] を選択します。[**パイプラインの変更を保存**] ダイアログボックスで、[**保存して続行**] を選択します。

1. パイプラインに新しいステージが追加されましたが、パイプラインの別の実行をトリガーした変更がないため、そのステージのステータスは [**まだ実行はありません**] と表示されます。修正したパイプラインによりサンプルを実行するには、パイプラインの詳細ページで [**リリースの変更**] を選択します。

   パイプラインビューには、パイプラインのステージとアクション、それらの 4 つのステージを実行しているリビジョンの状態が表示されます。パイプラインがすべてのステージを実行するのにかかる時間は、アーティファクトのサイズ、ビルドとテストのアクションの複雑さ、その他の要因によって異なります。

## ステップ 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 ルールをセットアップし、パイプラインの状態の変更の E メール通知を送信します。
<a name="tutorials-cloudwatch-sns-notifications"></a>

でパイプラインを設定したら AWS CodePipeline、パイプラインの実行状態、またはパイプラインのステージやアクションに変更があるたびに通知を送信するように CloudWatch Events ルールを設定できます。CloudWatch Events を使用してパイプラインの状態の変更の通知をセットアップする方法の詳細は、[CodePipeline イベントのモニタリング](detect-state-changes-cloudwatch-events.md) を参照してください。

このチュートリアルでは、パイプラインの状態が失敗に変わったら E メールを送信する通知を設定します。このチュートリアルでは、CloudWatch Events ルールを作成するときの入力変換方法を使用します。メッセージスキーマの詳細を変換し、人間が読み取れるテキストでメッセージを配信します。

**注記**  
Amazon SNS 通知や CloudWatch Events ルールなど、このチュートリアルのリソースを作成するときは、リソースがパイプラインと同じ AWS リージョンに作成されていることを確認します。

**Topics**
+ [

## ステップ 1 : Amazon SNS を使用して E メール通知をセットアップします。
](#create-filter-for-target)
+ [

## ステップ 2: ルールを作成し SNS トピックをターゲットとして追加する
](#create-notification-rule)
+ [

## ステップ 3: リソースをクリーンアップする
](#notifications-clean-up-resources)

## ステップ 1 : Amazon SNS を使用して E メール通知をセットアップします。
<a name="create-filter-for-target"></a>

Amazon SNS は、トピックの使用を調整して、サブスクライブしているエンドポイントやクライアントへのメッセージを配信します。Amazon SNS を使用して通知トピックを作成してから、E メールアドレスを使用してトピックをサブスクライブします。Amazon SNS トピックが CloudWatch Events ルールにターゲットとして追加されます。詳細については、「[Amazon Simple Notification Service デベロッパーガイド](https://docs.aws.amazon.com/sns/latest/dg/)」を参照してください。

Amazon SNS でトピックを作成または識別します。CodePipeline は CloudWatch Events を使用して、Amazon SNS を介してこのトピックに通知を送信します。トピックを作成するには:

1. Amazon SNS コンソール（[https://console.aws.amazon.com/sns](https://console.aws.amazon.com/sns)）を開きます。

1. [**トピックの作成**] を選択します。

1. [**Create new topic (新しいトピックの作成)**] ダイアログボックスの [**Topic name (トピック名)**] で、トピックの名前 (例: **PipelineNotificationTopic**) を入力します。  
![\[Amazon SNS を使用して通知トピックを作成します。\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/tutorial-SNS-topic.png)

1. **[トピックを作成]** を選択します。

   詳細については、*Amazon SNS デベロッパーガイド* の [トピックの作成](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html) を参照してください。

1 つかそれ以上の受信者にトピックをサブスクライブさせ、E メール通知を受け取ります。受信者にトピックをサブスクライブさせるには:

1. Amazon SNS コンソールで、**トピック** リストから、新しいトピックの横にあるチェックボックスを選択します。[**Actions, Subscribe to topic**] を選択します。

1. [**Create subscription**] ダイアログボックスで、ARN が [**Topic ARN**] に表示されていることを確認します。

1. [**Protocol (プロトコル)**] として [**Email (E メール)**] を選択してください。

1. [**Endpoint**] に、新しい受信者の完全な E メールアドレスを入力します。

1. **[Create Subscription]** (サブスクリプションの作成) を選択します。

1. Amazon SNS は受信者にサブスクリプション確認の E メールを送信します。E メール通知を受信するには、受信者は、この E メールで [**サブスクリプションを確認**] リンクを選択する必要があります。受信者がリンクをクリックした後、正常にサブスクライブされたら、Amazon SNS により受信者のウェブブラウザに確認メッセージが表示されます。

   詳細については、*Amazon SNS デベロッパーガイド* の [トピックのサブスクライブ](https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html) を参照してください。

## ステップ 2: ルールを作成し SNS トピックをターゲットとして追加する
<a name="create-notification-rule"></a>

CodePipeline でイベント出典として CloudWatch Events 通知ルールを作成します。

1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。

1. ナビゲーションペインの **Events**] を選択します。

1. **Create rule** を選択します。[**イベントソース**] で、[**AWS CodePipeline**] を選択します。[**イベントタイプ**] で、**パイプライン実行の状態変更**を選択します。

1. [**特定の状態**] を選択し、[**FAILED**] を選択します。

1. [**編集**] を選択し、[**イベントパターンのプレビュー**] ペインで JSON テキストエディタを開きます。**pipeline** パラメータを、次の例 (「myPipeline」という名前のパイプライン) に示すように、パイプラインの名前とともに追加します。

   ここでイベントパターンをコピーしてコンソールに貼り付けることができます。

   ```
   {
     "source": [
       "aws.codepipeline"
     ],
     "detail-type": [
       "CodePipeline Pipeline Execution State Change"
     ],
     "detail": {
       "state": [
         "FAILED"
       ],
       "pipeline": [
         "myPipeline"
       ]
     }
   }
   ```

1. [**Targets**] で、[**Add target**] を選択します。

1. ターゲットのリストで、[**SNS トピック**] を選択します。[**トピック**] に、作成したトピックを入力します。

1. [**入力の設定**] を展開して、[**インプットトランスフォーマー**] を閉じます。

1. [**入力パス**] ボックスに、次のキーと値のペアを入力します。

   ```
   { "pipeline" : "$.detail.pipeline" }
   ```

   [**入力テンプレート**] ボックスに、以下のように入力します。

   ```
   "The Pipeline <pipeline> has failed."
   ```

1. [**詳細の設定**] を選択します。

1. [**ルールの詳細を設定する**] ページで、名前とオプションの説明を入力します。[**状態**] では、[**有効**] ボックスをオンのままにします。

1. **[‬ルールを作成]‭** を選択します。

1. CodePipeline が構築通知を現在送信していることを確認します。たとえば、ビルド通知 E メールが受信トレイにあるかどうかを確認します。

1. ルールの動作を変更するには、CloudWatch コンソールで、ルールを選択してから、**アクション**、**編集** の順に選択します。ルールを編集し、[**詳細設定**] を選択し、[**Update**] を選択します。

   ルールがビルド通知を送信するのを停止するには、CloudWatch コンソールで、ルールを選択してから、**アクション**、**無効化** を選択します。

   ルールを削除するには、 CloudWatch コンソールで、ルールを選択してから、**アクション**、**削除** の順に選択します。

## ステップ 3: リソースをクリーンアップする
<a name="notifications-clean-up-resources"></a>

これらのチュートリアルが完了したら、使用したパイプラインおよびリソースを削除する必要があるため、このリソースに対する継続利用料金がかかることはありません。

SNS 通知をクリーンアップして Amazon CloudWatch Events ルールを削除する方法については、[ クリーンアップ (Amazon SNSトピックからの退会)](https://docs.aws.amazon.com/sns/latest/dg/CleanUp.html) および [Amazon CloudWatch Events API リファレンス](https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/) の `DeleteRule` リファレンスを参照してください。

# チュートリアル: を使用して 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
   ```

## Device Farm テストを使用するように CodePipeline を設定します。
<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 マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

   1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

   1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。[**次へ**] を選択します。

   1. **[ステップ 2: パイプラインの設定を選択する]** ページで、**[パイプライン名]** にパイプラインの名前を入力します。

   1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

   1. [**サービスロール**] で、[**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. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

   1. **[ステップ 3: ソースステージの追加]** ページの **[ソースプロバイダー]** で、**[GitHub (GitHub アプリ経由)]** を選択します。

   1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理するには、「[GitHub コネクション](connections-github.md)」を参照してください。

   1. [**リポジトリ**] で、ソースリポジトリを選択します。

   1. [**ブランチ**] で、使用するブランチを選択します。

   1. ソースアクションの残りの設定はデフォルトのままにします。[**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、ビルドステージを追加します。

   1. **[プロバイダーを構築する]** で、**[その他のビルドプロバイダー]**、**[AWS CodeBuild]** の順に選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. **[プロジェクトを作成]** を選択します。

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。[**イメージ**] で、[**aws/codebuild/standard:5.0**] を選択します。

      CodeBuild は、Android Studio がインストールされているこの OS イメージを使用してアプリケーションを構築します。

   1. **サービスロール** で、既存の CodeBuild サービスロールを選択するか、新しいサービスロールを作成します。

   1. [**ビルド仕様**] で、[**Use a buildspec file (ビルド仕様ファイルの使用)**] を選択します。

   1. [**Continue to CodePipeline **] (CodePipeline に進む) を選択します。これにより、CodePipeline コンソールに戻り、設定用にリポジトリ内の `buildspec.yml` を使用する CodeBuild プロジェクトが作成されます。ビルドプロジェクトでは、サービスロールを使用して AWS のサービス のアクセス許可を管理します。このステップには数分かかる場合があります。

   1. [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 6: デプロイステージの追加]** ページで、**[デプロイステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。[**次へ**] を選択します。

1. **ステップ 7: 確認**で、**パイプラインの作成**を選択します。ソースとビルドステージを示す図が表示されます。

1. パイプラインに Device Farm テストアクションを追加します。

   1. 右上の [**編集**] を選択します。

   1. 図の最下部で [**\$1 Add stage]** (\$1 ステージの追加) を選択します。[**ステージ名**] に名前 (**Test** など) を入力します。

   1. [**\$1 Add action group (\$1 アクションの追加)**] を選択します。

   1. **[アクション名]** に名前を入力します。

   1. **アクションプロバイダ** で、**AWS Device Farm** を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. [**入力アーティファクト**] で、テストステージに先立つステージの出力アーティファクトと一致する入力アーティファクト (`BuildArtifact` など) を選択します。

       AWS CodePipeline コンソールでは、パイプライン図の情報アイコンにカーソルを合わせると、各ステージの出力アーティファクトの名前を確認できます。パイプラインでアプリケーションを [**ソース**] ステージから直接テストする場合は、[**SourceArtifact**] を選択します。パイプラインに [**ビルド**] ステージが含まれている場合は、[**BuildArtifact**] を選択します。

   1. **ProjectId** に、Device Farm プロジェクト ID を入力します。このチュートリアルの最初の手順に従い、プロジェクト ID を取得します。

   1. [**DevicePoolArn**] に、デバイスプールの ARN を入力します。上位デバイスの ARNs など、プロジェクトの使用可能なデバイスプール ARN を取得するには、 CLI AWS を使用して次のコマンドを入力します。

      ```
      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-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\$1FUZZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**注記**  
カスタム環境ノードはサポートされていません。

   1. 残りのフィールドにはテストおよびアプリケーションタイプに適した構成を入力します。

   1. (オプション) [**アドバンスト**] で、テストランの情報の設定を行います。

   1. **[保存]** を選択します。

   1. 編集中のステージで、[**完了**] を選択します。 AWS CodePipeline のペインで [**保存**] を選択し、警告メッセージで [**保存**] を選択します。

   1. 変更を送信してパイプラインのビルドを開始するには、**[変更をリリース]**、**[リリース]** の順に選択します。

# チュートリアル: で iOS アプリをテストするパイプラインを作成する AWS Device Farm
<a name="tutorials-codebuild-devicefarm-S3"></a>

 AWS CodePipeline を使用して、ソースバケットが変更されるたびにアプリをテストする継続的な統合フローを簡単に設定できます。このチュートリアルでは、S3 バケットからビルドした iOS アプリをテストするためのパイプラインを作成して設定する方法を示します。パイプラインは保存された変更の到着を Amazon CloudWatch Events を介して検出し、構築したアプリケーションをテストするために [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
   ```

## Device Farm テスト(例 Amazon S3) を使用するように CodePipeline を設定する
<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 マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

   1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

   1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。[**次へ**] を選択します。

   1. **[ステップ 2: パイプラインの設定を選択する]** ページで、**[パイプライン名]** にパイプラインの名前を入力します。

   1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

   1. [**サービスロール**] で、[**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. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

   1. **[ステップ 3: ソースステージの追加]** ページの **[ソースプロバイダー]** で、**[Amazon S3]** を選択します。

   1. [**Amazon S3 の場所**] に、.zip ファイルのバケット (`my-storage-bucket` など) とオブジェクトキー (`s3-ios-test-1.zip` など) を入力します。

   1. [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、パイプラインのプレースホルダービルドステージを作成します。これにより、ウィザードでパイプラインを作成することができます。ウィザードを使用して 2 ステージパイプラインを作成した後は、このプレースホルダービルドステージは不要になります。パイプラインが完了した後、この第 2 ステージが削除され、ステップ 5 で新しいテストステージが追加されます。

   

   1. [**ビルドプロバイダ**] で、[**Jenkins の追加**] を選択します。このビルド選択はプレースホルダーです。それは使用されていません。

   1. [**プロバイダ名**] に名前を入力します。名前はプレースホルダーです。それは使用されていません。

   1. [**サーバー URL**] にテキストを入力します。テキストはプレースホルダーです。それは使用されていません。

   1. [**プロジェクト名**] に名前を入力します。名前はプレースホルダーです。それは使用されていません。

   1. [**次へ**] を選択します。

   1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

      [**次へ**] を選択します。

   1. **[ステップ 6: デプロイステージの追加]** ページで、**[デプロイステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   1. **ステップ 7: 確認**で、**パイプラインの作成**を選択します。ソースとビルドステージを示す図が表示されます。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/codepipeline-view-pipeline-S3.png)

1. 次のようにして、Device Farm テストアクションをパイプラインに追加します。

   1. 右上の [**編集**] を選択します。

   1. [**Edit stage (ステージの編集)**] を選択します。**[削除]** を選択します。これにより、パイプライン作成のためには使用しないプレースホルダーステージが削除されます。

   1. 図の最下部で [**\$1 Add stage]** (\$1 ステージの追加) を選択します。

   1. [ステージ名] にステージ名 (Test など) を入力し、[**Add stage (ステージの追加)**] を選択します。

   1. [**\$1 Add action group (\$1 アクションの追加)**] を選択します。

   1. [**アクション名**] に、名前を入力します (DeviceFarmTest など)。

   1. **アクションプロバイダ** で、**AWS Device Farm** を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. [**入力アーティファクト**] で、テストステージに先立つステージの出力アーティファクトと一致する入力アーティファクト (`SourceArtifact` など) を選択します。

       AWS CodePipeline コンソールでは、パイプライン図の情報アイコンにカーソルを合わせると、各ステージの出力アーティファクトの名前を確認できます。パイプラインでアプリケーションを [**ソース**] ステージから直接テストする場合は、[**SourceArtifact**] を選択します。パイプラインに [**ビルド**] ステージが含まれている場合は、[**BuildArtifact**] を選択します。

   1. **ProjectId** で、Device Farm のプロジェクト ID を選択します。このチュートリアルの最初の手順に従い、プロジェクト ID を取得します。

   1. [**DevicePoolArn**] に、デバイスプールの ARN を入力します。上位デバイスの ARNs など、プロジェクトの使用可能なデバイスプール ARN を取得するには、 CLI AWS を使用して次のコマンドを入力します。

      ```
      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. [**デプロイ**] に、コンパイルされたアプリケーションパッケージのパスを入力します。パスは、テストステージの入力アーティファクトのルートを基準とする相対パスです。このパスは `ios-test.ipa` に似ています。

   1. **TestType** にテストのタイプを入力し、**Test** にテスト定義ファイルのパスを入力します。パスは、テストの入力アーティファクトのルートに関連します。

      Device Farm の組み込みテストのいずれかを使用している場合は、BUILTIN\$1FUZZ など Device Farm プロジェクトに設定されたテストのタイプを入力します。[**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\$1FUZZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**注記**  
カスタム環境ノードはサポートされていません。

   1. 残りのフィールドにはテストおよびアプリケーションタイプに適した構成を入力します。

   1. (オプション) [**アドバンスト**] で、テストランの情報の設定を行います。

   1. **[保存]** を選択します。

   1. 編集中のステージで、[**完了**] を選択します。 AWS CodePipeline のペインで [**保存**] を選択し、警告メッセージで [**保存**] を選択します。

   1. 変更を送信してパイプラインの実行を開始するには、[**変更のリリース**]、[**リリース**] の順に選択します。

# チュートリアル: 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 がパイプラインのソースプロバイダーである場合、すべてのソースファイルを 1 つの .zip ファイルとしてパッケージ化してバケットにアップロードする必要があります。それ以外の場合、ソースアクションは失敗します。

まず Service Catalog で製品を作成し、次に AWS CodePipelineでパイプラインを作成します。このチュートリアルでは、デプロイ設定を指定するための 2 つのオプションを取り上げます。
+ Service Catalog で製品を作成し、テンプレートファイルをソースリポジトリにアップロードします。(個別の設定ファイルではなく) CodePipeline コンソールで製品バージョンとデプロイ設定を指定します。「[オプション 1: 設定ファイルを使用しないで Service Catalog にデプロイする](#tutorials-S3-servicecatalog-ex1-configure)」を参照してください。
**注記**  
テンプレートファイルは YAML または JSON 形式で作成できます。
+ Service Catalog で製品を作成し、テンプレートファイルをソースリポジトリにアップロードします。個別の設定ファイルを使用して製品バージョンとデプロイ設定を指定します。「[オプション 2: 設定ファイルを使用して Service Catalog にデプロイする](#tutorials-S3-servicecatalog-ex2-configure)」を参照してください。

## オプション 1: 設定ファイルを使用しないで Service Catalog にデプロイする
<a name="tutorials-S3-servicecatalog-ex1-configure"></a>

この例では、S3 バケットのサンプル AWS CloudFormation テンプレートファイルをアップロードし、Service Catalog で製品を作成します。次に、CodePipeline コンソールで、パイプラインを作成し、デプロイ設定を指定します。

### ステップ 1: サンプルテンプレートファイルをソースリポジトリにアップロードする
<a name="tutorials-S3-servicecatalog-configure"></a>

1. テキストエディタを開きます。以下のコードをファイルに貼り付けて、サンプルテンプレートを作成します。`S3_template.json` という名前でファイルを保存します。

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the resources used if you create a stack from this template.",
     "Resources": {
       "S3Bucket": {
         "Type": "AWS::S3::Bucket",
         "Properties": {}
       }
     },
     "Outputs": {
       "BucketName": {
         "Value": {
           "Ref": "S3Bucket"
         },
         "Description": "Name of Amazon S3 bucket to hold website content"
       }
     }
   }
   ```

   このテンプレートにより AWS CloudFormation 、 は Service Catalog で使用できる S3 バケットを作成できます。

1. `S3_template.json` ファイルを AWS CodeCommit リポジトリにアップロードします。

### ステップ 2: Service Catalog で製品を作成する
<a name="tutorials-S3-servicecatalog-product"></a>

1. IT 管理者として、Service Catalog コンソールにサインインし、[**製品**] ページに移動して、[**新しい製品のアップロード**] を選択します。

1. [**新しい製品のアップロード**] ページで、以下の手順を実行します。

   1. [**製品名**] に、新しい製品に使用する名前を入力します。

   1. [**Description (説明)**] に製品カタログの説明を入力します。この説明は、製品リストでユーザーが正しい製品を選択できるように表示されます。

   1. [**提供元**] に IT 部門または管理者の名前を入力します。

   1. [**次へ**] を選択します。

1. (オプション) [**サポート詳細の入力**] に製品サポートの連絡先情報を入力し、[**次へ**] を選択します。

1. [**バージョンの詳細**] に以下の情報を入力します。

   1. [**Upload a template file（テンプレートファイルをアップロード）**] を選択します。`S3_template.json` ファイルを見つけ、アップロードします。

   1. [**バージョンタイトル**] に、製品バージョンの名前 (**devops S3 v2** など) を入力します。

   1. [**Description (説明)**] に、このバージョンと他のバージョンを区別するための詳細を入力します。

   1. [**次へ**] を選択します。

1. [**確認**] ページで、情報が正しいことを確認し、[**作成**] を選択します。

1. ブラウザの [**製品**] ページで、新しい製品の URL をコピーします。これには製品 ID が含まれています。この製品 ID をコピーして保持します。CodePipeline でパイプラインを作成するときに、それを使用します。

   以下に示しているのは、`my-product` という製品の URL です。製品 ID を抽出するには、等号 (`=`) とアンパサンド (`&`) との間の値をコピーします。この例では、製品 ID は `prod-example123456` です。

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**注記**  
ページから移動する前に、製品の URL をコピーします。このページから移動したら、CLI を使用して製品 ID を取得する必要があります。

   数秒後、製品が [**製品**] ページに表示されます。製品をリストに表示するには、ブラウザの更新が必要になる場合があります。

### ステップ 3: パイプラインを作成する
<a name="tutorials-S3-servicecatalog-pipeline"></a>

1. パイプラインに名前を付け、パイプラインのパラメータを選択するには、以下の手順を実行します。

   1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

   1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

   1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。[**次へ**] を選択します。

   1. **[ステップ 2: パイプラインの設定を選択する]** ページで、**[パイプライン名]** にパイプラインの名前を入力します。

   1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

   1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

   1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページにソースステージを追加するには、以下を行います。

   1. [**ソースプロバイダ**] で、**AWS CodeCommit** を選択します。

   1. [**リポジトリ名**] と [**ブランチ名**] に、ソースアクションに使用するリポジトリとブランチを入力します。

   1. [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、**[ビルドステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 6: デプロイステージの追加]** で、以下の手順を実行します。

   1. [**デプロイプロバイダ**] で、[**AWS Service Catalog**] を選択します。

   1. デプロイ設定で、[**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/ja_jp/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 デプロイパラメータ/設定を定義するために使用されます。パイプラインを作成するときに、このファイルを使用します。

   このサンプルでは、`ProductVersionName` を「devops S3 v2」、`ProductVersionDescription` を `MyProductVersionDescription` としています。テンプレートの変更を新しい製品バージョンにデプロイする場合は、同じ製品の以前の製品バージョンで使用されていない製品バージョン名を入力するだけです。

    `sample_config.json` という名前でファイルを保存します。

   ```
   {
       "SchemaVersion": "1.0",
       "ProductVersionName": "devops S3 v2",
       "ProductVersionDescription": "MyProductVersionDescription",
       "ProductType": "CLOUD_FORMATION_TEMPLATE",
       "Properties": {
           "TemplateFilePath": "/S3_template.json"
       }
   }
   ```

   このファイルにより、パイプラインが実行されるたびに製品バージョン情報が作成されます。

1. `sample_config.json` ファイルを AWS CodeCommit リポジトリにアップロードします。必ずこのファイルはソースリポジトリにアップロードしてください。

### ステップ 3: Service Catalog で製品を作成する
<a name="tutorials-S3-servicecatalog-product2"></a>

1. IT 管理者として、Service Catalog コンソールにサインインし、[**製品**] ページに移動して、[**新しい製品のアップロード**] を選択します。

1. [**新しい製品のアップロード**] ページで、以下の手順を実行します。

   1. [**製品名**] に、新しい製品に使用する名前を入力します。

   1. [**Description (説明)**] に製品カタログの説明を入力します。この説明は製品リストに表示されて、ユーザーが正しい製品を選択するのに役立ちます。

   1. [**提供元**] に IT 部門または管理者の名前を入力します。

   1. [**次へ**] を選択します。

1. (オプション) [**サポート詳細の入力**] に、製品サポートの連絡先情報を入力し、[**次へ**] を選択します。

1. [**バージョンの詳細**] に以下の情報を入力します。

   1. [**Upload a template file（テンプレートファイルをアップロード）**] を選択します。`S3_template.json` ファイルを見つけ、アップロードします。

   1. [**バージョンタイトル**] に製品バージョンの名前 (devops S3 v2 など) を入力します。

   1. [**Description (説明)**] に、このバージョンと他のバージョンを区別するための詳細を入力します。

   1. [**次へ**] を選択します。

1. [**Review (確認)**] ページで、情報が正しいことを確認し、[**Confirm and upload (確認してアップロード)**] を選択します。

1. ブラウザの [**製品**] ページで、新しい製品の URL をコピーします。これには製品 ID が含まれています。この製品 ID をコピーして保持します。CodePipeline でパイプラインを作成するときに使用します。

   以下に示しているのは、`my-product` という製品の URL です。製品 ID を抽出するには、等号 (`=`) とアンパサンド (`&`) との間の値をコピーします。この例では、製品 ID は `prod-example123456` です。

   ```
   https://<region-URL>/servicecatalog/home?region=<region>#/admin-products?productCreated=prod-example123456&createdProductTitle=my-product
   ```
**注記**  
ページから移動する前に、製品の URL をコピーします。このページから移動したら、CLI を使用して製品 ID を取得する必要があります。

   数秒後、製品が [**製品**] ページに表示されます。製品をリストに表示するには、ブラウザの更新が必要になる場合があります。

### ステップ 4: パイプラインを作成する
<a name="tutorials-S3-servicecatalog-pipeline2"></a>

1. パイプラインに名前を付け、パイプラインのパラメータを選択するには、以下の手順を実行します。

   1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

   1. [**開始方法**] を選択します。[**パイプラインの作成**] を選択し、パイプラインの名前を入力します。

   1. ** サービスロール ** で、**新しいサービスロール** を選択し、CodePipeline に IAM でのサービスロールの作成を許可します。

   1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. ソースステージを追加するには、以下の手順を実行します。

   1. [**ソースプロバイダ**] で、**AWS CodeCommit** を選択します。

   1. [**リポジトリ名**] と [**ブランチ名**] に、ソースアクションに使用するリポジトリとブランチを入力します。

   1. [**次へ**] を選択します。

1. [**Add build stage (ビルドステージの追加)**] で [**Skip build stage (ビルドステージのスキップ)**] を選択し、もう一度 [**スキップ**] を選択して警告メッセージを受け入れます。

1. [**Add deploy stage (デプロイステージの追加)**] で、以下の手順を実行します。

   1. [**デプロイプロバイダ**] で、[**AWS Service Catalog**] を選択します。

   1. [**設定ファイルの使用**] を選択します。

   1. [**プロダクト ID**] に、Service Catalog コンソールからコピーしたプロダクト ID を貼り付けます。

   1. [**Configuration file path (設定ファイルのパス)**] に、リポジトリ内の設定ファイルのファイルパスを入力します。

   1. [**次へ**] を選択します。

1. [**確認**] で、パイプライン設定を確認し、[**作成**] を選択します。

1. パイプラインが正常に実行されたら、デプロイステージで [**詳細**] を選択して、製品を Service Catalog で開きます。  
![\[\]](http://docs.aws.amazon.com/ja_jp/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 デプロイステージの 2 つのステージパイプラインになります。

**前提条件**:

 AWS CloudFormation サンプルテンプレートで使用するには、次のリソースを作成しておく必要があります。
+ ソースリポジトリを作成しておく必要があります。で作成した AWS CodeCommit リポジトリを使用できます[チュートリアル: シンプルなパイプラインを作成する (CodeCommit リポジトリ)](tutorials-simple-codecommit.md)。
+ CodeDeploy アプリケーションとデプロイグループを作成しておく必要があります。[チュートリアル: シンプルなパイプラインを作成する (CodeCommit リポジトリ)](tutorials-simple-codecommit.md) で作成したCodeDeploy リソースを使用できます。
+ パイプラインを作成するためのサンプル AWS CloudFormation テンプレートファイルをダウンロードするには、次のいずれかのリンクを選択します。[YAML](samples/codepipeline-codecommit-events-yaml.zip) \$1 [JSON](samples/codepipeline-codecommit-events-json.zip)

  ファイルを解凍し、ローカルコンピュータに配置します。
+ [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) サンプルアプリケーションファイルをダウンロードします。



**でパイプラインを作成する AWS CloudFormation**

1. [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) からファイルを解凍し、リポジトリにアップロードします AWS CodeCommit 。解凍したファイルをリポジトリのルートディレクトリにアップロードする必要があります。「[ステップ 2: CodeCommit リポジトリにサンプルコードを追加する](tutorials-simple-codecommit.md#codecommit-add-code)」の指示に従って、ファイルをリポジトリにプッシュできます。

1.  AWS CloudFormation コンソールを開き、**スタックの作成**を選択します。**[With new resources (standard)]** (新しいリソースの使用 (標準)) を選択します。

1. [**テンプレートの指定**] で、[**テンプレートのアップロード**] を選択します。[**ファイルを選択**] を選択し、ローカルコンピュータからテンプレートファイルを選択します。[**次へ**] を選択します。

1. [**スタック名**] に、パイプラインの名前を入力します。サンプルテンプレートで指定されたパラメータが表示されます。以下のパラメータを入力します。

   1. **ApplicationName** に、CodeDeploy アプリケーションの名前を入力します。

   1. **BetaFleet** に CodeDeploy デプロイグループの名前を入力します。

   1. [**BranchName**] に、使用するリポジトリブランチを入力します。

   1. **RepositoryName** に CodeCommit サービスリポジトリの名前を入力します。

1. [**次へ**] を選択します。以下のページのデフォルト値を受け入れ、[**次へ**] を選択します。

1. **「機能**」で、 **が IAM リソースを作成する AWS CloudFormation 可能性があることを確認し**、**「スタックの作成**」を選択します。

1. スタックの作成が完了したら、イベントリストを表示して、エラーがないか確認します。

   **トラブルシューティング**

   でパイプラインを作成する IAM ユーザーには、パイプラインのリソースを作成するための追加のアクセス許可が必要になる AWS CloudFormation 場合があります。が CodeCommit パイプラインに必要な Amazon CloudWatch Events リソースを作成できるようにするには AWS CloudFormation 、ポリシーで次のアクセス許可が必要です。

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

   [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。
**注記**  
作成されたパイプラインを表示するには、 CloudFormationのスタックの [**リソース**] タブで [**論理 ID**] 列を見つけます。パイプラインの [**物理 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 デプロイステージの 2 つのステージパイプラインになります。

**前提条件**:

 AWS CloudFormation サンプルテンプレートで使用するには、次のリソースが必要です。
+ Amazon EC2 インスタンスを作成して CodeDeploy エージェントをインスタンスにインストールしておく必要があります。CodeDeploy アプリケーションとデプロイグループを作成しておく必要があります。[チュートリアル: シンプルなパイプラインを作成する (CodeCommit リポジトリ)](tutorials-simple-codecommit.md) で作成した Amazon EC2 リソースと CodeDeploy リソースを使用します。
+ 次のリンクを選択して、Amazon S3 ソースでパイプラインを作成するためのサンプル AWS CloudFormation テンプレートファイルをダウンロードします。
  + パイプラインのサンプルテンプレートをダウンロードする: [YAML](samples/codepipeline-s3-events-yaml.zip) \$1 [JSON](samples/codepipeline-s3-events-json.zip)
  + CloudTrail バケットおよび証跡のサンプルテンプレート ([YAML](samples/codepipeline-s3-cloudtrail-yaml.zip) \$1 [JSON](samples/codepipeline-s3-cloudtrail-json.zip)) をダウンロードします。
  + ファイルを解凍し、ローカルコンピュータに配置します。
+ [SampleApp\$1Linux.zip](samples/SampleApp_Linux.zip) からサンプルアプリケーションファイルをダウンロードします。

  .zip ファイルをローカルコンピューターに保存します。スタックの作成後、.zip ファイルをアップロードします。

**でパイプラインを作成する AWS CloudFormation**

1.  AWS CloudFormation コンソールを開き、**スタックの作成**を選択します。**[With new resources (standard)]** (新しいリソースの使用 (標準)) を選択します。

1. [**テンプレートの選択**] で、[**テンプレートのアップロード**] を選択します。[**ファイルの選択**] を選択し、ローカルコンピュータからテンプレートファイルを選択します。[**次へ**] を選択します。

1. [**スタック名**] に、パイプラインの名前を入力します。サンプルテンプレートで指定されたパラメータが表示されます。以下のパラメータを入力します。

   1. **ApplicationName** に、CodeDeploy アプリケーションの名前を入力します。`DemoApplication` デフォルト名は置き換えることができます。

   1. **BetaFleet** に CodeDeploy デプロイグループの名前を入力します。`DemoFleet` デフォルト名は置き換えることができます。

   1. [**SourceObjectKey**] に `SampleApp_Linux.zip` と入力します。このファイルは、テンプレートによってバケットとパイプラインが作成された後に、バケットにアップロードします。

1. [**次へ**] を選択します。以下のページのデフォルト値を受け入れ、[**次へ**] を選択します。

1. **「機能**」で、 **が IAM リソースを作成する AWS CloudFormation 可能性があることを確認し**、**「スタックの作成**」を選択します。

1. スタックの作成が完了したら、イベントリストを表示して、エラーがないか確認します。

   **トラブルシューティング**

   でパイプラインを作成している IAM ユーザーには、パイプラインのリソースを作成するための追加のアクセス許可が必要になる AWS CloudFormation 場合があります。が Amazon S3 パイプラインに必要な Amazon CloudWatch Events リソースを作成できるようにするには AWS CloudFormation 、ポリシーで次のアクセス許可が必要です。 Amazon S3 

   ```
   {
        "Effect": "Allow",
        "Action": [
           "events:PutRule",
           "events:PutEvents",
           "events:PutTargets",
           "events:DeleteRule",
           "events:RemoveTargets",
           "events:DescribeRule"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. スタックの**リソース**タブ CloudFormationで、スタック用に作成されたリソースを表示します。
**注記**  
作成されたパイプラインを表示するには、 CloudFormationのスタックの [**リソース**] タブで [**論理 ID**] 列を見つけます。パイプラインの [**物理 ID**] 列の名前をメモします。CodePipeline で、スタックを作成したリージョン内の同じ物理 ID (パイプライン名) のパイプラインを表示できます。

   名前に `sourcebucket` ラベルが付いた S3 バケットを選択します (`s3-cfn-codepipeline-sourcebucket-y04EXAMPLE.` など)。パイプラインアーティファクトバケットは選択しないでください。

   リソースは CloudFormationによって新しく作成されたため、ソースバケットは空です。Amazon S3 コンソールを開き、`sourcebucket` バケットを見つけます。[**アップロード**] を選択し、指示に従って `SampleApp_Linux.zip` .zip ファイルをアップロードします。
**注記**  
Amazon S3 がパイプラインのサービスプロバイダである場合、すべてのサービスファイルを 1 つの .zip ファイルとしてパッケージ化したバケットにアップロードする必要があります。それ以外の場合、ソースアクションは失敗します。

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

   [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

1.  AWS CloudTrail リソースを作成するには、以下の手順を実行します。

**で AWS CloudTrail リソースを作成する AWS CloudFormation**

1.  AWS CloudFormation コンソールを開き、**スタックの作成**を選択します。

1. [**テンプレートの選択**] で、[**テンプレートを Amazon S3 にアップロード**] を選択します。**参照**を選択し、ローカルコンピュータから AWS CloudTrail リソースのテンプレートファイルを選択します。[**次へ**] を選択します。

1. [**スタックの名前**] にリソーススタックの名前を入力します。サンプルテンプレートで指定されたパラメータが表示されます。以下のパラメータを入力します。

   1. **SourceObjectKey** では、サンプルアプリケーションの zip ファイルのデフォルトを受け入れます。

1. [**次へ**] を選択します。以下のページのデフォルト値を受け入れ、[**次へ**] を選択します。

1. **「機能**」で、 **が IAM リソースを作成する AWS CloudFormation 可能性があることを確認し**、**「作成**」を選択します。

1. スタックの作成が完了したら、イベントリストを表示して、エラーがないか確認します。

   が Amazon S3 パイプラインに必要な CloudTrail リソースを作成できるようにするには AWS CloudFormation 、ポリシーで次のアクセス許可が必要です。

   ```
   {
        "Effect": "Allow",
        "Action": [
           "cloudtrail:CreateTrail",
           "cloudtrail:DeleteTrail",
           "cloudtrail:StartLogging",
           "cloudtrail:StopLogging",
           "cloudtrail:PutEventSelectors"
        ],
        "Resource": "resource_ARN"
   }
   ```

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

   [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

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. 次の例では、テンプレートの `Parameters` セクションに次の `Purpose:` パラメータを追加します。

      ```
        Purpose:
          Type: String
          Default: testing
          AllowedValues:
            - testing
            - production
          Description: The purpose of this instance.
      ```

   1. 次の例では、テンプレートの `Outputs:` セクションに次の `StackName` 出力を追加します。

      ```
        StackName:
          Value: !Ref AWS::StackName
      ```

1. テンプレートファイルを AWS CodeCommit リポジトリにアップロードします。解凍および編集したテンプレートファイルを、リポジトリのルートディレクトリにアップロードする必要があります。

    CodeCommit コンソールを 使用して、ファイルをアップロードします。

   1. CodeCommit コンソールを開き、**リポジトリ** リストから自分のリポジトリを選択します。

   1. [**Add file**]、[**Upload file**] の順に選択します。

   1. [**ファイルの選択**] を選択し、ファイルを参照します。ユーザー名とメールアドレスを入力して、変更をコミットします。**[Commit changes]** (変更のコミット) を選択します。

   ファイルは、リポジトリのルートレベルに次のように表示されます。

   ```
   documentdb_full_stack.yaml
   ```

## ステップ 2: パイプラインを作成する
<a name="tutorials-cloudformation-action-pipeline"></a>

このセクションでは、次のアクションを使用してパイプラインを作成します。
+ ソースアーティファクトがテンプレートファイルである CodeCommit アクションを含むソースステージ。
+ デプロイアクションを含む CloudFormation デプロイステージ。

ウィザードによって作成されたソースステージとデプロイステージの各アクションには、変数の名前空間として `SourceVariables`、`DeployVariables` がそれぞれ割り当てられます。アクションには名前空間が割り当てられるため、この例で設定した変数はダウンストリームアクションで使用可能になります。詳細については、「[変数リファレンス](reference-variables.md)」を参照してください。

**ウィザードを使用してパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyCFNDeployPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. [**Service role (サービスロール)**] で、次のいずれかの操作を行います。
   + **新しいサービスロール** を選択して、CodePipeline に IAM でのサービスロールの作成を許可します。
   + [**Existing service role (既存のサービスロール)**] を選択します。[**ロール名**] で、リストからサービスロールを選択します。

1. **アーティファクトストア**: 

   1. パイプライン用に選択したリージョンのパイプラインに、デフォルトとして指定された Amazon S3 アーティファクトバケットなどのデフォルトのアーティファクトストアを使用するには、**デフォルトの場所** を選択します。

   1. Amazon S3 アーティファクトバケットなどのアーティファクトストアがパイプラインと同じリージョンに既に存在する場合は、**カスタムの場所** を選択します。
**注記**  
これはソースコードのソースバケットではありません。パイプラインのアーティファクトストアです。パイプラインごとに S3 バケットなどの個別のアーティファクトストアが必要です。パイプラインを作成または編集するときは、パイプラインリージョンにアーティファクトバケットと、アクションを実行している AWS リージョンごとに 1 つのアーティファクトバケットが必要です。  
詳細については、「[入力および出力アーティファクト](welcome-introducing-artifacts.md)」および「[CodePipeline パイプライン構造リファレンス](reference-pipeline-structure.md)」を参照してください。

   [**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** で、次の操作を行います。

   1. [**ソースプロバイダ**] で、**AWS CodeCommit** を選択します。

   1. **リポジトリ名** で、[ステップ 1: CodeCommit リポジトリを作成する](tutorials-simple-codecommit.md#codecommit-create-repository) で作成した CodeCommit リポジトリの名前を選択します。

   1. [**Branch name**] で、最新のコード更新を含むブランチの名前を選択します。

   リポジトリ名とブランチを選択した後、このパイプライン用に作成される Amazon CloudWatch Events ルールが表示されます。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、**[ビルドステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **ステップ 6: デプロイステージの追加**:

   1. [**アクション名**] で、[**デプロイ**] をクリックします。[**デプロイプロバイダー**] で、[**CloudFormation**] を選択します。

   1. [**アクションモード**] で、[**スタックを作成または更新する**] をクリックします。

   1. [**スタック名**] に、スタックの名前を入力します。これは、テンプレートが作成するスタックの名前です。

   1. [**出力ファイル名**] に、出力ファイルの名前 (**outputs** など) を入力します。これは、スタックの作成後にアクションによって作成されるファイルの名前です。

   1. [**Advanced**] を展開します。[**パラメータの上書き**] で、テンプレートの上書きをキーと値のペアとして入力します。例えば、このテンプレートには、次の上書きが必要です。

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "testing"}
      ```

      上書きを入力しない場合、テンプレートはスタックをデフォルト値で作成します。

   1. [**次へ**] を選択します。

   1. **ステップ 7: 確認**で、**パイプラインの作成**を選択します。パイプラインステージを示す図が表示されます。パイプラインの実行を許可します。2 つのステージで構成されたパイプラインが完成し、他のステージを追加する準備が整いました。

## ステップ 3: CloudFormation デプロイアクションを追加して変更セットを作成する
<a name="tutorials-cloudformation-action-changeset"></a>

手動承認アクションの前に CloudFormation が変更セットを作成できるようにする次のアクションをパイプラインに作成します。



1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

   [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

1. [**編集**] モードで、パイプラインを編集するか、引き続きパイプラインを表示するかを選択します。

1. **デプロイ**ステージを編集することを選択します。

1. 前のアクションで作成したスタックに対する変更セットを作成するデプロイアクションを追加します。このアクションは、ステージ内の既存のアクションの後に追加します。

   1. [**アクション名**] に、「**Change\$1Set**」と入力します。[**アクションプロバイダー**] で、[**AWS CloudFormation **] を選択します。

   1. [**入力アーティファクト**] で、[**SourceArtifact**] を選択します。

   1. **[Action mode]** (アクションモード) で **[Create or replace a change set]** (変更セットの作成または置換) を選択します。

   1. [**スタック名**] に、次のように変数の構文を入力します。これは、変更セットを作成する対象のスタックの名前です。アクションには、デフォルトの名前空間 `DeployVariables` が割り当てられます。

      ```
      #{DeployVariables.StackName}
      ```

   1. [**変更セット名**] に、変更セットの名前を入力します。

      ```
      my-changeset
      ```

   1. [**パラメータの上書き**] で、`Purpose` パラメータを `testing` から `production` に変更します。

      ```
      {
      "DBClusterName": "MyDBCluster",
      "DBInstanceName": "MyDBInstance",
      "MasterUser": "UserName",
      "MasterPassword": "Password",
      "DBInstanceClass": "db.r4.large",
      "Purpose": "production"}
      ```

   1. [**完了**] をクリックしてアクションを保存します。

## ステップ 4: 手動承認アクションを追加する
<a name="tutorials-cloudformation-action-approval"></a>

パイプラインで手動承認アクションを作成します。



1. [**編集**] モードで、パイプラインを編集するか、引き続きパイプラインを表示するかを選択します。

1. **デプロイ**ステージを編集することを選択します。

1. 変更セットを作成するデプロイアクションの後に、手動承認アクションを追加します。このアクションにより、パイプラインが変更セットを実行する CloudFormation 前に、 で作成されたリソース変更セットを確認できます。

## ステップ 5: 変更セットを実行するための CloudFormation デプロイアクションを追加する
<a name="tutorials-cloudformation-action-deployment"></a>

手動承認アクションの後に CloudFormation が変更セットを実行できるようにする次のアクションをパイプラインに作成します。



1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

   [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

1. [**編集**] モードで、パイプラインを編集するか、引き続きパイプラインを表示するかを選択します。

1. **デプロイ**ステージを編集することを選択します。

1. 前の手動アクションで承認した変更セットを実行するデプロイアクションを追加します。

   1. [**アクション名**] に、「**Execute\$1Change\$1Set**」と入力します。[**アクションプロバイダー**] で、[**AWS CloudFormation** ] を選択します。

   1. [**入力アーティファクト**] で、[**SourceArtifact**] を選択します。

   1. **[Action mode]** (アクションモード) で、 **[Execute a change set]** (変更セットの実行) を選択します。

   1. [**スタック名**] に、次のように変数の構文を入力します。これは、変更セットを作成する対象のスタックの名前です。

      ```
      #{DeployVariables.StackName}
      ```

   1. [**変更セット名**] に、前のアクションで作成した変更セットの名前を入力します。

      ```
      my-changeset
      ```

   1. [**完了**] をクリックしてアクションを保存します。

   1. パイプラインの実行を続行します。

## ステップ 6: スタックを削除するための CloudFormation デプロイアクションを追加する
<a name="tutorials-cloudformation-action-delete"></a>

が出力ファイルの 変数からスタック名を取得し、スタックを削除 CloudFormation できるようにする最終アクションをパイプラインに作成します。



1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

   [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

1. パイプラインの編集を選択します。

1. **デプロイ**ステージを編集することを選択します。

1. スタックを削除するデプロイアクションを追加します。

   1. [**アクション名**] で、[**DeleteStack**] を選択します。[**デプロイプロバイダー**] で、[**CloudFormation**] を選択します。

   1. [**アクションモード**] で、[**スタックを削除する**] をクリックします。

   1. [**スタック名**] に、次のように変数の構文を入力します。これは、アクションで削除するスタックの名前です。

   1. [**完了**] をクリックしてアクションを保存します。

   1. [**保存**] をクリックしてポリシーを保存します。

   パイプラインは保存すると実行されます。

# チュートリアル: CodePipeline を使用した Amazon ECS 標準デプロイ
<a name="ecs-cd-pipeline"></a>

このチュートリアルでは、CodePipeline を使用して Amazon ECS で完全なエンドツーエンドの継続的デプロイメント (CD) パイプラインを作成する方法を説明します。

**重要**  
コンソールでのパイプライン作成の一環として、CodePipeline は S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**注記**  
このトピックとチュートリアルでは、CodePipeline の Amazon ECS 標準デプロイアクションについて説明します。CodePipeline で Amazon ECS から CodeDeploy の blue/green デプロイアクションを使用するチュートリアルは、[チュートリアル: Amazon ECR ソース、ECS - CodeDeploy 間のデプロイでパイプラインを作成する](tutorials-ecs-ecr-codedeploy.md) を参照してください。

**注記**  
このトピックとチュートリアルでは、ソースアクションを含む CodePipeline の Amazon ECS 標準デプロイアクションについて説明します。CodePipeline で Amazon ECS 標準デプロイアクションと ECRBuildAndPublish ビルドアクションを使用してイメージをプッシュするチュートリアルについては、「[チュートリアル: CodePipeline (V2 タイプ) を使用して Docker イメージを構築し Amazon ECR にプッシュする](tutorials-ecr-build-publish.md)」を参照してください。

## 前提条件
<a name="ecs-cd-prereqs"></a>

このチュートリアルで CD パイプラインを作成する前に、いつくかのリソースを用意する必要があります。使用を開始するために必要なものは以下のとおりです。

**注記**  
これらのリソースはすべて、同じ AWS リージョン内に作成する必要があります。
+ Dockerfile およびアプリケーションリソースを使用するソースコントロールリポジトリ (このチュートリアルでは CodeCommit を使用します)。詳細については、*AWS CodeCommit ユーザーガイド* の「[CodeCommit リポジトリの作成](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html)」を参照してください。
+ Dockerfile およびアプリケーションソースから作成したイメージを含む Docker イメージリポジトリ (このチュートリアルでは Amazon ECR を使用します)。詳細については、*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 Simple Queue Serviceデベロッパーガイド* の [クラスターの作成](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) と [サービスの作成](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html) を参照してください。

これらの前提条件を満たした後、チュートリアルに進んで CD パイプラインを作成できます。

## ステップ 1: ビルド仕様ファイルをソースリポジトリに追加する
<a name="cd-buildspec"></a>

このチュートリアルでは、CodeBuild を使用して Docker イメージを構築し、Amazon ECR にイメージをプッシュします。`buildspec.yml` ファイルをソースコードリポジトリに追加して CodeBuild に処理方法を指示します。ビルド仕様の以下の例では、次のように動作します。
+ プレビルドステージ:
  + Amazon ECR にログインします。
  + リポジトリ URI を ECR イメージに設定して、ソースの Git コミット ID の最初の 7 文字を使用するイメージタグを追加します。
+ ビルドステージ
  + 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
```

このチュートリアルで使用する Amazon ECS サービスで、[前提条件](#ecs-cd-prereqs) で提供されているサンプルタスクの定義に合わせてビルド仕様が書き込まれています。`REPOSITORY_URI` 値は `image` リポジトリ (イメージタグなし) に対応し、ファイルの末尾近くの `hello-world` 値はサービスのタスク定義のコンテナ名に対応します。

**ソースリポジトリに `buildspec.yml` ファイルを追加するには**

1. テキストエディタを開き、上記のビルド仕様をコピーして新しいファイルに貼り付けます。

1. `REPOSITORY_URI` の値 (`012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world`) を、Docker イメージの自分の Amazon ECR リポジトリ URI (イメージタグなし) に置き換えます。`hello-world` を、Docker イメージを参照するサービスのタスク定義のコンテナ名に置き換えます。

1. ソースリポジトリに `buildspec.yml` ファイルをコミットし、プッシュします。

   1. ファイルを追加します。

      ```
      git add .
      ```

   1. 変更をコミットします。

      ```
      git commit -m "Adding build specification."
      ```

   1. コミットをプッシュします。

      ```
      git push
      ```

## ステップ 2: 継続的デプロイパイプラインを作成する
<a name="pipeline-wizard"></a>

CodePipeline ウィザードを使用してパイプラインステージを作成し、ソースリポジトリを ECS サービスに接続します。

**パイプラインを作成するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**Welcome (ようこそ)**] ページで、[**Create pipeline (パイプラインの作成)**] を選択します。

   CodePipeline を初めて使用する場合は、**[Welcome (ようこそ)]** の代わりに紹介ページが表示されます。[**今すぐ始める**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。[**次へ**] を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** ページで、**[パイプライン名]** にパイプラインの名前を入力します。このチュートリアルでは、パイプライン名は **hello-world** です。

1. [**パイプラインのタイプ**] で、デフォルトの選択を [**V2**] のままにします。パイプラインのタイプによって特徴および価格が異なります。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。**[Next]** (次へ) を選択します。

1. **ステップ 3: ソースステージの追加**ページで、**ソースプロバイダー**で ** AWS CodeCommit**を選択します。

   1. [**Repository name (リポジトリ名)**] で、パイプラインのソース場所として使用する リポジトリの名前を選択します。

   1. [**ブランチ名**] で使用するブランチを選択し、[**Next (次へ)**] を選択します。

1. **ステップ 4: ビルドステージの追加**ページで、**ビルドプロバイダー**で を選択し**AWS CodeBuild**、**プロジェクトの作成**を選択します。

   1. [**Project name**] では、ビルドプロジェクトに一意の名前を選択します。このチュートリアルでは、プロジェクト名は **hello-world** です。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。

   1. [**オペレーティングシステム**] で、[**Amazon Linux 2**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。

   1. [**イメージ**] で、[**`aws/codebuild/amazonlinux2-x86_64-standard:3.0`**] を選択します。

   1. [**イメージバージョン**] と [**環境タイプ**] には、既定値を使用します。

   1. [**Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Docker イメージを構築する場合、またはビルドで昇格された権限を取得する場合は、このフラグを有効にする)**] を選択します。

   1. [**CloudWatch logs**] の選択を解除します。**アドバンスト** の拡張を必要とする場合があります。

   1. [**Continue to CodePipeline **] (CodePipeline に進む) を選択します。

   1. [**次へ**] を選択します。
**注記**  
ウィザードによって、**codebuild-*build-project-name*-service-role** という名前のビルドプロジェクト用の CodeBuild サービスロールが作成されます。このロール名を書き留めます。これには後で Amazon ECR アクセス権限を追加します。

1. **[Step 5: デプロイステージの追加]** の **[デプロイプロバイダ]** で **[Amazon ECS]** を選択します。

   1. [**Cluster name (クラスター名)**] で、サービスが実行されている Amazon ECS クラスターを選択します。このチュートリアルでは、クラスターは **default** です。

   1. [**サービス名**] で更新するサービスを選択し、[**Next (次へ)**] を選択します。このチュートリアルでは、サービス名は **hello-world** です。

1. [**Step 6: Review**] ページで、パイプラインの設定を確認し、[**Create pipeline**] を選択してパイプラインを作成します。
**注記**  
これでパイプラインが作成され、さまざまなパイプラインステージを通して実行を試みます。ただし、ウィザードによって作成されたデフォルトの CodeBuild ロールには、`buildspec.yml` ファイルに含まれるコマンドのすべてを実行するアクセス権限がないため、ビルドステージは失敗します。次のセクションで、ビルドステージのアクセス権限を追加します。

## ステップ 3: CodeBuild ロールに Amazon ECR 権限を追加する
<a name="code-build-perms"></a>

CodePipeline ウィザードによって、**codebuild-*build-project-name*-service-role** という名前の CodeBuild ビルドプロジェクト用の IAM ロールが作成されます。このチュートリアルで名前は **codebuild-hello-world-service-role** です。`buildspec.yml` ファイルは Amazon ECR API オペレーションの呼び出しを実行するため、これらの Amazon ECR コールを行うアクセス権限を許可するポリシーがロールに必要です。以下の手順では、適切なアクセス権限をロールにアタッチします。

**ステップ 3: CodeBuild ロールに Amazon ECR 権限を追加する**

1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) を開きます。

1. 左のナビゲーションペインで、**[ロール]** を選択してください。

1. 検索ボックスに「**codebuild-**」と入力し、CodePipeline ウィザードによって作成されたロールを選択します。このチュートリアルでは、ロール名は **codebuild-hello-world-service-role** です。

1. [**Summary (概要)**] ページで、[**Attach policy (ポリシーのアタッチ)**] を選択します。

1. [**AmazonEC2ContainerRegistryPowerUser**] ポリシーの左にあるボックスをオンにし、[**Attach policy**] を選択します。

## ステップ 4: パイプラインのテスト
<a name="commit-change"></a>

パイプラインには、end-to-endのネイティブ AWS 継続的デプロイを実行するためのすべてが必要です。次は、コードの変更をソースリポジトリにプッシュすることで機能をテストします。

**パイプラインをテストするには**

1. 設定済みソースリポジトリにコード変更を行い、変更をコミットしてプッシュします。

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. リストからパイプラインを選択します。

1. ステージを通してパイプラインの進行状況を監視します。パイプラインが終了し、Amazon ECS サービスがコード変更から作成された Docker イメージを実行することを確認します。

# チュートリアル: Amazon ECR ソース、ECS - CodeDeploy 間のデプロイでパイプラインを作成する
<a name="tutorials-ecs-ecr-codedeploy"></a>

このチュートリアルでは、Docker イメージをサポートする Blue/Green デプロイを使用して AWS CodePipeline コンテナアプリケーションをデプロイするパイプラインを で設定します。Blue/Green デプロイでは、古いバージョンと一緒に新しいバージョンのアプリケーションを起動し、トラフィックを再ルーティングする前に新しいバージョンをテストできます。また、デプロイプロセスをモニタリングし、問題がある場合は迅速にロールバックすることもできます。

**重要**  
パイプライン作成の一環として、CodePipeline は、ユーザーが指定した S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**注記**  
このチュートリアルでは、CodePipeline の Amazon ECS から CodeDeploy Blue/Green デプロイアクションについて説明します。CodePipeline で Amazon ECS スタンダードデプロイアクションを使用するチュートリアルについては、[チュートリアル: CodePipeline を使用した Amazon ECS 標準デプロイ](ecs-cd-pipeline.md) を参照してください。

完了したパイプラインは、Amazon ECR などのイメージリポジトリに保存されているイメージへの変更を検出し、CodeDeploy を使用してトラフィックを AmazonECS クラスターとロードバランサーにルーティングおよびデプロイします。CodeDeploy は、リスナーを使用して、AppSpec ファイルで指定し更新されたコンテナのポートにトラフィックを再ルーティングします。ロードバランサー、製造リスナー、ターゲットグループ、Amazon ECS アプリケーションが青/緑のデプロイでどのように使用されるかについては、[チュートリアル：Amazon ECS サービスのデプロイ](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html) を参照してください。

また、Amazon ECS タスク定義が保存されている CodeCommit リポジトリなどのソース場所を使用するようにパイプラインを設定することもできます。このチュートリアルでは、これらの各 AWS リソースを設定し、各リソースのアクションを含むステージでパイプラインを作成します。

ソースコードが変更されたり、新しいベースイメージが Amazon ECR にアップロードしたときは、継続的デリバリーパイプラインが自動的にコンテナイメージを構築してデプロイします。

このフローでは、次のアーティファクトを使用します。
+ Amazon ECR イメージリポジトリのコンテナ名とリポジトリ URI を指定する Docker イメージファイル。
+ Docker イメージ名、コンテナ名、Amazon ECS サービス名、およびロードバランサーの設定を一覧表示する Amazon ECS タスク定義。
+ Amazon ECS タスク定義ファイルの名前、更新されたアプリケーションのコンテナの名前、および CodeDeploy が製造トラフィックを再ルーティングするコンテナポートを指定する CodeDeployAppSpec ファイル。デプロイライフサイクルイベントフック中に実行できるオプションのネットワーク設定と Lambda 関数も指定できます。

**注記**  
Amazon ECR イメージリポジトリへの変更をコミットすると、パイプラインソースアクションはそのコミット用に `imageDetail.json` ファイルを作成します。`imageDetail.json` ファイルの詳細については、「[Amazon ECS Blue/Green デプロイアクション用の 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 を使用してイメージを作成し、 を使用して Amazon ECR リポジトリ AWS CLI を作成し、そのイメージをリポジトリにプッシュします。

**注記**  
使用するイメージがすでにある場合、このスキップは省略できます。

**イメージを作成するには**

1. Docker がインストールされている Linux インスタンスにサインインします。

   `nginx` のイメージをプルダウンから選択します。このコマンドは `nginx:latest` イメージを返します。

   ```
   docker pull nginx
   ```

1. **docker images** を実行します。リストにイメージが表示されます.。

   ```
   docker images
   ```

**Amazon ECR リポジトリを作成してイメージをプッシュするには**

1.  イメージを保存する Amazon ECR リポジトリを作成します。出力の `repositoryUri` を書き留めます。

   ```
   aws ecr create-repository --repository-name nginx
   ```

   出力:

   ```
   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }
   ```

1. 前のステップの `repositoryUri` でイメージをタグ付けします。

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. この例に示すように、`us-west-2` リージョンと 111122223333 アカウント ID を指定して **aws ecr get-login-password** コマンドを実行します。

   ```
   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>

このセクションでは、Amazon ECS でタスク定義 JSON ファイルを作成します。次に、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 サービスを作成するときに、ロードバランサーで作成したサブネット名とターゲットグループ値を使用します。Application Load Balancer または Network Load Balancer を作成できます。ロードバランサーでは、2 つのパブリックサブネットを別々のアベイラビリティーゾーンに持つ VPC を使用する必要があります。以下のステップでは、デフォルト VPC を確認して、ロードバランサーを作成してから、ロードバランサーの 2 つのターゲットグループを作成します。詳細については、「[Network Load Balancer のターゲットグループ](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** 列に **はい** と表示されている VPC に注意してください。これがデフォルト VPC です。選択するデフォルトのサブネットが含まれています。

1. [**サブネット**] を選択します。**デフォルトのサブネット** 列に **はい** と表示されている 2 つのサブネットを選択します。
**注記**  
サブネット ID を書き留めます。これらは、このチュートリアルで後ほど必要になります。

1. サブネットを選択後、[**説明**] タブを選択します。使用するサブネットが、異なるアベイラビリティーゾーンにあることを確認します。

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. ナビゲーションペインで、**[ロードバランサー]** を選択します。

1. [**Create Load Balancer**] を選択します。

1. [**Application Load Balancer**] を選択し、[**Create**] を選択します。

1. [**Name**] に、ロードバランサーの名前を入力します。

1. [**Scheme**] で、[**インターネット向け**] を選択します。

1. [**IP address type**] で、[**ipv4**] を選択します。

1. ロードバランサー用に 2 つのリスナーポートを設定するには:

   1. [**Load Balancer Protocol (ロードバランサーのプロトコル)**] で、[**HTTP**] を選択します。[**Load Balancer Port (ロードバランサーポート)**] に [**80**] を入力します。

   1. **[リスナーの追加]** を選択します。

   1. 2 番目のリスナーの [**Load Balancer Protocol**] で、[**HTTP**] を選択します。[**Load Balancer Port (ロードバランサーポート)**] に [**8080**] を入力します。

1. [**アベイラビリティーゾーン**] の [**VPC**] で、デフォルトの VPC を選択します。次に、使用する 2 つのデフォルトサブネットを選択します。

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**] の順に選択します。

**ロードバランサーの 2 番目のターゲットグループを作成するには**

1. ロードバランサーがプロビジョニングされたら、Amazon EC2 コンソールを開きます。ナビゲーションペインで、[**ターゲットグループ**] を選択します。

1. [**ターゲットグループの作成**] を選択します。

1. [**Name**] に、ターゲットグループの名前 (例: **target-group-2**) を入力します。

1. [**Target type**] で、[**IP**] を選択します。

1. [**Protocol**] で、[**HTTP**] を選択します。[**Port**] に「**8080**」と入力します。

1. [**VPC**] で、デフォルトの VPC を選択します。

1. [**作成**] を選択します。
**注記**  
デプロイを実行するには、ロードバランサー用に 2 つのターゲットグループを作成する必要があります。最初のターゲットグループの ARN を書き留める必要があります。この ARN は、次のステップの `create-service` JSON ファイルで使用されます。

**2 番目のターゲットグループを含めるようにロードバランサーを更新するには**

1. Amazon EC2 コンソールを開きます。ナビゲーションペインで、**[ロードバランサー]** を選択します。

1. ロードバランサーを選択後、[**Listeners**] を選択します。ポート 8080 のリスナーを選択後、[**編集**] を選択します。

1. [**Forward to**] の横の鉛筆アイコンを選択します。2 番目のターゲットグループを選択してから、チェックマークを選択します。[**更新**] を選択して、更新を保存します。

## ステップ 4: Amazon ECS クラスターとサービスを作成する
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

このセクションでは、CodeDeploy がデプロイ中に（EC2インスタンスではなくAmazon ECS クラスターに）トラフィックをルーティングするAmazon ECS クラスターとサービスを作成します。Amazon ECS サービスを作成するには、ロードバランサーで作成したサブネット名、セキュリティグループ、ターゲットグループの値を使用してサービスを作成する必要があります。

**注記**  
これらのステップを使用して Amazon ECS クラスターを作成する場合、Fargate コンテナをプロビジョニング AWS する **Networking Only** クラスターテンプレートを使用します。 AWS Fargate は、コンテナインスタンスインフラストラクチャを管理するテクノロジーです。Amazon ECS クラスター用の Amazon EC2 インスタンスを手動で選択または作成する必要はありません。

**Amazon ECS クラスターを作成するには**

1. Amazon ECS クラシックコンソール ([https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/)) を開きます。

1. ナビゲーションペインで **[Clusters]** (クラスター) を選択してください。

1. **[クラスターを作成]** を選択します。

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 コンソールを開き、ナビゲーションペインの **ロードバランシング** で **ターゲットグループ** を選択します。最初のターゲットグループを選択します。[**説明**] タブから 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. JSON ファイルを指定して、**create-service** コマンドを実行します。
**重要**  
ファイル名の前に必ず `file://` を含めてください。このコマンドでは必須です。

   この例では、`my-service` という名前のサービスが作成されます。
**注記**  
このコマンド例では、my-service という名前のサービスを作成します。この名前のサービスがすでにある場合、このコマンドはエラーを返します。

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   出力はサービスの説明フィールドが返ります。

1. **describe-services** コマンドを実行して、サービスが作成されたことを確認します。

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## ステップ 5: CodeDeploy アプリケーションとデプロイグループ (ECS コンピューティングプラットフォーム) を作成する
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

Amazon ECS コンピューティングプラットフォーム用の CodeDeploy アプリケーションとデプロイグループを作成すると、アプリケーションはデプロイ中に使用され、正しいデプロイグループ、ターゲットグループ、リスナー、およびトラフィックの再ルーティング動作を参照します。

**CodeDeploy でアプリケーションを作成する。**

1. CodeDeploy コンソールを開き、**アプリケーションの作成** を選択します。

1. [**アプリケーション名**] に、使用する名前を入力します。

1. [**コンピューティングプラットフォーム**] で [**Amazon ECS**] を選択します。

1. [**アプリケーションを作成**] を選択します。

**次に、CodeDeploy デプロイ グループを作成します。**

1. アプリケーションページの [**デプロイグループ**] タブで [**デプロイグループの作成**] を選択します。

1. [**デプロイグループ名**] に、デプロイグループを表す名前を入力します。

1. **サービスロール** で、CodeDeployに Amazon ECS へのアクセスを許可するサービスロールを選択します。新しいサービスロールを作成するには、次の手順を実行します。

   1. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソール を開きます。

   1. コンソールダッシュボードで [**ロール**] を選択します。

   1. [**ロールの作成**] を選択してください。

   1. [**信頼されたエンティティのタイプを選択**] で、[**AWS のサービス** ] を選択します。**ユースケースの選択** で、**CodeDeploy** を選択します。[**ユースケースの選択**] で、[**CodeDeploy - ECS**] を選択します。**[Next: Permissions]** (次のステップ: 許可) を選択します。`AWSCodeDeployRoleForECS` マネージドポリシーはロールにアタッチ済みです。

   1. [**次の手順: タグ**]、[**次の手順: 確認**] の順に選択します。

   1. ロールの名前 (例: **CodeDeployECSRole**) を入力し、[**ロールの作成**] を選択します。

1. **環境設定** で、Amazon ECS クラスターの名前とサービス名を選択します。

1. **ロードバランサー** から、Amazon ECS サービスにトラフィックを提供するロードバランサーの名前を選択します。

1. [**Production listener port**] から、Amazon ECS サービスへの本稼働トラフィックを提供するリスナーのポートとプロトコルを選択します。[**Test listener port**] で、テストリスナーのポートとプロトコルを選択します。

1. [**Target group 1 name**] および [**Target group 2 name**] から、デプロイ時にトラフィックをルーティングするターゲットグループを選択します。これらが、ロードバランサー用に作成したターゲットグループであることを確認します。

1. **すぐにトラフィックを再ルーティング** を選択して、デプロイが成功してから更新された Amazon ECS タスクにトラフィックを再ルーティングするまでの時間を決定します。

1. **デプロイグループの作成** を選択します。

## ステップ 6: パイプラインを作成する
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

このセクションでは、以下のアクションを使用してパイプラインを作成します。
+ ソースアーティファクトがタスク定義と AppSpec ファイルである CodeCommit アクション。
+ ソースアーティファクトがイメージファイルである Amazon ECR ソースアクションを持つソースステージ。
+ デプロイが CodeDeploy アプリケーションとデプロイグループで実行される、Amazon ECS デプロイアクションを使用したデプロイステージ。

**ウィザードで 2 ステージパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyImagePipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** の **[ソースプロバイダー]** で、**[AWS CodeCommit]** を選択します。**リポジトリ名** で、[ステップ 1: CodeCommit リポジトリを作成する](tutorials-simple-codecommit.md#codecommit-create-repository) で作成した CodeCommit リポジトリの名前を選択します。[**Branch name**] で、最新のコード更新を含むブランチの名前を選択します。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、**[ビルドステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。[**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **ステップ 6: デプロイステージの追加**:

   1. [**Deploy provider**] で、[**Amazon ECS (Blue/Green)**] を選択します。[**アプリケーション名**] で、`codedeployapp` などの、アプリケーションの名前を入力またはリストから選択します。[**デプロイグループ**] に、`codedeploydeplgroup` などの、デプロイグループの名前を入力またはリストから選択します。

       
**注記**  
「デプロイ」は、[**ステップ 4: デプロイ**] ステップで作成されるステージにデフォルトで付けられる名前であり、「ソース」は、パイプラインの最初のステージに付けられる名前です。

   1. [**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. ソースステージで、[**ステージを編集**] を選択します。

1. CodeCommitソースアクションの横にある **\$1アクションの追加** を選択して、並列アクションを追加します。

1. [**アクション名**] に、名前を入力します (例えば、**Image**)。

1. [**アクションプロバイダ**] で [**Amazon ECR**] を選択します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/ECR-source-action.png)

1. **リポジトリ名** で、Amazon ECR リポジトリの名前を選択します。

1. [**Image tag**] で、イメージの名前とバージョンを指定します (最新でない場合)。

1. **出力アーティファクト**で、次のステージで使用するイメージ名およびリポジトリ URI 情報が含まれている出力アーティファクトのデフォルト(例: `MyImage`)を選択します。

1. アクション画面で、[**Save**] を選択します。ステージ画面で、[**Done**] を選択します。パイプラインで、[**Save**] を選択します。メッセージは、Amazon ECR ソースアクション用に作成されるAmazon CloudWatch Events ルールを示しています。

**ソースアーティファクトをデプロイアクションに関連付けるには**

1. デプロイステージで **編集** を選択後、アイコンを選択して、**Amazon ECS (Blue/Green)** アクションを編集します。

1. ペインの下部までスクロールします。[**入力アーティファクト**] で [**Add**] を選択します。新しい Amazon ECR リポジトリ (例: `MyImage` など) からソースアーティファクトを追加します。

1. [**タスク定義**] で [**SourceArtifact**] を選択し、「**taskdef.json**」と入力されていることを確認します。

1. **AWS CodeDeploy AppSpec ファイル** で、**SourceArtifact** を選択し、**appspec.yaml**と入力されていることを確認します。

1. [**Dynamically update task definition image**] の [**Input Artifact with Image 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. 変更を送信してパイプラインのビルドを開始するには、**[変更をリリース]**、**[リリース]** の順に選択します。

1. デプロイアクションを選択して CodeDeploy で表示し、トラフィックシフトの進捗状況を確認します。
**注記**  
オプションの待機時間を示すデプロイステップが表示される場合があります。デフォルトで、CodeDeploy はデプロイが成功してから 1 時間後に元のタスク設定を終了します。この時間を使用してタスクをロールバックまたは終了することはできますが、それ以外の場合、タスクセットが終了した時点でデプロイは完了します。

## ステップ 7: パイプラインに変更を加えてデプロイを確認する
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

イメージを変更して、その変更を Amazon ECR リポジトリにプッシュします。これにより、パイプラインの実行がトリガーされます。イメージソースの変更がデプロイされていることを確認します。

# チュートリアル: Amazon Alexa Skill をデプロイするパイプラインを作成する
<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)」の手順を使用して、セキュリティプロファイルを作成します。
+ プロファイルを作成したら、[**クライアント ID**] と [**クライアントシークレット**] の値をメモしておきます。
+ それらの手順に従って [**Allowed Return URLs (許可されたリターン URL)**] に入力します。これらの URL を ASK CLI コマンドで使用して、更新トークンリクエストをリダイレクトできます。

## ステップ 2 : Alexa スキルのソースファイルを作成して CodeCommit リポジトリにプッシュします。
<a name="tutorials-alexa-skills-kit-push"></a>

このセクションでは、Alexa スキルのソースファイルを作成し、パイプラインによってソースステージに使用されるリポジトリにプッシュします。Amazon 開発者コンソールで作成したスキル用に、以下のものを作成してプッシュします。
+ `skill.json` ファイル。
+ `interactionModel/custom` フォルダ。
**注記**  
このディレクトリ構造は、「[スキルパッケージ形式](https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format)」で説明されているように、Alexa Skills Kit スキルパッケージ形式の要件に準拠しています。ディレクトリ構造で正しいスキルパッケージ形式が使用されていない場合、変更は 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` フォルダを作成します。

   以下のコマンドを使用して、フォルダ内にインタラクションモデルファイルを生成します。locale について、このチュートリアルではファイル名のロケールとして en-US を使用します。

   ```
   ask api get-model --skill-id skill-ID --locale locale >
       ./interactionModel/custom/locale.json
   ```

**ファイルを CodeCommit リポジトリにプッシュするには**

1. ファイルを CodeCommit リポジトリにプッシュまたはアップロードします。これらのファイルは、 AWS CodePipelineでのデプロイアクションのために **パイプライン作成** ウィザードによって作成されたソースアーティファクトです。ファイルは、ローカルディレクトリに次のように表示されます。

   ```
   skill.json
   /interactionModel
     /custom
       |en-US.json
   ```

1. ファイルをアップロードする方法を選択します。

   1. ローカルコンピュータで複製されたリポジトリから Git コマンドラインを使用するには:

      1. 以下のコマンドを実行して、すべてのファイルを一度にステージングします。

         ```
         git add -A
         ```

      1. 以下のコマンドを実行して、コミットメッセージによりファイルをコミットします。

         ```
         git commit -m "Added Alexa skill files"
         ```

      1. 以下のコマンドを実行して、ローカルリポジトリから CodeCommit リポジトリにファイルをプッシュします。

         ```
         git push
         ```

   1. CodeCommit コンソールを使用してファイルをアップロードするには: 

      1. CodeCommit コンソールを開き、**リポジトリ** リストから自分のリポジトリを選択します。

      1. [**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 を使用してトークンを作成します。[**パイプラインを作成する**] ウィザードでこれらの認証情報を使用します。

**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>

このセクションでは、以下のアクションを使用してパイプラインを作成します。
+ ソースアーティファクトがスキルをサポートする Alexa スキルファイルである CodeCommit アクションを含むソースステージ。
+ Alexa Skills Kit のデプロイアクションを含むデプロイステージ。

**ウィザードを使用してパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. プロジェクトとそのリソースを作成する AWS リージョンを選択します。Alexa スキルランタイムは、以下のリージョンでのみ利用できます。
   + アジアパシフィック (東京)
   + 欧州 (アイルランド)
   + 米国東部 (バージニア北部)
   + 米国西部 (オレゴン)

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyAlexaPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** の **[ソースプロバイダー]** で、**[AWS CodeCommit]** を選択します。**リポジトリ名** で、[ステップ 1: CodeCommit リポジトリを作成する](tutorials-simple-codecommit.md#codecommit-create-repository) で作成した CodeCommit リポジトリの名前を選択します。[**Branch name**] で、最新のコード更新を含むブランチの名前を選択します。

   リポジトリ名とブランチを選択した後、このパイプラインのために作成される Amazon CloudWatch Events ルールを示すメッセージが表示されます。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、**[ビルドステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **ステップ 6: デプロイステージの追加**:

   1. [**デプロイプロバイダ**] で、[**Alexa Skills Kit**] を選択します。

   1. [**Alexa skill ID (Alexa スキル ID)**] に、Alexa Skills Kit 開発者コンソールでスキルに割り当てられているスキル ID を入力します。

   1. [**クライアント ID**] に、登録したアプリケーションの ID を入力します。

   1. [**Client secret (クライアントシークレット)**] に、登録時に選択したシークレットを入力します。

   1. [**Refresh token (更新トークン)**] に、ステップ 3 で生成したトークンを入力します。  
![\[Alexa Skills Kit アクションのステップ 6: デプロイページ\]](http://docs.aws.amazon.com/ja_jp/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 を使用してそれらのファイルをバケットにデプロイします。ソースの場所で Web サイトのファイルを変更または追加するたびに、デプロイで最新のファイルを使用して Web サイトが作成されます。

**重要**  
パイプライン作成の一環として、CodePipeline は、ユーザーが指定した S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**注記**  
ソースリポジトリからファイルを削除しても、S3 デプロイアクションでは、削除されたファイルに対応する S3 オブジェクトは削除されません。

このチュートリアルには 2 つのオプションがあります。
+ 静的ウェブサイトを S3 パブリックバケットにデプロイするパイプラインを作成する。この例では、 AWS CodeCommit ソースアクションと Amazon S3 デプロイアクションを使用してパイプラインを作成します。「[オプション 1: 静的ウェブサイトファイルを Amazon S3 にデプロイする](#tutorials-s3deploy-acc)」を参照してください。
+ サンプル TypeScript コードを JavaScript にコンパイルし、CodeBuild 出力アーティファクトをアーカイブ用の S3 バケットにデプロイするパイプラインを作成します。この例では、Amazon S3 ソースアクション、CodeBuild 構築アクション、Amazon S3 デプロイアクションを使用するパイプラインを作成します。「[オプション 2：構築されたアーカイブファイルを S3 ソースバケットから Amazon S3 にデプロイする](#tutorials-s3deploy-s3source)」を参照してください。

**重要**  
この手順でパイプラインに追加するアクションの多くには、パイプラインを作成する前に作成する必要がある AWS リソースが含まれます。ソースアクションの AWS リソースは常に、パイプラインを作成するのと同じ AWS リージョンで作成する必要があります。例えば、米国東部 (オハイオ) リージョンにパイプラインを作成している場合、CodeCommit リポジトリは米国東部 (オハイオ) リージョンにある必要があります。  
パイプラインの作成時にクロスリージョンアクションを追加できます。クロスリージョンアクションの AWS リソースは、アクションを実行する予定のリージョンと同じ AWS リージョンに存在する必要があります。詳細については、「[CodePipeline にクロスリージョンアクションを追加する](actions-create-cross-region.md)」を参照してください。

## オプション 1: 静的ウェブサイトファイルを Amazon S3 にデプロイする
<a name="tutorials-s3deploy-acc"></a>

この例では、サンプルの静的ウェブサイトテンプレートファイルをダウンロードし、 AWS CodeCommit リポジトリにファイルをアップロードしてバケットを作成し、ホスティング用に設定します。次に、 AWS CodePipeline コンソールを使用してパイプラインを作成し、Amazon S3 デプロイ設定を指定します。

### 前提条件
<a name="tutorials-s3deploy-acc-prereq"></a>

以下のものを用意しておく必要があります。
+ CodeCommit リポジトリ。で作成した AWS CodeCommit リポジトリを使用できます[チュートリアル: シンプルなパイプラインを作成する (CodeCommit リポジトリ)](tutorials-simple-codecommit.md)。
+ 静的ウェブサイトのソースファイル。このリンクを使用して [サンプル静的ウェブサイト](samples/sample-website.zip)をダウンロードします。sample-website.zip をダウンロードすると、以下のファイルが生成されます。
  + `index.html` ファイル
  + `main.css` ファイル
  + `graphic.jpg` ファイル
+ ウェブサイトホスティング用に設定された S3 バケット。「[静的ウェブサイトを Amazon S3 でホスティングする](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)」を参照してください。必ずパイプラインと同じリージョンにバケットを作成します。
**注記**  
ウェブサイトのホスティングには、バケットへのパブリック読み取りアクセスを許可するアクセス設定が必要です。ウェブサイトのホスティングを除き、S3 バケットへのパブリックアクセスをブロックするデフォルトのアクセス設定を維持してください。

### ステップ 1: ソースファイルを CodeCommit リポジトリにプッシュする
<a name="tutorials-s3deploy-acc-push"></a>

このセクションでは、パイプラインによってソースステージに使用されるリポジトリに、ソースファイルをプッシュします。

**ファイルを CodeCommit リポジトリにプッシュするには**

1. ダウンロードしたサンプルファイルを解凍します。ZIP ファイルをリポジトリにアップロードしないでください。

1. ファイルを CodeCommit リポジトリにプッシュまたはアップロードします。このファイルは、CodePipeline でのデプロイアクションのために **パイプラインの作成** ウィザードで作成したソースアーティファクトです。ファイルは、ローカルディレクトリに次のように表示されます。

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. Git または CodeCommit コンソールを使用してファイルをアップロードできます。

   1. ローカルコンピュータで複製されたリポジトリから Git コマンドラインを使用するには:

      1. 以下のコマンドを実行して、すべてのファイルを一度にステージングします。

         ```
         git add -A
         ```

      1. 以下のコマンドを実行して、コミットメッセージによりファイルをコミットします。

         ```
         git commit -m "Added static website files"
         ```

      1. 以下のコマンドを実行して、ローカルリポジトリから CodeCommit リポジトリにファイルをプッシュします。

         ```
         git push
         ```

   1. CodeCommit コンソールを使用してファイルをアップロードするには: 

      1. CodeCommit コンソールを開き、**リポジトリ** リストから自分のリポジトリを選択します。

      1. [**Add file**]、[**Upload file**] の順に選択します。

      1. [**ファイルの選択**] を選択し、ファイルを参照します。ユーザー名とメールアドレスを入力して、変更をコミットします。**[Commit changes]** (変更のコミット) を選択します。

      1. アップロードするファイルごとにこのステップを繰り返します。

### ステップ 2: パイプラインを作成する
<a name="tutorials-s3deploy-acc-pipeline"></a>

このセクションでは、次のアクションを使用してパイプラインを作成します。
+ ソースアーティファクトが Web サイトのファイルである CodeCommit アクションを使用したソースステージ。
+ Amazon S3 デプロイメントアクションを使用したデプロイメントステージ。

**ウィザードを使用してパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyS3DeployPipeline**」と入力します。

1. **[パイプラインタイプ]** で、**[V2]** を選択します。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。**[Next]** (次へ) を選択します。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** の **[ソースプロバイダー]** で、**[AWS CodeCommit]** を選択します。**リポジトリ名** で、[ステップ 1: CodeCommit リポジトリを作成する](tutorials-simple-codecommit.md#codecommit-create-repository) で作成した CodeCommit リポジトリの名前を選択します。[**Branch name**] で、最新のコード更新を含むブランチの名前を選択します。独自のブランチを作成する場合を除き、ここで使用できるのは `main` のみです。

   リポジトリ名とブランチを選択した後、このパイプライン用に作成される Amazon CloudWatch Events ルールが表示されます。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、**[ビルドステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **ステップ 6: デプロイステージの追加**:

   1. [**デプロイプロバイダ**] で、[**Amazon S3**] を選択します。

   1. [**バケット**] にパブリックバケットの名前を入力します。

   1. [**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/ja_jp/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-codecommit.png)

   1. (オプション) [**既定 ACL**] で、[既定 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) と呼ばれる、あらかじめ定義された一連の許可を、アップロードされたアーティファクトに適用できます。

   1. (オプション) [**キャッシュコントロール**] で、キャッシュパラメータを入力します。これを設定して、リクエスト/レスポンスのキャッシュ動作を制御できます。有効な値については、HTTP オペレーションの [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) ヘッダーフィールドを参照してください。

   1. [**次へ**] を選択します。

1. **ステップ 7: **情報を確認してから、**パイプラインの作成**を選択します。

1. パイプラインが正常に実行されたら、Amazon S3 コンソールを開き、ファイルが公開バケットに表示されていることを確認します。

   ```
   index.html
   main.css
   graphic.jpg
   ```

1. エンドポイントにアクセスしてウェブサイトをテストします。エンドポイントは `http://bucket-name.s3-website-region.amazonaws.com/` という形式に従います。

   エンドポイントの例: `http://my-bucket.s3-website-us-west-2.amazonaws.com/` 

   サンプルのウェブページが表示されます。

### ステップ 3: 任意のソースファイルに変更を加えてデプロイを確認する
<a name="tutorials-s3deploy-acc-update"></a>

ソースファイルに変更を加え、その変更をリポジトリにプッシュします。これにより、パイプラインの実行がトリガーされます。ウェブサイトが更新されていることを確認します。

## オプション 2：構築されたアーカイブファイルを S3 ソースバケットから Amazon S3 にデプロイする
<a name="tutorials-s3deploy-s3source"></a>

このオプションでは、ビルドステージのビルドコマンドが TypeScript コードを JavaScript コードとしてコンパイルし、出力を別のタイムスタンプ付きフォルダの下の S3 ターゲットバケットにデプロイします。まず、TypeScript コードと buildspec.yml ファイルを作成します。ソースファイルを ZIP ファイルに結合した後、ソース ZIP ファイルを S3 ソースバケットにアップロードし、CodeBuild ステージを使用して構築されたアプリケーション ZIP ファイルを S3 ターゲットバケットにデプロイします。コンパイルされたコードはアーカイブとしてターゲットバケットに保存されます。

### 前提条件
<a name="tutorials-s3deploy-s3source-prereq"></a>

以下のものを用意しておく必要があります。
+ S3 ソースバケット。「[チュートリアル: シンプルなパイプラインを作成する (S3 バケット)](tutorials-simple-s3.md)」で作成したバケットを使用できます。
+ S3 ターゲットバケット。「[静的ウェブサイトを Amazon S3 でホスティングする](https://docs.aws.amazon.com/AmazonS3/latest/userguide/WebsiteHosting.html)」を参照してください。バケットは、作成するパイプライン AWS リージョン と同じ に作成してください。
**注記**  
この例では、ファイルをプライベートバケットにデプロイする方法を示します。ウェブサイトのホスティング用にターゲットバケットを有効にしたり、バケットを公開するポリシーをアタッチしたりしないでください。

### ステップ 1: ソースファイルを作成して S3 ソースバケットにアップロードする
<a name="tutorials-s3deploy-s3source-upload"></a>

このセクションでは、ソースファイルを作成し、パイプラインによってソースステージに使用されるバケットにプッシュします。このセクションでは、以下のソースファイルを作成する手順について説明します。
+ CodeBuild 構築プロジェクトに使用される `buildspec.yml` ファイル。
+ `index.ts` ファイル。

**buildspec.yml ファイルを作成するには**
+ 次の内容で、`buildspec.yml` という名前のファイルを作成します。これらのビルドコマンドは TypeScript をインストールし、TypeScript コンパイラを使用して `index.ts` のコードを JavaScript コードに書き換えます。

  ```
  version: 0.2
  
  phases:
    install:
      commands:
        - npm install -g typescript
    build:
      commands:
        - tsc index.ts
  artifacts:
    files:
      - index.js
  ```

**index.ts ファイルを作成するには**
+ 次の内容で、`index.ts` という名前のファイルを作成します。

  ```
  interface Greeting {
      message: string;
  }
  
  class HelloGreeting implements Greeting {
      message = "Hello!";
  }
  
  function greet(greeting: Greeting) {
      console.log(greeting.message);
  }
  
  let greeting = new HelloGreeting();
  
  greet(greeting);
  ```

**ファイルを S3 ソースバケットにアップロードするには**

1. ファイルは、ローカルディレクトリに次のように表示されます。

   ```
   buildspec.yml
   index.ts
   ```

   ファイルを圧縮して、ファイルに `source.zip` という名前を付けます。

1. Amazon S3 コンソールで、ソースバケット用に **アップロード** を選択します。[**ファイルを追加**] を選択し、作成した ZIP ファイルを参照します。

1.  **アップロード** を選択します。このファイルは、CodePipeline でのデプロイアクションのために **パイプラインの作成** ウィザードで作成したソースアーティファクトです。ファイルはバケットで以下のようになっています。

   ```
   source.zip
   ```

### ステップ 2: パイプラインを作成する
<a name="tutorials-s3deploy-s3source-pipeline"></a>

このセクションでは、次のアクションを使用してパイプラインを作成します。
+ ソースアーティファクトがダウンロード可能なアプリケーションのファイルである Amazon S3 アクションを含むソースステージ。
+ Amazon S3 デプロイメントアクションを使用したデプロイメントステージ。

**ウィザードを使用してパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyS3DeployPipeline**」と入力します。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** の **[ソースプロバイダー]** で、**[Amazon S3]** を選択します。[**バケット**] で、ソースバケットの名前を選択します。[**S3 object key (S3 オブジェクトキー)**] に、ソース ZIP ファイルの名前を入力します。必ず、ファイル拡張子.zip を含めてください。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、次の操作を行います。

   1. [**ビルドプロバイダー]** で、[**CodeBuild**] を選択します。

   1. **Create build project (ビルドプロジェクトの作成)**を選択します。[**プロジェクトの作成**] ページで:

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境**] で、[**マネージド型イメージ**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。[**ランタイムバージョン**] で、[**aws/codebuild/standard:1.0**] を選択します。

   1. [**イメージのバージョン**] で、[**Always use the latest image for this runtime version (このランタイムバージョンには常に最新のイメージを使用)**] を選択します。

   1. **サービスのロール** で、CodeBuild サービスロールを選択または作成します。

   1. [**ビルド仕様**] で、[**Use a buildspec file (ビルド仕様ファイルの使用)**] を選択します。

   1. [**Continue to CodePipeline **] (CodePipeline に進む) を選択します。プロジェクトが正常に作成された場合はメッセージが表示されます。

   1. [**次へ**] を選択します。

1. **[ステップ 5: デプロイステージの追加]** で、次の操作を行います。

   1. [**デプロイプロバイダ**] で、[**Amazon S3**] を選択します。

   1. [**バケット**] に、S3 ターゲットバケットの名前を入力します。

   1. [**Extract file before deploy (デプロイ前にファイルを展開)**] がオフになっていることを確認します。

      [**Extract file before deploy (デプロイ前にファイルを展開)**] がオフになっていると、[**S3 object key (S3 オブジェクトキー)**] が表示されています。使用するパスの名前を入力します: `js-application/{datetime}.zip`。

      これにより、ファイルが展開される `js-application` フォルダが Amazon S3 に作成されます。このフォルダでは、パイプラインの実行時に `{datetime}` 変数によって各出力ファイルにタイムスタンプが付けられます。  
![\[Amazon S3 ソースを使用した Amazon S3 デプロイアクションの [ステップ 5: デプロイ] ページ\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/tutorial-s3deploy-stage-s3source.png)

   1. (オプション) [**既定 ACL**] で、[既定 ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) と呼ばれる、あらかじめ定義された一連の許可を、アップロードされたアーティファクトに適用できます。

   1. (オプション) [**キャッシュコントロール**] で、キャッシュパラメータを入力します。これを設定して、リクエスト/レスポンスのキャッシュ動作を制御できます。有効な値については、HTTP オペレーションの [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) ヘッダーフィールドを参照してください。

   1. [**次へ**] を選択します。

1. [**ステップ 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/ja_jp/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/) をよく理解していること。
+ CLI AWS Serverless Application Repository を使用して に発行したサーバーレスアプリケーションが GitHub AWS SAM でホストされている。サンプルアプリケーションを に公開するには 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 デベロッパーガイド*[」の「 CLI AWS SAM を使用したアプリケーションの発行](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html)」を参照してください。

## ステップ 1: buildspec.yml ファイルを作成する
<a name="serverlessrepo-auto-publish-create-buildspec"></a>

`buildspec.yml` ファイルを以下のとおりに作成し、これをサーバーレスアプリケーションの GitHub リポジトリに追加します。*template.yml* をアプリケーションの AWS SAM テンプレートに置き換え、 *bucketname* をパッケージ化されたアプリケーションが保存されている S3 バケットに置き換えます。

```
version: 0.2
phases:
  install:
    runtime-versions:
        python: 3.8
  build:
    commands:
      - sam package --template-file template.yml --s3-bucket bucketname --output-template-file packaged-template.yml
artifacts:
  files:
    - packaged-template.yml
```

## ステップ 2: パイプラインを作成して設定する
<a name="serverlessrepo-auto-publish-create-pipeline"></a>

サーバーレスアプリケーションを公開 AWS リージョン する にパイプラインを作成するには、次の手順に従います。

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/) で CodePipeline コンソールを開きます。

1. 必要に応じて、サーバーレスアプリケーションを公開 AWS リージョン する に切り替えます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。[**次へ**] を選択します。

1. [**パイプラインの作成**] を選択します。**[ステップ 2: パイプラインの設定を選択する]** ページで、**[パイプライン名]** にパイプラインの名前を入力します。

1. **[パイプラインタイプ]** で、**[V2]** を選択します。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。**[Next]** (次へ) を選択します。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページの **[ソースプロバイダー]** で、**[GitHub]** を選択します。

1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理するには、[GitHub コネクション](connections-github.md) を参照してください。

1. [**リポジトリ**] で、GitHub ソースリポジトリを選択します。

1. [**ブランチ**] で、GitHub ブランチを選択します。

1.  ソースアクションの残りはデフォルトのままにしておきます。[**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** ページで、ビルドステージを追加します。

   1. [**ビルドプロバイダ**] で、[**AWS CodeBuild**] を選択します。[**リージョン**] で、パイプラインリージョンを使用します。

   1. **[プロジェクトを作成]** を選択します。

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] と [**ランタイムバージョン**] で、サーバーレスアプリケーションに必要なランタイムとバージョンを選択します。

   1. [**サービスロール**] で、[**New service role (新しいサービスロール)**] を選択します。

   1. [**ビルド仕様**] で、[**Use a buildspec file (ビルド仕様ファイルの使用)**] を選択します。

   1. [**Continue to CodePipeline **] (CodePipeline に進む) を選択します。これにより CodePipeline コンソールが開き、リポジトリ内の `buildspec.yml` の作成に使用する CodeBuild プロジェクトが作成されます。ビルドプロジェクトでは、サービスロールを使用して AWS のサービス のアクセス許可を管理します。このステップには数分かかる場合があります。

   1. [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 6: デプロイステージの追加]** ページで、**[デプロイステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。[**次へ**] を選択します。

1. **ステップ 7: 確認**で、**パイプラインの作成**を選択します。ステージを示す図が表示されます。

1. パッケージ化されたアプリケーションの保存先の S3 バケットにアクセスする許可を CodeBuild サービスロールに付与します。

   1. 新しいパイプラインの [**ビルド**] ステージで、[**CodeBuild**] を選択します。

   1. [**Build details (ビルドの詳細)**] タブを選択します。

   1. [**環境**] で、CodeBuild サービスロールを選択して IAM コンソールを開きます。

   1. `CodeBuildBasePolicy` の選択を展開し、[**Edit policy (ポリシーの編集)**] を選択します。

   1. **JSON** を選択します。

   1. 新しいポリシーステートメントを以下の内容で追加します。このステートメントにより、 CodeBuild はパッケージ化されたアプリケーションの保存先である S3 バケットにオブジェクトを配置できます。*bucketname* は、実際の S3 バケット名に置き換えます。

      ```
              {
                  "Effect": "Allow",
                  "Resource": [
                      "arn:aws:s3:::bucketname/*"
                  ],
                  "Action": [
                      "s3:PutObject"
                  ]
              }
      ```

   1. **[ポリシーの確認]** を選択します。

   1. **[Save changes]** (変更の保存) をクリックします。

## ステップ 3: 発行アプリケーションをデプロイする
<a name="serverlessrepo-auto-publish-deploy-app"></a>

以下のステップに従って、 AWS Serverless Application Repositoryの公開を実行する Lambda 関数を含むアプリケーションをデプロイします。このアプリケーションは **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 )のページに移動し、[**デプロイ**] を選択します。

1. [**I acknowledge that this app creates custom IAM roles (このアプリケーションがカスタム IAM ロールを作成することを承認します)**] を選択します。

1. **[デプロイ]** をクリックします。

1. ** CloudFormation スタックの表示**を選択して CloudFormation コンソールを開きます。

1. [**リソース**] セクションを展開します。**ServerlessRepoPublish** (**AWS::Lambda::Function** 型) が表示されます。このリソースの物理 ID を書き留めます。次のステップで使用します。この物理 ID は、CodePipeline で新しい公開アクションを作成するときに使用します。

## ステップ 4: 発行アクションを作成する
<a name="serverlessrepo-auto-publish-create-action"></a>

以下のステップに従って、パイプラインの発行アクションを作成します。

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. 左のナビゲーションセクションで、編集するパイプラインを選択します。

1. **[編集]** を選択します。

1. 現在のパイプラインの最後のステージが終わったら、[**\$1 Add stage (\$1 ステージの追加)**] を選択します。[**Stage name (ステージ名)**] に名前 (**Publish** など) を入力し、[**Add stage (ステージの追加)**] を選択します。

1. 新しいステージで、[**\$1 Add action group (\$1 アクショングループの追加)**] を選択します。

1. アクション名を入力します。[**アクションプロバイダ**] の [**呼び出し**] で、[**AWS Lambda**] を選択します。

1. [**入力アーティファクト**] で、[**BuildArtifact**] を選択します。

1. [**関数名**] で、前のステップで書き留めた Lambda 関数の物理 ID を選択します。

1. アクションの [**保存**] を選択します。

1. ステージの [**完了**] を選択します。

1. 右上の [**保存**] を選択します。

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>

このチュートリアルは、Lambda で設定した関数にコードをデプロイするデプロイアクションを CodePipeline で作成する方法について説明します。ここでは、サンプル Lambda 関数を作成します。この関数では、エイリアスとバージョンを作成し、圧縮された Lambda 関数をソースの場所に追加して、パイプラインで Lambda アクションを実行します。

**注記**  
コンソールでのパイプライン作成の一環として、CodePipeline は S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**注記**  
`Lambda` デプロイアクションは V2 タイプのパイプラインでのみ使用できます。

## 前提条件
<a name="tutorials-lambda-deploy-prereqs"></a>

このチュートリアルで CD パイプラインを作成する前に、いつくかのリソースを用意する必要があります。使用を開始するために必要なものは以下のとおりです。

**注記**  
これらのリソースはすべて、同じ AWS リージョン内に作成する必要があります。
+ GitHub などのソースコントロールリポジトリ、または Lambda 関数用に作成した `.zip` ファイルを保存するソース S3 バケット (このチュートリアルでは S3 を使用します)。
+ このアクションのアクセス許可で更新された既存の CodePipeline サービスロールを使用する必要があります。サービスロールを更新するには、「[Lambda デプロイアクションのサービスロールポリシーのアクセス許可](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action)」を参照してください。

これらの前提条件を満たした後、チュートリアルに進んで CD パイプラインを作成できます。

## ステップ 1: サンプル Lambda 関数を作成する
<a name="tutorials-lambda-deploy-instances"></a>

このステップでは、デプロイする Lambda 関数を作成します。

**Lambda 関数を作成するには**

1. Lambda コンソールにアクセスし、次のチュートリアルの手順に従ってサンプル Lambda 関数を作成します。

1. 上部のナビゲーションで **[作成]**を選択し、ページの上部で **[ゼロから開始]** を選択します。

1. [**名前**] に「**MyLambdaFunction**」と入力します。

1. 新しいバージョンを発行します。これは、エイリアスが指すボットの更新されたバージョンになります。

   1. 関数を選択します。

   1. **[アクション]** ドロップダウンメニューを選択します。

   1. **[新しいバージョンを発行]** を選択します。

   1. (オプション) **[説明]** に説明を追加します。

   1. **[公開]** を選択します。

1. `aliasV1` などの関数のエイリアスを作成します。

1. エイリアスが、先ほど作成したバージョン (1 など) を指していることを確認します。
**注記**  
[\$1LATEST] を選択した場合、Lambda は複数のバージョンを指すエイリアスに対して \$1LATEST をサポートしていないため、トラフィックシフト機能は使用できません。

## ステップ 2: 関数ファイルをリポジトリにアップロードする
<a name="tutorials-lambda-deploy-file"></a>

関数をダウンロードして、zip ファイルとして保存します。次の手順を使用して、圧縮ファイルを S3 バケットにアップロードします。

**ソースリポジトリに `.zip` ファイルを追加するには**

1. S3 バケットを開きます。

1. **アップロード** を選択します。

1. `sample_lambda_source.zip` ファイルを含む zip ファイルをソースバケットにアップロードします。

   パスをメモします。

   ```
   object key
   ```

## ステップ 3: パイプラインを作成する
<a name="tutorials-lambda-deploy-pipeline"></a>

CodePipeline ウィザードを使用してパイプラインステージを作成し、ソースリポジトリを接続します。

**パイプラインを作成するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **[サービスロール]** で、**[既存サービスロールの使用]** を選択し、このアクションに必要なアクセス許可で更新された CodePipeline サービスロールを選択します。このアクション用に CodePipeline サービスロールを設定するには、「[Lambda デプロイアクションのサービスロールポリシーのアクセス許可](action-reference-LambdaDeploy.md#action-reference-LambdaDeploy-permissions-action)」を参照してください。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページで、ソースステージを追加します。

   1. [**ソースプロバイダ**] で [**Amazon S3**] を選択します。

   1. **[オブジェクトキー]** で、`sample_lambda_source.zip` などのファイル拡張子を含む .zip ファイルの名前を追加します。

      

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** ページで、**[スキップ]** を選択します。

1. **[ステップ 5: テストステージの追加]** ページで、**[スキップ]** を選択します。

1. **[ステップ 6: デプロイステージの追加]** ページで、**[Lambda]** を選択します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)

   1. 関数名とエイリアスを追加します。

   1. デプロイ戦略を選択します。

   1. [**次へ**] を選択します。

1. **ステップ 7: 確認**ページで、パイプライン設定を確認し、**パイプラインの作成**を選択してパイプラインを作成します。  
![\[\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/lambdadeploy-pipeline-screen.png)

## ステップ 4: パイプラインのテスト
<a name="tutorials-lambda-deploy-test"></a>

パイプラインには、end-to-endのネイティブ AWS 継続的デプロイを実行するためのすべてが必要です。次は、コードの変更をソースリポジトリにプッシュすることで機能をテストします。

**パイプラインをテストするには**

1. 設定済みソースリポジトリにコード変更を行い、変更をコミットしてプッシュします。

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. リストからパイプラインを選択します。

1. ステージを通してパイプラインの進行状況を監視します。これでパイプラインが完了し、アクションが Lambda 関数にデプロイされます。

## 詳細情報
<a name="tutorials-lambda-deploy-learn"></a>

Lambda デプロイアクションでは、2 つのデプロイ方法を使用できます。1 つ目の方法は、ソースアクションからの入力アーティファクトなしでトラフィックを単独で移行することです。もう 1 つの方法は、ソースアクションの入力アーティファクトを使用して関数コードを更新し、更新されたコードに基づいて新しいバージョンを発行することです。2 つ目の方法では、エイリアスが指定されている場合、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` 変数を使用する
  + 3 つの新しい変数として `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 リポジトリ)](tutorials-simple-codecommit.md) の CodeCommit ソースを使用してパイプラインを作成または使用できます。
+ 既存のパイプラインを編集して CodeCommit ソースアクションに名前空間を含めます。名前空間 `SourceVariables` をアクションに割り当てます。

## ステップ 1: Lambda 関数を作成する
<a name="lambda-variables-function"></a>

次のステップを使用して Lambda 関数と Lambda 実行ロールを作成します。Lambda 関数を作成した後、パイプラインに Lambda アクションを追加します。

**Lambda 関数と実行ロールを作成するには**

1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) で AWS Lambda コンソールを開きます。

1. [**関数の作成**] を選択してください。[**一から作成**] が選択された状態のままにしておきます。

1. [**関数名**] に、関数の名前 (**myInvokeFunction** など) を入力します。[**ランタイム**] は、デフォルトのオプションを選択したままにします。

1. [**実行ロールの選択または作成**] を選択します。[**基本的な Lambda アクセス権限で新しいロールを作成**] を選択します。

1. [**関数の作成**] を選択してください。

1. 別のアクションからの変数を使用するには、Lambda 呼び出しアクションの設定で `UserParameters` にその変数を渡す必要があります。このチュートリアルで後ほどパイプラインのアクションを設定しますが、ここでは変数を渡したものとしてコードを追加します。

   新しい変数を生成するには、入力の `outputVariables` というプロパティを `putJobSuccessResult` に設定します。`putJobFailureResult` の一部として変数を生成することはできない点に注意してください。

   ```
    const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
   ```

   新しい関数の **[コード]** タブで、次のサンプルコードを `index.mjs` の下に貼り付けます。

   ```
   import { CodePipeline } from '@aws-sdk/client-codepipeline';
   
   export const handler = async (event, context) => {
       const codepipeline = new CodePipeline({});
       
       // Retrieve the Job ID from the Lambda action
       const jobId = event["CodePipeline.job"].id;
       
       // Retrieve UserParameters
       const params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
       
       // The region from where the lambda function is being executed
       const lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           
           try {
               await codepipeline.putJobSuccessResult(params);
               return message;
           } catch (err) {
               throw err;
           }
       };
       
       // Notify CodePipeline of a failed job
       const putJobFailure = async (message) => {
           const params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           
           try {
               await codepipeline.putJobFailureResult(params);
               throw message;
           } catch (err) {
               throw err;
           }
       };
       
       try {
           console.log("Testing commit - " + params);
           
           // Your tests here
           
           // Succeed the job
           return await putJobSuccess("Tests passed.");
       } catch (ex) {
           // If any of the assertions failed then fail the job
           return await putJobFailure(ex);
       }
   };
   ```

1. 自動保存することを関数に許可します。

1. 画面上部の **[関数 ARN]** にある Amazon リソースネーム (ARN) をコピーします。

1. 最後のステップとして、[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. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

    AWS アカウントに関連付けられているすべてのパイプラインの名前が表示されます。アクションを追加するパイプラインを選択します。

1. パイプラインに Lambda テストアクションを追加します。

   1. パイプラインを編集するには、[**編集**] を選択します。既存のパイプラインで、ソースアクションの後にステージを追加します。ステージの名前 (**Test** など) を入力します。

   1. 新しいステージで、**[アクショングループを追加する]** を選択してアクションを追加します。「**アクション名**」に、呼び出しアクションの名前 (**Test\$1Commit** など) を入力します。

   1. [**アクションプロバイダー**] で、[**AWS Lambda** ] を選択します。

   1. [**入力アーティファクト**] で、ソースアクションの出力アーティファクトの名前 (`SourceArtifact` など) を選択します。

   1. **[関数名]** で、作成した Lambda 関数の ARN を追加します。

   1. [**変数名前空間**] に名前空間名 (**TestVariables** など) を追加します。

   1. **[出力アーティファクト]** で、出力アーティファクト名 (**LambdaArtifact** など) を追加します。

   1. **[Done]** (完了) をクリックします。

1. パイプラインに手動の承認アクションを追加します。

   1. パイプラインが編集モードのままで、呼び出しアクションの後にステージを追加します。ステージの名前 (**Approval** など) を入力します。

   1. 新しいステージで、アクションを追加するアイコンを選択します。[**アクション名**] に、承認アクションの名前 (**Change\$1Approval** など) を入力します。

   1. [**アクションプロバイダ**] で、[**手動承認**] を選択します。

   1. [**レビューする URL**] で、`region` 変数と `CommitId` 変数の変数構文を追加して URL を作成します。出力変数を提供するアクションに割り当てられた名前空間を使用してください。

      この例では、CodeCommit アクションの変数構文を持つ URL にはデフォルトの名前空間 `SourceVariables` があります。Lambda リージョン出力変数には、`TestVariables` 名前空間があります。URL は次のようになります。

      ```
      https://#{TestVariables.region}.console.aws.amazon.com/codesuite/codecommit/repositories/MyDemoRepo/commit/#{SourceVariables.CommitId}
      ```

      [**コメント**] で、`testRunId` 変数の変数構文を追加して、承認メッセージテキストを作成します。この例では、Lambda `testRunId` 出力変数の変数構文を持つ URL には `TestVariables` 名前空間があります。以下のメッセージを入力します。

      ```
      Make sure to review the code before approving this action. Test Run ID: #{TestVariables.testRunId}
      ```

1. [**完了**] を選択してアクションの編集画面を閉じ、[**完了**] を選択してステージの編集画面を閉じます。パイプラインを保存するには、[**完了**] を選択します。完成したパイプラインには、ソース、テスト、承認、デプロイの各ステージがある構造が含まれています。

   [**変更のリリース**] を選択して、パイプライン構造で最新の変更を実行します。

1. パイプラインが手動承認ステージに達したら、[**確認**] を選択します。解決された変数は、コミット ID の URL として表示されます。承認者は、コミットを表示する URL を選択できます。

1. パイプラインが正常に実行されたら、アクションの実行履歴ページで変数の値を表示することもできます。

# チュートリアル: パイプラインで 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: パイプラインにステップ関数呼び出しアクションを追加する
](#tutorials-step-functions-pipeline)

## 前提条件: シンプルなパイプラインを作成または選択する
<a name="tutorials-step-functions-prereq"></a>

このチュートリアルでは、既存のパイプラインに呼び出しアクションを追加します。[チュートリアル: シンプルなパイプラインを作成する (S3 バケット)](tutorials-simple-s3.md) または [チュートリアル: シンプルなパイプラインを作成する (CodeCommit リポジトリ)](tutorials-simple-codecommit.md) で作成したパイプラインを使用できます。

ソースアクションと少なくとも 2 ステージ構造を持つ既存のパイプラインを使用しますが、この例ではソースアーティファクトを使用しません。

**注記**  
このアクションを実行するために必要な追加のアクセス許可を使用して、パイプラインで使用されるサービスロールを更新する必要がある場合があります。これを行うには、 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>

ステップ関数コンソールで、`HelloWorld` サンプルテンプレートを使用してステートマシンを作成します。手順については、*AWS Step Functions デベロッパーガイド* の [ステートマシンの作成](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started.html#create-state-machine) を参照してください。

## ステップ 2: パイプラインにステップ関数呼び出しアクションを追加する
<a name="tutorials-step-functions-pipeline"></a>

次のように、ステップ関数呼び出しアクションをパイプラインに追加します。

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

    AWS アカウントに関連付けられているすべてのパイプラインの名前が表示されます。

1. **[名前]** で、編集するパイプラインの名前を選択します。これにより、パイプラインの詳細ビューが開いて、パイプラインの各ステージの各アクションの状態などがわかります。

1. パイプライン詳細ページで、[**編集**] を選択します。

1. シンプルなパイプラインの 2 番目のステージで、[**Edit stage (ステージの編集)**] を選択します。**[削除]** を選択します。これで、不要になった 2 番目のステージが削除されました。

1. 図の最下部で [**\$1 Add stage]** (\$1 ステージの追加) を選択します。

1. [**ステージ名**] にステージ名 (**Invoke** など) を入力し、[**Add stage (ステージの追加)**] を選択します。

1. [**\$1 Add action group (\$1 アクションの追加)**] を選択します。

1. [**アクション名**] に名前 (**Invoke** など) を入力します。

1. [**アクションプロバイダー**] で、[**AWS ステップ関数**] を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

1. [**入力アーティファクト**] で [`SourceArtifact`] を選択します。

1. [**State machine ARN (ステートマシン ARN)**] で、前に作成したステートマシンの Amazon リソースネーム (ARN) を選択します。

1. (オプション) [**Execution name prefix (実行名のプレフィックス)**] に、ステートマシンの実行 ID に追加するプレフィックスを入力します。

1. [**Input type (入力タイプ)**] で [**Literal (リテラル)**] を選択します。

1. [**Input (入力)**] に、`HelloWorld` サンプルステートマシンが想定する入力 JSON を入力します。
**注記**  
ステートマシンの実行への入力は、CodePipeline でアクションの入力アーティファクトを記述するために使用される条件とは異なります。

   この例では、次の JSON を入力します。

   ```
   {"IsHelloWorldExample": true}
   ```

1. **[Done]** (完了) をクリックします。

1. 編集中のステージで、[**完了**] を選択します。 AWS CodePipeline のペインで [**保存**] を選択し、警告メッセージで [**保存**] を選択します。

1. 変更を送信してパイプラインの実行を開始するには、[**変更のリリース**]、[**リリース**] の順に選択します。

1. 完了したパイプライン内の呼び出しアクションで、[**AWS ステップ関数**] を選択します。 AWS Step Functions コンソールで、ステートマシンの実行 ID を表示します。ID には、ステートマシン名 `HelloWorld` と、ステートマシンの実行 ID とプレフィックス `my-prefix` が表示されます。

   ```
   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: AWS AppConfig リソースを作成する
](#tutorials-AppConfig-application)
+ [

## ステップ 2：ファイルを S3 ソースバケットにアップロードします。
](#tutorials-AppConfig-bucket)
+ [

## ステップ 3: パイプラインを作成する
](#tutorials-AppConfig-pipeline)
+ [

## ステップ 4 : 任意のソースファイルに変更を加えてデプロイを確認します。
](#tutorials-AppConfig-verify)

## 前提条件
<a name="tutorials-AppConfig-prereq"></a>

開始する前に、次を完了しておく必要があります。
+ この例では、パイプラインに S3 ソースを使用します。バージョニングが有効になっている Amazon S3 バケットを作成するか、使用します。「[ステップ 1: アプリケーションの S3 バケットを作成する](tutorials-simple-s3.md#s3-create-s3-bucket)」の手順に従って、S3 バケットを作成します。

## ステップ 1: AWS AppConfig リソースを作成する
<a name="tutorials-AppConfig-application"></a>

このセクションでは、次のリソースを作成します。
+  AWS AppConfig の*アプリケーション*は、顧客に機能を提供するコードの論理単位です。
+  AWS AppConfig の*環境*は、ベータ環境や本番環境のアプリケーションなど、AppConfig ターゲットの論理デプロイグループです。
+ *設定プロファイル* は、アプリケーションの動作に影響する設定のコレクションです。設定プロファイルにより、 AWS AppConfig は保存された場所にある設定にアクセスできます。
+ （オプション） AWS AppConfig の *デプロイメント戦略* は、デプロイメント中の任意の時点で、クライアントの何パーセントが新しいデプロイされた設定を受け取る必要があるかなど、設定デプロイメントの動作を定義します。

**アプリケーション、環境、設定プロファイル、デプロイ戦略を作成します。**

1.  AWS マネジメントコンソールにサインインします。

1.  AWS AppConfig のリソースを作成するには、次のトピックのステップを使用します
   + [アプリケーションを作成します](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-application.html)。
   + [環境を作成します](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-environment.html)。
   + [AWS CodePipeline 設定プロファイルを作成します](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-configuration-and-profile.html)。
   + (オプション) [定義済みのデプロイ戦略を選択するか、独自のデプロイメント戦略を作成します](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-deployment-strategy.html)。

## ステップ 2：ファイルを S3 ソースバケットにアップロードします。
<a name="tutorials-AppConfig-bucket"></a>

このセクションでは、設定ファイルを作成します。次に、パイプラインがソースステージに使用するバケットにソースファイルを zip してプッシュします。

**設定ファイルを作成します。**

1. 各リージョンの設定ごとに `configuration.json` ファイルを作成します。次の内容を含めます。:

   ```
   Hello World!
   ```

1. 次のステップを使用して、設定ファイルを zip してアップロードします。

**ソースファイルを zip してアップロードします。**

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 マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyAppConfigPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. **サービスロール** で、**新しいサービスロール** を選択して、CodePipeline が IAM でサービスロールを作成できるようにします。

1. [**詳細設定**] をデフォルト設定のままにし、[**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** の **[ソースプロバイダー]** で、**[Amazon S3]** を選択します。**バケット** で、S3 ソースバケットの名前を選択します。

   **S3 オブジェクトキー** に、ZIP ファイル名に `configuration-files.zip` を入力します。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、**[ビルドステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **[ステップ 5: テストステージの追加]** で、**[テストステージをスキップ]** を選択し、もう一度 **[スキップ]** を選択して警告メッセージを受け入れます。

   [**次へ**] を選択します。

1. **ステップ 6: デプロイステージの追加**:

   1. **[デプロイプロバイダー]** で、**[AWS AppConfig]** を選択します。

   1. **Application** で、 AWS AppConfig で作成したアプリケーションの名前を選択します。フィールドにはアプリケーションの ID が表示されます。

   1. Environment で****、 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>

ソースファイルに変更を加え、変更をバケットにアップロードします。これにより、パイプラインの実行がトリガーされます。バージョンを表示して、設定が使用可能であることを確認します。

# チュートリアル: CodeCommit パイプラインソースで完全なクローンを使用する
<a name="tutorials-github-gitclone"></a>

CodePipeline で GitHub ソースアクションの完全なクローンオプションを選択できます。このオプションを使用して、パイプラインビルドアクションで Git メタデータの CodeBuild コマンドを実行します。

**注記**  
ここで説明する完全クローンオプションは、CodePipeline でリポジトリメタデータをクローンするかどうかを指定するもので、CodeBuild コマンドでのみ使用できます。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)を使用するには、以下の手順に従って AWS Connector for GitHub アプリをインストールし、アプリのインストールフィールドを空のままにします。CodeConnections は、ユーザーアクセストークンを接続に使用します。



**重要**  
パイプライン作成の一環として、CodePipeline は、ユーザーが指定した S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

このチュートリアルでは、CodeCommit リポジトリにアクセスし、ソースデータに完全クローンオプションを使用し、リポジトリをクローンし、リポジトリの Git コマンドを実行する CodeBuild ビルドを実行するパイプラインを作成します。

**注記**  
この機能は、アジアパシフィック (香港）、アフリカ (ケープタウン）、中東 (バーレーン）、欧州 (チューリッヒ）、または AWS GovCloud (米国西部) の各リージョンでは使用できません。利用可能なその他のアクションについては、「[CodePipeline との製品とサービスの統合](integrations.md)」を参照してください。欧州 (ミラノ) リージョンでのこのアクションに関する考慮事項については、「[CodeStarSourceConnection (Bitbucket Cloud、GitHub、GitHub Enterprise Server、GitLab.com、および GitLab セルフマネージドアクションの場合)](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>

 このセクションでは、次のアクションを使用してパイプラインを作成します。
+ Bitbucket リポジトリとアクションへの接続を持つソースステージ。
+ ビルドアクションを含む AWS CodeBuild ビルドステージ。

**ウィザードを使用してパイプラインを作成するには**

1. CodePipeline コンソール ([http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codepipeline/)) にサインインします。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyGitHubPipeline**」と入力します。

1. このチュートリアルの目的では、**[パイプラインタイプ]** で、**[V1]** を選択します。**[V2]** を選択することもできますが、パイプラインタイプは特性と価格が異なることに注意してください。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。

1. [**サービスロール**] で、[**New service role (新しいサービスロール)**] を選択します。
**注記**  
既存の CodePipeline サービスロールを代わりに使用する場合は、サービスロールポリシーに対する `codestar-connections:UseConnection` IAM アクセス許可を追加したことを確認してください。CodePipeline サービスロールの手順については、「[Add permissions to the the CodePipeline service role](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#how-to-update-role-new-services)」を参照してください。

1. **[詳細設定]** では、デフォルト値のままにします。**アーティファクトストア**で、[**Default location**] (デフォルトの場所)を選択し、パイプライン用に選択したリージョン内のパイプラインのデフォルトのアーティファクトストア (デフォルトとして指定された Amazon S3 アーティファクトバケットなど) を使用します。
**注記**  
これはソースコードのソースバケットではありません。パイプラインのアーティファクトストアです。パイプラインごとに S3 バケットなどの個別のアーティファクトストアが必要です。

   [**次へ**] を選択します。

1. **[ステップ 3: ソースステージの追加]** ページで、ソースステージを追加します。

   1. **[ソースプロバイダー]** で、**[GitHub (GitHub アプリ経由)]** を選択します。

   1. **接続** で、既存の接続を選択するか、新規の接続を作成します。GitHub ソースアクション用の接続を作成または管理するには、「[GitHub コネクション](connections-github.md)」を参照してください。

      特定のプロバイダーへのすべての接続に対してアプリを 1 つインストールします。 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. **BranchName** に、使用するリポジトリブランチを入力します。

   1. **[ソースコードの変更時にパイプラインを開始する]** オプションが選択されていることを確認します。

   1. [**出力アーティファクト形式**] で [**完全なクローン**] を選択し、ソースリポジトリの Git クローンオプションを有効にします。Git クローンオプションを使用できるのは、CodeBuild によって提供されるアクションだけです。このチュートリアルでは、このオプションを使用するための CodeBuild プロジェクトサービスロールの許可を更新するために [ステップ 3: 接続を使用するように CodeBuild サービスロールポリシーを更新する](#tutorials-github-gitclone-rolepolicy) を使用します。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、ビルドステージを追加します。

   1. [**ビルドプロバイダ**] で、[**AWS CodeBuild**] を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. **[プロジェクトを作成]** を選択します。

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。[**イメージ**] で、[**aws/codebuild/standard:5.0**] を選択します。

   1. [**サービスロール**] で、[**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 アクセス許可を追加します。](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 ソースアクションの完全なクローンオプションを選択できます。このオプションを使用して、CodeBuild がパイプライン構築アクションで Git メタデータにアクセスできるようにします。

このチュートリアルでは、CodeCommit リポジトリにアクセスし、ソースデータの完全なクローンオプションを使用し、リポジトリのクローンを作成してリポジトリの Git コマンドを実行する CodeBuild 構築を実行するパイプラインを作成します。

**注記**  
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. CodePipeline コンソール ([http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codepipeline/)) にサインインします。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyCodeCommitPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. [**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 クローンオプションを有効にします。Git クローンオプションを使用できるのは、CodeBuild によって提供されるアクションだけです。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、以下を行います。

   1. [**ビルドプロバイダ**] で、[**AWS CodeBuild**] を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. **[プロジェクトを作成]** を選択します。

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。[**イメージ**] で、[**aws/codebuild/standard:5.0**] を選択します。

   1. [**サービスロール**] で、[**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 コンソールでポリシーを更新する手順については、[CodeBuild GitClone のアクセス権限を CodeCommit ソースアクションに追加します。](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 アカウント されており、安全で信頼できることを確認してください。

スタックセットのアクセス許可を管理するには、セルフマネージド IAM ロールとマネージド IAM ロール AWSの 2 つの方法があります。このチュートリアルでは、セルフマネージド型の許可の例を示します。

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: CloudFormationsStackInstances アクションを追加する
](#tutorials-stacksets-instances)
+ [

## ステップ 5: デプロイのスタックセットリソースを表示する
](#tutorials-stacksets-view)
+ [

## ステップ 6: スタックセットを更新する
](#tutorials-stacksets-update)

## 前提条件
<a name="tutorials-stackset-deployment-prereq"></a>

スタックセットオペレーションでは、管理者アカウントとターゲットアカウントの 2 つの異なるアカウントを使用します。管理者アカウントでは、スタックセットを作成します。ターゲットアカウントでは、スタックセットに属する個別のスタックを作成します。

**管理者アカウントで管理者ロールを作成するには**
+ 「[スタックセットオペレーションの基本アクセス許可の設定](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. バケットが作成されると、成功バナーが表示されます。[**バケットの詳細に移動**] を選択します。

1. [**プロパティ**] タブで、[**バージョニング**] を選択します。[**バージョニングの有効化**] を選択し、[**保存**] を選択します。

**AWS CloudFormation テンプレートファイルを作成するには**

1. スタックセットの CloudTrail 設定を生成するために、サンプルテンプレートファイル [https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml](https://s3.amazonaws.com/cloudformation-stackset-sample-templates-us-east-1/EnableAWSCloudtrail.yml) をダウンロードします。

1. `template.yml` という名前でファイルを保存します。

**parameters.txt ファイルを作成するには**

1. デプロイのパラメータでファイルを作成します。パラメータは、実行時にスタック内で更新する値です。次のサンプルファイルは、スタックセットのテンプレートパラメータを更新して、ログ記録検証とグローバルイベントを有効にします。

   ```
   [
     {
       "ParameterKey": "EnableLogFileValidation",
       "ParameterValue": "true"
     }, 
     {
       "ParameterKey": "IncludeGlobalEvents",
       "ParameterValue": "true"
     }
   ]
   ```

1. `parameters.txt` という名前でファイルを保存します。

**accounts.txt ファイルを作成するには**

1. 次のサンプルファイルに示されているように、インスタンスを作成するアカウントでファイルを作成します。

   ```
   [
       "111111222222","333333444444"
   ]
   ```

1. `accounts.txt` という名前でファイルを保存します。

**ソースファイルを作成してアップロードするには**

1. ファイルを単一の zip ファイルに結合します。ファイルは zip ファイルで以下のようになっています。

   ```
   template.yml
   parameters.txt
   accounts.txt
   ```

1. zip ファイルを S3 バケットにアップロードします。このファイルは、CodePipeline でのデプロイアクションのために [**パイプラインを作成する**] ウィザードによって作成されたソースアーティファクトです。

## ステップ 2: パイプラインを作成する
<a name="tutorials-stackset-action-pipeline"></a>

このセクションでは、次のアクションを使用してパイプラインを作成します。
+ ソースアーティファクトがテンプレートファイルやサポートソースファイルである S3 ソースアクションのあるソースステージ。
+  CloudFormation スタックセットを作成するスタックセットデプロイアクションを含むデプロイステージ。
+ ターゲットアカウント内に CloudFormation スタックとインスタンスを作成するスタックインスタンスのデプロイアクションを含むデプロイステージ。

**CloudFormationStackSet アクションを使用してパイプラインを作成するには**

1. にサインイン AWS マネジメントコンソール し、[http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home) で CodePipeline コンソールを開きます。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyStackSetsPipeline**」と入力します。

1. このチュートリアルの目的では、**[パイプラインタイプ]** で、**[V1]** を選択します。**[V2]** を選択することもできますが、パイプラインタイプは特性と価格が異なることに注意してください。詳細については、「[パイプラインのタイプ](pipeline-types.md)」を参照してください。

1. [**サービスロール**] で、[**新しいサービスロール**] を選択し、CodePipeline に IAM でのサービスロールの作成を許可します。

1. [**アーティファクトストア**] では、デフォルト値はそのままにしておきます。
**注記**  
これはソースコードのソースバケットではありません。パイプラインのアーティファクトストアです。パイプラインごとに S3 バケットなどの個別のアーティファクトストアが必要です。パイプラインを作成または編集するときは、パイプラインリージョンにアーティファクトバケットと、アクションを実行している AWS リージョンごとに 1 つのアーティファクトバケットが必要です。  
詳細については、「[入力および出力アーティファクト](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. [**スタックセット名**] に、スタックセットの名前を入力します。これは、テンプレートが作成するスタックセットの名前です。
**注記**  
スタックセット名を記録します。この名前は、パイプラインに 2 番目の StackSets デプロイアクションを追加するときに使用します。

   1. [**テンプレートパス**] に、テンプレートファイルをアップロードしたアーティファクト名とファイルパスを入力します。例えば、デフォルトのソースアーティファクト名 `SourceArtifact` を使用して次のように入力します。

      ```
      SourceArtifact::template.yml
      ```

   1. [**デプロイターゲット**] に、アカウントファイルをアップロードしたアーティファクト名とファイルパスを入力します。例えば、デフォルトのソースアーティファクト名 `SourceArtifact` を使用して次のように入力します。

      ```
      SourceArtifact::accounts.txt
      ```

   1. **デプロイターゲット AWS リージョン**で、 など、最初のスタックインスタンスをデプロイするリージョンを 1 つ入力します`us-east-1`。

   1. [**デプロイオプション**] を拡張します。[**パラメータ**] に、パラメータファイルをアップロードしたアーティファクト名とファイルパスを入力します。例えば、デフォルトのソースアーティファクト名 `SourceArtifact` を使用して次のように入力します。

      ```
      SourceArtifact::parameters.txt
      ```

      パラメータをファイルパスではなく、リテラル入力として入力するには、次のように入力します。

      ```
      ParameterKey=EnableLogFileValidation,ParameterValue=true
      ParameterKey=IncludeGlobalEvents,ParameterValue=true
      ```

   1. [**Capabilities**] (機能) で、[CAPABILITY\$1IAM] と [CAPABILITY\$1NAMED\$1IAM] を選択します。

   1. [**アクセス許可モデル**] で、[SELF\$1MANAGED] を選択します。

   1. [**障害耐性の割合**] に「`20`」と入力します。

   1. [**最大同時割合**] に「`25`」と入力します。

   1. [**次へ**] を選択します。

   1. **[ステップ 7: レビュー]** で、**[パイプラインを作成する]** を選択します。パイプラインが表示されます。

   1. パイプラインの実行を許可します。

## ステップ 3: 初期デプロイを表示する
<a name="tutorials-stackset-action-initial"></a>

初期デプロイのリソースとステータスを表示します。デプロイでスタックセットが正常に作成されたことを確認したら、2 番目のアクションを [**デプロイ**] ステージに追加します。

**リソースを表示するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

1. パイプラインの **CloudFormationStackSet** CloudFormation アクションで アクションを選択します。スタックセットのテンプレート、リソース、イベントが CloudFormation コンソールに表示されます。

1. 左のナビゲーションメニューから [**StackSets**] を選択します。リストで、新しいスタックセットを選択します。

1. [**スタックインスタンス**] タブを選択します。us-east-1 リージョンでは、提供したアカウントごとに 1 つのスタックインスタンスが作成されていることを確認します。各スタックインスタンスのステータスが `CURRENT` になっていることを確認します。

## ステップ 4: CloudFormationsStackInstances アクションを追加する
<a name="tutorials-stacksets-instances"></a>

パイプラインに次のアクションを作成し、 CloudFormation StackSets が残りのスタックインスタンスを作成できるようにします。

**パイプラインで次のアクションを作成するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

   [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

1. パイプラインの編集を選択します。パイプラインは [**編集**] モードで表示されます。

1. [**デプロイ**] ステージで、[**編集**] を選択します。

1. [**AWS CloudFormation スタックセット**] デプロイアクションで、[**アクショングループの追加**] を選択します。

1. [**アクションの編集**] ページで、アクションの詳細を追加します。

   1. [**アクション名**] に、アクションの名前を入力します。

   1. [**アクションプロバイダー**] で、[**AWS CloudFormation スタックインスタンス**] を選択します。

   1. [**入力アーティファクト**] で、[**ソースアーティファクト**] を選択します。

   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. 手動で変更を解除します。更新されたパイプラインがデプロイステージに 2 つのアクションと共に表示されます。

## ステップ 5: デプロイのスタックセットリソースを表示する
<a name="tutorials-stacksets-view"></a>

スタックセットのデプロイのリソースとステータスを表示します。

**リソースを表示するには**

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**パイプライン**] で、パイプラインを選択してから、[**表示**] を選択します。この図は、パイプラインのソースとデプロイのステージを示しています。

1. パイプライン内の CloudFormation アクションの**`AWS CloudFormation Stack Instances`**アクションを選択します。スタックセットのテンプレート、リソース、イベントが CloudFormation コンソールに表示されます。

1. 左のナビゲーションメニューから [**StackSets**] を選択します。リストで、スタックセットを選択します。

1. [**スタックインスタンス**] タブを選択します。提供した各アカウントの残りのスタックインスタンスが、すべて想定したリージョンで作成または更新されていることを確認します。各スタックインスタンスのステータスが `CURRENT` になっていることを確認します。

## ステップ 6: スタックセットを更新する
<a name="tutorials-stacksets-update"></a>

スタックセットを更新し、インスタンスに更新をデプロイします。この例では、更新用に指定するデプロイターゲットも変更します。更新のパートではないインスタンスは、古いステータスに移行します。

1. CodePipeline コンソール ([https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)) を開きます。

1. [**パイプライン**] で、パイプラインを選択してから、[**編集**] を選択します。[**デプロイ**] ステージで、[**編集**] を選択します。

1. パイプラインで、[**AWS CloudFormation スタックセット**] アクションを選択して編集します。[**説明**] で、既存の説明をスタックセットの新しい説明に書き直します。

1. パイプラインで、[**AWS CloudFormation スタックインスタンス**] アクションを選択して編集します。**デプロイターゲット AWS リージョン**で、アクションの作成時に入力された`us-east-2`値を削除します。

1. 変更を保存します。[**変更のリリース**] を選択して、パイプラインを実行します。

1.  CloudFormationでアクションを開きます。[**StackSet の情報**] タブを選択します。[**StackSet の説明**] で、新しい説明が表示されていることを確認します。

1. [**スタックインスタンス**] タブを選択します。[**ステータス**] で、us-east-2 のスタックインスタンスのステータスが `OUTDATED` であることを確認します。

# チュートリアル: パイプラインの変数チェックルールを入力条件として作成する
<a name="tutorials-varcheckrule"></a>

このチュートリアルでは、ソースステージで GitHub をソースアクションプロバイダーとして使用して、ファイルを継続的に配信するパイプラインを設定します。ソースリポジトリ内のソースファイルに変更を加えると、完成したパイプラインはその変更を検出します。パイプラインは出力変数を実行して、ビルドステージへの入力条件で指定したソースリポジトリ名およびブランチ名と照合します。

**重要**  
パイプライン作成の一環として、CodePipeline は、ユーザーが指定した S3 アーティファクトバケットをアーティファクトとして使用します (これは S3 ソースアクションで使用するバケットとは異なります)。S3 アーティファクトバケットがパイプラインのアカウントとは異なるアカウントにある場合は、S3 アーティファクトバケットが によって所有 AWS アカウント されており、安全で信頼できることを確認してください。

**重要**  
この手順でパイプラインに追加するアクションの多くには、パイプラインを作成する前に作成する必要がある AWS リソースが含まれます。ソースアクションの AWS リソースは常に、パイプラインを作成するのと同じ AWS リージョンで作成する必要があります。例えば、米国東部 (オハイオ) リージョンにパイプラインを作成している場合、CodeCommit リポジトリは米国東部 (オハイオ) リージョンにある必要があります。  
パイプラインの作成時にクロスリージョンアクションを追加できます。クロスリージョンアクションの AWS リソースは、アクションを実行する予定のリージョンと同じ AWS リージョンに存在する必要があります。詳細については、「[CodePipeline にクロスリージョンアクションを追加する](actions-create-cross-region.md)」を参照してください。

この例では、GitHub (Version2) ソースアクションと 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」を含むコミットメッセージを追加します。

   ```
   Update to source files
   ```
**注記**  
文字列のルールチェックでは、大文字と小文字が区別されます。

   `README.md` ファイルがリポジトリのルートレベルにあることを確認してください。

## ステップ 2: パイプラインを作成する
<a name="tutorials-varcheckrule-create-pipeline"></a>

このセクションでは、次のアクションを使用してパイプラインを作成します。
+ Bitbucket リポジトリとアクションへの接続を持つソースステージ。
+ CodeBuild ビルドステージ。ステージには、変数チェックルールに対するエントリ時の条件が設定されています。

**ウィザードを使用してパイプラインを作成するには**

1. CodePipeline コンソール ([http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codepipeline/)) にサインインします。

1. [**ようこそ**] ページ、[**開始方法**] ページ、または [**パイプライン**] ページで、[**パイプラインの作成**] を選択します。

1. **[ステップ 1: 作成オプションを選択する]** ページの **[作成オプション]** で、**[カスタムパイプラインを構築する]** オプションを選択します。**[次へ]** を選択します。

1. **[ステップ 2: パイプラインの設定を選択する]** で、**[パイプライン名]** に「**MyVarCheckPipeline**」と入力します。

1. CodePipeline は、特徴と料金が異なる V1 タイプと V2 タイプのパイプラインを提供しています。V2 タイプは、コンソールで選択できる唯一のタイプです。詳細については、「[パイプラインタイプ](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel)」を参照してください。CodePipeline の料金については、[料金](https://aws.amazon.com/codepipeline/pricing/)を参照してください。

1. [**サービスロール**] で、[**New service role (新しいサービスロール)**] を選択します。
**注記**  
既存の CodePipeline サービスロールを代わりに使用する場合は、サービスロールポリシーに対する `codeconnections:UseConnection` IAM アクセス許可を追加したことを確認してください。CodePipeline サービスロールの手順については、「[Add permissions to the the CodePipeline service role](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. **BranchName** に、使用するリポジトリブランチを入力します。

   1. **[トリガーなし]** オプションが選択されていないことを確認します。

   [**次へ**] を選択します。

1. **[ステップ 4: ビルドステージの追加]** で、ビルドステージを追加します。

   1. [**ビルドプロバイダ**] で、[**AWS CodeBuild**] を選択します。**[リージョン]** をデフォルトでパイプラインのリージョンにすることを許可します。

   1. **[プロジェクトを作成]** を選択します。

   1. [**プロジェクト名**] に、このビルドプロジェクトの名前を入力します。

   1. [**環境イメージ**] で、[**Managed image (マネージド型イメージ)**] を選択します。[**Operating system**] で、[**Ubuntu**] を選択します。

   1. [**ランタイム**] で、[**Standard (標準)**] を選択します。[**イメージ**] で、[**aws/codebuild/standard:5.0**] を選択します。

   1. [**サービスロール**] で、[**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>

このステップでは、ステージを編集して、可変チェックルールのエントリ時の条件を追加します。

1. パイプラインを選択し、**[編集]** を選択します。ビルドステージでエントリルールを追加することを選択します。

   **[ルールプロバイダー]** で、**[VariableCheck]** を選択します。

1. **[変数]** に、チェックする変数を入力します。**[値]** に文字列値を入力して、解決された変数と照合します。次の画面の例では、[等しい] チェック用のルールを作成し、[含む] チェック用の別のルールを作成します。  
![\[[等しい] 変数チェックのルール作成ページ\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/varcheck-tut-create-rule-equals.png)  
![\[[含む] 変数チェックのルール作成ページ\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/varcheck-tut-create-rule-contains.png)

1. **[保存]** を選択します。

   **[Done]** (完了) をクリックします。

## ステップ 3: パイプラインを実行し、解決された変数を表示する
<a name="tutorials-varcheckrule-run"></a>

このステップでは、変数チェックルールの解決された値と結果を表示します。

1. 次の例に示すように、ルールチェックが成功した後の解決された実行を表示します。  
![\[成功した実行\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/varcheck-tut-run-succeeded.png)

1. **[タイムライン]** タブで変数情報を表示します。  
![\[変数が成功した [タイムライン] タブを示す履歴ページ\]](http://docs.aws.amazon.com/ja_jp/codepipeline/latest/userguide/images/varcheck-tut-history.png)