**Bantu tingkatkan halaman ini** 

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

Untuk berkontribusi pada panduan pengguna ini, pilih **Edit halaman ini pada GitHub** tautan yang terletak di panel kanan setiap halaman.

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

# Menerapkan contoh beban kerja stateful ke Mode Otomatis EKS
<a name="sample-storage-workload"></a>

Tutorial ini akan memandu Anda melalui penerapan contoh aplikasi stateful ke kluster Mode Otomatis EKS Anda. Aplikasi ini menulis stempel waktu ke volume persisten, mendemonstrasikan penyediaan volume EBS otomatis dan kemampuan persistensi EKS Auto Mode.

## Prasyarat
<a name="_prerequisites"></a>
+ Kluster Mode Otomatis EKS
+  AWS CLI dikonfigurasi dengan izin yang sesuai
+  `kubectl`diinstal dan dikonfigurasi
  + Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan Amazon EKS](setting-up.md).

## Langkah 1: Konfigurasikan lingkungan Anda
<a name="_step_1_configure_your_environment"></a>

1. Tetapkan variabel lingkungan Anda:

   ```
   export CLUSTER_NAME=my-auto-cluster
   export AWS_REGION="us-west-2"
   ```

1. Perbarui kubeconfig Anda:

   ```
   aws eks update-kubeconfig --name "${CLUSTER_NAME}"
   ```

## Langkah 2: Buat kelas penyimpanan
<a name="_step_2_create_the_storage_class"></a>

Ini `StorageClass` menentukan bagaimana Mode Otomatis EKS akan menyediakan volume EBS.

Mode Otomatis EKS tidak membuat `StorageClass` untuk Anda. Anda harus membuat `StorageClass` referensi `ebs.csi.eks.amazonaws.com` untuk menggunakan kemampuan penyimpanan Mode Otomatis EKS.

1. Buat file bernama `storage-class.yaml`:

   ```
   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: auto-ebs-sc
     annotations:
       storageclass.kubernetes.io/is-default-class: "true"
   provisioner: ebs.csi.eks.amazonaws.com
   volumeBindingMode: WaitForFirstConsumer
   parameters:
     type: gp3
     encrypted: "true"
   ```

1. Terapkan`StorageClass`:

   ```
   kubectl apply -f storage-class.yaml
   ```

 **Komponen kunci:** 
+  `provisioner: ebs.csi.eks.amazonaws.com`- Menggunakan Mode Otomatis EKS
+  `volumeBindingMode: WaitForFirstConsumer`- Menunda pembuatan volume hingga pod membutuhkannya
+  `type: gp3`- Menentukan jenis volume EBS
+  `encrypted: "true"`- EBS akan menggunakan `aws/ebs` kunci default untuk mengenkripsi volume yang dibuat dengan kelas ini. Ini memang opsional, tetapi direkomendasikan.
+  `storageclass.kubernetes.io/is-default-class: "true"`- Kubernetes akan menggunakan kelas penyimpanan ini secara default, kecuali Anda menentukan kelas volume yang berbeda pada klaim volume persisten. Berhati-hatilah saat menyetel nilai ini jika Anda bermigrasi dari pengontrol penyimpanan lain. (opsional)

## Langkah 3: Buat klaim volume persisten
<a name="_step_3_create_the_persistent_volume_claim"></a>

PVC meminta penyimpanan dari`StorageClass`.

1. Buat file bernama `pvc.yaml`:

   ```
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: auto-ebs-claim
   spec:
     accessModes:
       - ReadWriteOnce
     storageClassName: auto-ebs-sc
     resources:
       requests:
         storage: 8Gi
   ```

1. Terapkan PVC:

   ```
   kubectl apply -f pvc.yaml
   ```

 **Komponen kunci:** 
+  `accessModes: ReadWriteOnce`- Volume dapat dipasang oleh satu node pada satu waktu
+  `storage: 8Gi`- Meminta volume 8 GiB
+  `storageClassName: auto-ebs-sc`- Referensi yang `StorageClass` kami buat

