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.

# 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**.