**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. # Jalankan beban kerja sampel di kluster Mode Otomatis EKS Bab ini memberikan contoh cara menerapkan berbagai jenis beban kerja ke kluster Amazon EKS yang berjalan dalam Mode Otomatis. Contoh menunjukkan pola beban kerja utama termasuk aplikasi sampel, aplikasi web yang seimbang beban, beban kerja stateful menggunakan penyimpanan persisten, dan beban kerja dengan persyaratan penempatan node tertentu. Setiap contoh mencakup manifes lengkap dan instruksi step-by-step penerapan yang dapat Anda gunakan sebagai templat untuk aplikasi Anda sendiri. Sebelum melanjutkan dengan contoh, pastikan bahwa Anda memiliki kluster EKS yang berjalan dalam Mode Otomatis dan bahwa Anda telah menginstal CLI dan AWS kubectl. Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan Amazon EKS](setting-up.md). Contohnya mengasumsikan keakraban dasar dengan konsep Kubernetes dan perintah kubectl. Anda dapat menggunakan sampel berbasis kasus penggunaan ini untuk menjalankan beban kerja di kluster Mode Otomatis EKS. [Menerapkan sampel beban kerja inflate ke klaster Mode Otomatis Amazon EKS](automode-workload.md) Menunjukkan cara menerapkan beban kerja sampel ke kluster Mode Otomatis EKS menggunakan `kubectl` perintah. [Menerapkan Beban Kerja Load Balancer Sampel ke Mode Otomatis EKS](auto-elb-example.md) Menunjukkan cara menerapkan versi kontainer dari game 2048 di Amazon EKS. [Menerapkan contoh beban kerja stateful ke Mode Otomatis EKS](sample-storage-workload.md) Menunjukkan cara menerapkan contoh aplikasi stateful ke kluster Mode Otomatis EKS. [Menerapkan beban kerja yang dipercepat](auto-accelerated.md) Menunjukkan cara menerapkan beban kerja yang dipercepat perangkat keras ke node yang dikelola oleh Mode Otomatis EKS. [Kontrol jika beban kerja diterapkan pada node Mode Otomatis EKS](associate-workload.md) Menunjukkan cara menggunakan anotasi untuk mengontrol jika beban kerja diterapkan ke node yang dikelola oleh Mode Otomatis EKS. # Menerapkan sampel beban kerja inflate ke klaster Mode Otomatis Amazon EKS Dalam tutorial ini, Anda akan mempelajari cara menerapkan beban kerja sampel ke cluster Mode Otomatis EKS dan mengamati bagaimana ia secara otomatis menyediakan sumber daya komputasi yang diperlukan. Anda akan menggunakan `kubectl` perintah untuk melihat perilaku klaster dan melihat secara langsung bagaimana Mode Otomatis menyederhanakan operasi Kubernetes. AWS Pada akhir tutorial ini, Anda akan memahami bagaimana EKS Auto Mode merespons penerapan beban kerja dengan secara otomatis mengelola sumber daya komputasi yang mendasarinya, tanpa memerlukan konfigurasi grup node manual. ## Prasyarat + Cluster Mode Otomatis Amazon EKS. Perhatikan nama dan AWS wilayah cluster. + Prinsipal IAM, seperti pengguna atau peran, dengan izin yang cukup untuk mengelola jaringan, komputasi, dan sumber daya EKS. + Untuk informasi selengkapnya, lihat [Membuat peran dan melampirkan kebijakan di Panduan Pengguna IAM di Panduan Pengguna](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions_create-policies.html) IAM. + `aws`CLI diinstal dan dikonfigurasi dengan identitas IAM. + `kubectl`CLI diinstal dan terhubung ke cluster. + Untuk informasi selengkapnya, lihat [Siapkan untuk menggunakan Amazon EKS](setting-up.md). ## Langkah 1: Tinjau sumber daya komputasi yang ada (opsional) Pertama, gunakan `kubectl` untuk membuat daftar kumpulan node di cluster Anda. ``` kubectl get nodepools ``` Keluaran sampel: ``` general-purpose ``` Dalam tutorial ini, kita akan menyebarkan beban kerja yang dikonfigurasi untuk menggunakan `general-purpose` node pool. Kumpulan node ini dibangun ke dalam Mode Otomatis EKS, dan mencakup default yang wajar untuk beban kerja umum, seperti layanan mikro dan aplikasi web. Anda dapat membuat kumpulan node Anda sendiri. Untuk informasi selengkapnya, lihat [Buat Node Pool untuk Mode Otomatis EKS](create-node-pool.md). Kedua, gunakan `kubectl` untuk membuat daftar node yang terhubung ke cluster Anda. ``` kubectl get nodes ``` Jika Anda baru saja membuat kluster Mode Otomatis EKS, Anda tidak akan memiliki node. Dalam tutorial ini Anda akan menyebarkan beban kerja sampel. Jika Anda tidak memiliki node, atau beban kerja tidak dapat muat pada node yang ada, Mode Otomatis EKS akan menyediakan node baru. ## Langkah 2: Menyebarkan aplikasi sampel ke cluster Tinjau Deployment Kubernetes berikut dan simpan sebagai `inflate.yaml` ``` apiVersion: apps/v1 kind: Deployment metadata: name: inflate spec: replicas: 1 selector: matchLabels: app: inflate template: metadata: labels: app: inflate spec: terminationGracePeriodSeconds: 0 nodeSelector: eks.amazonaws.com/compute-type: auto securityContext: runAsUser: 1000 runAsGroup: 3000 fsGroup: 2000 containers: - name: inflate image: public.ecr.aws/eks-distro/kubernetes/pause:3.7 resources: requests: cpu: 1 securityContext: allowPrivilegeEscalation: false ``` Perhatikan bahwa `eks.amazonaws.com/compute-type: auto` pemilih mengharuskan beban kerja diterapkan pada node Mode Otomatis Amazon EKS. Terapkan Deployment ke cluster Anda. ``` kubectl apply -f inflate.yaml ``` ## Langkah 3: Tonton Acara Kubernetes Gunakan perintah berikut untuk menonton peristiwa Kubernetes, termasuk membuat node baru. Gunakan `ctrl+c` untuk berhenti menonton acara. ``` kubectl get events -w --sort-by '.lastTimestamp' ``` Gunakan `kubectl` untuk membuat daftar node yang terhubung ke cluster Anda lagi. Perhatikan node yang baru dibuat. ``` kubectl get nodes ``` ## Langkah 4: Lihat node dan instance di konsol AWS Anda dapat melihat Node Mode Otomatis EKS di konsol EKS, dan EC2 instance terkait di EC2 konsol. EC2 Instans yang digunakan oleh Mode Otomatis EKS dibatasi. Anda tidak dapat menjalankan perintah arbitrer pada node Mode Otomatis EKS. ## Langkah 5: Hapus penyebaran Gunakan `kubectl` untuk menghapus penyebaran sampel ``` kubectl delete -f inflate.yaml ``` Jika Anda tidak memiliki beban kerja lain yang diterapkan ke cluster Anda, node yang dibuat oleh Mode Otomatis EKS akan kosong. Dalam konfigurasi default, Mode Otomatis EKS mendeteksi node yang telah kosong selama tiga puluh detik, dan menghentikannya. Gunakan `kubectl` atau EC2 konsol untuk mengonfirmasi instance terkait telah dihapus. # Menerapkan Beban Kerja Load Balancer Sampel ke Mode Otomatis EKS Panduan ini memandu Anda melalui penerapan versi kontainer dari game 2048 di Amazon EKS, lengkap dengan penyeimbangan beban dan aksesibilitas internet. ## Prasyarat + Kluster Mode Otomatis EKS + `kubectl`dikonfigurasi untuk berinteraksi dengan cluster Anda + Izin IAM yang sesuai untuk membuat sumber daya ALB ## Langkah 1: Buat Namespace Pertama, buat namespace khusus untuk aplikasi game 2048. Buat file bernama `01-namespace.yaml`: ``` apiVersion: v1 kind: Namespace metadata: name: game-2048 ``` Terapkan konfigurasi namespace: ``` kubectl apply -f 01-namespace.yaml ``` ## Langkah 2: Menyebarkan Aplikasi Aplikasi ini menjalankan beberapa replika dari kontainer game 2048. Buat file bernama `02-deployment.yaml`: ``` apiVersion: apps/v1 kind: Deployment metadata: namespace: game-2048 name: deployment-2048 spec: selector: matchLabels: app.kubernetes.io/name: app-2048 replicas: 5 template: metadata: labels: app.kubernetes.io/name: app-2048 spec: containers: - image: public.ecr.aws/l6m2t8p7/docker-2048:latest imagePullPolicy: Always name: app-2048 ports: - containerPort: 80 resources: requests: cpu: "0.5" ``` **catatan** Jika Anda menerima kesalahan saat memuat gambar`public.ecr.aws/l6m2t8p7/docker-2048:latest`, konfirmasikan peran IAM Node Anda memiliki izin yang cukup untuk menarik gambar dari ECR. Untuk informasi selengkapnya, lihat [IAM role simpul](auto-learn-iam.md#auto-learn-node-iam-role). Juga, `docker-2048` gambar dalam contoh adalah `x86_64` gambar dan tidak akan berjalan pada arsitektur lain. **Komponen kunci:** + Menyebarkan 5 replika aplikasi + Menggunakan gambar ECR publik + Meminta 0,5 inti CPU per pod + Mengekspos port 80 untuk lalu lintas HTTP Terapkan penyebaran: ``` kubectl apply -f 02-deployment.yaml ``` ## Langkah 3: Buat Layanan Layanan mengekspos penyebaran ke jaringan cluster. Buat file bernama `03-service.yaml`: ``` apiVersion: v1 kind: Service metadata: namespace: game-2048 name: service-2048 spec: ports: - port: 80 targetPort: 80 protocol: TCP selector: app.kubernetes.io/name: app-2048 ``` **Komponen kunci:** + Menciptakan NodePort layanan + Memetakan port 80 ke port kontainer 80 + Menggunakan pemilih label untuk menemukan pod Terapkan layanan: ``` kubectl apply -f 03-service.yaml ``` ## Langkah 4: Konfigurasikan Load Balancing Anda akan mengatur ingress untuk mengekspos aplikasi ke internet. Pertama, buat`IngressClass`. Buat file bernama `04-ingressclass.yaml`: ``` apiVersion: networking.k8s.io/v1 kind: IngressClass metadata: labels: app.kubernetes.io/name: LoadBalancerController name: alb spec: controller: eks.amazonaws.com/alb ``` **catatan** Mode Otomatis EKS memerlukan tag subnet untuk mengidentifikasi subnet publik dan pribadi. Jika Anda membuat cluster Anda dengan`eksctl`, Anda sudah memiliki tag ini. Pelajari cara [Tag subnet untuk Mode Otomatis EKS](tag-subnets-auto.md). Kemudian buat sumber daya Ingress. Buat file bernama `05-ingress.yaml`: ``` apiVersion: networking.k8s.io/v1 kind: Ingress metadata: namespace: game-2048 name: ingress-2048 annotations: alb.ingress.kubernetes.io/scheme: internet-facing alb.ingress.kubernetes.io/target-type: ip spec: ingressClassName: alb rules: - http: paths: - path: / pathType: Prefix backend: service: name: service-2048 port: number: 80 ``` **Komponen kunci:** + Menciptakan ALB yang menghadap ke internet + Menggunakan tipe target IP untuk routing pod langsung + Rutekan semua lalu lintas (/) ke layanan game Terapkan konfigurasi ingress: ``` kubectl apply -f 04-ingressclass.yaml kubectl apply -f 05-ingress.yaml ``` ## Langkah 5: Verifikasi Deployment 1. Periksa apakah semua pod berjalan: ``` kubectl get pods -n game-2048 ``` 1. Verifikasi layanan dibuat: ``` kubectl get svc -n game-2048 ``` 1. Dapatkan titik akhir ALB: ``` kubectl get ingress -n game-2048 ``` Bidang ADDRESS pada keluaran ingress akan menampilkan endpoint ALB Anda. Tunggu 2-3 menit hingga ALB menyediakan dan mendaftarkan semua target. ## Langkah 6: Akses Game Buka browser web Anda dan telusuri URL endpoint ALB dari langkah sebelumnya. Anda akan melihat antarmuka game 2048. ## Langkah 7: Pembersihan Untuk menghapus semua sumber daya yang dibuat dalam tutorial ini: ``` kubectl delete namespace game-2048 ``` Ini akan menghapus semua sumber daya di namespace, termasuk penerapan, layanan, dan sumber daya ingress. ## Apa yang Terjadi Di Balik Layar 1. Deployment menciptakan 5 pod yang menjalankan game 2048 1. Layanan ini menyediakan akses jaringan yang stabil ke pod ini 1. Mode Otomatis EKS: + Membuat Application Load Balancer di AWS + Mengonfigurasi grup target untuk pod + Menyiapkan aturan perutean untuk mengarahkan lalu lintas ke layanan ## Pemecahan Masalah Jika game tidak dimuat: + Pastikan semua pod berjalan: `kubectl get pods -n game-2048` + Periksa status masuknya: `kubectl describe ingress -n game-2048` + Verifikasi pemeriksaan kesehatan ALB: Periksa kesehatan grup target di Konsol AWS # Menerapkan contoh beban kerja stateful ke Mode Otomatis EKS 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 + 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 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 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 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 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 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 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 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 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) # Menerapkan beban kerja yang dipercepat Tutorial ini menunjukkan bagaimana Amazon EKS Auto Mode menyederhanakan peluncuran beban kerja yang dipercepat perangkat keras. Amazon EKS Auto Mode merampingkan operasi di luar klaster itu sendiri dengan mengotomatiskan komponen infrastruktur utama yang menyediakan kemampuan komputasi, jaringan, penyeimbangan beban, penyimpanan, dan Akses Identitas dan Manajemen di luar kotak. Amazon EKS Auto Mode menyertakan driver dan plugin perangkat yang diperlukan untuk jenis instans tertentu, seperti driver NVIDIA dan AWS Neuron. Anda tidak perlu menginstal atau memperbarui komponen ini. Mode Otomatis EKS secara otomatis mengelola driver untuk akselerator ini: + [AWS Trainium](https://aws.amazon.com/ai/machine-learning/trainium/) + [AWS Inferensia](https://aws.amazon.com/ai/machine-learning/inferentia/) + [NVIDIA GPUs di Amazon EC2 mempercepat instans](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html) **catatan** Mode Otomatis EKS menyertakan plugin perangkat NVIDIA untuk Kubernetes. Plugin ini berjalan secara otomatis dan tidak terlihat sebagai daemon yang disetel di cluster Anda. Dukungan jaringan tambahan: + [Adaptor Kain Elastis (EFA)](https://aws.amazon.com/hpc/efa/) Amazon EKS Auto Mode menghilangkan kerja keras driver akselerator dan manajemen plugin perangkat. Anda juga bisa mendapatkan keuntungan dari penghematan biaya dengan menskalakan cluster ke nol. Anda dapat mengonfigurasi Mode Otomatis EKS untuk menghentikan instance saat tidak ada beban kerja yang berjalan. Ini berguna untuk beban kerja inferensi berbasis batch. Berikut ini memberikan contoh cara meluncurkan beban kerja yang dipercepat dengan Amazon EKS Auto Mode. ## Prasyarat + Cluster Kubernetes dengan Amazon EKS Auto Mode dikonfigurasi. + Kelas `default` EKS Node seperti yang dibuat saat `general-purpose` atau `system` Managed Node Pools diaktifkan. ## Langkah 1: Menyebarkan beban kerja GPU Dalam contoh ini, Anda akan membuat beban kerja berbasis NVIDIA NodePool untuk yang membutuhkan memori GPU 45GB. Dengan Mode Otomatis EKS, Anda menggunakan batasan penjadwalan Kubernetes untuk menentukan persyaratan instans Anda. Untuk menerapkan Amazon EKS Auto Mode `NodePool` dan sampel`workload`, tinjau definisi berikut NodePool dan Pod dan simpan sebagai `nodepool-gpu.yaml` dan`pod.yaml`: **nodepool-gpu.yaml** ``` apiVersion: karpenter.sh/v1 kind: NodePool metadata: name: gpu spec: disruption: budgets: - nodes: 10% consolidateAfter: 1h consolidationPolicy: WhenEmpty template: metadata: {} spec: nodeClassRef: group: eks.amazonaws.com kind: NodeClass name: default requirements: - key: "karpenter.sh/capacity-type" operator: In values: ["on-demand"] - key: "kubernetes.io/arch" operator: In values: ["amd64"] - key: "eks.amazonaws.com/instance-family" operator: In values: - g6e - g6 taints: - key: nvidia.com/gpu effect: NoSchedule terminationGracePeriod: 24h0m0s ``` **pod.yaml** ``` apiVersion: v1 kind: Pod metadata: name: nvidia-smi spec: nodeSelector: eks.amazonaws.com/compute-type: auto restartPolicy: OnFailure containers: - name: nvidia-smi image: public.ecr.aws/amazonlinux/amazonlinux:2023-minimal args: - "nvidia-smi" resources: requests: memory: "30Gi" cpu: "3500m" nvidia.com/gpu: 1 limits: memory: "30Gi" nvidia.com/gpu: 1 tolerations: - key: nvidia.com/gpu effect: NoSchedule operator: Exists ``` Perhatikan bahwa `eks.amazonaws.com/compute-type: auto` pemilih mengharuskan beban kerja diterapkan pada node Mode Otomatis Amazon EKS. Ini NodePool juga menetapkan taint yang hanya memungkinkan pod dengan toleransi untuk Nvidia GPUs dijadwalkan. Terapkan NodePool dan beban kerja ke cluster Anda. ``` kubectl apply -f nodepool-gpu.yaml kubectl apply -f pod.yaml ``` Anda akan melihat output berikut: ``` nodepool.karpenter.sh/gpu configured created pod/nvidia-smi created ``` Tunggu beberapa detik, dan periksa node di cluster Anda. Anda sekarang akan melihat node baru yang disediakan di kluster Mode Otomatis Amazon EKS Anda: ``` > kubectl get nodes NAME TYPE CAPACITY ZONE NODE READY AGE gpu-dnknr g6e.2xlarge on-demand us-west-2b i-02315c7d7643cdee6 True 76s ``` ## Langkah 2: Validasi Anda dapat melihat Amazon EKS Auto Mode meluncurkan a, `g6e.2xlarge` bukan `g6.2xlarge` karena beban kerja memerlukan instance dengan l40s`GPU`, menurut batasan penjadwalan Kubernetes berikut: ``` ... nodeSelector: eks.amazonaws.com/instance-gpu-name: l40s ... requests: memory: "30Gi" cpu: "3500m" nvidia.com/gpu: 1 limits: memory: "30Gi" nvidia.com/gpu: 1 ``` Sekarang, lihat log kontainer, dengan menjalankan perintah berikut: ``` kubectl logs nvidia-smi ``` Contoh output: ``` +---------------------------------------------------------------------------------------+ | NVIDIA-SMI 535.230.02 Driver Version: 535.230.02 CUDA Version: 12.2 | |-----------------------------------------+----------------------+----------------------+ | GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. | | | | MIG M. | |=========================================+======================+======================| | 0 NVIDIA L40S On | 00000000:30:00.0 Off | 0 | | N/A 27C P8 23W / 350W | 0MiB / 46068MiB | 0% Default | | | | N/A | +-----------------------------------------+----------------------+----------------------+ +---------------------------------------------------------------------------------------+ | Processes: | | GPU GI CI PID Type Process name GPU Memory | | ID ID Usage | |=======================================================================================| | No running processes found | +---------------------------------------------------------------------------------------+ ``` Anda dapat melihat bahwa penampung telah mendeteksi itu berjalan pada instance dengan `NVIDIA` GPU dan Anda tidak perlu menginstal driver perangkat apa pun, karena ini dikelola oleh Amazon EKS Auto Mode. ## Langkah 3: Membersihkan Untuk menghapus semua objek yang dibuat, gunakan `kubectl` untuk menghapus penyebaran sampel NodePool sehingga node dihentikan: ``` kubectl delete -f nodepool-gpu.yaml kubectl delete -f pod.yaml ``` ## Contoh NodePools Referensi ### Buat NVIDIA NodePool Berikut ini NodePool mendefinisikan: + Hanya meluncurkan contoh `g6e` dan keluarga `g6` + Konsolidasikan node saat kosong selama 1 jam + Nilai 1 jam untuk `consolodateAfter` mendukung beban kerja runcing dan mengurangi churn node. Anda dapat menyetel `consolidateAfter` berdasarkan persyaratan beban kerja Anda. **Contoh NodePool dengan keluarga instans GPU dan konsolidasi** ``` apiVersion: karpenter.sh/v1 kind: NodePool metadata: name: gpu spec: disruption: budgets: - nodes: 10% consolidateAfter: 1h consolidationPolicy: WhenEmpty template: metadata: {} spec: nodeClassRef: group: eks.amazonaws.com kind: NodeClass name: default requirements: - key: "karpenter.sh/capacity-type" operator: In values: ["on-demand"] - key: "kubernetes.io/arch" operator: In values: ["amd64"] - key: "eks.amazonaws.com/instance-family" operator: In values: - g6e - g6 terminationGracePeriod: 24h0m0s ``` Alih-alih menyetel yang mungkin `eks.amazonaws.com/instance-gpu-name` Anda gunakan `eks.amazonaws.com/instance-family` untuk menentukan keluarga instance. Untuk label terkenal lainnya yang memengaruhi tinjauan penjadwalan, lihat[Label yang Didukung Mode Otomatis EKS](create-node-pool.md#auto-supported-labels). Jika Anda memiliki persyaratan penyimpanan khusus, Anda dapat menyetel penyimpanan singkat node`iops`, `size` dan `throughput` dengan membuat sendiri [NodeClass](create-node-class.md)untuk referensi di. NodePool Pelajari lebih lanjut tentang [ NodeClass opsi yang dapat dikonfigurasi](create-node-class.md). **Contoh konfigurasi penyimpanan untuk NodeClass** ``` apiVersion: eks.amazonaws.com/v1 kind: NodeClass metadata: name: gpu spec: ephemeralStorage: iops: 3000 size: 80Gi throughput: 125 ``` ### Tentukan AWS Trainium dan AWS Inferensia NodePool Berikut ini NodePool memiliki `eks.amazonaws.com/instance-category` satu set yang mengatakan, hanya meluncurkan contoh keluarga Inferentia dan Trainium: ``` - key: "eks.amazonaws.com/instance-category" operator: In values: - inf - trn ```