

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Tutorial: Membuat pipeline dengan sumber dan ECS-to-CodeDeploy penerapan Amazon ECR
<a name="tutorials-ecs-ecr-codedeploy"></a>

Dalam tutorial ini, Anda mengonfigurasi pipeline AWS CodePipeline yang menyebarkan aplikasi kontainer menggunakan blue/green penerapan yang mendukung gambar Docker. Dalam penerapan biru/hijau, Anda dapat meluncurkan versi baru aplikasi Anda bersama versi lama dan menguji versi baru sebelum Anda mengubah rute lalu lintas. Anda juga dapat memantau proses penerapan dan memutar kembali dengan cepat jika ada masalah.

**penting**  
Sebagai bagian dari pembuatan pipa, ember artefak S3 yang disediakan oleh pelanggan akan digunakan CodePipeline untuk artefak. (Ini berbeda dari bucket yang digunakan untuk aksi sumber S3.) Jika bucket artefak S3 berada di akun yang berbeda dari akun untuk pipeline Anda, pastikan bucket artefak S3 dimiliki oleh Akun AWS yang aman dan dapat diandalkan.

**catatan**  
Tutorial ini untuk Amazon ECS untuk CodeDeploy tindakan penyebaran biru/hijau untuk. CodePipeline Untuk tutorial yang menggunakan tindakan penerapan standar Amazon ECS CodePipeline, lihat. [Tutorial: Penerapan Standar Amazon ECS dengan CodePipeline](ecs-cd-pipeline.md)

Pipeline yang telah selesai mendeteksi perubahan pada gambar Anda, yang disimpan dalam repositori gambar seperti Amazon ECR, dan digunakan CodeDeploy untuk merutekan dan menyebarkan lalu lintas ke cluster Amazon ECS dan penyeimbang beban. CodeDeploy menggunakan pendengar untuk mengalihkan lalu lintas ke port wadah yang diperbarui yang ditentukan dalam file. AppSpec Untuk informasi tentang cara penyeimbang beban, pendengar produksi, grup target, dan aplikasi Amazon ECS Anda digunakan dalam blue/green penerapan, lihat [Tutorial: Menerapkan Layanan Amazon ECS](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html).

Pipeline juga dikonfigurasi untuk menggunakan lokasi sumber, seperti CodeCommit, tempat definisi tugas Amazon ECS Anda disimpan. Dalam tutorial ini, Anda mengonfigurasi masing-masing sumber AWS daya ini dan kemudian membuat pipeline Anda dengan tahapan yang berisi tindakan untuk setiap sumber daya.

Pipeline pengiriman berkelanjutan Anda akan secara otomatis membuat dan menerapkan gambar kontainer setiap kali kode sumber diubah atau gambar dasar baru diunggah ke Amazon ECR.

Aliran ini menggunakan artefak berikut:
+ File image Docker yang menentukan nama container dan URI repositori repositori image Amazon ECR Anda.
+ Definisi tugas Amazon ECS yang mencantumkan nama gambar Docker, nama kontainer, nama layanan Amazon ECS, dan konfigurasi penyeimbang beban.
+  CodeDeploy AppSpec File yang menentukan nama file definisi tugas Amazon ECS, nama kontainer aplikasi yang diperbarui, dan port kontainer tempat CodeDeploy mengalihkan lalu lintas produksi. Ini juga dapat menentukan konfigurasi jaringan opsional dan fungsi Lambda yang dapat Anda jalankan selama kait peristiwa siklus hidup penerapan.

