Amazon CodeCatalyst tidak lagi terbuka untuk pelanggan baru. Pelanggan yang sudah ada dapat terus menggunakan layanan ini seperti biasa. Lihat informasi yang lebih lengkap di [Cara bermigrasi dari CodeCatalyst](migration.md).

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

# Menyebarkan ke Amazon ECS dengan alur kerja
<a name="deploy-action-ecs"></a>

Bagian ini menjelaskan cara menerapkan aplikasi kontainer ke dalam klaster Amazon Elastic Container Service menggunakan alur kerja. CodeCatalyst Untuk mencapai hal ini, Anda harus menambahkan tindakan **Deploy ke Amazon ECS** ke alur kerja Anda. Tindakan ini mendaftarkan file [definisi tugas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) yang Anda berikan. Setelah pendaftaran, definisi tugas akan dipakai oleh [layanan Amazon ECS Anda yang berjalan di cluster [Amazon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) Anda. “Membuat instantiasi definisi tugas” setara dengan menerapkan aplikasi ke Amazon ECS.

Untuk menggunakan tindakan ini, Anda harus memiliki kluster Amazon ECS, layanan, dan file definisi tugas yang siap.

Untuk informasi selengkapnya tentang Amazon ECS, lihat *Panduan Pengembang Layanan Kontainer Elastis Amazon*.

**Tip**  
Untuk tutorial yang menunjukkan cara menggunakan tindakan **Deploy to Amazon ECS**, lihat. [Tutorial: Menyebarkan aplikasi ke Amazon ECS](deploy-tut-ecs.md)

**Tip**  
Untuk contoh kerja tindakan **Deploy to Amazon ECS**, buat project dengan **API Node.js dengan AWS Fargate atau **Java API dengan AWS Fargate**** cetak biru. Untuk informasi selengkapnya, lihat [Membuat proyek dengan cetak biru](projects-create.md#projects-create-console-template).

**Topics**
+ [

## Gambar runtime yang digunakan oleh aksi 'Deploy to Amazon ECS'
](#deploy-action-ecs-runtime)
+ [

# Tutorial: Menyebarkan aplikasi ke Amazon ECS
](deploy-tut-ecs.md)
+ [

# Menambahkan tindakan 'Terapkan ke Amazon ECS'
](deploy-action-ecs-adding.md)
+ [

# Variabel 'Terapkan ke Amazon ECS'
](deploy-action-ecs-variables.md)
+ [

# Tindakan 'Terapkan ke Amazon ECS' YAML'
](deploy-action-ref-ecs.md)

## Gambar runtime yang digunakan oleh aksi 'Deploy to Amazon ECS'
<a name="deploy-action-ecs-runtime"></a>

Tindakan **Deploy to Amazon ECS** berjalan pada gambar [November 2022](build-images.md#build.previous-image). Lihat informasi yang lebih lengkap di [Gambar aktif](build-images.md#build-curated-images).

# Tutorial: Menyebarkan aplikasi ke Amazon ECS
<a name="deploy-tut-ecs"></a>

Dalam tutorial ini, Anda mempelajari cara menerapkan aplikasi tanpa server ke Amazon Elastic Container Service (Amazon ECS) menggunakan alur kerja, Amazon ECS, dan beberapa layanan lainnya. AWS Aplikasi yang digunakan adalah situs web Hello World sederhana yang dibangun di atas image Docker server web Apache. Tutorial memandu Anda melalui pekerjaan persiapan yang diperlukan seperti menyiapkan cluster, dan kemudian menjelaskan cara membuat alur kerja untuk membangun dan menyebarkan aplikasi.

**Tip**  
Alih-alih mengerjakan tutorial ini, Anda dapat menggunakan cetak biru yang melakukan pengaturan Amazon ECS lengkap untuk Anda. Anda harus menggunakan **API Node.js dengan AWS Fargate** atau **Java API dengan AWS Fargate** cetak biru. Untuk informasi selengkapnya, lihat [Membuat proyek dengan cetak biru](projects-create.md#projects-create-console-template).

**Topics**
+ [

## Prasyarat
](#deploy-tut-ecs-prereqs)
+ [

## Langkah 1: Siapkan AWS pengguna dan AWS CloudShell
](#deploy-tut-ecs-user-cloudshell)
+ [

## Langkah 2: Menyebarkan aplikasi placeholder ke Amazon ECS
](#deploy-tut-ecs-placeholder)
+ [

## Langkah 3: Buat repositori gambar Amazon ECR
](#deploy-tut-ecs-ecr)
+ [

## Langkah 4: Buat AWS peran
](#deploy-tut-ecs-build-deploy-roles)
+ [

## Langkah 5: Tambahkan AWS peran ke CodeCatalyst
](#deploy-tut-ecs-import-roles)
+ [

## Langkah 6: Buat repositori sumber
](#deploy-tut-ecs-source-repo)
+ [

## Langkah 7: Tambahkan file sumber
](#deploy-tut-ecs-source-files)
+ [

## Langkah 8: Buat dan jalankan alur kerja
](#deploy-tut-ecs-workflow)
+ [

## Langkah 9: Buat perubahan pada file sumber Anda
](#deploy-tut-ecs-change)
+ [

## Bersihkan
](#deploy-tut-ecs-cleanup)

## Prasyarat
<a name="deploy-tut-ecs-prereqs"></a>

Sebelum Anda memulai:
+ Anda membutuhkan CodeCatalyst **ruang** dengan AWS akun yang terhubung. Untuk informasi selengkapnya, lihat [Membuat ruang](spaces-create.md).
+ Di ruang Anda, Anda memerlukan proyek kosong yang disebut:

  ```
  codecatalyst-ecs-project
  ```

  Gunakan opsi **Mulai dari awal** untuk membuat proyek ini.

  Untuk informasi selengkapnya, lihat [Membuat proyek kosong di Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ Dalam proyek Anda, Anda memerlukan CodeCatalyst **lingkungan** yang disebut:

  ```
  codecatalyst-ecs-environment
  ```

  Konfigurasikan lingkungan ini sebagai berikut:
  + Pilih jenis apa saja, seperti **Non-produksi**.
  + Hubungkan AWS akun Anda ke sana.
  + Untuk peran **IAM Default, pilih peran** apa pun. Anda akan menentukan peran yang berbeda nanti.

  Untuk informasi selengkapnya, lihat [Menyebarkan ke dalam Akun AWS dan VPCs](deploy-environments.md).

## Langkah 1: Siapkan AWS pengguna dan AWS CloudShell
<a name="deploy-tut-ecs-user-cloudshell"></a>

Langkah pertama dalam tutorial ini adalah membuat pengguna AWS IAM Identity Center, dan meluncurkan AWS CloudShell instance sebagai pengguna ini. Selama tutorial ini, CloudShell adalah komputer pengembangan Anda dan di mana Anda mengkonfigurasi AWS sumber daya dan layanan. Hapus pengguna ini setelah menyelesaikan tutorial.

**catatan**  
Jangan gunakan pengguna root Anda untuk tutorial ini. Anda harus membuat pengguna terpisah atau Anda mungkin mengalami masalah saat melakukan tindakan di AWS Command Line Interface (CLI) nanti.

Untuk informasi selengkapnya tentang pengguna Pusat Identitas IAM dan CloudShell, lihat *Panduan AWS IAM Identity Center Pengguna dan Panduan AWS CloudShell * *Pengguna*. 

**Untuk membuat pengguna IAM Identity Center**

1. Masuk ke Konsol Manajemen AWS dan buka AWS IAM Identity Center konsol di [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/).
**catatan**  
Pastikan Anda masuk menggunakan Akun AWS yang terhubung ke CodeCatalyst ruang Anda. Anda dapat memverifikasi akun mana yang terhubung dengan menavigasi ke ruang Anda dan memilih tab **akun AWS**. Untuk informasi selengkapnya, lihat [Membuat ruang](spaces-create.md).

1. Pada panel navigasi, silakan pilih **Pengguna**, lalu pilih **Tambahkan pengguna**.

1. Di **Nama Pengguna**, masukkan:

   ```
   CodeCatalystECSUser
   ```

1. Di bawah **Kata Sandi**, pilih **Buat kata sandi satu kali yang dapat Anda bagikan dengan pengguna ini**.

1. Di **Alamat Email** dan **Konfirmasi alamat email**, masukkan alamat email yang belum ada di Pusat Identitas IAM.

1. Di **Nama depan** dan **nama belakang**, masukkan:

   ```
   CodeCatalystECSUser
   ```

1. Di **Nama tampilan**, simpan nama yang dihasilkan secara otomatis:

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

1. Pilih **Berikutnya**.

1. Pada halaman **Tambahkan pengguna ke grup**, pilih **Berikutnya**.

1. Pada halaman **Tinjau dan tambahkan pengguna**, tinjau informasi dan pilih **Tambah pengguna**.

   Kotak dialog **kata sandi satu kali** muncul.

1. Pilih **Salin** lalu tempel informasi masuk, termasuk URL portal AWS akses dan kata sandi satu kali.

1. Pilih **Tutup**.

**Untuk membuat set izin**

Anda akan menetapkan izin ini disetel `CodeCatalystECSUser` nanti.

1. Di panel navigasi, pilih **Set izin**, lalu pilih **Buat set izin**.

1. Pilih **Set izin yang telah ditentukan sebelumnya** dan kemudian pilih **AdministratorAccess**. Kebijakan ini memberikan izin penuh untuk semua Layanan AWS. 

1. Pilih **Berikutnya**.

1. Dalam **nama set Izin**, masukkan:

   ```
   CodeCatalystECSPermissionSet
   ```

1. Pilih **Berikutnya**.

1. Pada halaman **Tinjau dan buat**, tinjau informasi dan pilih **Buat**.

**Untuk menetapkan izin yang disetel ke CodeCatalyst ECSUser**

1. Di panel navigasi, pilih **Akun AWS**, lalu pilih kotak centang di Akun AWS samping tempat Anda masuk saat ini.

1. Pilih **Tetapkan pengguna atau grup**.

1. Pilih tab **Pengguna**.

1. Pilih kotak centang di sebelah`CodeCatalystECSUser`.

1. Pilih **Berikutnya**.

1. Pilih kotak centang di sebelah`CodeCatalystECSPermissionSet`.

1. Pilih **Berikutnya**.

1. Tinjau informasi dan pilih **Kirim**.

   Anda sekarang telah menetapkan `CodeCatalystECSUser` dan `CodeCatalystECSPermissionSet` untuk Anda Akun AWS, mengikat mereka bersama-sama.

**Untuk keluar dan masuk kembali sebagai CodeCatalyst ECSUser**

1. Sebelum Anda keluar, pastikan Anda memiliki URL portal AWS akses dan nama pengguna dan kata sandi satu kali untuk`CodeCatalystECSUser`. Anda seharusnya menyalin informasi ini ke editor teks sebelumnya.
**catatan**  
Jika Anda tidak memiliki informasi ini, buka halaman `CodeCatalystECSUser` detail di Pusat Identitas IAM, pilih **Atur ulang kata sandi**, **Hasilkan kata sandi satu kali [**...] , dan **Reset kata sandi** lagi untuk menampilkan informasi di layar.

1. Keluar dari AWS.

1. Rekatkan URL portal AWS akses ke bilah alamat browser Anda.

1. Masuk dengan nama pengguna dan kata sandi satu kali untuk`CodeCatalystECSUser`.

1. Di **Kata sandi baru**, masukkan kata sandi, dan pilih **Atur kata sandi baru**.

   Sebuah **Akun AWS**kotak muncul di layar.

1. Pilih **Akun AWS**, lalu pilih nama yang Akun AWS Anda tetapkan `CodeCatalystECSUser` pengguna dan set izin.

1. Di sebelah`CodeCatalystECSPermissionSet`, pilih **Konsol manajemen**.

    Konsol Manajemen AWS Muncul. Anda sekarang masuk `CodeCatalystECSUser` dengan izin yang sesuai.

**Untuk meluncurkan sebuah AWS CloudShell instance**

1. Seperti`CodeCatalystECSUser`, di bilah navigasi atas, pilih AWS ikon (![\[AWS icon\]](http://docs.aws.amazon.com/id_id/codecatalyst/latest/userguide/images/deploy/aws-logo.png)).

   Halaman utama Konsol Manajemen AWS muncul.

1. Di bilah navigasi atas, pilih AWS CloudShell ikon (![\[CloudShell icon\]](http://docs.aws.amazon.com/id_id/codecatalyst/latest/userguide/images/deploy/CloudShell.png)).

   CloudShell terbuka. Tunggu sementara CloudShell lingkungan dibuat.
**catatan**  
Jika Anda tidak melihat CloudShell ikon, pastikan Anda berada di [Wilayah yang didukung oleh CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available). Tutorial ini mengasumsikan Anda berada di Wilayah AS Barat (Oregon).

**Untuk memverifikasi bahwa AWS CLI sudah diinstal**

1. Di CloudShell terminal, masukkan:

   ```
   aws --version
   ```

1. Periksa apakah ada versi yang muncul.

   Sudah AWS CLI dikonfigurasi untuk pengguna saat ini`CodeCatalystECSUser`, jadi tidak perlu mengkonfigurasi AWS CLI kunci dan kredensyal, seperti biasanya.

## Langkah 2: Menyebarkan aplikasi placeholder ke Amazon ECS
<a name="deploy-tut-ecs-placeholder"></a>

Di bagian ini, Anda secara manual menyebarkan aplikasi placeholder ke Amazon ECS. Aplikasi placeholder ini akan digantikan oleh aplikasi Hello World yang digunakan oleh alur kerja Anda. Aplikasi placeholder adalah Apache Web Server.

Untuk informasi selengkapnya tentang Amazon ECS, lihat *Panduan Pengembang Layanan Kontainer Elastis Amazon*.

Lengkapi serangkaian prosedur berikut untuk menyebarkan aplikasi placeholder.<a name="deploy-tut-ecs-create-task-execution-role"></a>

**Untuk membuat peran eksekusi tugas**

Peran ini memberikan Amazon ECS dan AWS Fargate izin untuk melakukan panggilan API atas nama Anda. 

1. Buat kebijakan kepercayaan:

   1. Di AWS CloudShell, masukkan perintah berikut:

      ```
      cat > codecatalyst-ecs-trust-policy.json
      ```

      Prompt berkedip muncul di CloudShell terminal.

   1. Masukkan kode berikut pada prompt:

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

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

   1. Tempatkan kursor Anda setelah braket keriting terakhir (). `}`

   1. Tekan **Enter** dan kemudian **Ctrl\$1d** untuk menyimpan file dan keluar dari kucing.

1. Buat peran eksekusi tugas:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-task-execution-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Lampirkan `AmazonECSTaskExecutionRolePolicy` kebijakan AWS terkelola ke peran:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-task-execution-role \
         --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
   ```

1. Menampilkan detail peran:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-task-execution-role
   ```

1. Perhatikan `"Arn":` nilai peran, misalnya,`arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role`. Anda akan memerlukan Nama Sumber Daya Amazon (ARN) ini nanti.

**Untuk membuat cluster Amazon ECS**

Cluster ini akan berisi aplikasi placeholder Apache, dan kemudian, aplikasi Hello World. 

1. Seperti`CodeCatalystECSUser`, di AWS CloudShell, buat cluster kosong:

   ```
   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
   ```

1. (Opsional) Verifikasi bahwa cluster berhasil dibuat:

   ```
   aws ecs list-clusters
   ```

   ARN `codecatalyst-ecs-cluster` cluster akan muncul dalam daftar, menunjukkan penciptaan yang berhasil.

**Untuk membuat file definisi tugas**

File definisi tugas menunjukkan untuk menjalankan [Apache 2.4 Web server](https://hub.docker.com/_/httpd) Docker image (`httpd:2.4`) yang ditarik dari. DockerHub

1. Seperti`CodeCatalystECSUser`, di AWS CloudShell, buat file definisi tugas:

   ```
   cat > taskdef.json
   ```

1. Tempel kode berikut pada prompt:

   ```
   {
       "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               "image": "httpd:2.4",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "cpu": "256",
       "family": "codecatalyst-ecs-task-def",
       "memory": "512",
       "networkMode": "awsvpc"
   }
   ```

   Pada kode sebelumnya, ganti *arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role*

   dengan ARN dari peran eksekusi tugas yang Anda catat. [Untuk membuat peran eksekusi tugas](#deploy-tut-ecs-create-task-execution-role)

1. Tempatkan kursor Anda setelah braket keriting terakhir (). `}`

1. Tekan **Enter** dan kemudian **Ctrl\$1d** untuk menyimpan file dan keluar dari kucing.

**Untuk mendaftarkan file definisi tugas dengan Amazon ECS**

1. Seperti`CodeCatalystECSUser`, dalam AWS CloudShell, daftarkan definisi tugas:

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

1. (Opsional) Verifikasi bahwa definisi tugas telah terdaftar:

   ```
   aws ecs list-task-definitions
   ```

   Definisi `codecatalyst-ecs-task-def` tugas akan muncul dalam daftar.

**Untuk membuat layanan Amazon ECS**

Layanan Amazon ECS menjalankan tugas (dan wadah Docker terkait) dari aplikasi placeholder Apache, dan kemudian, aplikasi Hello World.

1. Sebagai`CodeCatalystECSUser`, beralihlah ke konsol Amazon Elastic Container Service jika Anda belum melakukannya.

1. Pilih cluster yang Anda buat sebelumnya,`codecatalyst-ecs-cluster`.

1. Di tab **Layanan**, pilih **Buat**.

1. Di halaman **Create**, lakukan hal berikut:

   1. Simpan semua pengaturan default kecuali yang tercantum berikutnya.

   1. Untuk **jenis Peluncuran**, pilih **FARGATE**.

   1. Di bawah **Definisi tugas**, dalam daftar drop-down **Keluarga**, pilih:

      `codecatalyst-ecs-task-def`

   1. Untuk **nama Layanan**, masukkan:

      ```
      codecatalyst-ecs-service
      ```

   1. Untuk **tugas yang diinginkan**, masukkan:

      ```
      3
      ```

      Dalam tutorial ini, setiap tugas meluncurkan satu wadah Docker.

   1. Perluas bagian **Jaringan**.

   1. Untuk **VPC, pilih VPC** apa saja.

   1. Untuk **Subnet**, pilih subnet apa saja.
**catatan**  
Hanya tentukan satu subnet. Itu saja yang diperlukan untuk tutorial ini.
**catatan**  
Jika Anda tidak memiliki VPC dan subnet, buatlah. Lihat [Membuat VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC), dan [Membuat subnet di VPC Anda di Panduan Pengguna *Amazon* VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet).

   1. Untuk **grup Keamanan**, pilih **Buat grup keamanan baru**, lalu lakukan hal berikut:

      1. Untuk **nama grup Keamanan**, masukkan:

         ```
         codecatalyst-ecs-security-group
         ```

      1. Untuk **deskripsi grup Keamanan**, masukkan:

         ```
         CodeCatalyst ECS security group
         ```

      1. Pilih **Tambahkan aturan**. Untuk **Type**, pilih **HTTP**, dan untuk **Source**, pilih **Anywhere**.

   1. Di bagian bawah, pilih **Buat**.

   1. Tunggu sementara layanan dibuat. Ini mungkin memakan waktu beberapa menit.

1. Pilih tab **Tugas**, lalu pilih tombol segarkan. Verifikasi bahwa ketiga tugas memiliki kolom **Status Terakhir** yang disetel ke **Running**.

**(Opsional) Untuk memverifikasi bahwa aplikasi placeholder Apache Anda berjalan**

1. Di tab **Tugas**, pilih salah satu dari tiga tugas.

1. Di bidang **IP Publik**, pilih **alamat terbuka**.

   Sebuah `It Works!` halaman muncul. Ini menunjukkan bahwa layanan Amazon ECS berhasil memulai tugas yang meluncurkan wadah Docker dengan gambar Apache.

   Pada titik ini dalam tutorial, Anda telah secara manual menerapkan klaster Amazon ECS, layanan, dan definisi tugas, serta aplikasi placeholder Apache. Dengan semua item ini di tempat, Anda sekarang siap untuk membuat alur kerja yang akan menggantikan aplikasi placeholder Apache dengan aplikasi Hello World tutorial.

## Langkah 3: Buat repositori gambar Amazon ECR
<a name="deploy-tut-ecs-ecr"></a>

Di bagian ini, Anda membuat repositori gambar pribadi di Amazon Elastic Container Registry (Amazon ECR) Registry ECR). Repositori ini menyimpan gambar Docker tutorial yang akan menggantikan gambar placeholder Apache yang Anda gunakan sebelumnya. 

Untuk informasi selengkapnya tentang Amazon ECR, lihat *Panduan Pengguna Amazon Elastic Container Registry*.

**Untuk membuat repositori gambar di Amazon ECR**

1. Seperti`CodeCatalystECSUser`, di AWS CloudShell, buat repositori kosong di Amazon ECR:

   ```
   aws ecr create-repository --repository-name codecatalyst-ecs-image-repo
   ```

1. Tampilkan detail repositori Amazon ECR:

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-ecs-image-repo
   ```

1. Perhatikan `“repositoryUri”:` nilainya, misalnya,`111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo`.

   Anda membutuhkannya nanti saat menambahkan repositori ke alur kerja Anda. 

## Langkah 4: Buat AWS peran
<a name="deploy-tut-ecs-build-deploy-roles"></a>

Di bagian ini, Anda membuat peran AWS IAM yang dibutuhkan CodeCatalyst alur kerja Anda agar berfungsi. Peran ini adalah:
+ **Peran build** - Memberikan izin tindakan CodeCatalyst build (dalam alur kerja) untuk mengakses AWS akun Anda dan menulis ke Amazon ECR dan Amazon EC2.
+ **Menyebarkan peran** - Memberikan izin tindakan CodeCatalyst **Deploy to ECS** (dalam alur kerja) untuk mengakses akun Anda AWS , Amazon ECS, dan beberapa layanan lainnya. AWS 

Untuk informasi selengkapnya tentang peran IAM, lihat [peran IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) di *AWS Identity and Access Management Panduan Pengguna*.

**catatan**  
Untuk menghemat waktu, Anda dapat membuat satu peran, yang disebut `CodeCatalystWorkflowDevelopmentRole-spaceName` peran, alih-alih dua peran yang tercantum sebelumnya. Untuk informasi selengkapnya, lihat [Membuat **CodeCatalystWorkflowDevelopmentRole-*spaceName***peran untuk akun dan ruang Anda](ipa-iam-roles.md#ipa-iam-roles-service-create). Pahami bahwa `CodeCatalystWorkflowDevelopmentRole-spaceName` peran tersebut memiliki izin yang sangat luas yang dapat menimbulkan risiko keamanan. Kami menyarankan Anda hanya menggunakan peran ini dalam tutorial dan skenario di mana keamanan kurang menjadi perhatian. Tutorial ini mengasumsikan Anda membuat dua peran yang tercantum sebelumnya.

Untuk membuat peran build dan deploy, Anda dapat menggunakan peran Konsol Manajemen AWS atau. AWS CLI

------
#### [ Konsol Manajemen AWS ]

Untuk membuat peran build dan deploy, selesaikan rangkaian prosedur berikut.

**Untuk membuat peran build**

1. Buat kebijakan untuk peran tersebut, sebagai berikut:

   1. Masuk ke AWS.

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

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

   1. Pilih **Buat kebijakan**.

   1. Pilih tab **JSON**.

   1. Hapus kode yang ada.

   1. Tempel kode berikut:

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "ecr:*",
                      "ec2:*"
                  ],
                  "Resource": "*"
              }
          ]
      }
      ```

------
**catatan**  
Pertama kali peran digunakan untuk menjalankan tindakan alur kerja, gunakan wildcard dalam pernyataan kebijakan sumber daya dan kemudian cakup kebijakan dengan nama sumber daya setelah tersedia.  

      ```
      "Resource": "*"
      ```

   1. Pilih **Berikutnya: Tanda**.

   1. Pilih **Berikutnya: Tinjau**.

   1. Dalam **Nama**, masukkan:

      ```
      codecatalyst-ecs-build-policy
      ```

   1. Pilih **Buat kebijakan**.

      Anda sekarang telah membuat kebijakan izin.

1. Buat peran build, sebagai berikut:

   1. Di panel navigasi, pilih **Peran**, lalu pilih **Buat peran**.

   1. Pilih **Kebijakan kepercayaan khusus**.

   1. Hapus kebijakan kepercayaan kustom yang ada.

   1. Tambahkan kebijakan kepercayaan khusus berikut:

   1. Pilih **Berikutnya**.

   1. Di **Kebijakan izin**, cari`codecatalyst-ecs-build-policy`, pilih kotak centang.

   1. Pilih **Berikutnya**.

   1. Untuk **nama Peran**, masukkan:

      ```
      codecatalyst-ecs-build-role
      ```

   1. Untuk **deskripsi Peran**, masukkan:

      ```
      CodeCatalyst ECS build role
      ```

   1. Pilih **Buat peran**.

   Anda sekarang telah membuat peran build dengan kebijakan izin dan kebijakan kepercayaan.

1. Dapatkan peran membangun ARN, sebagai berikut:

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

   1. Di kotak pencarian, masukkan nama peran yang baru saja Anda buat (`codecatalyst-ecs-build-role`).

   1. Pilih peran dari daftar.

      Halaman **Ringkasan** peran muncul.

   1. Di bagian atas, salin nilai **ARN**. Anda membutuhkannya nanti.

**Untuk membuat peran penerapan**

1. Buat kebijakan untuk peran tersebut, sebagai berikut:

   1. Masuk ke AWS.

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

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

   1. Pilih **Buat Kebijakan**.

   1. Pilih tab **JSON**.

   1. Hapus kode yang ada.

   1. Tempel kode berikut:

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**catatan**  
Pertama kali peran digunakan untuk menjalankan tindakan alur kerja, gunakan wildcard dalam pernyataan kebijakan sumber daya. Anda kemudian dapat mencatat kebijakan dengan nama sumber daya setelah tersedia.  

      ```
      "Resource": "*"
      ```

   1. Pilih **Berikutnya: Tanda**.

   1. Pilih **Berikutnya: Tinjau**.

   1. Dalam **Nama**, masukkan:

      ```
      codecatalyst-ecs-deploy-policy
      ```

   1. Pilih **Buat kebijakan**.

      Anda sekarang telah membuat kebijakan izin.

1. Buat peran deploy, sebagai berikut:

   1. Di panel navigasi, pilih **Peran**, lalu pilih **Buat peran**.

   1. Pilih **Kebijakan kepercayaan khusus**.

   1. Hapus kebijakan kepercayaan kustom yang ada.

   1. Tambahkan kebijakan kepercayaan khusus berikut:

   1. Pilih **Berikutnya**.

   1. Di **Kebijakan izin**, cari`codecatalyst-ecs-deploy-policy`, pilih kotak centang.

   1. Pilih **Berikutnya**.

   1. Untuk **nama Peran**, masukkan:

      ```
      codecatalyst-ecs-deploy-role
      ```

   1. Untuk **deskripsi Peran**, masukkan:

      ```
      CodeCatalyst ECS deploy role
      ```

   1. Pilih **Buat peran**.

   Anda sekarang telah membuat peran penerapan dengan kebijakan kepercayaan.

1. Dapatkan peran penyebaran ARN, sebagai berikut:

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

   1. Di kotak pencarian, masukkan nama peran yang baru saja Anda buat (`codecatalyst-ecs-deploy-role`).

   1. Pilih peran dari daftar.

      Halaman **Ringkasan** peran muncul.

   1. Di bagian atas, salin nilai **ARN**. Anda membutuhkannya nanti.

------
#### [ AWS CLI ]

Untuk membuat peran build dan deploy, selesaikan rangkaian prosedur berikut.

**Untuk membuat kebijakan kepercayaan untuk kedua peran**

Seperti`CodeCatalystECSUser`, di AWS CloudShell, buat file kebijakan kepercayaan:

1. Buat file:

   ```
   cat > codecatalyst-ecs-trust-policy.json
   ```

1. Pada prompt terminal, tempel kode berikut:

1. Tempatkan kursor Anda setelah braket keriting terakhir (). `}`

1. Tekan **Enter** dan kemudian **Ctrl\$1d** untuk menyimpan file dan keluar dari kucing.

**Untuk membuat kebijakan membangun dan membangun peran**

1. Buat kebijakan build:

   1. Seperti`CodeCatalystECSUser`, dalam AWS CloudShell, membuat file kebijakan build:

      ```
      cat > codecatalyst-ecs-build-policy.json
      ```

   1. Pada prompt, masukkan kode berikut:

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "ecr:*",
                      "ec2:*"
                  ],
                  "Resource": "*"
              }
          ]
      }
      ```

------

   1. Tempatkan kursor Anda setelah braket keriting terakhir (). `}`

   1. Tekan **Enter** dan kemudian **Ctrl\$1d** untuk menyimpan file dan keluar dari kucing.

1. Tambahkan kebijakan build ke AWS:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-build-policy \
       --policy-document file://codecatalyst-ecs-build-policy.json
   ```

1. Dalam output perintah, perhatikan `"arn":` nilainya, misalnya,`arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy`. Anda membutuhkan ARN ini nanti.

1. Buat peran build dan lampirkan kebijakan kepercayaan padanya:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-build-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Lampirkan kebijakan build ke peran build:

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-build-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy
   ```

   *arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy*Dimana diganti dengan ARN dari kebijakan build yang Anda catat sebelumnya.

1. Menampilkan detail peran build:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-build-role
   ```

1. Perhatikan `"Arn":` nilai peran, misalnya,`arn:aws:iam::111122223333:role/codecatalyst-ecs-build-role`. Anda membutuhkan ARN ini nanti.

**Untuk membuat kebijakan penerapan dan peran penerapan**

1. Buat kebijakan penerapan:

   1. Di AWS CloudShell, buat file kebijakan penerapan:

      ```
      cat > codecatalyst-ecs-deploy-policy.json
      ```

   1. Pada prompt, masukkan kode berikut:

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**catatan**  
Pertama kali peran digunakan untuk menjalankan tindakan alur kerja, gunakan wildcard dalam pernyataan kebijakan sumber daya dan kemudian cakup kebijakan dengan nama sumber daya setelah tersedia.  

      ```
      "Resource": "*"
      ```

   1. Tempatkan kursor Anda setelah braket keriting terakhir (). `}`

   1. Tekan **Enter** dan kemudian **Ctrl\$1d** untuk menyimpan file dan keluar dari kucing.

1. Tambahkan kebijakan penerapan ke AWS:

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-deploy-policy \
       --policy-document file://codecatalyst-ecs-deploy-policy.json
   ```

1. Dalam output perintah, perhatikan `"arn":` nilai kebijakan penerapan, misalnya,`arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy`. Anda membutuhkan ARN ini nanti.

1. Buat peran penerapan dan lampirkan kebijakan kepercayaan padanya:

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-deploy-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Lampirkan kebijakan penerapan ke peran penerapan, yang diganti dengan ARN dari kebijakan penerapan yang Anda sebutkan sebelumnya. *arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy*

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-deploy-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy
   ```

1. Menampilkan detail peran penerapan:

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-deploy-role
   ```

1. Perhatikan `"Arn":` nilai peran, misalnya,`arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role`. Anda membutuhkan ARN ini nanti.

------

## Langkah 5: Tambahkan AWS peran ke CodeCatalyst
<a name="deploy-tut-ecs-import-roles"></a>

Pada langkah ini, Anda menambahkan build role (`codecatalyst-ecs-build-role`) dan deploy role (`codecatalyst-ecs-deploy-role`) ke koneksi CodeCatalyst akun di ruang Anda.

**Untuk menambahkan peran build dan deploy ke koneksi akun**

1. Masuk CodeCatalyst, navigasikan ke ruang Anda.

1. Pilih **AWS akun**. Daftar koneksi akun muncul.

1. Pilih koneksi akun yang mewakili AWS akun tempat Anda membuat peran build dan deploy.

1. Pilih **Kelola peran dari konsol AWS manajemen**.

   **Peran Tambahkan IAM ke halaman CodeCatalyst ruang Amazon** muncul. Anda mungkin perlu masuk untuk mengakses halaman.

1. Pilih **Tambahkan peran yang sudah Anda buat di IAM**.

   Daftar drop-down muncul. Daftar ini menampilkan semua peran IAM dengan kebijakan kepercayaan yang mencakup prinsip `codecatalyst-runner.amazonaws.com` dan `codecatalyst.amazonaws.com` layanan.

1. Dalam daftar drop-down, pilih`codecatalyst-ecs-build-role`, dan pilih **Tambah peran**.
**catatan**  
Jika Anda melihat`The security token included in the request is invalid`, itu mungkin karena Anda tidak memiliki izin yang tepat. Untuk memperbaiki masalah ini, keluar dari AWS sebagai masuk kembali dengan AWS akun yang Anda gunakan saat membuat CodeCatalyst ruang.

1. Pilih **Tambahkan peran IAM**, pilih **Tambahkan peran yang ada yang telah Anda buat di IAM**, dan dalam daftar drop-down, pilih. `codecatalyst-ecs-deploy-role` Pilih **Tambahkan peran**.

   Anda sekarang telah menambahkan peran build dan deploy ke ruang Anda.

1. Salin nilai **nama CodeCatalyst tampilan Amazon**. Anda akan membutuhkan nilai ini nanti, saat membuat alur kerja Anda.

## Langkah 6: Buat repositori sumber
<a name="deploy-tut-ecs-source-repo"></a>

Pada langkah ini, Anda membuat repositori sumber di. CodeCatalyst Repositori ini menyimpan file sumber tutorial, seperti file definisi tugas.

Untuk informasi selengkapnya tentang repositori sumber, lihat. [Membuat repositori sumber](source-repositories-create.md)

**Untuk membuat repositori sumber**

1. Buka CodeCatalyst konsol di [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Arahkan ke proyek Anda,`codecatalyst-ecs-project`.

1. Di panel navigasi, pilih **Kode**, lalu pilih **Repositori sumber**. 

1. Pilih **Tambahkan repositori**, lalu pilih **Buat** repositori.

1. Dalam **nama Repositori, masukkan:**

   ```
   codecatalyst-ecs-source-repository
   ```

1. Pilih **Buat**.

## Langkah 7: Tambahkan file sumber
<a name="deploy-tut-ecs-source-files"></a>

Di bagian ini, Anda menambahkan file sumber Hello World ke CodeCatalyst repositori Anda,. `codecatalyst-ecs-source-repository` Mereka terdiri dari:
+ `index.html`File - Menampilkan pesan Hello World di browser. 
+ A Dockerfile - Menjelaskan gambar dasar yang akan digunakan untuk image Docker Anda dan perintah Docker untuk menerapkannya. 
+ `taskdef.json`File - Mendefinisikan image Docker yang akan digunakan saat meluncurkan tugas ke cluster Anda.

Struktur folder adalah sebagai berikut:

```
.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json
```

**catatan**  
Petunjuk berikut menunjukkan cara menambahkan file menggunakan CodeCatalyst konsol tetapi Anda dapat menggunakan Git jika Anda mau. Lihat perinciannya di [Mengkloning repositori sumber](source-repositories-clone.md). 

**Topics**
+ [

### index.html
](#deploy-tut-ecs-source-files-index)
+ [

### Dockerfile
](#deploy-tut-ecs-source-files-dockerfile)
+ [

### taskdef.json
](#deploy-tut-ecs-source-files-taskdef)

### index.html
<a name="deploy-tut-ecs-source-files-index"></a>

`index.html`File menampilkan pesan Hello World di browser. 

**Untuk menambahkan file index.html**

1. Di CodeCatalyst konsol, buka repositori sumber Anda,. `codecatalyst-ecs-source-repository`

1. Di **File**, pilih **Buat file**.

1. Untuk **nama File**, masukkan:

   ```
   public-html/index.html
   ```
**penting**  
Pastikan untuk menyertakan `public-html/` awalan untuk membuat folder dengan nama yang sama. `index.html`Diharapkan ada di folder ini.

1. Di kotak teks, masukkan kode berikut:

   ```
   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello World</h1>
     </body>
   </html>
   ```

1. Pilih **Komit**, lalu pilih **Komit** lagi.

   Ditambahkan ke repositori Anda dalam folder. `index.html` `public-html` 

### Dockerfile
<a name="deploy-tut-ecs-source-files-dockerfile"></a>

Dockerfile menjelaskan image Docker dasar yang akan digunakan dan perintah Docker untuk diterapkan padanya. Untuk informasi selengkapnya tentang Dockerfile, lihat Referensi [Dockerfile](https://docs.docker.com/engine/reference/builder/).

Dockerfile yang ditentukan di sini menunjukkan untuk menggunakan image dasar Apache 2.4 (). `httpd` Ini juga mencakup instruksi untuk menyalin file sumber yang dipanggil `index.html` ke folder di server Apache yang melayani halaman web. `EXPOSE`Instruksi di Dockerfile memberi tahu Docker bahwa wadah mendengarkan pada port 80.

**Untuk menambahkan Dockerfile**

1. Di repositori sumber Anda, pilih **Buat** file.

1. Untuk **nama File**, masukkan:

   ```
   Dockerfile
   ```

   Jangan sertakan ekstensi file.
**penting**  
Dockerfile harus berada di folder root repositori Anda. `Docker build`Perintah alur kerja mengharapkannya ada di sana.

1. Di kotak teks, masukkan kode berikut:

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

1. Pilih **Komit**, lalu pilih **Komit** lagi.

   Dockerfile ditambahkan ke repositori Anda. 

### taskdef.json
<a name="deploy-tut-ecs-source-files-taskdef"></a>

`taskdef.json`File yang Anda tambahkan pada langkah ini sama dengan yang sudah Anda tentukan [Langkah 2: Menyebarkan aplikasi placeholder ke Amazon ECS](#deploy-tut-ecs-placeholder) dengan perbedaan berikut:

Alih-alih menentukan nama gambar Docker yang di-hardcode di `image:` bidang (`httpd:2.4`), definisi tugas di sini menggunakan beberapa variabel untuk menunjukkan gambar: dan. `$REPOSITORY_URI` `$IMAGE_TAG` Variabel ini akan diganti dengan nilai nyata yang dihasilkan oleh aksi build alur kerja saat Anda menjalankan alur kerja di langkah selanjutnya.

Untuk detail tentang parameter definisi tugas, lihat [Parameter definisi tugas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) di *Panduan Pengembang Layanan Kontainer Elastis Amazon*.

**Untuk menambahkan file taskdef.json**

1. Di repositori sumber Anda, pilih **Buat** file.

1. Untuk **nama File**, masukkan:

   ```
   taskdef.json
   ```

1. Di kotak teks, masukkan kode berikut:

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
               # by the workflow at build time (see the build action in the 
               # workflow)
               "image": $REPOSITORY_URI:$IMAGE_TAG,
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "codecatalyst-ecs-task-def"
   }
   ```

   Pada kode sebelumnya, ganti

   *arn:aws:iam::account\$1ID:role/codecatalyst-ecs-task-execution-role*

   dengan ARN dari peran eksekusi tugas yang Anda catat. [Untuk membuat peran eksekusi tugas](#deploy-tut-ecs-create-task-execution-role)

1. Pilih **Komit**, lalu pilih **Komit** lagi.

   `taskdef.json`File ditambahkan ke repositori Anda. 

## Langkah 8: Buat dan jalankan alur kerja
<a name="deploy-tut-ecs-workflow"></a>

Pada langkah ini, Anda membuat alur kerja yang mengambil file sumber Anda, membuatnya menjadi image Docker, dan kemudian menyebarkan gambar ke cluster Amazon ECS Anda. Deployment ini menggantikan aplikasi placeholder Apache yang ada.

Alur kerja terdiri dari blok bangunan berikut yang berjalan secara berurutan:
+ Pemicu - Pemicu ini memulai alur kerja yang dijalankan secara otomatis saat Anda mendorong perubahan ke repositori sumber Anda. Untuk informasi lebih lanjut tentang menggunakan pemicu, lihat [Memulai alur kerja berjalan secara otomatis menggunakan pemicu](workflows-add-trigger.md).
+ Tindakan build (`BuildBackend`) — Pada pemicu, aksi membangun image Docker menggunakan Dockerfile dan mendorong gambar ke Amazon ECR. Tindakan build juga memperbarui `taskdef.json` dengan nilai `image` bidang yang benar, dan kemudian membuat artefak keluaran file ini. Artefak ini digunakan sebagai input untuk tindakan penyebaran, yang berikutnya.

  Untuk informasi selengkapnya tentang tindakan build, lihat[Membangun dengan alur kerja](build-workflow-actions.md).
+ Tindakan penerapan (`DeployToECS`) — Setelah menyelesaikan aksi build, tindakan deploy mencari artefak keluaran yang dihasilkan oleh build action (`TaskDefArtifact`), menemukan `taskdef.json` bagian dalamnya, dan mendaftarkannya dengan layanan Amazon ECS Anda. Layanan kemudian mengikuti instruksi dalam `taskdef.json` file untuk menjalankan tiga tugas Amazon ECS — dan container Hello World Docker terkait — di dalam cluster Amazon ECS Anda. 

**Untuk membuat alur kerja**

1. **Di CodeCatalyst konsol, di panel navigasi, pilih **CI/CD, lalu pilih Alur** kerja.**

1. Pilih **Buat alur kerja**.

1. Untuk **repositori Sumber, pilih**. `codecatalyst-ecs-source-repository`

1. Untuk **Cabang**, pilih`main`.

1. Pilih **Buat**.

1. Hapus kode sampel YAMAL.

1. Tambahkan kode YAML berikut:
**catatan**  
Dalam kode YAMAL berikut, Anda dapat menghilangkan `Connections:` bagian jika Anda mau. Jika Anda menghilangkan bagian ini, Anda harus memastikan bahwa peran yang ditentukan dalam bidang **peran IAM default** di lingkungan Anda mencakup izin dan kebijakan kepercayaan dari kedua peran yang dijelaskan. [Langkah 5: Tambahkan AWS peran ke CodeCatalyst](#deploy-tut-ecs-import-roles) Untuk informasi selengkapnya tentang menyiapkan lingkungan dengan peran IAM default, lihat[Pembuatan lingkungan](deploy-environments-creating-environment.md).

   ```
   Name: codecatalyst-ecs-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in taskdef.json
           - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat taskdef.json
           # The output artifact will be a zip file that contains a task definition file.
       Outputs:
         Artifacts:
           - Name: TaskDefArtifact
             Files: 
               - taskdef.json
     DeployToECS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/ecs-deploy@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-deploy-role
       Inputs:
         Sources: []
         Artifacts:
           - TaskDefArtifact
       Configuration:
         region: us-west-2
         cluster: codecatalyst-ecs-cluster
         service: codecatalyst-ecs-service
         task-definition: taskdef.json
   ```

   Pada kode sebelumnya, ganti:
   + Kedua contoh *codecatalyst-ecs-environment* dengan nama lingkungan yang Anda buat. [Prasyarat](#deploy-tut-ecs-prereqs)
   + Kedua contoh *codecatalyst-account-connection* dengan nama tampilan koneksi akun Anda. Nama tampilan mungkin nomor. Untuk informasi selengkapnya, lihat [Langkah 5: Tambahkan AWS peran ke CodeCatalyst](#deploy-tut-ecs-import-roles).
   + *codecatalyst-ecs-build-role*dengan nama peran build yang Anda buat[Langkah 4: Buat AWS peran](#deploy-tut-ecs-build-deploy-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo*(di `Value:` properti) dengan URI dari repositori Amazon ECR yang Anda buat. [Langkah 3: Buat repositori gambar Amazon ECR](#deploy-tut-ecs-ecr)
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(dalam `Run: aws ecr` perintah) dengan URI repositori Amazon ECR tanpa akhiran gambar (). `/codecatalyst-ecs-image-repo`
   + *codecatalyst-ecs-deploy-role*dengan nama peran penerapan yang Anda buat. [Langkah 4: Buat AWS peran](#deploy-tut-ecs-build-deploy-roles)
   + Kedua contoh *us-west-2* dengan kode AWS Wilayah Anda. Untuk daftar kode Wilayah, lihat [Titik akhir Regional](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) di. *Referensi Umum AWS*
**catatan**  
Jika Anda memutuskan untuk tidak membuat peran build dan deploy, ganti *codecatalyst-ecs-build-role* dan *codecatalyst-ecs-deploy-role* dengan nama `CodeCatalystWorkflowDevelopmentRole-spaceName` peran tersebut. Untuk informasi selengkapnya tentang peran ini, silakan lihat [Langkah 4: Buat AWS peran](#deploy-tut-ecs-build-deploy-roles).
**Tip**  
Alih-alih menggunakan `sed` perintah `find` dan yang ditampilkan dalam kode alur kerja sebelumnya untuk memperbarui repositori dan nama gambar, Anda dapat menggunakan tindakan **definisi tugas Render Amazon ECS** untuk tujuan ini. Untuk informasi selengkapnya, lihat [Memodifikasi definisi tugas Amazon ECS](render-ecs-action.md).

1. (Opsional) Pilih **Validasi** untuk memastikan bahwa kode YAMAL valid sebelum melakukan.

1. Pilih **Terapkan**.

1. Dalam kotak dialog **Commit workflow**, masukkan yang berikut ini:

   1. Untuk **pesan Commit**, hapus teks dan masukkan:

      ```
      Add first workflow
      ```

   1. Untuk **Repositori, pilih**. `codecatalyst-ecs-source-repository`

   1. Untuk **nama Branch**, pilih main.

   1. Pilih **Terapkan**.

   Anda sekarang telah membuat alur kerja. Jalankan alur kerja dimulai secara otomatis karena pemicu yang ditentukan di bagian atas alur kerja. Khususnya, ketika Anda melakukan (dan mendorong) `workflow.yaml` file ke repositori sumber Anda, pemicu memulai alur kerja dijalankan.

**Untuk melihat alur kerja, jalankan kemajuan**

1. **Di panel navigasi CodeCatalyst konsol, pilih **CI/CD, lalu pilih Alur** kerja.**

1. Pilih alur kerja yang baru saja Anda buat,`codecatalyst-ecs-workflow`.

1. Pilih **BuildBackend**untuk melihat kemajuan pembangunan.

1. Pilih **DeployToECS** untuk melihat kemajuan penerapan.

   Untuk informasi selengkapnya tentang melihat detail run, lihat[Melihat status dan detail alur kerja](workflows-view-run.md).

**Untuk memverifikasi penyebaran**

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

1. Pilih cluster Anda,`codecatalyst-ecs-cluster`.

1. Pilih tab **Tugas**. 

1. Pilih salah satu dari tiga tugas.

1. Di bidang **IP Publik**, pilih **alamat terbuka**.

   Halaman “Hello World” muncul di browser, menunjukkan bahwa layanan Amazon ECS berhasil menyebarkan aplikasi Anda.

## Langkah 9: Buat perubahan pada file sumber Anda
<a name="deploy-tut-ecs-change"></a>

Di bagian ini, Anda membuat perubahan pada `index.html` file di repositori sumber Anda. Perubahan ini menyebabkan alur kerja membuat image Docker baru, menandainya dengan ID komit, mendorongnya ke Amazon ECR, dan menerapkannya ke Amazon ECS. 

**Untuk mengubah index.html**

1. Di CodeCatalyst konsol, di panel navigasi, pilih **Kode**, lalu pilih repositori **Sumber, lalu pilih repositori** Anda,. `codecatalyst-ecs-source-repository`

1. Pilih`public-html`, lalu pilih`index.html`.

   Isi `index.html` muncul.

1. Pilih **Edit**. 

1. Pada baris 14, ubah `Hello World` teks menjadi`Tutorial complete!`.

1. Pilih **Komit**, lalu pilih **Komit** lagi.

   Komit menyebabkan alur kerja baru dijalankan. 

1. (Opsional) Buka halaman utama repositori sumber Anda, pilih **Lihat komit**, lalu catat ID komit untuk perubahan tersebut. `index.html`

1. Perhatikan kemajuan penerapan:

   1. **Di panel navigasi, pilih **CI/CD, lalu pilih Alur** kerja.**

   1. Pilih `codecatalyst-ecs-workflow` untuk melihat proses terbaru.

   1. Pilih **BuildBackend**, dan **DeployToECS** untuk melihat alur kerja berjalan kemajuan.

1. Verifikasi bahwa aplikasi Anda telah diperbarui, sebagai berikut:

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

   1. Pilih cluster Anda,`codecatalyst-ecs-cluster`.

   1. Pilih tab **Tugas**. 

   1. Pilih salah satu dari tiga tugas.

   1. Di bidang **IP Publik**, pilih **alamat terbuka**.

      Sebuah `Tutorial complete!` halaman muncul.

1. (Opsional) Di AWS, alihkan ke konsol Amazon ECR dan verifikasi bahwa image Docker baru ditandai dengan ID komit dari langkah 6.

## Bersihkan
<a name="deploy-tut-ecs-cleanup"></a>

Bersihkan file dan layanan yang digunakan dalam tutorial ini untuk menghindari biaya untuk mereka.

Dalam Konsol Manajemen AWS, bersihkan dalam urutan ini:

1. Di Amazon ECS, lakukan hal berikut:

   1. Hapus`codecatalyst-ecs-service`.

   1. Hapus`codecatalyst-ecs-cluster`.

   1. Deregister`codecatalyst-ecs-task-definition`.

1. Di Amazon ECR, hapus`codecatalyst-ecs-image-repo`.

1. Di Amazon EC2, hapus. `codecatalyst-ecs-security-group`

1. Di Pusat Identitas IAM, hapus:

   1. `CodeCatalystECSUser`

   1. `CodeCatalystECSPermissionSet`

Di CodeCatalyst konsol, bersihkan sebagai berikut:

1. Hapus`codecatalyst-ecs-workflow`.

1. Hapus`codecatalyst-ecs-environment`.

1. Hapus`codecatalyst-ecs-source-repository`.

1. Hapus`codecatalyst-ecs-project`.

Dalam tutorial ini, Anda mempelajari cara menerapkan aplikasi ke layanan Amazon ECS menggunakan CodeCatalyst alur kerja dan tindakan **Deploy ke Amazon** ECS.

# Menambahkan tindakan 'Terapkan ke Amazon ECS'
<a name="deploy-action-ecs-adding"></a>

Gunakan petunjuk berikut untuk menambahkan tindakan **Deploy ke Amazon ECS** ke alur kerja Anda. 

------
#### [ Visual ]

**Untuk menambahkan tindakan 'Terapkan ke Amazon ECS' menggunakan editor visual**

1. Buka CodeCatalyst konsol di [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Pilih proyek Anda.

1. **Di panel navigasi, pilih **CI/CD, lalu pilih Alur** kerja.**

1. Pilih nama alur kerja Anda. Anda dapat memfilter berdasarkan repositori sumber atau nama cabang tempat alur kerja ditentukan, atau memfilter berdasarkan nama atau status alur kerja.

1. Pilih **Edit**.

1. Pilih **Visual**.

1. Di kiri atas, pilih **\$1 Tindakan** untuk membuka katalog tindakan.

1. Dari daftar drop-down, pilih **Amazon CodeCatalyst**.

1. Cari tindakan **Deploy to Amazon ECS**, dan lakukan salah satu hal berikut:
   + Pilih tanda plus (**\$1**) untuk menambahkan tindakan ke diagram alur kerja dan buka panel konfigurasinya.

     Atau
   + Pilih **Terapkan ke Amazon ECS**. Kotak dialog detail tindakan muncul. Pada kotak dialog ini:
     + (Opsional) Pilih **Unduh** untuk [melihat kode sumber tindakan](workflows-view-source.md#workflows-view-source.title).
     + Pilih **Tambahkan ke alur kerja** untuk menambahkan tindakan ke diagram alur kerja dan buka panel konfigurasinya.

1. Pada tab **Input** dan **Konfigurasi**, lengkapi bidang sesuai dengan kebutuhan Anda. Untuk deskripsi setiap bidang, lihat[Tindakan 'Terapkan ke Amazon ECS' YAML'](deploy-action-ref-ecs.md). Referensi ini memberikan informasi rinci tentang setiap bidang (dan nilai properti YAMAL yang sesuai) seperti yang muncul di YAMAL dan editor visual.

1. (Opsional) Pilih **Validasi** untuk memvalidasi kode YAMAL alur kerja sebelum melakukan.

1. Pilih **Komit**, masukkan pesan komit, dan pilih **Komit** lagi.

------
#### [ YAML ]

**Untuk menambahkan tindakan 'Deploy to Amazon ECS' menggunakan editor YAMAL**

1. Buka CodeCatalyst konsol di [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Pilih proyek Anda.

1. **Di panel navigasi, pilih **CI/CD, lalu pilih Alur** kerja.**

1. Pilih nama alur kerja Anda. Anda dapat memfilter berdasarkan repositori sumber atau nama cabang tempat alur kerja ditentukan, atau memfilter berdasarkan nama atau status alur kerja.

1. Pilih **Edit**.

1. Pilih **YAMAL.**

1. Di kiri atas, pilih **\$1 Tindakan** untuk membuka katalog tindakan.

1. Dari daftar drop-down, pilih **Amazon CodeCatalyst**.

1. Cari tindakan **Deploy to Amazon ECS**, dan lakukan salah satu hal berikut:
   + Pilih tanda plus (**\$1**) untuk menambahkan tindakan ke diagram alur kerja dan buka panel konfigurasinya.

     Atau
   + Pilih **Terapkan ke Amazon ECS**. Kotak dialog detail tindakan muncul. Pada kotak dialog ini:
     + (Opsional) Pilih **Unduh** untuk [melihat kode sumber tindakan](workflows-view-source.md#workflows-view-source.title).
     + Pilih **Tambahkan ke alur kerja** untuk menambahkan tindakan ke diagram alur kerja dan buka panel konfigurasinya.

1. Ubah properti dalam kode YAMAL sesuai dengan kebutuhan Anda. Penjelasan tentang setiap properti yang tersedia disediakan di[Tindakan 'Terapkan ke Amazon ECS' YAML'](deploy-action-ref-ecs.md).

1. (Opsional) Pilih **Validasi** untuk memvalidasi kode YAMAL alur kerja sebelum melakukan.

1. Pilih **Komit**, masukkan pesan komit, dan pilih **Komit** lagi.

------

# Variabel 'Terapkan ke Amazon ECS'
<a name="deploy-action-ecs-variables"></a>

Tindakan **Deploy to Amazon ECS** menghasilkan dan menetapkan variabel berikut pada waktu berjalan. Ini dikenal sebagai *variabel yang telah ditentukan sebelumnya*.

Untuk informasi tentang mereferensikan variabel-variabel ini dalam alur kerja, lihat. [Menggunakan variabel yang telah ditentukan](workflows-using-predefined-variables.md)


| Key | Nilai | 
| --- | --- | 
|  klaster  |  Nama kluster Amazon ECS yang digunakan selama alur kerja dijalankan. Contoh: `codecatalyst-ecs-cluster`  | 
|  platform penyebaran  |  Nama platform penyebaran. Hardcode ke. `AWS:ECS`  | 
|  layanan  |  Nama layanan Amazon ECS yang digunakan selama alur kerja dijalankan. Contoh: `codecatalyst-ecs-service`  | 
|  task-definition-arn  |  Nama Sumber Daya Amazon (ARN) dari definisi tugas yang didaftarkan selama alur kerja dijalankan. Contoh: `arn:aws:ecs:us-west-2:111122223333:task-definition/codecatalyst-task-def:8`Contoh sebelumnya menunjukkan revisi yang terdaftar. `:8`  | 
|  deployment-url  |  Tautan ke tab **Acara** konsol Amazon ECS, tempat Anda dapat melihat detail penerapan Amazon ECS yang terkait dengan alur kerja yang dijalankan. Contoh: `https://console.aws.amazon.com/ecs/home?region=us-west-2#/clusters/codecatalyst-ecs-cluster/services/codecatalyst-ecs-service/events`  | 
|  region  |  Kode wilayah Wilayah AWS yang digunakan selama alur kerja dijalankan. Contoh: `us-west-2`  | 

# Tindakan 'Terapkan ke Amazon ECS' YAML'
<a name="deploy-action-ref-ecs"></a>

Berikut ini adalah definisi YAMAL dari tindakan **Deploy to Amazon ECS**. Untuk mempelajari cara menggunakan tindakan ini, lihat[Menyebarkan ke Amazon ECS dengan alur kerja](deploy-action-ecs.md).

Definisi tindakan ini ada sebagai bagian dalam file definisi alur kerja yang lebih luas. Untuk informasi selengkapnya tentang file ini, lihat[Alur kerja definisi YAMAL](workflow-reference.md).

**catatan**  
Sebagian besar properti YAMAL yang mengikuti memiliki elemen UI yang sesuai di editor visual. Untuk mencari elemen UI, gunakan **Ctrl\$1F**. Elemen akan terdaftar dengan properti YAMLnya yang terkait.

```
# The workflow definition starts here.
# See Properti tingkat atas for details.
        
Name: MyWorkflow
SchemaVersion: 1.0 
Actions:

# The action definition starts here.   
  ECSDeployAction\$1nn: 
    Identifier: aws/ecs-deploy@v1
    DependsOn:
      - build-action
    Compute:  
      Type: EC2 | Lambda
      Fleet: fleet-name
    Timeout: timeout-minutes
    Environment:
      Name: environment-name
      Connections:
        - Name: account-connection-name
          Role: iam-role-name
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - task-definition-artifact
    Configuration: 
      region: us-east-1 
      cluster: ecs-cluster
      service: ecs-service
      task-definition: task-definition-path
      force-new-deployment: false|true
      codedeploy-appspec: app-spec-file-path
      codedeploy-application: application-name
      codedeploy-deployment-group: deployment-group-name
      codedeploy-deployment-description: deployment-description
```

## ECSDeployAction
<a name="deploy.action.ecs.name"></a>

(Diperlukan)

Tentukan nama tindakan. Semua nama tindakan harus unik dalam alur kerja. Nama aksi terbatas pada karakter alfanumerik (a-z, A-Z, 0-9), tanda hubung (-), dan garis bawah (\$1). Spasi tidak diizinkan. Anda tidak dapat menggunakan tanda kutip untuk mengaktifkan karakter dan spasi khusus dalam nama tindakan.

Default: `ECSDeployAction_nn`.

UI yang sesuai: Tab **konfigurasi/Nama tampilan tindakan**

## Identifier
<a name="deploy.action.ecs.identifier"></a>

(*ECSDeployAction*/**Identifier**)

(Diperlukan)

Mengidentifikasi tindakan. Jangan mengubah properti ini kecuali Anda ingin mengubah versi. Untuk informasi selengkapnya, lihat [Menentukan versi tindakan yang akan digunakan](workflows-action-versions.md).

Default: `aws/ecs-deploy@v1`.

**UI yang sesuai: Diagram alur ECSDeploy kerja/Action\$1nn/ aws/ecs-deploy @v1 label**

## DependsOn
<a name="deploy.action.ecs.dependson"></a>

(*ECSDeployAction*/**DependsOn**)

(Opsional)

Tentukan tindakan, grup tindakan, atau gerbang yang harus berjalan dengan sukses agar tindakan ini berjalan.

Untuk informasi selengkapnya tentang fungsionalitas 'tergantung pada', lihat. [Tindakan pengurutan](workflows-depends-on.md)

UI yang sesuai: Tab **masukan/Tergantung pada** - opsional

## Compute
<a name="deploy.action.ecs.computename"></a>

(*ECSDeployAction*/**Compute**)

(Opsional)

Mesin komputasi yang digunakan untuk menjalankan tindakan alur kerja Anda. Anda dapat menentukan komputasi baik di tingkat alur kerja atau di tingkat tindakan, tetapi tidak keduanya. Ketika ditentukan pada tingkat alur kerja, konfigurasi komputasi berlaku untuk semua tindakan yang ditentukan dalam alur kerja. Pada tingkat alur kerja, Anda juga dapat menjalankan beberapa tindakan pada instance yang sama. Untuk informasi selengkapnya, lihat [Berbagi komputasi di seluruh tindakan](compute-sharing.md).

UI yang sesuai: *tidak ada*

## Type
<a name="deploy.action.ecs.computetype"></a>

(*ECSDeployAction*/Compute/**Type**)

(Diperlukan [Compute](#deploy.action.ecs.computename) jika disertakan)

Jenis mesin komputasi. Anda dapat menggunakan salah satu nilai berikut:
+ **EC2** (editor visual) atau `EC2` (editor YAMG)

  Dioptimalkan untuk fleksibilitas selama aksi berjalan.
+ **Lambda** (editor visual) atau `Lambda` (editor YAMG)

  Kecepatan start-up aksi yang dioptimalkan.

Untuk informasi selengkapnya tentang jenis komputasi, lihat[Jenis komputasi](workflows-working-compute.md#compute.types).

**UI yang sesuai: Konfigurasi tab/Advanced - tipe opsional/Komputasi**

## Fleet
<a name="deploy.action.ecs.computefleet"></a>

(*ECSDeployAction*/Compute/**Fleet**)

(Opsional)

Tentukan mesin atau armada yang akan menjalankan alur kerja atau tindakan alur kerja Anda. Dengan armada sesuai permintaan, ketika suatu tindakan dimulai, alur kerja menyediakan sumber daya yang dibutuhkan, dan mesin dihancurkan ketika tindakan selesai. Contoh armada sesuai permintaan:`Linux.x86-64.Large`,. `Linux.x86-64.XLarge` Untuk informasi lebih lanjut tentang armada sesuai permintaan, lihat. [Properti armada sesuai permintaan](workflows-working-compute.md#compute.on-demand)

Dengan armada yang disediakan, Anda mengonfigurasi satu set mesin khusus untuk menjalankan tindakan alur kerja Anda. Mesin-mesin ini tetap menganggur, siap untuk memproses tindakan segera. Untuk informasi selengkapnya tentang armada yang disediakan, lihat. [Properti armada yang disediakan](workflows-working-compute.md#compute.provisioned-fleets)

Jika `Fleet` dihilangkan, defaultnya adalah. `Linux.x86-64.Large`

**UI yang sesuai: Konfigurasi tab/Advanced - armada opsional/Komputasi**

## Timeout
<a name="deploy.action.ecs.timeout"></a>

(*ECSDeployAction*/**Timeout**)

(Opsional)

Tentukan jumlah waktu dalam menit (editor YAMG), atau jam dan menit (editor visual), bahwa tindakan dapat berjalan sebelum CodeCatalyst mengakhiri tindakan. Minimal adalah 5 menit dan maksimum dijelaskan dalam[Kuota untuk alur kerja di CodeCatalyst](workflows-quotas.md). Batas waktu default sama dengan batas waktu maksimum.

UI yang sesuai: Tab **konfigurasi/Timeout** - opsional

## Environment
<a name="deploy.action.ecs.environment"></a>

(*ECSDeployAction*/**Environment**)

(Diperlukan)

Tentukan CodeCatalyst lingkungan yang akan digunakan dengan tindakan. Tindakan terhubung ke Akun AWS dan VPC Amazon opsional yang ditentukan di lingkungan yang dipilih. Tindakan ini menggunakan peran IAM default yang ditentukan di lingkungan untuk terhubung ke Akun AWS, dan menggunakan peran IAM yang ditentukan dalam [koneksi VPC Amazon untuk terhubung ke VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) Amazon.

**catatan**  
Jika peran IAM default tidak memiliki izin yang diperlukan oleh tindakan, Anda dapat mengonfigurasi tindakan untuk menggunakan peran yang berbeda. Untuk informasi selengkapnya, lihat [Mengubah peran IAM dari suatu tindakan](deploy-environments-switch-role.md).

Untuk informasi selengkapnya tentang lingkungan, lihat [Menyebarkan ke dalam Akun AWS dan VPCs](deploy-environments.md) dan[Pembuatan lingkungan](deploy-environments-creating-environment.md).

**UI yang sesuai: Tab konfigurasi/Lingkungan**

## Name
<a name="deploy.action.ecs.environment.name"></a>

(*ECSDeployAction*/Environment/**Name**)

(Diperlukan [Environment](#deploy.action.ecs.environment) jika disertakan)

Tentukan nama lingkungan yang ada yang ingin Anda kaitkan dengan tindakan.

**UI yang sesuai: Tab konfigurasi/Lingkungan**

## Connections
<a name="deploy.action.ecs.environment.connections"></a>

(*ECSDeployAction*/Environment/**Connections**)

(Opsional dalam versi tindakan yang lebih baru; diperlukan dalam versi yang lebih lama)

Tentukan koneksi akun untuk dikaitkan dengan tindakan. Anda dapat menentukan maksimum satu koneksi akun di bawah`Environment`.

Jika Anda tidak menentukan koneksi akun:
+ Tindakan menggunakan Akun AWS koneksi dan peran IAM default yang ditentukan di lingkungan di CodeCatalyst konsol. Untuk informasi tentang menambahkan koneksi akun dan peran IAM default ke lingkungan, lihat[Pembuatan lingkungan](deploy-environments-creating-environment.md).
+ Peran IAM default harus menyertakan kebijakan dan izin yang diperlukan oleh tindakan. Untuk menentukan kebijakan dan izin tersebut, lihat deskripsi properti **Peran** dalam dokumentasi definisi YAMAL tindakan.

Untuk informasi selengkapnya tentang koneksi akun, lihat[Memungkinkan akses ke AWS sumber daya yang terhubung Akun AWS](ipa-connect-account.md). Untuk informasi tentang menambahkan koneksi akun ke lingkungan, lihat[Pembuatan lingkungan](deploy-environments-creating-environment.md).

UI yang sesuai: Salah satu dari berikut ini tergantung pada versi tindakan:
+ (Versi yang lebih baru) Konfigurasi tab/Environment/What masuk? *my-environment* **/menu tiga titik/Beralih peran**
+ **(Versi lama) Tab konfigurasi/' Environment/account/role AWS '/ koneksi akun**

## Name
<a name="deploy.action.ecs.environment.connections.name"></a>

(*ECSDeployAction*/Environment/Connections/**Name**)

(Diperlukan [Connections](#deploy.action.ecs.environment.connections) jika disertakan)

Tentukan nama koneksi akun.

UI yang sesuai: Salah satu dari berikut ini tergantung pada versi tindakan:
+ (Versi yang lebih baru) Konfigurasi tab/Environment/What masuk? *my-environment* **/menu tiga titik/Beralih peran**
+ **(Versi lama) Tab konfigurasi/' Environment/account/role AWS '/ koneksi akun**

## Role
<a name="deploy.action.ecs.environment.connections.role"></a>

(*ECSDeployAction*/Environment/Connections/**Role**)

(Diperlukan [Connections](#deploy.action.ecs.environment.connections) jika disertakan)

Tentukan nama peran IAM yang digunakan tindakan **Deploy to Amazon ECS** untuk mengakses. AWS Pastikan Anda telah [menambahkan peran ke CodeCatalyst ruang Anda](ipa-connect-account-addroles.md), dan peran tersebut mencakup kebijakan berikut.

Jika Anda tidak menentukan peran IAM, maka tindakan tersebut menggunakan peran IAM default yang tercantum di [lingkungan](deploy-environments.md) di CodeCatalyst konsol. Jika Anda menggunakan peran default di lingkungan, pastikan itu memiliki kebijakan berikut.
+ Kebijakan izin berikut:
**Awas**  
Batasi izin untuk yang ditampilkan dalam kebijakan berikut. Menggunakan peran dengan izin yang lebih luas dapat menimbulkan risiko keamanan.

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [{
      "Action":[
        "ecs:DescribeServices",
        "ecs:CreateTaskSet",
        "ecs:DeleteTaskSet",
        "ecs:ListClusters",
        "ecs:RegisterTaskDefinition",
        "ecs:UpdateServicePrimaryTaskSet",
        "ecs:UpdateService",
        "elasticloadbalancing:DescribeTargetGroups",
        "elasticloadbalancing:DescribeListeners",
        "elasticloadbalancing:ModifyListener",
        "elasticloadbalancing:DescribeRules",
        "elasticloadbalancing:ModifyRule",
        "lambda:InvokeFunction",
        "lambda:ListFunctions",
        "cloudwatch:DescribeAlarms",
        "sns:Publish",
        "sns:ListTopics", 
        "s3:GetObject",
        "s3:GetObjectVersion",
        "codedeploy:CreateApplication", 
        "codedeploy:CreateDeployment", 
        "codedeploy:CreateDeploymentGroup", 
        "codedeploy:GetApplication", 
        "codedeploy:GetDeployment", 
        "codedeploy:GetDeploymentGroup", 
        "codedeploy:ListApplications", 
        "codedeploy:ListDeploymentGroups", 
        "codedeploy:ListDeployments", 
        "codedeploy:StopDeployment", 
        "codedeploy:GetDeploymentTarget", 
        "codedeploy:ListDeploymentTargets", 
        "codedeploy:GetDeploymentConfig", 
        "codedeploy:GetApplicationRevision", 
        "codedeploy:RegisterApplicationRevision", 
        "codedeploy:BatchGetApplicationRevisions", 
        "codedeploy:BatchGetDeploymentGroups", 
        "codedeploy:BatchGetDeployments", 
        "codedeploy:BatchGetApplications", 
        "codedeploy:ListApplicationRevisions", 
        "codedeploy:ListDeploymentConfigs", 
        "codedeploy:ContinueDeployment"           
     ],
     "Resource":"*",
     "Effect":"Allow"
  },{"Action":[
        "iam:PassRole"
     ],
     "Effect":"Allow",
     "Resource":"*",
     "Condition":{"StringLike":{"iam:PassedToService":[
              "ecs-tasks.amazonaws.com",
              "codedeploy.amazonaws.com"
           ]
        }
     }
  }]
  }
  ```

------
**catatan**  
Pertama kali peran digunakan, gunakan wildcard berikut dalam pernyataan kebijakan sumber daya dan kemudian cakup kebijakan dengan nama sumber daya setelah tersedia.  

  ```
  "Resource": "*"
  ```
+ Kebijakan kepercayaan khusus berikut:

**catatan**  
Anda dapat menggunakan `CodeCatalystWorkflowDevelopmentRole-spaceName` peran dengan tindakan ini, jika Anda mau. Untuk informasi selengkapnya tentang peran ini, silakan lihat [Membuat **CodeCatalystWorkflowDevelopmentRole-*spaceName***peran untuk akun dan ruang Anda](ipa-iam-roles.md#ipa-iam-roles-service-create). Memahami bahwa `CodeCatalystWorkflowDevelopmentRole-spaceName` peran tersebut memiliki izin akses penuh yang dapat menimbulkan risiko keamanan. Kami menyarankan Anda hanya menggunakan peran ini dalam tutorial dan skenario di mana keamanan kurang menjadi perhatian. 

UI yang sesuai: Salah satu dari berikut ini tergantung pada versi tindakan:
+ (Versi yang lebih baru) Konfigurasi tab/Environment/What masuk? *my-environment* **/menu tiga titik/Beralih peran**
+ **(Versi lama) Tab konfigurasi/' '/ Environment/account/role Peran**

## Inputs
<a name="deploy.action.ecs.inputs"></a>

(*ECSDeployAction*/**Inputs**)

(Opsional)

`Inputs`Bagian ini mendefinisikan data yang `ECSDeployAction` dibutuhkan selama menjalankan alur kerja.

**catatan**  
Hanya satu input (baik sumber atau artefak) yang diizinkan per tindakan **Deploy ke Amazon ECS**.

UI yang sesuai: **Tab input**

## Sources
<a name="deploy.action.ecs.inputs.sources"></a>

(*ECSDeployAction*/Inputs/**Sources**)

(Diperlukan jika file definisi tugas Anda disimpan dalam repositori sumber)

Jika file definisi tugas Anda disimpan dalam repositori sumber, tentukan label repositori sumber tersebut. Saat ini, satu-satunya label yang didukung adalah`WorkflowSource`.

Jika file definisi tugas Anda tidak terkandung dalam repositori sumber, itu harus berada dalam artefak yang dihasilkan oleh tindakan lain.

Untuk informasi selengkapnya tentang sumber, lihat [Menghubungkan repositori sumber ke alur kerja](workflows-sources.md).

UI yang sesuai: **Tab/Sumber** Input - opsional

## Artifacts - input
<a name="deploy.action.ecs.inputs.artifacts"></a>

(*ECSDeployAction*/Inputs/**Artifacts**)

(Diperlukan jika file definisi tugas Anda disimpan dalam [artefak keluaran](workflows-working-artifacts-output.md) dari tindakan sebelumnya)

Jika file definisi tugas yang ingin Anda terapkan terkandung dalam artefak yang dihasilkan oleh tindakan sebelumnya, tentukan artefak tersebut di sini. Jika file definisi tugas Anda tidak terkandung dalam artefak, itu harus berada di repositori sumber Anda.

Untuk informasi selengkapnya tentang artefak, termasuk contoh, lihat[Berbagi artefak dan file antar tindakan](workflows-working-artifacts.md).

UI yang sesuai: Tab **konfigurasi/Artefak** - opsional

## Configuration
<a name="deploy.action.ecs.configuration"></a>

(*ECSDeployAction*/**Configuration**)

(Diperlukan)

Bagian di mana Anda dapat menentukan properti konfigurasi tindakan.

UI yang sesuai: Tab **konfigurasi**

## region
<a name="deploy.action.ecs.region"></a>

(Configuration/**region**)

(Diperlukan)

Tentukan AWS Wilayah tempat klaster dan layanan Amazon ECS Anda berada. Untuk daftar kode Region, lihat [Titik akhir Regional](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) di. *Referensi Umum AWS*

**UI yang sesuai: Tab konfigurasi/Wilayah**

## cluster
<a name="deploy.action.ecs.cluster"></a>

(*ECSDeployAction*/Configuration/**cluster**)

(Diperlukan)

Tentukan nama cluster Amazon ECS yang ada. Tindakan **Deploy to Amazon ECS** akan menerapkan aplikasi kontainer Anda sebagai tugas ke dalam klaster ini. Untuk informasi selengkapnya tentang klaster Amazon ECS, lihat Cluster di [Panduan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-clusters) Pengembang *Layanan Kontainer Elastis Amazon*.

**UI yang sesuai: Tab konfigurasi/Cluster**

## service
<a name="deploy.action.ecs.service"></a>

(*ECSDeployAction*/Configuration/**service**)

(Diperlukan)

Tentukan nama layanan Amazon ECS yang ada yang akan membuat instance file definisi tugas. Layanan ini harus berada di bawah cluster yang ditentukan di `cluster` bidang. Untuk informasi selengkapnya tentang layanan Amazon ECS, lihat Layanan [Amazon ECS di Panduan Pengembang Layanan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html) *Kontainer Elastis Amazon*.

**UI yang sesuai: Tab konfigurasi/Layanan**

## task-definition
<a name="deploy.action.ecs.task.definition"></a>

(*ECSDeployAction*/Configuration/**task-definition**)

(Diperlukan)

Tentukan jalur ke file definisi tugas yang ada. Jika file berada di repositori sumber Anda, jalurnya relatif terhadap folder root repositori sumber. Jika file Anda berada dalam artefak dari tindakan alur kerja sebelumnya, jalurnya relatif terhadap folder root artefak. Untuk informasi selengkapnya tentang file definisi tugas, lihat [Definisi tugas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html#welcome-task-definitions) di *Panduan Pengembang Layanan Kontainer Elastis Amazon*.

UI yang sesuai: Tab konfigurasi/Definisi **tugas**

## force-new-deployment
<a name="deploy.action.ecs.forcenewdeployment"></a>

(*ECSDeployAction*/Configuration/**force-new-deployment**)

(Diperlukan)

Jika diaktifkan, layanan Amazon ECS dapat memulai penerapan baru tanpa perubahan definisi layanan. Memaksa penerapan menyebabkan layanan menghentikan semua tugas yang sedang berjalan dan meluncurkan tugas baru. Untuk informasi selengkapnya tentang pemaksaan penerapan baru, lihat [Memperbarui layanan di Panduan Pengembang Layanan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service.html) *Amazon Elastic Container*.

Default: `false`

UI yang sesuai: Tab **konfigurasi/Paksa penerapan layanan baru**

## codedeploy-appspec
<a name="deploy.action.ecs.codedeploy.appspec"></a>

(*ECSDeployAction*/Configuration/**codedeploy-appspec**)

(Diperlukan jika Anda telah mengonfigurasi layanan Amazon ECS Anda untuk menggunakan blue/green penerapan, jika tidak, hilangkan)

Tentukan nama dan jalur ke file spesifikasi CodeDeploy aplikasi (AppSpec) yang ada. File ini harus berada di root repositori CodeCatalyst sumber Anda. Untuk informasi selengkapnya tentang AppSpec file, lihat [file spesifikasi CodeDeploy aplikasi (AppSpec)](https://docs.aws.amazon.com/codedeploy/latest/userguide/application-specification-files.html) di *Panduan AWS CodeDeploy Pengguna*.

**catatan**  
Hanya berikan CodeDeploy informasi jika Anda telah mengonfigurasi layanan Amazon ECS untuk melakukan blue/green penerapan. Untuk penerapan pembaruan bergulir (default), hilangkan CodeDeploy informasi. Untuk informasi selengkapnya tentang penerapan Amazon ECS, lihat [jenis penerapan Amazon ECS di](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) Panduan Pengembang Layanan Kontainer *Elastis Amazon*.

**catatan**  
**CodeDeploy**Bidang mungkin disembunyikan di editor visual. Untuk membuat mereka muncul, lihat[Mengapa CodeDeploy bidang hilang dari editor visual?](troubleshooting-workflows.md#troubleshooting-workflows-codedeploy).

UI yang sesuai: Tab konfigurasi/**CodeDeploy AppSpec**

## codedeploy-application
<a name="deploy.action.ecs.codedeploy.application"></a>

(*ECSDeployAction*/Configuration/**codedeploy-application**)

(Diperlukan `codedeploy-appspec` jika disertakan)

Tentukan nama CodeDeploy aplikasi yang ada. Untuk informasi selengkapnya tentang CodeDeploy aplikasi, lihat [Bekerja dengan aplikasi CodeDeploy di](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) *Panduan AWS CodeDeploy Pengguna*.

**UI yang sesuai: Tab konfigurasi/aplikasi CodeDeploy **

## codedeploy-deployment-group
<a name="deploy.action.ecs.codedeploy.deploymentgroup"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-group**)

(Diperlukan `codedeploy-appspec` jika disertakan)

Tentukan nama grup CodeDeploy penyebaran yang ada. Untuk informasi selengkapnya tentang grup CodeDeploy penerapan, lihat [Bekerja dengan grup penerapan CodeDeploy di AWS CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) *Panduan Pengguna*.

UI yang sesuai: Tab konfigurasi/grup **CodeDeploy penerapan**

## codedeploy-deployment-description
<a name="deploy.action.ecs.codedeploy.deploymentdescription"></a>

(*ECSDeployAction*/Configuration/**codedeploy-deployment-description**)

(Opsional)

Tentukan deskripsi penerapan yang akan dibuat oleh tindakan ini. Untuk informasi selengkapnya, lihat [Bekerja dengan penerapan CodeDeploy di AWS CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments.html) *Panduan Pengguna*.

UI yang sesuai: Tab konfigurasi/deskripsi **CodeDeploy penerapan**