**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.
# Mulai cepat: Menyebarkan aplikasi web dan menyimpan data
[Tutorial quickstart ini memandu Anda melalui langkah-langkah untuk menyebarkan aplikasi contoh game 2048 dan menyimpan datanya di cluster Amazon EKS Auto Mode menggunakan eksctl.](https://eksctl.io/)
[Amazon EKS Auto Mode](automode.md) menyederhanakan manajemen klaster dengan mengotomatiskan tugas rutin seperti penyimpanan blok, jaringan, penyeimbangan beban, dan penskalaan otomatis komputasi. Selama penyiapan, ia menangani pembuatan node dengan instance EC2 terkelola, penyeimbang beban aplikasi, dan volume EBS.
Singkatnya, Anda akan menerapkan contoh beban kerja dengan anotasi khusus yang diperlukan untuk integrasi tanpa batas dengan layanan. AWS
## Dalam tutorial ini
Menggunakan template `eksctl` cluster berikut, Anda akan membangun sebuah cluster dengan EKS Auto Mode untuk penyediaan node otomatis.
+ **Konfigurasi VPC**: Saat menggunakan template cluster eksctl yang mengikuti, eksctl secara otomatis membuat Virtual Private Cloud ( IPv4 VPC) untuk cluster. Secara default, eksctl mengonfigurasi VPC yang menangani semua persyaratan jaringan, selain membuat titik akhir publik dan pribadi.
+ **Manajemen Instance**: Mode Otomatis EKS secara dinamis menambahkan atau menghapus node di klaster EKS Anda berdasarkan permintaan aplikasi Kubernetes Anda.
+ **Persistensi Data**: Gunakan kemampuan penyimpanan blok Mode Otomatis EKS untuk memastikan persistensi data aplikasi, bahkan dalam skenario yang melibatkan restart atau kegagalan pod.
+ **Akses Aplikasi Eksternal**: Gunakan kemampuan load balancing dari Mode Otomatis EKS untuk menyediakan Application Load Balancer (ALB) secara dinamis.
## Prasyarat
Sebelum memulai, pastikan Anda telah melakukan tugas-tugas berikut:
+ [Siapkan lingkungan Anda untuk Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/setting-up.html)
+ [Instal versi terbaru eksctl](https://eksctl.io/installation/)
## Konfigurasikan cluster
Di bagian ini, Anda akan membuat cluster menggunakan Mode Otomatis EKS untuk penyediaan node dinamis.
Buat `cluster-config.yaml` file dan tempel konten berikut ke dalamnya. Ganti `region-code` dengan Region yang valid (mis.,`us-east-1`).
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: web-quickstart
region:
autoModeConfig:
enabled: true
```
Sekarang, kita siap untuk membuat cluster.
Buat cluster EKS menggunakan`cluster-config.yaml``:
```
eksctl create cluster -f cluster-config.yaml
```
**penting**
Jika Anda tidak menggunakan eksctl untuk membuat cluster, Anda perlu menandai subnet VPC secara manual.
## Buat IngressClass
Buat Kubernetes `IngressClass` untuk Mode Otomatis EKS. Ini IngressClass mendefinisikan bagaimana Mode Otomatis EKS menangani sumber daya Ingress. Langkah ini mengonfigurasi kemampuan load balancing dari Mode Otomatis EKS. Ketika Anda membuat sumber daya Ingress untuk aplikasi Anda, Mode Otomatis EKS menggunakan ini IngressClass untuk secara otomatis menyediakan dan mengelola load balancer, mengintegrasikan aplikasi Kubernetes Anda dengan layanan load balancing. AWS
Simpan file yaml berikut sebagai`ingressclass.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
name: alb
annotations:
ingressclass.kubernetes.io/is-default-class: "true"
spec:
controller: eks.amazonaws.com/alb
```
Terapkan IngressClass ke cluster Anda:
```
kubectl apply -f ingressclass.yaml
```
## Menyebarkan aplikasi sampel game 2048
Di bagian ini, kami memandu Anda melalui langkah-langkah untuk menyebarkan “game 2048" yang populer sebagai contoh aplikasi di dalam cluster. Manifes yang disediakan mencakup anotasi khusus untuk Application Load Balancer (ALB). Anotasi ini terintegrasi dengan dan menginstruksikan EKS untuk menangani lalu lintas HTTP yang masuk sebagai “menghadap ke internet” dan mengarahkannya ke layanan yang sesuai di `game-2048` namespace menggunakan tipe target “ip”.
**catatan**
`docker-2048`Gambar dalam contoh adalah gambar `x86_64` kontainer dan tidak akan berjalan pada arsitektur lain.
1. Buat namespace Kubernetes yang dipanggil dengan bendera. `game-2048` `--save-config`
```
kubectl create namespace game-2048 --save-config
```
Anda akan melihat output respons berikut:
```
namespace/game-2048 created
```
1. Menyebarkan aplikasi [Contoh Game 2048](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml).
```
kubectl apply -n game-2048 -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml
```
Manifes ini menyiapkan Deployment, Service, dan Ingress Kubernetes untuk `game-2048` namespace, menciptakan sumber daya yang diperlukan untuk menyebarkan dan mengekspos aplikasi di dalam klaster. `game-2048` Ini mencakup pembuatan layanan bernama `service-2048` yang mengekspos penyebaran pada port`80`, dan sumber daya Ingress bernama yang mendefinisikan aturan routing untuk lalu lintas HTTP `ingress-2048` yang masuk dan anotasi untuk Application Load Balancer (ALB) yang menghadap ke internet. Anda akan melihat output respons berikut:
```
namespace/game-2048 configured
deployment.apps/deployment-2048 created
service/service-2048 created
ingress.networking.k8s.io/ingress-2048 created
```
1. Jalankan perintah berikut untuk mendapatkan sumber daya Ingress untuk `game-2048` namespace.
```
kubectl get ingress -n game-2048
```
Anda akan melihat output respons berikut:
```
NAME CLASS HOSTS ADDRESS PORTS AGE
ingress-2048 alb * k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com 80 31s
```
Anda harus menunggu beberapa menit untuk Application Load Balancer (ALB) untuk menyediakan sebelum Anda memulai langkah-langkah berikut.
1. Buka browser web dan masukkan `ADDRESS` dari langkah sebelumnya untuk mengakses aplikasi web. Contoh:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Anda akan melihat game 2048 di browser Anda. Bermain\$1
![\[Mainkan game 2048\]](http://docs.aws.amazon.com/id_id/eks/latest/userguide/images/quick2048.png)
## Pertahankan Data menggunakan Mode Otomatis Amazon EKS
Sekarang game 2048 sudah aktif dan berjalan di cluster Amazon EKS Anda, saatnya untuk memastikan bahwa data game Anda disimpan dengan aman menggunakan kemampuan penyimpanan blok Amazon EKS Auto Mode.
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
```
1. Buat Klaim Volume Persisten (PVC) untuk meminta penyimpanan data game Anda. Buat file bernama `ebs-pvc.yaml` dan tambahkan konten berikut ke dalamnya:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: game-data-pvc
namespace: game-2048
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
storageClassName: auto-ebs-sc
```
1. Terapkan PVC ke cluster Anda:
```
kubectl apply -f ebs-pvc.yaml
```
Anda akan melihat output respons berikut:
```
persistentvolumeclaim/game-data-pvc created
```
1. Sekarang, Anda perlu memperbarui penerapan game 2048 Anda untuk menggunakan PVC ini untuk menyimpan data. Penyebaran berikut dikonfigurasi untuk menggunakan PVC untuk menyimpan data game. Buat file bernama `ebs-deployment.yaml` dan tambahkan konten berikut ke dalamnya:
```
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: game-2048
name: deployment-2048
spec:
replicas: 3 # Adjust the number of replicas as needed
selector:
matchLabels:
app.kubernetes.io/name: app-2048
template:
metadata:
labels:
app.kubernetes.io/name: app-2048
spec:
containers:
- name: app-2048
image: public.ecr.aws/l6m2t8p7/docker-2048:latest
imagePullPolicy: Always
ports:
- containerPort: 80
volumeMounts:
- name: game-data
mountPath: /var/lib/2048
volumes:
- name: game-data
persistentVolumeClaim:
claimName: game-data-pvc
```
1. Terapkan penerapan yang diperbarui:
```
kubectl apply -f ebs-deployment.yaml
```
Anda akan melihat output respons berikut:
```
deployment.apps/deployment-2048 configured
```
Dengan langkah-langkah ini, game 2048 Anda di cluster sekarang diatur untuk mempertahankan data menggunakan kemampuan penyimpanan blok Amazon EKS Auto Mode. Ini memastikan bahwa kemajuan dan data game Anda aman bahkan jika terjadi kegagalan pod atau node.
Jika Anda menyukai tutorial ini, beri tahu kami dengan memberikan umpan balik sehingga kami dapat memberi Anda lebih banyak tutorial mulai cepat khusus kasus penggunaan seperti ini.
## Bersihkan
Untuk menghindari biaya future charge, Anda perlu menghapus CloudFormation tumpukan terkait secara manual untuk menghapus semua sumber daya yang dibuat selama panduan ini, termasuk jaringan VPC.
Hapus CloudFormation tumpukan:
```
eksctl delete cluster -f ./cluster-config.yaml
```