**catatan**  
Saat Anda melakukan perubahan ke repositori gambar Amazon ECR, tindakan sumber pipeline akan membuat `imageDetail.json` file untuk komit tersebut. Untuk informasi tentang `imageDetail.json` file, lihat[File ImageDetail.json untuk tindakan penerapan Amazon ECS blue/green](file-reference.md#file-reference-ecs-bluegreen).

Saat Anda membuat atau mengedit pipeline dan memperbarui atau menentukan artefak sumber untuk tahap penerapan, pastikan untuk menunjuk ke artefak sumber dengan nama dan versi terbaru yang ingin Anda gunakan. Setelah menyiapkan pipeline, saat membuat perubahan pada definisi gambar atau tugas, Anda mungkin perlu memperbarui file artefak sumber di repositori, lalu mengedit tahap penerapan di pipeline.

**Topics**
+ [Prasyarat](#tutorials-ecs-ecr-codedeploy-prereq)
+ [Langkah 1: Buat gambar dan dorong ke repositori Amazon ECR](#tutorials-ecs-ecr-codedeploy-imagerepository)
+ [Langkah 2: Buat definisi tugas dan file AppSpec sumber dan dorong ke CodeCommit repositori](#tutorials-ecs-ecr-codedeploy-taskdefinition)
+ [Langkah 3: Buat Application Load Balancer dan grup target](#tutorials-ecs-ecr-codedeploy-loadbal)
+ [Langkah 4: Buat kluster dan layanan Amazon ECS Anda](#tutorials-ecs-ecr-codedeploy-cluster)
+ [Langkah 5: Buat grup CodeDeploy aplikasi dan penyebaran Anda (platform komputasi ECS)](#tutorials-ecs-ecr-codedeploy-deployment)
+ [Langkah 6: Buat pipeline Anda](#tutorials-ecs-ecr-codedeploy-pipeline)
+ [Langkah 7: Buat perubahan pada pipeline Anda dan verifikasi penerapan](#tutorials-ecs-ecr-codedeploy-update)

## Prasyarat
<a name="tutorials-ecs-ecr-codedeploy-prereq"></a>

Anda harus sudah membuat sumber daya berikut:
+ Sebuah CodeCommit repositori. Anda dapat menggunakan AWS CodeCommit repositori yang Anda buat. [Tutorial: Buat pipeline sederhana (CodeCommit repositori)](tutorials-simple-codecommit.md)
+ Luncurkan instance Amazon EC2 Linux dan instal Docker untuk membuat gambar seperti yang ditunjukkan dalam tutorial ini. Jika Anda sudah memiliki gambar yang ingin Anda gunakan, Anda dapat melewati prasyarat ini.

## Langkah 1: Buat gambar dan dorong ke repositori Amazon ECR
<a name="tutorials-ecs-ecr-codedeploy-imagerepository"></a>

Di bagian ini, Anda menggunakan Docker untuk membuat gambar dan kemudian menggunakan AWS CLI untuk membuat repositori Amazon ECR dan mendorong gambar ke repositori.

**catatan**  
Jika Anda sudah memiliki gambar yang ingin Anda gunakan, Anda dapat melewati langkah ini.

**Untuk membuat gambar**

1. Masuk ke instance Linux Anda di mana Anda telah menginstal Docker.

   Tarik gambar ke bawah untuk`nginx`. Perintah ini memberikan `nginx:latest` gambar:

   ```
   docker pull nginx
   ```

1. Jalankan **docker images**. Anda akan melihat gambar dalam daftar.

   ```
   docker images
   ```

**Untuk membuat repositori Amazon ECR dan mendorong gambar Anda**

1. Buat repositori Amazon ECR untuk menyimpan gambar Anda. Buat catatan `repositoryUri` di output.

   ```
   aws ecr create-repository --repository-name nginx
   ```

   Output:

   ```
   {
       "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. Tandai gambar dengan `repositoryUri` nilai dari langkah sebelumnya.

   ```
   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

1. Jalankan **aws ecr get-login-password** perintah, seperti yang ditunjukkan dalam contoh ini untuk `us-west-2` Region dan ID akun 111122223333.

   ```
   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. Dorong gambar ke Amazon ECR menggunakan `repositoryUri` dari langkah sebelumnya.

   ```
   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest
   ```

## Langkah 2: Buat definisi tugas dan file AppSpec sumber dan dorong ke CodeCommit repositori
<a name="tutorials-ecs-ecr-codedeploy-taskdefinition"></a>

Di bagian ini, Anda membuat file JSON definisi tugas dan mendaftarkannya ke Amazon ECS. Anda kemudian membuat AppSpec file untuk CodeDeploy dan menggunakan klien Git Anda untuk mendorong file ke CodeCommit repositori Anda.

**Untuk membuat definisi tugas untuk gambar Anda**

1. Buat file bernama `taskdef.json` dengan isi berikut ini. Untuk`image`, masukkan nama gambar Anda, seperti nginx. Nilai ini diperbarui saat pipeline Anda berjalan.
**catatan**  
Pastikan bahwa peran eksekusi yang ditentukan dalam definisi tugas berisi`AmazonECSTaskExecutionRolePolicy`. Untuk informasi selengkapnya, lihat [Peran IAM Eksekusi Tugas Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) di Panduan Pengembang *Amazon ECS.*

   ```
   {
       "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. Daftarkan definisi tugas Anda dengan `taskdef.json` file.

   ```
   aws ecs register-task-definition --cli-input-json file://taskdef.json
   ```

1. Setelah definisi tugas terdaftar, edit file Anda untuk menghapus nama gambar dan sertakan teks `<IMAGE1_NAME>` placeholder di bidang gambar.

   ```
   {
       "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"
   }
   ```

**Untuk membuat AppSpec file**
+  AppSpec File ini digunakan untuk CodeDeploy penerapan. File, yang mencakup bidang opsional, menggunakan format ini:

  ```
  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"
  ```

  Untuk informasi selengkapnya tentang AppSpec file, termasuk contoh, lihat [Referensi CodeDeploy AppSpec File](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html).

  Buat file bernama `appspec.yaml` dengan isi berikut ini. Untuk`TaskDefinition`, jangan mengubah teks `<TASK_DEFINITION>` placeholder. Nilai ini diperbarui saat pipeline Anda berjalan.

  ```
  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80
  ```

**Untuk mendorong file ke CodeCommit repositori Anda**

1. Dorong atau unggah file ke CodeCommit repositori Anda. File-file ini adalah artefak sumber yang dibuat oleh wizard **Create pipeline** untuk tindakan penerapan Anda. CodePipeline File Anda akan terlihat seperti ini di direktori lokal Anda:

   ```
   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json
   ```

1. Pilih metode yang ingin Anda gunakan untuk mengunggah file Anda:

   1. Untuk menggunakan baris perintah git Anda dari repositori kloning di komputer lokal Anda:

      1. Ubah direktori ke repositori lokal Anda:

         ```
         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo
         ```

      1. Jalankan perintah berikut untuk mementaskan semua file Anda sekaligus:

         ```
         git add -A
         ```

      1. Jalankan perintah berikut untuk mengkomit file dengan pesan komit:

         ```
         git commit -m "Added task definition files"
         ```

      1. Jalankan perintah berikut untuk mendorong file dari repo lokal Anda ke CodeCommit repositori Anda:

         ```
         git push
         ```

   1. Untuk menggunakan CodeCommit konsol untuk mengunggah file Anda:

      1. **Buka CodeCommit konsol, dan pilih repositori Anda dari daftar Repositori.**

      1. Pilih **Tambahkan file**, lalu pilih **Unggah file**.

      1. Pilih **Pilih file**, lalu telusuri file Anda. Lakukan perubahan dengan memasukkan nama pengguna dan alamat email Anda. Pilih **Perubahan commit**.

      1. Ulangi langkah ini untuk setiap file yang ingin Anda unggah.

## Langkah 3: Buat Application Load Balancer dan grup target
<a name="tutorials-ecs-ecr-codedeploy-loadbal"></a>

Di bagian ini, Anda membuat Application Load Balancer Amazon EC2. Anda menggunakan nama subnet dan nilai grup target yang Anda buat dengan penyeimbang beban nanti, saat Anda membuat layanan Amazon ECS. Anda dapat membuat Application Load Balancer atau Network Load Balancer. Penyeimbang beban harus menggunakan VPC dengan dua subnet publik di Availability Zone yang berbeda. Dalam langkah-langkah ini, Anda mengonfirmasi VPC default Anda, membuat penyeimbang beban, dan kemudian membuat dua grup target untuk penyeimbang beban Anda. Untuk informasi selengkapnya, lihat [Grup Target untuk Penyeimbang Beban Jaringan Anda](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html).

**Untuk memverifikasi VPC default dan subnet publik**

1. Masuk ke Konsol Manajemen AWS dan buka konsol VPC Amazon di. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)

1. Verifikasi VPC default yang akan digunakan. Di panel navigasi, pilih **Your VPCs**. Perhatikan VPC mana yang menunjukkan **Ya di kolom** **VPC** Default. Ini adalah VPC default. Ini berisi subnet default untuk Anda pilih.

1. Pilih **Subnet**. Pilih dua subnet yang menunjukkan **Ya di kolom** **subnet Default**.
**catatan**  
Catat subnet IDs Anda. Anda membutuhkannya nanti dalam tutorial ini.

1. Pilih subnet, lalu pilih tab **Deskripsi**. Verifikasi bahwa subnet yang ingin Anda gunakan berada di Availability Zone yang berbeda.

1. Pilih subnet, lalu pilih tab **Route Table**. Untuk memverifikasi bahwa setiap subnet yang ingin Anda gunakan adalah subnet publik, konfirmasikan bahwa baris gateway disertakan dalam tabel rute.

**Untuk membuat Application Load Balancer Amazon EC2**

1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Di panel navigasi, pilih **Load Balancers**.

1. Pilih **Buat Penyeimbang Beban**.

1. **Pilih **Application Load Balancer**, lalu pilih Create.**

1. Di **Nama**, masukkan nama penyeimbang beban Anda.

1. Dalam **Skema**, pilih yang menghadap ke **internet**.

1. Dalam **jenis alamat IP**, pilih **ipv4**.

1. Konfigurasikan dua port pendengar untuk penyeimbang beban Anda:

   1. **Di bawah **Protokol Load Balancer**, pilih HTTP.** Di bawah **Port Load Balancer, masukkan**. **80**

   1. Pilih **Tambahkan pendengar**.

   1. **Di bawah **Protokol Load Balancer** untuk pendengar kedua, pilih HTTP.** Di bawah **Port Load Balancer, masukkan**. **8080**

1. Di bawah **Availability Zones**, di **VPC**, pilih VPC default. Selanjutnya, pilih dua subnet default yang ingin Anda gunakan.

1. Pilih **Selanjutnya: Konfigurasikan Pengaturan Keamanan**.

1. Pilih **Selanjutnya: Konfigurasikan Grup Keamanan**.

1. Pilih **Pilih grup keamanan yang ada**, dan buat catatan ID grup keamanan.

1. Pilih **Selanjutnya: Konfigurasi Perutean**.

1. Di **Grup target**, pilih **Grup target baru** dan konfigurasikan grup target pertama Anda:

   1. Di **Nama**, masukkan nama grup target (misalnya,**target-group-1**).

   1. Pada **tipe Target**, pilih **IP**.

   1. Dalam **Protokol** pilih **HTTP**. Di **Pelabuhan**, masukkan**80**.

   1. Pilih **Selanjutnya: Daftarkan Target**.

1. Pilih **Berikutnya: Tinjau**, lalu pilih **Buat**.

**Untuk membuat grup target kedua untuk penyeimbang beban Anda**

1. Setelah penyeimbang beban Anda disediakan, buka konsol Amazon EC2. Di panel navigasi, pilih **Target Groups**.

1. Pilih**Buat grup target**.

1. Di **Nama**, masukkan nama grup target (misalnya,**target-group-2**).

1. Pada **tipe Target**, pilih **IP**.

1. Dalam **Protokol** pilih **HTTP**. Di **Pelabuhan**, masukkan**8080**.

1. Di **VPC**, pilih VPC default.

1. Pilih **Buat**.
**catatan**  
Anda harus memiliki dua grup target yang dibuat untuk penyeimbang beban Anda agar penerapan Anda berjalan. Anda hanya perlu membuat catatan ARN dari kelompok sasaran pertama Anda. ARN ini digunakan dalam file `create-service` JSON pada langkah berikutnya.

**Untuk memperbarui penyeimbang beban Anda untuk memasukkan grup target kedua Anda**

1. Buka konsol Amazon EC2. Di panel navigasi, pilih **Load Balancers**.

1. Pilih penyeimbang beban Anda, lalu pilih tab **Listeners**. **Pilih listener dengan port 8080, lalu pilih Edit.**

1. Pilih ikon pensil di sebelah **Teruskan ke**. Pilih grup target kedua Anda, lalu pilih tanda centang. Pilih **Perbarui** untuk menyimpan pembaruan.

## Langkah 4: Buat kluster dan layanan Amazon ECS Anda
<a name="tutorials-ecs-ecr-codedeploy-cluster"></a>

Di bagian ini, Anda membuat kluster dan layanan Amazon ECS tempat CodeDeploy merutekan lalu lintas selama penerapan (ke kluster Amazon ECS, bukan instans EC2). Untuk membuat layanan Amazon ECS, Anda harus menggunakan nama subnet, grup keamanan, dan nilai grup target yang Anda buat dengan penyeimbang beban untuk membuat layanan Anda.

**catatan**  
Bila Anda menggunakan langkah-langkah ini untuk membuat klaster Amazon ECS, Anda menggunakan template cluster **Networking only**, yang menyediakan container AWS Fargate. AWS Fargate adalah teknologi yang mengelola infrastruktur instans kontainer Anda untuk Anda. Anda tidak perlu memilih atau membuat instans Amazon EC2 secara manual untuk cluster Amazon ECS Anda.

**Untuk membuat cluster Amazon ECS**

1. Buka konsol klasik Amazon ECS di [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1. Di panel navigasi, pilih **Kluster**.

1. Pilih **Buat kluster**.

1. Pilih template cluster **Networking only** yang menggunakan AWS Fargate, lalu pilih **Next** step.

1. Masukkan nama cluster pada halaman **Configure cluster**. Anda dapat menambahkan tag opsional untuk sumber daya Anda. Pilih **Buat**.

**Untuk membuat layanan Amazon ECS**

Gunakan AWS CLI untuk membuat layanan Anda di Amazon ECS.

1. Buat file JSON dan beri nama. `create-service.json` Tempel berikut ini ke dalam file JSON.

   Untuk `taskDefinition` bidang ini, saat Anda mendaftarkan definisi tugas di Amazon ECS, Anda memberinya keluarga. Ini mirip dengan nama untuk beberapa versi definisi tugas, ditentukan dengan nomor revisi. Dalam contoh ini, gunakan "`ecs-demo:1`" untuk keluarga dan nomor revisi dalam file Anda. Gunakan nama subnet, grup keamanan, dan nilai grup target yang Anda buat dengan penyeimbang beban Anda. [Langkah 3: Buat Application Load Balancer dan grup target](#tutorials-ecs-ecr-codedeploy-loadbal)
**catatan**  
Anda perlu memasukkan ARN grup target Anda dalam file ini. **Buka konsol Amazon EC2 dan dari panel navigasi, di bawah **LOAD BALANCING**, pilih Grup Target.** Pilih kelompok target pertama Anda. Salin ARN Anda dari tab **Deskripsi**.

   ```
   {
       "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. Jalankan **create-service** perintah, tentukan file JSON:
**penting**  
Pastikan untuk menyertakan `file://` sebelum nama file. Diperlukan dalam perintah ini.

   Contoh ini menciptakan layanan bernama`my-service`.
**catatan**  
Perintah contoh ini membuat layanan bernama my-service. Jika Anda sudah memiliki layanan dengan nama ini, perintah mengembalikan kesalahan.

   ```
   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json
   ```

   Output mengembalikan kolom deskripsi untuk layanan Anda.

1. Jalankan **describe-services** perintah untuk memverifikasi bahwa layanan Anda telah dibuat.

   ```
   aws ecs describe-services --cluster cluster-name --services service-name
   ```

## Langkah 5: Buat grup CodeDeploy aplikasi dan penyebaran Anda (platform komputasi ECS)
<a name="tutorials-ecs-ecr-codedeploy-deployment"></a>

Saat Anda membuat grup CodeDeploy aplikasi dan penerapan untuk platform komputasi Amazon ECS, aplikasi akan digunakan selama penerapan untuk mereferensikan grup penerapan, grup target, pendengar, dan perilaku pengalihan rute lalu lintas yang benar.

**Untuk membuat CodeDeploy aplikasi**

1. Buka CodeDeploy konsol dan pilih **Buat aplikasi**.

1. Di **Nama aplikasi**, masukkan nama yang ingin Anda gunakan.

1. Di **platform Compute**, pilih **Amazon ECS**.

1. Pilih **Create application** (Buat aplikasi).

**Untuk membuat CodeDeploy grup penyebaran**

1. Pada tab **grup Deployment halaman aplikasi Anda, pilih Buat grup** **penerapan**.

1. Dalam **nama grup Deployment**, masukkan nama yang menjelaskan grup penyebaran.

1. Dalam **peran Layanan**, pilih peran layanan yang memberikan CodeDeploy akses ke Amazon ECS. Untuk membuat peran layanan baru, ikuti langkah-langkah berikut:

   1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

   1. Dari dasbor konsol, pilih **Peran**.

   1. Pilih **Buat peran**.

   1. Di bawah **Pilih jenis entitas tepercaya**, pilih **Layanan AWS**. Di bawah **Pilih kasus penggunaan**, pilih **CodeDeploy**. Di bawah **Pilih kasus penggunaan Anda**, pilih **CodeDeploy - ECS.** Pilih **Berikutnya: Izin**. Kebijakan yang `AWSCodeDeployRoleForECS` dikelola sudah melekat pada peran tersebut.

   1. Pilih **Berikutnya: Tag**, dan **Berikutnya: Tinjau**.

   1. Masukkan nama untuk peran (misalnya,**CodeDeployECSRole**), lalu pilih **Buat peran**.

1. Dalam **konfigurasi Lingkungan**, pilih nama cluster Amazon ECS dan nama layanan.

1. Dari **Load balancer**, pilih nama penyeimbang beban yang melayani lalu lintas ke layanan Amazon ECS Anda.

1. Dari **port pendengar Produksi**, pilih port dan protokol untuk pendengar yang menyajikan jalur produksi ke layanan Amazon ECS Anda. Dari **port Test listener**, pilih port dan protokol untuk test listener.

1. Dari nama **grup target 1 dan nama** **Grup target 2**, pilih grup target yang digunakan untuk merutekan lalu lintas selama penyebaran Anda. Pastikan bahwa ini adalah kelompok target yang Anda buat untuk penyeimbang beban Anda.

1. Pilih **Rute lalu lintas segera** untuk menentukan berapa lama setelah penerapan berhasil untuk mengalihkan lalu lintas ke tugas Amazon ECS Anda yang diperbarui.

1. Pilih **Buat grup penyebaran**.

## Langkah 6: Buat pipeline Anda
<a name="tutorials-ecs-ecr-codedeploy-pipeline"></a>

Dalam bagian ini, Anda membuat alur dengan tindakan berikut:
+  CodeCommit Tindakan di mana artefak sumber adalah definisi tugas dan AppSpec file.
+ Tahap sumber dengan aksi sumber Amazon ECR di mana artefak sumber adalah file gambar.
+ Tahap penerapan dengan tindakan penerapan Amazon ECS di mana penerapan berjalan dengan grup CodeDeploy aplikasi dan penerapan.

**Untuk membuat pipeline dua tahap dengan wizard**

1. Masuk ke Konsol Manajemen AWS dan buka CodePipeline konsol di [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. Pada halaman **Selamat Datang**, halaman **Memulai**, atau halaman **Pipelines**, pilih **Buat pipeline**.

1. Pada **Langkah 1: Pilih halaman opsi pembuatan**, di bawah **Opsi pembuatan**, pilih opsi **Build custom pipeline**. Pilih **Berikutnya**.

1. Pada **Langkah 2: Pilih pengaturan pipeline**, dalam **nama Pipeline**, masukkan**MyImagePipeline**.

1. CodePipeline menyediakan pipa tipe V1 dan V2, yang berbeda dalam karakteristik dan harga. Jenis V2 adalah satu-satunya jenis yang dapat Anda pilih di konsol. Untuk informasi selengkapnya, lihat [jenis pipa](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Untuk informasi tentang harga CodePipeline, lihat [Harga](https://aws.amazon.com/codepipeline/pricing/).

1. Dalam **peran Layanan**, pilih **Peran layanan baru** CodePipeline untuk memungkinkan membuat peran layanan di IAM.

1. **Biarkan pengaturan di bawah **Pengaturan lanjutan** pada defaultnya, lalu pilih Berikutnya.**

1. Pada **Langkah 3: Tambahkan tahap sumber**, di **penyedia Sumber**, pilih **AWS CodeCommit**. Dalam **nama Repositori**, pilih nama CodeCommit repositori yang Anda buat. [Langkah 1: Buat CodeCommit repositori](tutorials-simple-codecommit.md#codecommit-create-repository) Di **Nama cabang**, pilih nama cabang yang berisi pembaruan kode terbaru Anda.

   Pilih **Berikutnya**.

1. Pada **Langkah 4: Tambahkan tahap build**, pilih **Lewati tahap build**, lalu terima pesan peringatan dengan memilih **Lewati** lagi. Pilih **Berikutnya**.

1. Pada **Langkah 5: Tambahkan tahap pengujian**, pilih **Lewati tahap pengujian**, lalu terima pesan peringatan dengan memilih **Lewati** lagi. 

   Pilih **Berikutnya**.

1. Pada **Langkah 6: Tambahkan tahap penerapan**:

   1. Di **penyedia Deploy**, pilih **Amazon ECS (Biru/Hijau**). Di **Nama aplikasi**, masukkan atau pilih nama aplikasi dari daftar, seperti`codedeployapp`. Di **grup Deployment**, masukkan atau pilih nama grup penyebaran dari daftar, seperti. `codedeploydeplgroup`

       
**catatan**  
Nama “Deploy” adalah nama yang diberikan secara default ke tahap yang dibuat di **Langkah 4: Deploy** step, sama seperti “Source” adalah nama yang diberikan untuk tahap pertama pipeline.

   1. Di bawah **definisi tugas Amazon ECS**, pilih **SourceArtifact**. Di lapangan, masukkan**taskdef.json**.

   1. Di bawah **AWS CodeDeploy AppSpec file**, pilih **SourceArtifact**. Di lapangan, masukkan**appspec.yaml**.
**catatan**  
Pada titik ini, jangan mengisi informasi apa pun di bawah **Gambar definisi tugas perbarui secara dinamis**.

   1. Pilih **Berikutnya**.

1. Pada **Langkah 7: Tinjau**, tinjau informasinya, lalu pilih **Buat pipeline**.

**Untuk menambahkan tindakan sumber ECR Amazon ke pipeline Anda**

Lihat pipeline Anda dan tambahkan tindakan sumber Amazon ECR ke pipeline Anda.

1. Pilih pipa Anda. Di kiri atas, pilih **Edit**.

1. Pada tahap sumber, pilih **Edit tahap**.

1. Tambahkan aksi paralel dengan memilih **\$1 Tambahkan tindakan** di sebelah tindakan CodeCommit sumber Anda.

1. Di **Nama tindakan**, masukkan nama (misalnya,**Image**).

1. Di **penyedia Action**, pilih **Amazon ECR**.  
![\[\]](http://docs.aws.amazon.com/id_id/codepipeline/latest/userguide/images/ECR-source-action.png)

1. Dalam nama **Repositori, pilih nama** repositori Amazon ECR Anda.

1. Di **tag Gambar**, tentukan nama dan versi gambar, jika berbeda dari yang terbaru.

1. Di **artefak Output**, pilih artefak keluaran default (misalnya,`MyImage`) yang berisi nama gambar dan informasi URI repositori yang Anda inginkan untuk digunakan tahap selanjutnya.

1. Pilih **Simpan** di layar tindakan. Pilih **Selesai** di layar panggung. Pilih **Simpan** di pipa. Pesan menunjukkan aturan Amazon CloudWatch Events yang akan dibuat untuk tindakan sumber Amazon ECR.

**Untuk menghubungkan artefak sumber Anda ke tindakan penerapan**

1. Pilih **Edit** pada tahap Deploy Anda dan pilih ikon untuk mengedit tindakan **Amazon ECS (Biru/Hijau**).

1. Gulir ke bagian bawah panel. Di **artefak Input**, pilih **Tambah**. Tambahkan artefak sumber dari repositori Amazon ECR baru Anda (misalnya,). `MyImage`

1. Dalam **Definisi Tugas **SourceArtifact****, pilih, lalu verifikasi **taskdef.json** dimasukkan.

1. Di **AWS CodeDeploy AppSpec File**, pilih **SourceArtifact**, lalu verifikasi **appspec.yaml** dimasukkan.

1. Dalam **Perbarui gambar definisi tugas secara dinamis**, di **Artifact Input dengan URI Gambar**, **MyImage**pilih, lalu masukkan teks placeholder yang digunakan dalam file:. `taskdef.json` ** IMAGE1\$1NAME** Pilih **Simpan**.

1. Di AWS CodePipeline panel, pilih **Simpan perubahan pipeline**, lalu pilih **Simpan perubahan**. Lihat pipeline Anda yang diperbarui.

   Setelah contoh pipeline ini dibuat, konfigurasi tindakan untuk entri konsol muncul di struktur pipeline sebagai berikut:

   ```
   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   ```

1. Untuk mengirimkan perubahan dan memulai pembuatan pipeline, pilih **Rilis perubahan**, lalu pilih **Rilis**.

1. Pilih tindakan penerapan untuk melihatnya CodeDeploy dan melihat kemajuan pergeseran lalu lintas.
**catatan**  
Anda mungkin melihat langkah penerapan yang menunjukkan waktu tunggu opsional. Secara default, CodeDeploy menunggu satu jam setelah penerapan berhasil sebelum menghentikan set tugas asli. Anda dapat menggunakan waktu ini untuk memutar kembali atau menghentikan tugas, tetapi penerapan Anda akan selesai saat set tugas dihentikan.

## Langkah 7: Buat perubahan pada pipeline Anda dan verifikasi penerapan
<a name="tutorials-ecs-ecr-codedeploy-update"></a>

Buat perubahan pada gambar Anda dan kemudian dorong perubahan ke repositori Amazon ECR Anda. Ini memicu pipeline Anda untuk berjalan. Verifikasi bahwa perubahan sumber gambar Anda diterapkan.