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

# Tutorial: Connect dari aplikasi container yang di-host di Amazon Elastic Kubernetes Service
<a name="EKS-tutorial"></a>

Tutorial ini memandu Anda melalui langkah-langkah yang diperlukan untuk menyiapkan cluster Amazon Elastic Kubernetes Service (Amazon EKS) untuk meng-host aplikasi container yang terhubung ke Amazon Keyspaces menggunakan otentikasi SiGv4.

Amazon EKS adalah layanan terkelola yang menghilangkan kebutuhan untuk menginstal, mengoperasikan, dan memelihara pesawat kontrol Kubernetes Anda sendiri. [Kubernetes](https://kubernetes.io/docs/concepts/overview/) adalah sistem sumber terbuka untuk melakukan otomatisasi terhadap deployment, penskalaan, dan pengelolaan aplikasi dalam kontainer.

Tutorial ini menyediakan step-by-step panduan untuk mengonfigurasi, membangun, dan menyebarkan aplikasi Java kontainer ke Amazon EKS. Pada langkah terakhir Anda menjalankan aplikasi untuk menulis data ke tabel Amazon Keyspaces.

**Topics**
+ [Prasyarat untuk menghubungkan dari Amazon EKS ke Amazon Keyspaces](EKS-tutorial-prerequisites.md)
+ [Langkah 1: Konfigurasikan cluster Amazon EKS dan setel izin IAM](EKS-tutorial-step1.md)
+ [Langkah 2: Konfigurasikan aplikasi](EKS-tutorial-step2.md)
+ [Langkah 3: Buat gambar aplikasi dan unggah file Docker ke repositori Amazon ECR Anda](EKS-tutorial-step3.md)
+ [Langkah 4: Menyebarkan aplikasi ke Amazon EKS dan menulis data ke tabel Anda](EKS-tutorial-step4.md)
+ [Langkah 5: Pembersihan (Opsional)](EKS-tutorial-step5.md)

# Prasyarat untuk menghubungkan dari Amazon EKS ke Amazon Keyspaces
<a name="EKS-tutorial-prerequisites"></a>

**Buat AWS sumber daya berikut sebelum Anda dapat memulai dengan tutorial**

1. Sebelum Anda memulai tutorial ini, ikuti instruksi AWS pengaturan di[Mengakses Amazon Keyspaces (untuk Apache Cassandra)](accessing.md). Langkah-langkah ini termasuk mendaftar AWS dan membuat prinsipal AWS Identity and Access Management (IAM) dengan akses ke Amazon Keyspaces. 

1. Buat keyspace Amazon Keyspaces dengan nama `aws` dan tabel dengan nama yang dapat Anda tulis dari aplikasi container `user` yang berjalan di Amazon EKS nanti dalam tutorial ini. Anda dapat melakukan ini baik dengan AWS CLI atau menggunakan`cqlsh`.

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

   ```
   aws keyspaces create-keyspace --keyspace-name 'aws'
   ```

   Untuk mengonfirmasi bahwa ruang kunci telah dibuat, Anda dapat menggunakan perintah berikut.

   ```
   aws keyspaces list-keyspaces
   ```

   Untuk membuat tabel, Anda dapat menggunakan perintah berikut.

   ```
   aws keyspaces create-table --keyspace-name 'aws' --table-name 'user' --schema-definition 'allColumns=[
               {name=username,type=text}, {name=fname,type=text},{name=last_update_date,type=timestamp},{name=lname,type=text}],
               partitionKeys=[{name=username}]'
   ```

   Untuk mengonfirmasi bahwa tabel Anda telah dibuat, Anda dapat menggunakan perintah berikut.

   ```
   aws keyspaces list-tables --keyspace-name 'aws'
   ```

   Untuk informasi selengkapnya, lihat [membuat keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-keyspace.html) dan [membuat tabel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/create-table.html) di *AWS CLI Command Reference*.

------
#### [ cqlsh ]

   ```
   CREATE KEYSPACE aws WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '3'}  AND durable_writes = true;
   CREATE TABLE aws.user (
       username text PRIMARY KEY,
       fname text,
       last_update_date timestamp,
       lname text
   );
   ```

   Untuk memverifikasi bahwa tabel Anda telah dibuat, Anda dapat menggunakan pernyataan berikut.

   ```
   SELECT * FROM system_schema.tables WHERE keyspace_name = "aws";
   ```

   Tabel Anda harus tercantum dalam output pernyataan ini. Perhatikan bahwa mungkin ada penundaan hingga tabel dibuat. Untuk informasi selengkapnya, lihat [CREATE TABLE](cql.ddl.table.md#cql.ddl.table.create).

------

1. Buat cluster Amazon EKS dengan tipe simpul **Fargate - Linux**. Fargate adalah mesin komputasi tanpa server yang memungkinkan Anda menerapkan Pod Kubernetes tanpa mengelola instans Amazon Amazon EC2. Untuk mengikuti tutorial ini tanpa harus memperbarui nama cluster di semua perintah contoh, buat cluster dengan nama `my-eks-cluster` mengikuti petunjuk di [Memulai Amazon EKS — `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) di *Panduan Pengguna Amazon EKS*. Saat klaster Anda dibuat, verifikasi bahwa node Anda dan dua Pod default berjalan dan sehat. Anda dapat melakukannya dengan perintah berikut.

   ```
   kubectl get pods -A -o wide
   ```

   Anda akan melihat sesuatu yang mirip dengan output ini.

   ```
   NAMESPACE     NAME                       READY   STATUS    RESTARTS   AGE   IP          NODE                                                NOMINATED NODE   READINESS GATES
   kube-system   coredns-1234567890-abcde   1/1     Running   0          18m   192.0.2.0   fargate-ip-192-0-2-0.region-code.compute.internal   <none>           <none>
   kube-system   coredns-1234567890-12345   1/1     Running   0          18m   192.0.2.1   fargate-ip-192-0-2-1.region-code.compute.internal   <none>           <none>
   ```

1. Pasang Docker. Untuk petunjuk tentang cara menginstal Docker di instans Amazon EC2, [lihat Menginstal](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#getting-started-cli-prereqs) Docker di Panduan Pengguna Amazon Elastic Container Registry. 

   Docker tersedia untuk banyak sistem operasi yang berbeda, termasuk sebagian besar distribusi Linux modern, seperti Ubuntu, dan bahkan macOS dan Windows. Untuk informasi lebih lanjut tentang cara menginstal Docker pada sistem operasi tertentu Anda, kunjungi situs web[panduan penginstalan Docker](https://docs.docker.com/engine/install/#installation). 

1. Buat repositori Amazon ECR. Amazon ECR adalah layanan registri gambar kontainer AWS terkelola yang dapat Anda gunakan dengan CLI pilihan Anda untuk mendorong, menarik, dan mengelola gambar Docker. Untuk informasi selengkapnya tentang repositori Amazon ECR, lihat Panduan Pengguna [Amazon Elastic Container Registry](https://docs.aws.amazon.com/AmazonECR/latest/userguide/). Anda dapat menggunakan perintah berikut untuk membuat repositori dengan nama. `my-ecr-repository`

   ```
   aws ecr create-repository --repository-name my-ecr-repository
   ```

Setelah menyelesaikan langkah-langkah prasyarat, lanjutkan ke. [Langkah 1: Konfigurasikan cluster Amazon EKS dan setel izin IAM](EKS-tutorial-step1.md)

# Langkah 1: Konfigurasikan cluster Amazon EKS dan setel izin IAM
<a name="EKS-tutorial-step1"></a>

**Konfigurasikan kluster Amazon EKS dan buat resource IAM yang diperlukan agar akun layanan Amazon EKS dapat terhubung ke tabel Amazon Keyspaces**

1. Buat penyedia Open ID Connect (OIDC) untuk klaster Amazon EKS. Ini diperlukan untuk menggunakan peran IAM untuk akun layanan. *Untuk informasi selengkapnya tentang penyedia OIDC dan cara membuatnya, lihat [Membuat penyedia IAM OIDC untuk klaster Anda di](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) Panduan Pengguna Amazon EKS.*

   1. Buat penyedia identitas IAM OIDC untuk klaster Anda dengan perintah berikut. Contoh ini mengasumsikan bahwa nama cluster Anda adalah`my-eks-cluster`. Jika Anda memiliki cluster dengan nama yang berbeda, ingatlah untuk memperbarui nama di semua perintah future.

      ```
      eksctl utils associate-iam-oidc-provider --cluster my-eks-cluster --approve 
      ```

   1. Konfirmasikan bahwa penyedia identitas OIDC telah terdaftar dengan IAM dengan perintah berikut.

      ```
      aws iam list-open-id-connect-providers --region us-east-1
      ```

      Outputnya akan terlihat mirip dengan ini. Perhatikan Nama Sumber Daya Amazon (ARN) OIDC, Anda memerlukannya di langkah berikutnya saat membuat kebijakan kepercayaan untuk akun layanan.

      ```
      {
          "OpenIDConnectProviderList": [
              ..
              {
                  "Arn": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
              }
          ]
      }
      ```

1. Buat akun layanan untuk kluster Amazon EKS. Akun layanan menyediakan identitas untuk proses yang berjalan di *Pod*. Pod adalah objek Kubernetes terkecil dan paling sederhana yang dapat Anda gunakan untuk menyebarkan aplikasi kontainer. Selanjutnya, buat peran IAM yang dapat diasumsikan oleh akun layanan untuk mendapatkan izin ke sumber daya. Anda dapat mengakses AWS layanan apa pun dari Pod yang telah dikonfigurasi untuk menggunakan akun layanan yang dapat mengambil peran IAM dengan izin akses ke layanan tersebut.

   1. Buat namespace baru untuk akun layanan. Namespace membantu mengisolasi sumber daya cluster yang dibuat untuk tutorial ini. Anda dapat membuat namespace baru menggunakan perintah berikut.

      ```
      kubectl create namespace my-eks-namespace
      ```

   1. Untuk menggunakan namespace khusus, Anda harus mengaitkannya dengan profil Fargate. Kode berikut adalah contoh dari ini.

      ```
      eksctl create fargateprofile \
          --cluster my-eks-cluster \
          --name my-fargate-profile \
          --namespace my-eks-namespace \
          --labels *=*
      ```

   1. Buat akun layanan dengan nama `my-eks-serviceaccount` di namespace `my-eks-namespace` untuk cluster Amazon EKS Anda dengan menggunakan perintah berikut.

      ```
      cat >my-serviceaccount.yaml <<EOF
      apiVersion: v1
      kind: ServiceAccount
      metadata:
        name: my-eks-serviceaccount
        namespace: my-eks-namespace
      EOF
      kubectl apply -f my-serviceaccount.yaml
      ```

   1. Jalankan perintah berikut untuk membuat file kebijakan kepercayaan yang menginstruksikan peran IAM untuk mempercayai akun layanan Anda. Hubungan kepercayaan ini diperlukan sebelum kepala sekolah dapat mengambil peran. Anda perlu melakukan pengeditan berikut pada file:
      + Untuk`Principal`, masukkan ARN yang IAM kembali ke perintah. `list-open-id-connect-providers` ARN berisi nomor akun dan Wilayah Anda.
      + Dalam `condition` pernyataan itu, ganti Wilayah AWS dan id OIDC.
      + Konfirmasikan bahwa nama akun layanan dan namespace sudah benar.

      Anda perlu melampirkan file kebijakan kepercayaan di langkah berikutnya saat Anda membuat peran IAM.

      ```
      cat >trust-relationship.json <<EOF
      {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:my-eks-namespace:my-eks-serviceaccount",
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
                      }
                  }
              }
          ]
      }
      EOF
      ```

      Opsional: Anda juga dapat menambahkan beberapa entri dalam `StringLike` kondisi `StringEquals` atau untuk memungkinkan beberapa akun layanan atau ruang nama mengambil peran. Untuk mengizinkan akun layanan Anda mengambil peran IAM di AWS akun lain, lihat Izin [IAM lintas akun di](https://docs.aws.amazon.com/eks/latest/userguide/cross-account-access.html) Panduan Pengguna *Amazon* EKS.

1. Buat peran IAM dengan nama `my-iam-role` untuk akun layanan Amazon EKS untuk diasumsikan. Lampirkan file kebijakan kepercayaan yang dibuat pada langkah terakhir ke peran. Kebijakan kepercayaan menentukan akun layanan dan penyedia OIDC yang dapat dipercaya oleh peran IAM. 

   ```
   aws iam create-role --role-name my-iam-role --assume-role-policy-document file://trust-relationship.json --description "EKS service account role"
   ```

1. Tetapkan izin peran IAM ke Amazon Keyspaces dengan melampirkan kebijakan akses. 

   1. Lampirkan kebijakan akses untuk menentukan tindakan yang dapat dilakukan peran IAM pada resource Amazon Keyspaces tertentu. Untuk tutorial ini kami menggunakan kebijakan AWS terkelola`AmazonKeyspacesFullAccess`, karena aplikasi kami akan menulis data ke tabel Amazon Keyspaces Anda. Namun, sebagai praktik terbaik, disarankan untuk membuat kebijakan akses khusus yang menerapkan prinsip hak istimewa paling sedikit. Untuk informasi selengkapnya, lihat [Cara Amazon Keyspaces bekerja dengan IAM](security_iam_service-with-iam.md).

      ```
      aws iam attach-role-policy --role-name my-iam-role --policy-arn=arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess
      ```

      Konfirmasikan bahwa kebijakan telah berhasil dilampirkan ke peran IAM dengan pernyataan berikut.

      ```
      aws iam list-attached-role-policies --role-name my-iam-role
      ```

      Outputnya akan terlihat seperti ini.

      ```
      {
          "AttachedPolicies": [
              {
                  "PolicyName": "AmazonKeyspacesFullAccess",
                  "PolicyArn": "arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess"
              }
          ]
      }
      ```

   1. Beri anotasi akun layanan dengan Nama Sumber Daya Amazon (ARN) dari peran IAM yang dapat diasumsikan. Pastikan untuk memperbarui peran ARN dengan ID akun Anda.

      ```
      kubectl annotate serviceaccount -n my-eks-namespace my-eks-serviceaccount eks.amazonaws.com/role-arn=arn:aws:iam::111122223333:role/my-iam-role
      ```

1. Konfirmasikan bahwa peran IAM dan akun layanan dikonfigurasi dengan benar.

   1. Konfirmasikan bahwa kebijakan kepercayaan peran IAM telah dikonfigurasi dengan benar dengan pernyataan berikut.

      ```
      aws iam get-role --role-name my-iam-role --query Role.AssumeRolePolicyDocument
      ```

      Outputnya akan terlihat mirip dengan ini.

      ```
      {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Principal": {
                      "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
                  },
                  "Action": "sts:AssumeRoleWithWebIdentity",
                  "Condition": {
                      "StringEquals": {
                          "oidc.eks.us-east-1/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com",
                          "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:my-eks-namespace:my-eks-serviceaccount"
                      }
                  }
              }
          ]
      }
      ```

   1. Konfirmasikan bahwa akun layanan Amazon EKS dianotasi dengan peran IAM.

      ```
      kubectl describe serviceaccount my-eks-serviceaccount -n my-eks-namespace
      ```

      Outputnya akan terlihat mirip dengan ini.

      ```
      Name: my-eks-serviceaccount 
      Namespace:my-eks-namespace
      Labels: <none>
      Annotations: eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/my-iam-role 
      Image pull secrets: <none> 
      Mountable secrets: <none> 
      Tokens: <none> 
      [...]
      ```

Setelah Anda membuat akun layanan Amazon EKS, peran IAM, dan mengonfigurasi hubungan dan izin yang diperlukan, lanjutkan ke. [Langkah 2: Konfigurasikan aplikasi](EKS-tutorial-step2.md)

# Langkah 2: Konfigurasikan aplikasi
<a name="EKS-tutorial-step2"></a>

Pada langkah ini Anda membangun aplikasi Anda yang terhubung ke Amazon Keyspaces menggunakan plugin SiGv4. [Anda dapat melihat dan mengunduh contoh aplikasi Java dari repo kode contoh Amazon Keyspaces di Github.](https://github.com/aws-samples/amazon-keyspaces-examples/tree/main/java/datastax-v4/eks) Atau Anda dapat mengikuti bersama menggunakan aplikasi Anda sendiri, memastikan untuk menyelesaikan semua langkah konfigurasi.

**Konfigurasikan aplikasi Anda dan tambahkan dependensi yang diperlukan.**

1. Anda dapat mengunduh contoh aplikasi Java dengan mengkloning repositori Github menggunakan perintah berikut.

   ```
   git clone https://github.com/aws-samples/amazon-keyspaces-examples.git
   ```

1. Setelah mengunduh repo Github, unzip file yang diunduh dan arahkan ke `resources` direktori ke file. `application.conf`

   1. **Konfigurasi aplikasi**

      Pada langkah ini Anda mengonfigurasi plugin otentikasi SiGv4. Anda dapat menggunakan contoh berikut dalam aplikasi Anda. Jika Anda belum melakukannya, Anda perlu membuat kunci akses IAM Anda (ID kunci akses dan kunci akses rahasia) dan menyimpannya di file AWS konfigurasi Anda atau sebagai variabel lingkungan. Untuk petunjuk mendetail, lihat [Kredensional yang diperlukan oleh, AWS SDK AWS CLI, atau plugin Amazon Keyspaces SigV4 untuk driver klien Cassandra](SigV4_credentials.md). Perbarui AWS Wilayah dan titik akhir layanan untuk Amazon Keyspaces sesuai kebutuhan. Untuk titik akhir layanan lainnya, lihat[Titik akhir layanan untuk Amazon Keyspaces](programmatic.endpoints.md). Ganti lokasi truststore, nama truststore, dan kata sandi truststore dengan milik Anda.

      ```
      datastax-java-driver {
        basic.contact-points = ["cassandra.us-east-1.amazonaws.com:9142"]
        basic.load-balancing-policy.local-datacenter = "us-east-1"
        advanced.auth-provider {
          class = software.aws.mcs.auth.SigV4AuthProvider
          aws-region = "us-east-1"
        }
        advanced.ssl-engine-factory {
          class = DefaultSslEngineFactory
          truststore-path = "truststore_locationtruststore_name.jks"
          truststore-password = "truststore_password;"
        }
      }
      ```

   1. **Tambahkan ketergantungan modul STS.**

      Ini menambahkan kemampuan untuk menggunakan a `WebIdentityTokenCredentialsProvider` yang mengembalikan AWS kredensi yang perlu disediakan aplikasi sehingga akun layanan dapat mengambil peran IAM. Anda dapat melakukan ini berdasarkan contoh berikut.

      ```
              <dependency>
                  <groupId>com.amazonaws</groupId>
                  <artifactId>aws-java-sdk-sts</artifactId>
                  <version>1.11.717</version> 
              </dependency>
      ```

   1. **Tambahkan dependensi SigV4.**

       Paket ini mengimplementasikan plugin otentikasi SiGv4 yang diperlukan untuk mengautentikasi ke Amazon Keyspaces

      ```
              <dependency>
                  <groupId>software.aws.mcs</groupId>
                  <artifactId>aws-sigv4-auth-cassandra-java-driver-plugin</artifactId>
                  <version>4.0.3</version> 
              </dependency>
      ```

1. **Tambahkan ketergantungan logging.**

    Tanpa log, pemecahan masalah koneksi tidak mungkin dilakukan. Dalam tutorial ini, kita gunakan `slf4j` sebagai kerangka logging, dan gunakan `logback.xml` untuk menyimpan output log. Kami mengatur level logging `debug` untuk membuat koneksi. Anda dapat menggunakan contoh berikut untuk menambahkan ketergantungan.

   ```
           <dependency>
               <groupId>org.slf4j</groupId>
               <artifactId>slf4j-api</artifactId>
               <version>2.0.5</version> 
           </dependency>
   ```

   Anda dapat menggunakan cuplikan kode berikut untuk mengonfigurasi logging.

   ```
   <configuration>
       <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
           
           <encoder>
               <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
           </encoder>
       </appender>
   
       <root level="debug">
           <appender-ref ref="STDOUT" />
       </rootv
   </configuration>
   ```
**catatan**  
`debug`Level diperlukan untuk menyelidiki kegagalan koneksi. Setelah Anda berhasil terhubung ke Amazon Keyspaces dari aplikasi Anda, Anda dapat mengubah level logging ke `info` atau `warning` sesuai kebutuhan. 

# Langkah 3: Buat gambar aplikasi dan unggah file Docker ke repositori Amazon ECR Anda
<a name="EKS-tutorial-step3"></a>

Pada langkah ini, Anda mengkompilasi aplikasi contoh, membangun image Docker, dan mendorong gambar ke repositori Amazon ECR Anda.

**Buat aplikasi Anda, buat image Docker, dan kirimkan ke Amazon Elastic Container Registry**

1. Tetapkan variabel lingkungan untuk build yang menentukan Anda Wilayah AWS. Ganti Wilayah dalam contoh dengan milik Anda sendiri.

   ```
   export CASSANDRA_HOST=cassandra.us-east-1.amazonaws.com:9142
   export CASSANDRA_DC=us-east-1
   ```

1. Kompilasi aplikasi Anda dengan Apache Maven versi 3.6.3 atau lebih tinggi menggunakan perintah berikut.

   ```
   mvn clean install
   ```

   Ini membuat `JAR` file dengan semua dependensi yang disertakan dalam direktori. `target`

1. Ambil URI repositori ECR Anda yang diperlukan untuk langkah berikutnya dengan perintah berikut. Pastikan untuk memperbarui Wilayah ke wilayah yang telah Anda gunakan.

   ```
   aws ecr describe-repositories --region us-east-1
   ```

   Outputnya akan terlihat seperti pada contoh berikut.

   ```
   "repositories": [
    {
    "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/my-ecr-repository",
    "registryId": "111122223333",
    "repositoryName": "my-ecr-repository",
    "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository",
    "createdAt": "2023-11-02T03:46:34+00:00",
    "imageTagMutability": "MUTABLE",
    "imageScanningConfiguration": {
    "scanOnPush": false
    },
    "encryptionConfiguration": {
    "encryptionType": "AES256"
    }
    },
   ```

1. Dari direktori root aplikasi, buat image Docker menggunakan URI repositori dari langkah terakhir. Ubah file Docker sesuai kebutuhan. Dalam perintah build, pastikan untuk mengganti ID akun Anda dan atur Wilayah AWS ke Wilayah tempat repositori `my-ecr-repository` Amazon ECR berada. 

   ```
   docker build -t 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest .
   ```

1. Ambil token otentikasi untuk mendorong gambar Docker ke Amazon ECR. Anda dapat melakukannya dengan perintah berikut.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
   ```

1. Pertama, periksa gambar yang ada di repositori Amazon ECR Anda. Anda dapat menggunakan perintah berikut.

   ```
   aws ecr describe-images --repository-name my-ecr-repository --region us-east-1
   ```

   Kemudian, dorong image Docker ke repo. Anda dapat menggunakan perintah berikut.

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

# Langkah 4: Menyebarkan aplikasi ke Amazon EKS dan menulis data ke tabel Anda
<a name="EKS-tutorial-step4"></a>

Pada langkah tutorial ini, Anda mengonfigurasi penyebaran Amazon EKS untuk aplikasi Anda, dan mengonfirmasi bahwa aplikasi sedang berjalan dan dapat terhubung ke Amazon Keyspaces.

Untuk menyebarkan aplikasi ke Amazon EKS, Anda perlu mengonfigurasi semua pengaturan yang relevan dalam file bernama`deployment.yaml`. File ini kemudian digunakan oleh Amazon EKS untuk menyebarkan aplikasi. Metadata dalam file harus berisi informasi berikut:
+ **Nama aplikasi** nama aplikasi. Untuk tutorial ini, kita gunakan`my-keyspaces-app`.
+ **Kubernetes namespace adalah namespace** dari klaster Amazon EKS. Untuk tutorial ini, kita gunakan`my-eks-namespace`.
+ **Nama akun layanan Amazon EKS** nama akun layanan Amazon EKS. Untuk tutorial ini, kita gunakan`my-eks-serviceaccount`.
+ **nama gambar** nama gambar aplikasi. Untuk tutorial ini, kita gunakan`my-keyspaces-app`.
+ **URI gambar URI gambar** Docker dari Amazon ECR.
+  **AWS ID akun ID** AWS akun Anda.
+ Peran **IAM ARN ARN dari peran** IAM yang dibuat untuk diasumsikan oleh akun layanan. Untuk tutorial ini, kita gunakan`my-iam-role`.
+ **Wilayah AWS dari cluster Amazon EKS** tempat Wilayah AWS Anda membuat cluster Amazon EKS Anda.

Pada langkah ini, Anda menyebarkan dan menjalankan aplikasi yang terhubung ke Amazon Keyspaces dan menulis data ke tabel.

1. Konfigurasikan file `deployment.yaml`. Anda perlu mengganti nilai-nilai berikut:
   + `name`
   + `namespace`
   + `serviceAccountName`
   + `image`
   + `AWS_ROLE_ARN value`
   +  Wilayah AWS Di `CASSANDRA_HOST`
   + `AWS_REGION`

   Anda dapat menggunakan file berikut sebagai contoh.

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-keyspaces-app
     namespace: my-eks-namespace
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: my-keyspaces-app
     template:
       metadata:
         labels:
           app: my-keyspaces-app
       spec:
         serviceAccountName: my-eks-serviceaccount
         containers:
         - name: my-keyspaces-app
           image: 111122223333.dkr.ecr.us-east-1.amazonaws.com/my-ecr-repository:latest
           ports:
           - containerPort: 8080
           env:
           - name: CASSANDRA_HOST
             value: "cassandra.us-east-1.amazonaws.com:9142"
           - name: CASSANDRA_DC
             value: "us-east-1"
           - name: AWS_WEB_IDENTITY_TOKEN_FILE
             value: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
           - name: AWS_ROLE_ARN
             value: "arn:aws:iam::111122223333:role/my-iam-role"
           - name: AWS_REGION
             value: "us-east-1"
   ```

1. Menyebarkan`deployment.yaml`.

   ```
   kubectl apply -f deployment.yaml
   ```

   Outputnya akan terlihat seperti ini.

   ```
   deployment.apps/my-keyspaces-app created
   ```

1. Periksa status Pod di namespace Anda di klaster Amazon EKS. 

   ```
   kubectl get pods -n my-eks-namespace
   ```

   Outputnya akan terlihat mirip dengan contoh ini.

   ```
   NAME                    READY STATUS RESTARTS AGE
   my-keyspaces-app-123abcde4f-g5hij 1/1 Running 0 75s
   ```

   Untuk lebih jelasnya, Anda dapat menggunakan perintah berikut.

   ```
   kubectl describe pod my-keyspaces-app-123abcde4f-g5hij -n my-eks-namespace
   ```

   ```
   Name:                 my-keyspaces-app-123abcde4f-g5hij
   Namespace:            my-eks-namespace
   Priority:             2000001000
   Priority Class Name:  system-node-critical
   Service Account:      my-eks-serviceaccount
   Node:                 fargate-ip-192-168-102-209.ec2.internal/192.168.102.209
   Start Time:           Thu, 23 Nov 2023 12:15:43 +0000
   Labels:               app=my-keyspaces-app
                         eks.amazonaws.com/fargate-profile=my-fargate-profile
                         pod-template-hash=6c56fccc56
   Annotations:          CapacityProvisioned: 0.25vCPU 0.5GB
                         Logging: LoggingDisabled: LOGGING_CONFIGMAP_NOT_FOUND
   Status:               Running
   IP:                   192.168.102.209
   IPs:
     IP:           192.168.102.209
   Controlled By:  ReplicaSet/my-keyspaces-app-6c56fccc56
   Containers:
     my-keyspaces-app:
       Container ID:   containerd://41ff7811d33ae4bc398755800abcdc132335d51d74f218ba81da0700a6f8c67b
       Image:          111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest
       Image ID:       111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository@sha256:fd3c6430fc5251661efce99741c72c1b4b03061474940200d0524b84a951439c
       Port:           8080/TCP
       Host Port:      0/TCP
       State:          Running
         Started:      Thu, 23 Nov 2023 12:15:19 +0000
         Finished:     Thu, 23 Nov 2023 12:16:17 +0000
       Ready:          True
       Restart Count:  1
       Environment:
         CASSANDRA_HOST:               cassandra.us-east-1.amazonaws.com:9142
         CASSANDRA_DC:                 us-east-1
         AWS_WEB_IDENTITY_TOKEN_FILE:  /var/run/secrets/eks.amazonaws.com/serviceaccount/token
         AWS_ROLE_ARN:                 arn:aws:iam::111122223333:role/my-iam-role
         AWS_REGION:                   us-east-1
         AWS_STS_REGIONAL_ENDPOINTS:   regional
       Mounts:
         /var/run/secrets/eks.amazonaws.com/serviceaccount from aws-iam-token (ro)
         /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-fssbf (ro)
   Conditions:
     Type              Status
     Initialized       True 
     Ready             True 
     ContainersReady   True 
     PodScheduled      True 
   Volumes:
     aws-iam-token:
       Type:                    Projected (a volume that contains injected data from multiple sources)
       TokenExpirationSeconds:  86400
     kube-api-access-fssbf:
       Type:                    Projected (a volume that contains injected data from multiple sources)
       TokenExpirationSeconds:  3607
       ConfigMapName:           kube-root-ca.crt
       ConfigMapOptional:       <nil>
       DownwardAPI:             true
   QoS Class:                   BestEffort
   Node-Selectors:              <none>
   Tolerations:                 node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                                node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
   Events:
     Type     Reason           Age                From               Message
     ----     ------           ----               ----               -------
     Warning  LoggingDisabled  2m13s              fargate-scheduler  Disabled logging because aws-logging configmap was not found. configmap "aws-logging" not found
     Normal   Scheduled        89s                fargate-scheduler  Successfully assigned my-eks-namespace/my-keyspaces-app-6c56fccc56-mgs2m to fargate-ip-192-168-102-209.ec2.internal
     Normal   Pulled           75s                kubelet            Successfully pulled image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest" in 13.027s (13.027s including waiting)
     Normal   Pulling          54s (x2 over 88s)  kubelet            Pulling image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest"
     Normal   Created          54s (x2 over 75s)  kubelet            Created container my-keyspaces-app
     Normal   Pulled           54s                kubelet            Successfully pulled image "111122223333.dkr.ecr.us-east-1.amazonaws.com/my_eks_repository:latest" in 222ms (222ms including waiting)
     Normal   Started          53s (x2 over 75s)  kubelet            Started container my-keyspaces-app
   ```

1. Periksa log Pod untuk mengonfirmasi bahwa aplikasi Anda sedang berjalan dan dapat terhubung ke tabel Amazon Keyspaces Anda. Anda dapat melakukannya dengan perintah berikut. Pastikan untuk mengganti nama penerapan Anda.

   ```
   kubectl logs -f my-keyspaces-app-123abcde4f-g5hij -n my-eks-namespace
   ```

   Anda harus dapat melihat entri log aplikasi yang mengonfirmasi koneksi ke Amazon Keyspaces seperti pada contoh di bawah ini.

   ```
   2:47:20.553 [s0-admin-0] DEBUG c.d.o.d.i.c.metadata.MetadataManager - [s0] Adding initial contact points [Node(endPoint=cassandra.us-east-1.amazonaws.com/1.222.333.44:9142, hostId=null, hashCode=e750d92)]
   22:47:20.562 [s0-admin-1] DEBUG c.d.o.d.i.c.c.ControlConnection - [s0] Initializing with event types [SCHEMA_CHANGE, STATUS_CHANGE, TOPOLOGY_CHANGE]
   22:47:20.564 [s0-admin-1] DEBUG c.d.o.d.i.core.context.EventBus - [s0] Registering com.datastax.oss.driver.internal.core.metadata.LoadBalancingPolicyWrapper$$Lambda$812/0x0000000801105e88@769afb95 for class com.datastax.oss.driver.internal.core.metadata.NodeStateEvent
   22:47:20.566 [s0-admin-1] DEBUG c.d.o.d.i.c.c.ControlConnection - [s0] Trying to establish a connection to Node(endPoint=cassandra.us-east-1.amazonaws.com/1.222.333.44:9142, hostId=null, hashCode=e750d92)
   ```

1. Jalankan kueri CQL berikut di tabel Amazon Keyspaces Anda untuk mengonfirmasi bahwa satu baris data telah ditulis ke tabel Anda:

   ```
   SELECT * from aws.user;
   ```

   Anda akan melihat output berikut:

   ```
   fname    | lname | username | last_update_date 
   ----------+-------+----------+-----------------------------
   random    | k     | test     | 2023-12-07 13:58:31.57+0000
   ```

# Langkah 5: Pembersihan (Opsional)
<a name="EKS-tutorial-step5"></a>

Ikuti langkah-langkah ini untuk menghapus semua sumber daya yang dibuat dalam tutorial ini.

**Hapus sumber daya yang dibuat dalam tutorial ini**

1. Hapus penerapan Anda. Anda dapat menggunakan perintah berikut untuk melakukannya.

   ```
   kubectl delete deployment my-keyspaces-app -n my-eks-namespace
   ```

1. Hapus cluster Amazon EKS dan semua Pod yang ada di dalamnya. Ini juga menghapus sumber daya terkait seperti akun layanan dan penyedia identitas OIDC. Anda dapat menggunakan perintah berikut untuk melakukannya.

   ```
   eksctl delete cluster --name my-eks-cluster --region us-east-1
   ```

1. Hapus peran IAM yang digunakan untuk akun layanan Amazon EKS dengan izin akses ke Amazon Keyspaces. Pertama, Anda harus menghapus kebijakan terkelola yang dilampirkan pada peran.

   ```
   aws iam detach-role-policy --role-name my-iam-role --policy-arn arn:aws:iam::aws:policy/AmazonKeyspacesFullAccess
   ```

   Kemudian Anda dapat menghapus peran menggunakan perintah berikut.

   ```
   aws iam delete-role --role-name my-iam-role
   ```

   Untuk informasi selengkapnya, lihat [Menghapus peran IAM (AWS CLI)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html#roles-managingrole-deleting-cli) di Panduan Pengguna *IAM*. 

1. Hapus repositori Amazon ECR termasuk semua gambar yang tersimpan di dalamnya. Anda dapat melakukannya dengan menggunakan perintah berikut.

   ```
   aws ecr delete-repository \
         --repository-name my-ecr-repository \
         --force \
         --region us-east-1
   ```

   Perhatikan bahwa `force` bendera diperlukan untuk menghapus repositori yang berisi gambar. Untuk menghapus gambar Anda terlebih dahulu, Anda dapat melakukannya menggunakan perintah berikut. 

   ```
   aws ecr batch-delete-image \
         --repository-name my-ecr-repository \
         --image-ids imageTag=latest \
         --region us-east-1
   ```

   Untuk informasi selengkapnya, lihat [Menghapus gambar](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html#cli-delete-image) di Panduan Pengguna Amazon Elastic Container Registry.

1. Hapus ruang kunci dan tabel Amazon Keyspaces. Menghapus keyspace secara otomatis menghapus semua tabel di keyspace itu. Anda dapat menggunakan salah satu opsi berikut untuk melakukannya.

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

   ```
   aws keyspaces delete-keyspace --keyspace-name 'aws'
   ```

   Untuk mengonfirmasi bahwa ruang kunci telah dihapus, Anda dapat menggunakan perintah berikut.

   ```
   aws keyspaces list-keyspaces
   ```

   Untuk menghapus tabel terlebih dahulu, Anda dapat menggunakan perintah berikut.

   ```
   aws keyspaces delete-table --keyspace-name 'aws' --table-name 'user'
   ```

   Untuk mengonfirmasi bahwa tabel Anda telah dihapus, Anda dapat menggunakan perintah berikut.

   ```
   aws keyspaces list-tables --keyspace-name 'aws'
   ```

   Untuk informasi selengkapnya, lihat [menghapus keyspace](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-keyspace.html) dan [menghapus tabel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/keyspaces/delete-table.html) di *Referensi AWS CLI Perintah*.

------
#### [ cqlsh ]

   ```
   DROP KEYSPACE IF EXISTS "aws";
   ```

   Untuk memverifikasi bahwa ruang kunci Anda telah dihapus, Anda dapat menggunakan pernyataan berikut.

   ```
   SELECT * FROM system_schema.keyspaces ;
   ```

   Ruang kunci Anda tidak boleh tercantum dalam output pernyataan ini. Perhatikan bahwa mungkin ada penundaan hingga ruang kunci dihapus. Untuk informasi selengkapnya, lihat [JATUHKAN RUANG KUNCI](cql.ddl.keyspace.md#cql.ddl.keyspace.drop).

   Untuk menghapus tabel terlebih dahulu, Anda dapat menggunakan perintah berikut.

   ```
   DROP TABLE "aws.user"
   ```

   Untuk mengonfirmasi bahwa tabel Anda telah dihapus, Anda dapat menggunakan perintah berikut.

   ```
   SELECT * FROM system_schema.tables WHERE keyspace_name = "aws";
   ```

   Tabel Anda tidak boleh tercantum dalam output pernyataan ini. Perhatikan bahwa mungkin ada penundaan hingga tabel dihapus. Lihat informasi yang lebih lengkap di [MEJA DROP](cql.ddl.table.md#cql.ddl.table.drop).

------