## Langkah 4: Menyebarkan Aplikasi
<a name="_step_4_deploy_the_application"></a>

Deployment menjalankan container yang menulis stempel waktu ke volume persisten.

1. Buat file bernama `deployment.yaml`:

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: inflate-stateful
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: inflate-stateful
     template:
       metadata:
         labels:
           app: inflate-stateful
       spec:
         terminationGracePeriodSeconds: 0
         nodeSelector:
           eks.amazonaws.com/compute-type: auto
         containers:
           - name: bash
             image: public.ecr.aws/docker/library/bash:4.4
             command: ["/usr/local/bin/bash"]
             args: ["-c", "while true; do echo $(date -u) >> /data/out.txt; sleep 60; done"]
             resources:
               requests:
                 cpu: "1"
             volumeMounts:
               - name: persistent-storage
                 mountPath: /data
         volumes:
           - name: persistent-storage
             persistentVolumeClaim:
               claimName: auto-ebs-claim
   ```

1. Terapkan Deployment:

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

 **Komponen kunci:** 
+ Kontainer bash sederhana yang menulis stempel waktu ke file
+ Memasang PVC di `/data` 
+ Permintaan 1 inti CPU
+ Menggunakan pemilih node untuk node terkelola EKS

## Langkah 5: Verifikasi Pengaturan
<a name="_step_5_verify_the_setup"></a>

1. Periksa apakah pod sedang berjalan:

   ```
   kubectl get pods -l app=inflate-stateful
   ```

1. Verifikasi PVC terikat:

   ```
   kubectl get pvc auto-ebs-claim
   ```

1. Periksa volume EBS:

   ```
   # Get the PV name
   PV_NAME=$(kubectl get pvc auto-ebs-claim -o jsonpath='{.spec.volumeName}')
   # Describe the EBS volume
   aws ec2 describe-volumes \
     --filters Name=tag:CSIVolumeName,Values=${PV_NAME}
   ```

1. Verifikasi data sedang ditulis:

   ```
   kubectl exec "$(kubectl get pods -l app=inflate-stateful \
     -o=jsonpath='{.items[0].metadata.name}')" -- \
     cat /data/out.txt
   ```

## Langkah 6: Pembersihan
<a name="_step_6_cleanup"></a>

Jalankan perintah berikut untuk menghapus semua sumber daya yang dibuat dalam tutorial ini:

```
# Delete all resources in one command
kubectl delete deployment/inflate-stateful pvc/auto-ebs-claim storageclass/auto-ebs-sc
```

## Apa yang Terjadi Di Balik Layar
<a name="_whats_happening_behind_the_scenes"></a>

1. PVC meminta penyimpanan dari `StorageClass` 

1. Saat Pod dijadwalkan:

   1. Mode Otomatis EKS menyediakan volume EBS

   1. Menciptakan PersistentVolume

   1. Menempelkan volume ke node

1. Pod memasang volume dan mulai menulis stempel waktu

## Pengontrol Snapshot
<a name="_snapshot_controller"></a>

EKS Auto Mode kompatibel dengan Kubernetes CSI Snapshotter, juga dikenal sebagai pengontrol snapshot. Namun, Mode Otomatis EKS tidak menyertakan pengontrol snapshot. Anda bertanggung jawab untuk menginstal dan mengkonfigurasi pengontrol snapshot. Untuk informasi selengkapnya, lihat [Aktifkan fungsionalitas snapshot untuk volume CSI](csi-snapshot-controller.md).

Tinjau hal-hal berikut `VolumeSnapshotClass` yang mereferensikan kemampuan penyimpanan Mode Otomatis EKS.

```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: auto-ebs-vsclass
driver: ebs.csi.eks.amazonaws.com
deletionPolicy: Delete
```

 [Pelajari lebih lanjut tentang Snapshotter CSI Kubernetes.](https://github.com/kubernetes-csi/external-snapshotter/blob/master/README.md#usage)