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.

# Menerapkan ke Amazon EKS dengan alur kerja
<a name="deploy-action-eks"></a>

**Tip**  
Untuk tutorial yang menunjukkan cara menggunakan aksi **cluster Deploy to Kubernetes**, lihat. [Tutorial: Menyebarkan aplikasi ke Amazon EKS](deploy-tut-eks.md)

Bagian ini menjelaskan cara menerapkan aplikasi kontainer ke dalam klaster Kubernetes menggunakan alur kerja. CodeCatalyst Untuk mencapai hal ini, Anda harus menambahkan tindakan **cluster Deploy ke Kubernetes ke** alur kerja Anda. Tindakan ini menyebarkan aplikasi Anda ke klaster Kubernetes yang telah Anda siapkan di Amazon Elastic Kubernetes Service (EKS) menggunakan satu atau beberapa file manifes Kubernetes. Untuk contoh manifes, lihat [deployment.yaml](deploy-tut-eks.md#deploy-tut-eks-source-files-deployment-yml) di[Tutorial: Menyebarkan aplikasi ke Amazon EKS](deploy-tut-eks.md).

[Untuk informasi selengkapnya tentang Kubernetes, lihat Dokumentasi Kubernetes.](https://kubernetes.io/docs/home/)

Untuk informasi selengkapnya tentang Amazon EKS, lihat [Apa itu Amazon EKS?](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html) di *Panduan Pengguna Amazon EKS*.

**Topics**
+ [Cara kerja aksi 'Deploy to Kubernetes cluster'](#deploy-action-eks-howitworks)
+ [Gambar runtime yang digunakan oleh aksi 'Deploy to Amazon EKS'](#deploy-action-eks-runtime)
+ [Tutorial: Menyebarkan aplikasi ke Amazon EKS](deploy-tut-eks.md)
+ [Menambahkan aksi 'Deploy to Kubernetes cluster'](deploy-action-eks-adding.md)
+ [Variabel 'Terapkan ke klaster Kubernetes'](deploy-action-eks-variables.md)
+ [Tindakan 'Terapkan ke Kluster Kubernetes' YAML](deploy-action-ref-eks.md)

## Cara kerja aksi 'Deploy to Kubernetes cluster'
<a name="deploy-action-eks-howitworks"></a>

**Kluster Deploy ke Kubernetes berfungsi** sebagai berikut:

1. Saat runtime, action akan menginstal `kubectl` utilitas Kubernetes ke mesin CodeCatalyst komputasi tempat aksi berjalan. Tindakan dikonfigurasi `kubectl` untuk menunjuk ke kluster Amazon EKS yang Anda berikan saat mengonfigurasi tindakan. `kubectl`Utilitas diperlukan untuk menjalankan `kubectl apply` perintah, selanjutnya.

1. Tindakan ini menjalankan `kubectl apply -f my-manifest.yaml` perintah, yang menjalankan instruksi *my-manifest.yaml* untuk menyebarkan aplikasi Anda sebagai satu set kontainer dan pod ke dalam cluster yang dikonfigurasi. *Untuk informasi selengkapnya tentang perintah ini, lihat topik [kubectl apply di Kubernetes](https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands#apply) Reference Documentation.*

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

Tindakan **Deploy to Amazon EKS** 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 EKS
<a name="deploy-tut-eks"></a>

Dalam tutorial ini, Anda mempelajari cara menerapkan aplikasi container ke Amazon Elastic Kubernetes Service menggunakan alur kerja Amazon, CodeCatalyst Amazon EKS, dan beberapa layanan lainnya. AWS Aplikasi yang digunakan adalah 'Halo, Dunia\$1 'sederhana situs web yang dibangun di atas gambar Docker server web Apache. Tutorial memandu Anda melalui pekerjaan persiapan yang diperlukan seperti menyiapkan mesin pengembangan dan kluster Amazon EKS, dan kemudian menjelaskan cara membuat alur kerja untuk membangun aplikasi dan menerapkannya ke dalam cluster.

Setelah penerapan awal selesai, tutorial menginstruksikan Anda untuk membuat perubahan pada sumber aplikasi Anda. Perubahan ini menyebabkan image Docker baru dibangun dan didorong ke repositori gambar Docker Anda dengan informasi revisi baru. Revisi baru gambar Docker kemudian diterapkan ke Amazon EKS.

**Tip**  
Alih-alih mengerjakan tutorial ini, Anda dapat menggunakan cetak biru yang melakukan pengaturan Amazon EKS lengkap untuk Anda. Anda harus menggunakan cetak biru **Penerapan Aplikasi EKS**. Untuk informasi selengkapnya, lihat [Membuat proyek dengan cetak biru](projects-create.md#projects-create-console-template).

**Topics**
+ [Prasyarat](#deploy-tut-eks-prereqs)
+ [Langkah 1: Siapkan mesin pengembangan Anda](#deploy-tut-eks-dev-env-create)
+ [Langkah 2: Buat cluster Amazon EKS](#deploy-tut-eks-cluster)
+ [Langkah 3: Buat repositori gambar Amazon ECR](#deploy-tut-eks-ecr)
+ [Langkah 4: Tambahkan file sumber](#deploy-tut-eks-source-files)
+ [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles)
+ [Langkah 6: Tambahkan AWS peran ke CodeCatalyst](#deploy-tut-eks-import-roles)
+ [Langkah 7: Perbarui ConfigMap](#deploy-tut-eks-configmap)
+ [Langkah 8: Buat dan jalankan alur kerja](#deploy-tut-eks-workflow)
+ [Langkah 9: Buat perubahan pada file sumber Anda](#deploy-tut-eks-change)
+ [Bersihkan](#deploy-tut-eks-cleanup)

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

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

  ```
  codecatalyst-eks-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 **repositori CodeCatalyst sumber** kosong yang disebut:

  ```
  codecatalyst-eks-source-repository
  ```

  Untuk informasi selengkapnya, lihat [Simpan dan berkolaborasi pada kode dengan repositori sumber di CodeCatalystSimpan dan berkolaborasi pada kode dengan repositori sumber](source.md).
+ Dalam proyek Anda, Anda memerlukan lingkungan CodeCatalyst CI/CD (bukan **Lingkungan** Dev) yang disebut:

  ```
  codecatalyst-eks-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 mesin pengembangan Anda
<a name="deploy-tut-eks-dev-env-create"></a>

Langkah pertama dalam tutorial ini adalah mengkonfigurasi mesin pengembangan dengan beberapa alat yang akan Anda gunakan sepanjang tutorial ini. Alat-alat ini adalah:
+ `eksctl`utilitas - untuk pembuatan cluster
+ `kubectl`utilitas — prasyarat untuk `eksctl`
+ yang AWS CLI — juga merupakan prasyarat untuk `eksctl`

Anda dapat menginstal alat ini di mesin pengembangan yang ada jika Anda memilikinya, atau Anda dapat menggunakan Lingkungan CodeCatalyst Dev, yang berbasis Cloud. Manfaat dari CodeCatalyst Dev Environment adalah mudah untuk berputar dan turun, dan terintegrasi dengan CodeCatalyst layanan lain, memungkinkan Anda untuk bekerja melalui tutorial ini dalam langkah-langkah yang lebih sedikit.

Tutorial ini mengasumsikan Anda akan menggunakan CodeCatalyst Dev Environment.

Petunjuk berikut menjelaskan cara cepat untuk meluncurkan Lingkungan CodeCatalyst Dev dan mengonfigurasinya dengan alat yang diperlukan, tetapi jika Anda menginginkan instruksi terperinci, lihat:
+ [Membuat Lingkungan Pengembangan](devenvironment-create.md) dalam panduan ini.
+ [Menginstal kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) di Panduan Pengguna **Amazon EKS**.
+ [Menginstal atau memutakhirkan eksctl di Panduan](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) Pengguna **Amazon** EKS.
+ [Menginstal atau memperbarui versi terbaru dari AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dalam *Panduan AWS Command Line Interface Pengguna*.

**Untuk meluncurkan Lingkungan Dev**

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

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

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

1. Pilih nama repositori sumber Anda,. `codecatalyst-eks-source-repository`

1. Di dekat bagian atas pilih **Create Dev Environment**, lalu pilih **AWS Cloud9 (di browser)**.

1. Pastikan bahwa **Work di cabang dan **main** yang ada** dipilih, lalu pilih **Buat**.

   Lingkungan Dev Anda diluncurkan di tab browser baru, dan repositori (`codecatalyst-eks-source-repository`) Anda dikloning ke dalamnya.

**Untuk menginstal dan mengkonfigurasi kubectl**

1. Di terminal Dev Environment, masukkan:

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. Masukkan:

   ```
   chmod +x ./kubectl
   ```

1. Masukkan:

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. Masukkan:

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. Masukkan:

   ```
   kubectl version --short --client
   ```

1. Periksa apakah ada versi yang muncul.

   Anda sekarang telah menginstal`kubectl`.

**Untuk menginstal dan mengkonfigurasi eksctl**
**catatan**  
`eksctl`tidak sepenuhnya diperlukan karena Anda dapat menggunakannya `kubectl` sebagai gantinya. Namun, `eksctl` memiliki manfaat mengotomatisasi banyak konfigurasi cluster, dan oleh karena itu alat yang direkomendasikan untuk tutorial ini.

1. Di terminal Dev Environment, masukkan:

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. Masukkan:

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. Masukkan:

   ```
   eksctl version
   ```

1. Periksa apakah ada versi yang muncul.

   Anda sekarang telah menginstal`eksctl`.

**Untuk memverifikasi bahwa AWS CLI sudah diinstal**

1. Di terminal Dev Environment, masukkan:

   ```
   aws --version
   ```

1. Periksa apakah versi muncul untuk memverifikasi bahwa AWS CLI sudah diinstal.

   Lengkapi prosedur yang tersisa untuk mengkonfigurasi AWS CLI dengan izin yang diperlukan untuk mengakses AWS.

**Untuk mengkonfigurasi AWS CLI**

Anda harus mengonfigurasi tombol akses AWS CLI dengan dan token sesi untuk memberikannya akses ke AWS layanan. Petunjuk berikut menyediakan cara cepat untuk mengonfigurasi kunci dan token, tetapi jika Anda menginginkan instruksi terperinci, lihat [Mengonfigurasi AWS CLI di](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) *Panduan AWS Command Line Interface Pengguna*.

1. Buat pengguna IAM Identity Center, sebagai berikut:

   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/).

      (Anda mungkin perlu memilih **Aktifkan** jika Anda belum pernah masuk ke Pusat Identitas IAM sebelumnya.)
**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:

      ```
      codecatalyst-eks-user
      ```

   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**, masukkan:

      ```
      codecatalyst-eks-user
      ```

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

      ```
      codecatalyst-eks-user
      ```

   1. Di **Nama tampilan**, simpan:

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   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 ke file teks. Informasi masuk terdiri dari URL portal AWS akses, nama pengguna, dan kata sandi satu kali.

   1. Pilih **Tutup**.

1. Buat set izin, sebagai berikut:

   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**, hapus `AdministratorAccess` dan masukkan:

      ```
      codecatalyst-eks-permission-set
      ```

   1. Pilih **Berikutnya**.

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

1. Tetapkan izin yang disetel ke`codecatalyst-eks-user`, sebagai berikut:

   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`codecatalyst-eks-user`.

   1. Pilih **Berikutnya**.

   1. Pilih kotak centang di sebelah`codecatalyst-eks-permission-set`.

   1. Pilih **Berikutnya**.

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

      Anda sekarang telah menetapkan `codecatalyst-eks-user` dan `codecatalyst-eks-permission-set` untuk Anda Akun AWS, mengikat mereka bersama-sama.

1. Dapatkan `codecatalyst-eks-user` kunci akses dan token sesi, sebagai berikut:

   1. Pastikan Anda memiliki URL portal AWS akses dan nama pengguna dan kata sandi satu kali untuk`codecatalyst-eks-user`. Anda seharusnya menyalin informasi ini ke editor teks sebelumnya.
**catatan**  
Jika Anda tidak memiliki informasi ini, buka halaman `codecatalyst-eks-user` detail di Pusat Identitas IAM, pilih **Atur ulang kata sandi**, **Hasilkan kata sandi satu kali [**...] , dan **Atur ulang 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**:

        ```
        codecatalyst-eks-user
        ```
      + **Kata sandi**:

        *one-time-password*

   1. Di **Tetapkan kata sandi baru**, masukkan kata sandi baru 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 `codecatalyst-eks-user` pengguna dan set izin.

   1. Di samping`codecatalyst-eks-permission-set`, pilih **Baris perintah atau akses terprogram**.

   1. Salin perintah di tengah halaman. Mereka terlihat mirip dengan yang berikut:

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ... di *session-token* mana string acak panjang.

1. Tambahkan kunci akses dan token sesi ke AWS CLI, sebagai berikut:

   1. Kembali ke Lingkungan CodeCatalyst Pengembang Anda.

   1. Pada prompt terminal, tempel perintah yang Anda salin. Tekan Enter.

      Anda sekarang telah mengonfigurasi tombol akses AWS CLI dengan dan token sesi. Anda sekarang dapat menggunakan AWS CLI untuk menyelesaikan tugas-tugas yang diperlukan oleh tutorial ini.
**penting**  
Jika sewaktu-waktu selama tutorial ini Anda melihat pesan yang mirip dengan:  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
Atau:  
`ExpiredToken: The security token included in the request is expired`  
... itu karena AWS CLI sesi Anda telah kedaluwarsa. Dalam hal ini, *jangan* jalankan `aws configure` perintah. Sebagai gantinya, gunakan instruksi pada langkah 4 dari prosedur ini yang dimulai dengan `Obtain codecatalyst-eks-user's access key and session token` untuk menyegarkan sesi Anda.

## Langkah 2: Buat cluster Amazon EKS
<a name="deploy-tut-eks-cluster"></a>

Di bagian ini, Anda membuat cluster di Amazon EKS. Petunjuk di bawah ini menjelaskan cara cepat untuk membuat cluster menggunakan`eksctl`, tetapi jika Anda ingin petunjuk rinci, lihat:
+ [Memulai dengan eksctl di Panduan](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) Pengguna **Amazon** EKS

  atau
+ [Memulai konsol dan AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) di **Panduan Pengguna Amazon EKS** (topik ini memberikan `kubectl` instruksi untuk membuat cluster) 

**catatan**  
[Cluster pribadi](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) tidak didukung oleh CodeCatalyst integrasi dengan Amazon EKS.

**Sebelum Anda memulai**

Pastikan Anda telah menyelesaikan tugas-tugas berikut di mesin pengembangan Anda:
+ Menginstal `eksctl` utilitas.
+ Menginstal `kubectl` utilitas.
+ Menginstal AWS CLI dan mengkonfigurasinya dengan kunci akses dan token sesi.

Untuk informasi tentang cara menyelesaikan tugas-tugas ini, lihat[Langkah 1: Siapkan mesin pengembangan Anda](#deploy-tut-eks-dev-env-create).

**Untuk membuat klaster DB**
**penting**  
Jangan gunakan antarmuka pengguna layanan Amazon EKS untuk membuat klaster karena klaster tidak akan dikonfigurasi dengan benar. Gunakan `eksctl` utilitas, seperti yang dijelaskan dalam langkah-langkah berikut.

1. Pergi ke Lingkungan Pengembang Anda.

1. Buat cluster dan node:

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   Di mana:
   + *codecatalyst-eks-cluster*diganti dengan nama yang ingin Anda berikan pada cluster Anda.
   + *us-west-2*diganti dengan wilayah Anda.

   Setelah 10-20 menit, pesan yang mirip dengan yang berikut ini muncul: 

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**catatan**  
Anda akan melihat beberapa `waiting for CloudFormation stack` pesan saat AWS membuat cluster Anda. Ini yang diharapkan.

1. Verifikasi bahwa klaster Anda berhasil dibuat:

   ```
   kubectl cluster-info
   ```

   Anda akan melihat pesan yang mirip dengan berikut ini, yang menunjukkan pembuatan cluster yang berhasil:

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

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

Di bagian ini, Anda membuat repositori gambar pribadi di Amazon Elastic Container Registry (Amazon ECR) Registry ECR). Repositori ini menyimpan gambar Docker untuk tutorial.

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

**Untuk membuat repositori gambar di Amazon ECR**

1. Pergi ke Lingkungan Pengembang Anda.

1. Buat repositori kosong di Amazon ECR:

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

   Ganti *codecatalyst-eks-image-repo* dengan nama yang ingin Anda berikan pada repositori Amazon ECR.

   Tutorial ini mengasumsikan Anda menamai `codecatalyst-eks-image-repo` repositori Anda.

1. Tampilkan detail repositori Amazon ECR:

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

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

   Anda membutuhkannya nanti saat menambahkan repositori ke alur kerja Anda. 

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

Di bagian ini, Anda menambahkan file sumber aplikasi ke repositori sumber Anda ()`codecatalyst-eks-source-repository`. Mereka terdiri dari:
+ Sebuah `index.html` file - Menampilkan 'Halo, Dunia\$1 ' pesan di browser.
+ A Dockerfile - Menjelaskan gambar dasar yang akan digunakan untuk image Docker Anda dan perintah Docker untuk menerapkannya.
+ `deployment.yaml`File — Manifes Kubernetes yang mendefinisikan layanan dan penerapan Kubernetes. 

Struktur folder adalah sebagai berikut:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [index.html](#deploy-tut-eks-source-files-index)
+ [Dockerfile](#deploy-tut-eks-source-files-dockerfile)
+ [deployment.yaml](#deploy-tut-eks-source-files-deployment-yml)

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

`index.html`File tersebut menampilkan 'Hello, World\$1 ' pesan di browser. 

**Untuk menambahkan file index.html**

1. Pergi ke Lingkungan Pengembang Anda.

1. Di`codecatalyst-eks-source-repository`, buat folder bernama`public-html`.

1. Di`/public-html`, buat file yang disebut `index.html` dengan konten 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. Pada prompt terminal, masukkan:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. Tambahkan, komit, dan dorong:

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

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

### Dockerfile
<a name="deploy-tut-eks-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`codecatalyst-eks-source-repository`, buat file yang disebut `Dockerfile` dengan konten berikut:

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

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

1. Tambahkan, komit, dan dorong:

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

   Dockerfile ditambahkan ke repositori Anda.

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

Di bagian ini, Anda menambahkan `deployment.yaml` file ke repositori Anda. `deployment.yaml`File ini adalah manifes Kubernetes yang mendefinisikan dua tipe atau *jenis* resource Kubernetes untuk dijalankan: sebuah 'service' dan 'deployment'.
+ 'Layanan' menyebarkan penyeimbang beban ke Amazon EC2. Load balancer memberi Anda URL publik yang menghadap ke Internet dan port standar (port 80) yang dapat Anda gunakan untuk menelusuri 'Hello, World\$1 ' aplikasi. 
+ 'Deployment 'menyebarkan tiga pod, dan setiap pod akan berisi kontainer Docker dengan 'Hello, World\$1' aplikasi. Ketiga pod tersebut di-deploy ke node yang dibuat saat Anda membuat cluster.

Manifes dalam tutorial ini singkat; namun, manifes dapat mencakup sejumlah tipe sumber daya Kubernetes, seperti pod, job, ingresses, dan kebijakan jaringan. Selanjutnya, Anda dapat menggunakan beberapa file manifes jika penerapan Anda rumit.

**Untuk menambahkan berkas deployment.yaml**

1. Di`codecatalyst-eks-source-repository`, buat folder bernama`Kubernetes`.

1. Di`/Kubernetes`, buat file yang disebut `deployment.yaml` dengan konten berikut:

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. Tambahkan, komit, dan dorong:

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   `deployment.yaml`File ditambahkan ke repositori Anda dalam folder bernama. `Kubernetes` 

Anda sekarang telah menambahkan semua file sumber Anda.

Luangkan waktu sejenak untuk memeriksa ulang pekerjaan Anda dan pastikan Anda menempatkan semua file di folder yang benar. Struktur folder adalah sebagai berikut:

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## Langkah 5: Buat AWS peran
<a name="deploy-tut-eks-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.
+ **Deploy role** — Memberikan izin tindakan **klaster CodeCatalyst Deploy ke Kubernetes** (dalam alur kerja) untuk mengakses akun Anda dan Amazon EKS. 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, selesaikan rangkaian prosedur berikut.

**1. Untuk membuat kebijakan kepercayaan untuk kedua peran**

1. Pergi ke Lingkungan Pengembang Anda.

1. Di `Cloud9-long-string` direktori, buat file yang disebut `codecatalyst-eks-trust-policy.json` dengan konten berikut:

**2. Untuk membuat kebijakan build untuk peran build**
+ Di `Cloud9-long-string` direktori, buat file yang disebut `codecatalyst-eks-build-policy.json` dengan konten 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": "*"
  ```

**3. Untuk membuat kebijakan penerapan untuk peran penerapan**
+ Di `Cloud9-long-string` direktori, buat file yang disebut `codecatalyst-eks-deploy-policy.json` dengan konten berikut:

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "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": "*"
  ```

Anda sekarang telah menambahkan tiga dokumen kebijakan ke Lingkungan Pengembang Anda. Struktur direktori Anda sekarang terlihat seperti ini:

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. Untuk menambahkan kebijakan build ke AWS**

1. Di terminal Dev Environment, masukkan:

   ```
   cd /projects
   ```

1. Masukkan:

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

1. Tekan **Enter**.

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

**5. Untuk menambahkan kebijakan penerapan ke AWS**

1. Masukkan:

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

1. Tekan **Enter**.

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

**6. Untuk membuat peran build**

1. Masukkan: 

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

1. Tekan **Enter**.

1. Masukkan:

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

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

1. Tekan **Enter**.

1. Pada prompt terminal, masukkan:

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

1. Tekan **Enter**.

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

**7. Untuk membuat peran penerapan**

1. Masukkan:

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

1. Tekan **Enter**.

1. Masukkan:

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

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

1. Tekan **Enter**.

1. Masukkan:

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

1. Tekan **Enter**.

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

Anda sekarang telah membuat peran build dan deploy dan mencatatnya ARNs.

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

Pada langkah ini, Anda menambahkan build role (`codecatalyst-eks-build-role`) dan deploy role (`codecatalyst-eks-deploy-role`) ke Akun AWS yang Anda sambungkan ke ruang Anda. Ini membuat peran tersedia untuk digunakan dalam alur kerja Anda.

**Untuk menambahkan peran build dan deploy ke Akun AWS**

1. Di CodeCatalyst konsol, arahkan ke ruang Anda.

1. Di bagian atas, pilih **Pengaturan**.

1. Di panel navigasi, pilih **AWS akun**. Daftar akun muncul.

1. Di kolom **nama CodeCatalyst tampilan Amazon**, salin nama tampilan Akun AWS tempat Anda membuat peran build dan deploy. (Mungkin nomor.) Anda akan membutuhkan nilai ini nanti, saat membuat alur kerja Anda.

1. Pilih nama tampilan.

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 peran build dan deploy, dan peran IAM lainnya dengan kebijakan kepercayaan yang mencakup prinsip `codecatalyst-runner.amazonaws.com` dan `codecatalyst.amazonaws.com` layanan.

1. Dari daftar drop-down, tambahkan:
   + `codecatalyst-eks-build-role`
   + `codecatalyst-eks-deploy-role`
**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. Kembali ke CodeCatalyst konsol dan segarkan halaman.

   Peran build dan deploy sekarang akan muncul di bawah peran **IAM**.

   Peran ini sekarang tersedia untuk digunakan dalam CodeCatalyst alur kerja.

## Langkah 7: Perbarui ConfigMap
<a name="deploy-tut-eks-configmap"></a>

Anda harus menambahkan peran deploy yang Anda buat ke `ConfigMap` file Kubernetes [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles) untuk memberikan tindakan **klaster Deploy ke Kubernetes (dalam alur kerja Anda) kemampuan untuk mengakses dan berinteraksi dengan klaster** Anda. Anda dapat menggunakan `eksctl` atau `kubectl` melakukan tugas ini.

**Untuk mengkonfigurasi file Kubernetes ConfigMap menggunakan eksctl**
+ Di terminal Dev Environment, masukkan: 

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  Di mana:
  + *codecatalyst-eks-cluster*diganti dengan nama cluster cluster Amazon EKS.
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*diganti dengan ARN dari peran penerapan yang Anda buat. [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles)
  +  *codecatalyst-eks-deploy-role*(di sebelah`--username`) diganti dengan nama peran penerapan yang Anda buat. [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles)
**catatan**  
Jika Anda memutuskan untuk tidak membuat peran penerapan, ganti *codecatalyst-eks-deploy-role* dengan nama `CodeCatalystWorkflowDevelopmentRole-spaceName` peran. Untuk informasi selengkapnya tentang peran ini, silakan lihat [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles).
  +  *us-west-2*diganti dengan wilayah Anda.

  Untuk detail tentang perintah ini, lihat [Mengelola pengguna dan peran IAM](https://eksctl.io/usage/iam-identity-mappings/).

  Pesan yang mirip dengan berikut ini muncul:

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**Untuk mengkonfigurasi file Kubernetes ConfigMap menggunakan kubectl**

1. Di terminal Dev Environment, masukkan:

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

    ConfigMap File muncul di layar.

1. Tambahkan teks dengan huruf miring merah:

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   Di mana:
   +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*diganti dengan ARN dari peran penerapan yang Anda buat. [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles) 
   +  *codecatalyst-eks-deploy-role*(di sebelah`username:`) diganti dengan nama peran penerapan yang Anda buat. [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles)
**catatan**  
Jika Anda memutuskan untuk tidak membuat peran penerapan, ganti *codecatalyst-eks-deploy-role* dengan nama `CodeCatalystWorkflowDevelopmentRole-spaceName` peran. Untuk informasi selengkapnya tentang peran ini, silakan lihat [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles).

   Untuk detailnya, lihat [Mengaktifkan akses utama IAM ke klaster Anda](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) di **Panduan Pengguna Amazon EKS**.

Anda sekarang telah memberikan peran deploy, dan dengan ekstensi tindakan **Deploy to Amazon EKS**, `system:masters` izin ke klaster Kubernetes Anda.

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

Pada langkah ini, Anda membuat alur kerja yang mengambil file sumber Anda, membuatnya menjadi image Docker, dan kemudian menyebarkan gambar ke pod pohon di cluster Amazon EKS Anda.

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 `$IMAGE_TAG` variabel `$REPOSITORY_URI` dan dalam `deployment.yaml` file dengan nilai yang benar, dan kemudian membuat artefak keluaran file ini dan yang lainnya di `Kubernetes` folder. Dalam tutorial ini, satu-satunya file dalam `Kubernetes` folder adalah `deployment.yaml` tetapi Anda dapat menyertakan lebih banyak file. Artefak 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 (`DeployToEKS`) — Setelah menyelesaikan aksi build, tindakan deploy mencari artefak keluaran yang dihasilkan oleh build action (`Manifests`), dan menemukan `deployment.yaml` file di dalamnya. Tindakan kemudian mengikuti instruksi dalam `deployment.yaml` file untuk menjalankan tiga pod—masing-masing berisi satu 'Hello, World\$1 ' Kontainer Docker—di dalam kluster Amazon EKS Anda. 

**Untuk membuat alur kerja**

1. Pergi ke CodeCatalyst konsol.

1. Arahkan ke proyek Anda (`codecatalyst-eks-project`).

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

1. Pilih **Buat alur kerja**.

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

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

1. Pilih **Buat**.

1. Hapus kode sampel YAMAL.

1. Tambahkan kode YAMAL berikut untuk membuat file definisi alur kerja baru:
**catatan**  
Untuk informasi selengkapnya tentang file definisi alur kerja, lihat[Alur kerja definisi YAMAL](workflow-reference.md).
**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 6: Tambahkan AWS peran ke CodeCatalyst](#deploy-tut-eks-import-roles) Untuk informasi selengkapnya tentang menyiapkan lingkungan dengan peran IAM default, lihat[Pembuatan lingkungan](deploy-environments-creating-environment.md).

   ```
   Name: codecatalyst-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-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 deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

   Pada kode sebelumnya, ganti:
   + Kedua contoh *codecatalyst-eks-environment* dengan nama lingkungan yang Anda buat. [Prasyarat](#deploy-tut-eks-prereqs)
   + Kedua contoh *codecatalyst-account-connection* dengan nama tampilan koneksi akun Anda. Nama tampilan mungkin nomor. Untuk informasi selengkapnya, lihat [Langkah 6: Tambahkan AWS peran ke CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*dengan nama peran build yang Anda buat[Langkah 5: Buat AWS peran](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo*(di `Value:` properti) dengan URI dari repositori Amazon ECR yang Anda buat. [Langkah 3: Buat repositori gambar Amazon ECR](#deploy-tut-eks-ecr)
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(dalam `Run: aws ecr` perintah) dengan URI dari repositori Amazon ECR tanpa akhiran gambar (). `/codecatalyst-eks-image-repo`
   + *codecatalyst-eks-deploy-role*dengan nama peran penerapan yang Anda buat. [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles)
   + Kedua contoh *us-west-2* dengan kode AWS Wilayah Anda. Untuk daftar kode Region, lihat [Titik akhir Regional](https://docs.aws.amazon.com/general/latest/gr/rande.html) di. *Referensi Umum AWS*
**catatan**  
Jika Anda memutuskan untuk tidak membuat peran build dan deploy, ganti *codecatalyst-eks-build-role* dan *codecatalyst-eks-deploy-role* dengan nama `CodeCatalystWorkflowDevelopmentRole-spaceName` peran tersebut. Untuk informasi selengkapnya tentang peran ini, silakan lihat [Langkah 5: Buat AWS peran](#deploy-tut-eks-roles).

1. (Opsional) Pilih **Validasi** untuk memastikan bahwa kode YAMM 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-eks-source-repository`

   1. Untuk **nama cabang**, 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-eks-workflow`.

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

1. Pilih **DeployToEKS** 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 Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

1. Di sebelah kiri, dekat bagian bawah, pilih **Load Balancers**.

1. Pilih load balancer yang dibuat sebagai bagian dari penerapan Kubernetes Anda. Jika Anda tidak yakin penyeimbang beban mana yang harus dipilih, cari tag berikut di bawah tab **Tag:**
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. Dengan penyeimbang beban yang benar dipilih, pilih tab **Deskripsi**.

1. Salin dan tempel nilai **nama DNS** ke bilah alamat browser Anda.

   'Halo, Dunia\$1 ' halaman web muncul di browser Anda, menunjukkan bahwa Anda berhasil menerapkan aplikasi Anda.

## Langkah 9: Buat perubahan pada file sumber Anda
<a name="deploy-tut-eks-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. Pergi ke Lingkungan Pengembang Anda.

1. Pada prompt terminal, ubah ke repositori sumber Anda:

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  Tarik perubahan alur kerja terbaru:

   ```
   git pull
   ```

1. Buka `codecatalyst-eks-source-repository/public-html/index.html`.

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

1. Tambahkan, komit, dan dorong:

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   Jalankan alur kerja dimulai secara otomatis.

1. (Opsional) Masukkan:

   ```
   git show HEAD
   ```

   Perhatikan ID komit untuk `index.html` perubahan tersebut. ID komit ini akan ditandai ke image Docker yang akan digunakan oleh alur kerja yang baru saja Anda mulai.

1. Perhatikan kemajuan penerapan:

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

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

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

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

   1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

   1. Di sebelah kiri, dekat bagian bawah, pilih **Load Balancers**.

   1. Pilih load balancer yang dibuat sebagai bagian dari penerapan Kubernetes Anda.

   1. Salin dan tempel nilai **nama DNS** ke bilah alamat browser Anda.

      'Tutorial Lengkap\$1 ' halaman web muncul di browser Anda, menunjukkan bahwa Anda berhasil menerapkan revisi baru aplikasi Anda.

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

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

Anda harus membersihkan lingkungan Anda sehingga Anda tidak dikenakan biaya yang tidak perlu untuk penyimpanan dan sumber daya komputasi yang digunakan oleh tutorial ini.

**Untuk membersihkan**

1. Hapus klaster Anda:

   1. Di terminal Dev Environment, masukkan:

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     Di mana:
     + *us-west-2*diganti dengan wilayah Anda.
     + *codecatalyst-eks-cluster*diganti dengan nama cluster yang Anda buat.

     Setelah 5-10 menit, cluster dan sumber daya terkait dihapus, termasuk namun tidak terbatas pada CloudFormation tumpukan, grup node (di Amazon EC2), dan penyeimbang beban.
**penting**  
Jika `eksctl delete cluster` perintah tidak berfungsi, Anda mungkin perlu me-refresh kredensyal atau AWS kredensyal Anda`kubectl`. Jika Anda tidak yakin kredensyal mana yang akan disegarkan, segarkan kredensialnya terlebih AWS dahulu. Untuk menyegarkan AWS kredensyal Anda, lihat. [Bagaimana cara memperbaiki kesalahan “Tidak dapat menemukan kredensil” dan “ExpiredToken”?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks) Untuk menyegarkan `kubectl` kredensyal Anda, lihat. [Bagaimana cara memperbaiki kesalahan “Tidak dapat terhubung ke server”?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks)

1. Di AWS konsol, bersihkan sebagai berikut:

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

   1. Di Pusat Identitas IAM, hapus:

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. Di IAM, hapus:
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. Di CodeCatalyst konsol, bersihkan sebagai berikut:

   1. Hapus`codecatalyst-eks-workflow`.

   1. Hapus`codecatalyst-eks-environment`.

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

   1. Hapus Lingkungan Pengembang Anda.

   1. Hapus`codecatalyst-eks-project`.

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

# Menambahkan aksi 'Deploy to Kubernetes cluster'
<a name="deploy-action-eks-adding"></a>

Gunakan instruksi berikut untuk menambahkan tindakan **cluster Deploy ke Kubernetes** ke alur kerja Anda. 

**Sebelum Anda memulai**

Sebelum Anda menambahkan aksi **klaster Deploy ke Kubernetes** ke alur kerja Anda, Anda harus menyiapkan hal-hal berikut:

**Tip**  
Untuk mengatur prasyarat ini dengan cepat, ikuti instruksi di. [Tutorial: Menyebarkan aplikasi ke Amazon EKS](deploy-tut-eks.md)
+ Cluster Kubernetes di Amazon EKS. Untuk informasi tentang cluster, lihat [klaster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) di **Panduan Pengguna Amazon EKS**.
+ Setidaknya satu Dockerfile yang menjelaskan cara merakit aplikasi Anda menjadi image Docker. Untuk informasi selengkapnya tentang Dockerfiles, lihat referensi [Dockerfile](https://docs.docker.com/engine/reference/builder/).
+ Setidaknya satu file manifes Kubernetes, yang disebut file konfigurasi atau **konfigurasi* dalam dokumentasi* Kubernetes. Untuk informasi selengkapnya, lihat [Mengelola sumber daya](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/) dalam dokumentasi Kubernetes.
+ Peran IAM yang memberikan tindakan **cluster Deploy to Kubernetes kemampuan untuk mengakses dan berinteraksi dengan cluster** Amazon EKS Anda. Untuk informasi lebih lanjut, lihat [Role](deploy-action-ref-eks.md#deploy.action.eks.environment.connections.role) topik di[Tindakan 'Terapkan ke Kluster Kubernetes' YAML](deploy-action-ref-eks.md).

  Setelah membuat peran ini, Anda harus menambahkannya ke:
  + File Kubernetes ConfigMap Anda. Untuk mempelajari cara menambahkan peran ke ConfigMap file, lihat [Mengaktifkan akses utama IAM ke klaster Anda](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) di **Panduan Pengguna Amazon EKS**.
  + CodeCatalyst. Untuk mempelajari cara menambahkan peran IAM CodeCatalyst, lihat[Menambahkan peran IAM ke koneksi akun](ipa-connect-account-addroles.md).
+  CodeCatalyst Ruang, proyek, dan lingkungan. Ruang dan lingkungan keduanya harus terhubung ke AWS akun tempat Anda akan menggunakan aplikasi Anda. Lihat informasi selengkapnya di [Membuat ruang](spaces-create.md), [Membuat proyek kosong di Amazon CodeCatalyst](projects-create.md#projects-create-empty), dan [Menyebarkan ke dalam Akun AWS dan VPCs](deploy-environments.md).
+ Repositori sumber yang didukung oleh. CodeCatalyst Repositori menyimpan file sumber aplikasi Anda, Dockerfiles, dan manifes Kubernetes. Untuk informasi selengkapnya, lihat [Simpan dan berkolaborasi pada kode dengan repositori sumber di CodeCatalystSimpan dan berkolaborasi pada kode dengan repositori sumber](source.md).

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

**Untuk menambahkan aksi 'Deploy to Kubernetes cluster' 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 aksi **cluster Deploy to Kubernetes**, dan lakukan salah satu hal berikut:
   + Pilih tanda plus (**\$1**) untuk menambahkan tindakan ke diagram alur kerja dan buka panel konfigurasinya.

     Atau
   + Pilih **Deploy ke klaster Kubernetes**. 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 Kluster Kubernetes' YAML](deploy-action-ref-eks.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 aksi 'Deploy to Kubernetes cluster' 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 aksi **cluster Deploy to Kubernetes**, dan lakukan salah satu hal berikut:
   + Pilih tanda plus (**\$1**) untuk menambahkan tindakan ke diagram alur kerja dan buka panel konfigurasinya.

     Atau
   + Pilih **Deploy ke klaster Kubernetes**. 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 Kluster Kubernetes' YAML](deploy-action-ref-eks.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 klaster Kubernetes'
<a name="deploy-action-eks-variables"></a>

Tindakan **klaster Deploy to Kubernetes** menghasilkan dan menetapkan variabel-variabel berikut pada waktu proses. Ini dikenal sebagai *variabel yang telah ditentukan*.

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 Sumber Daya Amazon.com (ARN) dari kluster Amazon EKS yang digunakan selama alur kerja dijalankan. Contoh: `arn:aws:eks:us-west-2:111122223333:cluster/codecatalyst-eks-cluster`  | 
|  platform penyebaran  |  Nama platform penyebaran. Hardcode ke. `AWS:EKS`  | 
|  Metadata  |  Dicadangkan. Metadata berformat JSON yang terkait dengan cluster yang digunakan selama alur kerja dijalankan.  | 
|  namespace  |  Namespace Kubernetes tempat cluster digunakan. Contoh: `default`  | 
|  sumber daya  |  Dicadangkan. Metadata berformat JSON terkait dengan sumber daya yang digunakan selama alur kerja dijalankan.  | 
|  server  |  Nama endpoint server API yang dapat Anda gunakan untuk berkomunikasi dengan cluster Anda menggunakan alat manajemen seperti`kubectl`. Untuk informasi selengkapnya tentang titik akhir layanan API, lihat [kontrol akses titik akhir klaster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html) di **Panduan Pengguna Amazon EKS**. Contoh: `https://random-string.gr7.us-west-2.eks.amazonaws.com`  | 

# Tindakan 'Terapkan ke Kluster Kubernetes' YAML
<a name="deploy-action-ref-eks"></a>

Berikut ini adalah definisi YAMAL dari aksi cluster **Deploy to Kubernetes**. Untuk mempelajari cara menggunakan tindakan ini, lihat[Menerapkan ke Amazon EKS dengan alur kerja](deploy-action-eks.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 YAMM 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.   
  DeployToKubernetesCluster\$1nn: 
    Identifier: aws/kubernetes-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: DeployToEKS
    Inputs:
      # Specify a source or an artifact, but not both.
      Sources:
        - source-name-1
      Artifacts:
        - manifest-artifact
    Configuration:
      Namespace: namespace
      Region: us-east-1 
      Cluster: eks-cluster
      Manifests: manifest-path
```

## DeployToKubernetesCluster
<a name="deploy.action.eks.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: `DeployToKubernetesCluster_nn`.

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

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

(*DeployToKubernetesCluster*/**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/kubernetes-deploy@v1`.

**UI yang sesuai: Diagram alur kerja/ DeployToKubernetesCluster \$1nn/ aws/kubernetes-deploy @v1 label**

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

(*DeployToKubernetesCluster*/**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.eks.computename"></a>

(*DeployToKubernetesCluster*/**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.eks.computetype"></a>

(*DeployToKubernetesCluster*/Compute/**Type**)

(Diperlukan [Compute](#deploy.action.eks.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 YAMM)

  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.eks.computefleet"></a>

(*DeployToKubernetesCluster*/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 lebih lanjut 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.eks.timeout"></a>

(*DeployToKubernetesCluster*/**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.eks.environment"></a>

(*DeployToKubernetesCluster*/**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 lebih lanjut 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.eks.environment.name"></a>

(*DeployToKubernetesCluster*/Environment/**Name**)

(Diperlukan [Environment](#deploy.action.eks.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.eks.environment.connections"></a>

(*DeployToKubernetesCluster*/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.eks.environment.connections.name"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Name**)

(Opsional)

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.eks.environment.connections.role"></a>

(*DeployToKubernetesCluster*/Environment/Connections/**Role**)

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

Tentukan nama peran IAM yang digunakan tindakan **klaster Deploy to Kubernetes** 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": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "Resource": "*"
          }
      ]
  }
  ```

------
**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:

Pastikan bahwa peran ini ditambahkan ke:
+ Koneksi akun Anda. Untuk mempelajari selengkapnya tentang menambahkan peran IAM ke koneksi akun, lihat[Menambahkan peran IAM ke koneksi akun](ipa-connect-account-addroles.md).
+ Kubernetes ConfigMap Anda. Untuk mempelajari selengkapnya tentang menambahkan peran IAM ke sebuah ConfigMap, lihat [Mengelola pengguna dan peran IAM](https://eksctl.io/usage/iam-identity-mappings/) dalam dokumentasi. `eksctl`

**Tip**  
Lihat juga [Tutorial: Menyebarkan aplikasi ke Amazon EKS](deploy-tut-eks.md) untuk petunjuk tentang menambahkan peran AM IAM ke koneksi akun dan ConfigMap.

**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.eks.inputs"></a>

(*DeployToKubernetesCluster*/**Inputs**)

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

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

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

UI yang sesuai: **Tab input**

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

(*DeployToKubernetesCluster*/Inputs/**Sources**)

(Diperlukan jika file manifes Anda disimpan dalam repositori sumber)

Jika file manifes Kubernetes atau file disimpan dalam repositori sumber, tentukan label repositori sumber tersebut. Saat ini, satu-satunya label yang didukung adalah`WorkflowSource`.

Jika file manifes Anda tidak terkandung dalam repositori sumber, mereka 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.eks.inputs.artifacts"></a>

(*DeployToKubernetesCluster*/Inputs/**Artifacts**)

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

Jika file atau file manifes Kubernetes terkandung dalam artefak yang dihasilkan oleh tindakan sebelumnya, tentukan artefak tersebut di sini. Jika file manifes Anda tidak terkandung dalam artefak, mereka 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.eks.configuration"></a>

(*DeployToKubernetesCluster*/**Configuration**)

(Diperlukan)

Bagian di mana Anda dapat menentukan properti konfigurasi tindakan.

UI yang sesuai: Tab **konfigurasi**

## Namespace
<a name="deploy.action.eks.namespace"></a>

(*DeployToKubernetesCluster*/Configuration/**Namespace**)

(Opsional)

Tentukan namespace Kubernetes tempat aplikasi Kubernetes Anda akan di-deploy. Gunakan `default` jika Anda tidak menggunakan ruang nama dengan cluster Anda. Untuk informasi selengkapnya tentang namespace, lihat [Membagi klaster Anda menggunakan ruang nama Kubernetes dalam dokumentasi Kubernetes](https://kubernetes.io/docs/tasks/administer-cluster/namespaces/#subdividing-your-cluster-using-kubernetes-namespaces).

Jika Anda menghilangkan namespace, nilai digunakan. `default`

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

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

(*DeployToKubernetesCluster*/Configuration/**Region**)

(Diperlukan)

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

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

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

(*DeployToKubernetesCluster*/Configuration/**Cluster**)

(Diperlukan)

Tentukan nama kluster Amazon EKS yang ada. Tindakan **klaster Deploy to Kubernetes akan menyebarkan aplikasi kontainer Anda ke dalam klaster** ini. Untuk informasi selengkapnya tentang kluster Amazon EKS, lihat [Cluster](https://docs.aws.amazon.com/eks/latest/userguide/clusters.html) di **Panduan Pengguna Amazon EKS**.

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

## Manifests
<a name="deploy.action.eks.manifest"></a>

(*DeployToKubernetesCluster*/Configuration/**Manifests**)

(Diperlukan)

*Tentukan path ke file manifes Kubernetes Anda yang diformat YAML, yang disebut file konfigurasi, *file konfigurasi*, atau hanya, *konfigurasi dalam dokumentasi Kubernetes*.*

Jika Anda menggunakan beberapa file manifes, letakkan di satu folder dan rujuk folder itu. File manifes diproses secara alfanumerik oleh Kubernetes, jadi pastikan untuk mengawali nama file dengan angka atau huruf yang bertambah untuk mengontrol urutan pemrosesan. Contoh:

`00-namespace.yaml`

`01-deployment.yaml`

Jika file manifes Anda berada di repositori sumber Anda, jalurnya relatif terhadap folder root repositori sumber. Jika file berada dalam artefak dari tindakan alur kerja sebelumnya, jalurnya relatif terhadap folder root artefak. 

Contoh:

`Manifests/`

`deployment.yaml`

`my-deployment.yml`

Jangan gunakan wildcard (`*`).

**catatan**  
[Bagan helm](https://helm.sh/docs/topics/charts/) dan [file kustomisasi](https://kubernetes.io/docs/tasks/manage-kubernetes-objects/kustomization/) tidak didukung.

Untuk informasi selengkapnya tentang file manifes, lihat [Mengatur konfigurasi sumber daya](https://kubernetes.io/docs/concepts/cluster-administration/manage-deployment/#organizing-resource-configurations) dalam dokumentasi Kubernetes.

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