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

# Penskalaan otomatis pada EKS SageMaker HyperPod
<a name="sagemaker-hyperpod-eks-autoscaling"></a>

Amazon SageMaker HyperPod menyediakan solusi penskalaan otomatis node berbasis Karpenter terkelola untuk cluster yang dibuat dengan orkestrasi EKS. [Karpenter](https://karpenter.sh/) adalah pengelola siklus hidup node Kubernetes open-source yang dibangun oleh AWS Kubernetes yang mengoptimalkan penskalaan klaster dan efisiensi biaya. Tidak seperti penerapan Karpenter yang dikelola sendiri, implementasi SageMaker HyperPod terkelola menghilangkan overhead operasional untuk menginstal, mengonfigurasi, dan memelihara pengontrol Karpenter sambil memberikan ketahanan terintegrasi dan toleransi kesalahan. Solusi penskalaan otomatis terkelola ini dibangun di atas HyperPod kemampuan [penyediaan berkelanjutan dan memungkinkan Anda menskalakan](sagemaker-hyperpod-scaling-eks.md) sumber daya komputasi secara efisien untuk beban kerja pelatihan dan inferensi dengan penanganan dan pemulihan kegagalan otomatis. 

Pembayaran dilakukan sesuai penggunaan. Anda bertanggung jawab untuk membayar semua instans komputasi yang secara otomatis disediakan melalui penskalaan otomatis sesuai dengan harga standar. SageMaker HyperPod Untuk informasi harga terperinci, lihat [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).

Dengan mengaktifkan penskalaan otomatis berbasis Karpenter, Anda memiliki akses ke: HyperPod
+ **Siklus hidup terkelola layanan** - HyperPod menangani instalasi, pembaruan, dan pemeliharaan Karpenter, menghilangkan overhead operasional.
+ **Penyediaan tepat waktu** - Karpenter akan mengamati pod Anda yang tertunda dan menyediakan komputasi yang diperlukan untuk beban kerja Anda dari kumpulan sesuai permintaan.
+ **Skala ke nol** - Turunkan ke nol node tanpa mempertahankan infrastruktur pengontrol khusus.
+ **Pemilihan node sadar beban kerja** - Karpenter memilih jenis instans yang optimal berdasarkan persyaratan pod, zona ketersediaan, dan harga untuk meminimalkan biaya.
+ **Konsolidasi simpul otomatis** - Karpenter secara teratur mengevaluasi cluster untuk peluang pengoptimalan, menggeser beban kerja untuk menghilangkan node yang kurang dimanfaatkan.
+ **Ketahanan terintegrasi** - Memanfaatkan toleransi HyperPod kesalahan bawaan dan mekanisme pemulihan simpul.

Topik berikut menjelaskan cara mengaktifkan HyperPod penskalaan otomatis dengan Karpenter.

**Topics**
+ [

## Prasyarat
](#sagemaker-hyperpod-eks-autoscaling-prereqs)
+ [

# Buat peran IAM untuk HyperPod penskalaan otomatis dengan Karpenter
](sagemaker-hyperpod-eks-autoscaling-iam.md)
+ [

# Buat dan konfigurasikan HyperPod cluster dengan autoscaling Karpenter
](sagemaker-hyperpod-eks-autoscaling-cluster.md)
+ [

# Buat NodeClass
](sagemaker-hyperpod-eks-autoscaling-nodeclass.md)
+ [

# Buat NodePool
](sagemaker-hyperpod-eks-autoscaling-nodepool.md)
+ [

# Menerapkan beban kerja
](sagemaker-hyperpod-eks-autoscaling-workload.md)

## Prasyarat
<a name="sagemaker-hyperpod-eks-autoscaling-prereqs"></a>
+ Penyediaan berkelanjutan diaktifkan di klaster Anda HyperPod . Aktifkan penyediaan berkelanjutan dengan menyetel `Continuous` saat `--node-provisioning-mode` membuat klaster Anda SageMaker HyperPod . Untuk informasi selengkapnya, lihat [Penyediaan berkelanjutan untuk operasi klaster yang disempurnakan di Amazon EKS](sagemaker-hyperpod-scaling-eks.md).
+ Agen Pemantau Kesehatan versi 1.0.742.0\$11.0.241.0 atau lebih tinggi diinstal. Diperlukan untuk operasi dan pemantauan HyperPod cluster. Agen harus dikonfigurasi sebelum mengaktifkan penskalaan otomatis Karpenter untuk memastikan pelaporan kesehatan klaster dan manajemen siklus hidup node yang tepat. Untuk informasi selengkapnya, lihat [Sistem Pemantauan Kesehatan](sagemaker-hyperpod-eks-resiliency-health-monitoring-agent.md).
+ Hanya jika cluster Amazon EKS Anda memiliki Karpenter yang berjalan di atasnya, Karpenter `NodePool` dan `NodeClaim` versi harus v1.
+ `NodeRecovery`diatur ke otomatis. Untuk informasi selengkapnya, lihat [Pemulihan simpul otomatis](sagemaker-hyperpod-eks-resiliency-node-recovery.md).

# Buat peran IAM untuk HyperPod penskalaan otomatis dengan Karpenter
<a name="sagemaker-hyperpod-eks-autoscaling-iam"></a>

Pada langkah-langkah berikut, Anda akan membuat peran IAM yang memungkinkan SageMaker HyperPod untuk mengelola node Kubernetes di klaster Anda melalui penskalaan otomatis berbasis Karpenter. Peran ini memberikan izin yang diperlukan HyperPod untuk menambah dan menghapus node cluster secara otomatis berdasarkan permintaan beban kerja.

**Buka konsol IAM**

1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di console.aws.amazon.com.

1. Di panel navigasi, pilih **Peran**.

1. Pilih **Buat peran**.

**Konfigurasikan kebijakan kepercayaan**

1. Untuk **jenis entitas Tepercaya**, pilih **Kebijakan kepercayaan khusus**.

1. Di editor **kebijakan kepercayaan kustom**, ganti kebijakan default dengan yang berikut ini:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": [
                       "hyperpod.sagemaker.amazonaws.com"
                   ]
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

1. Pilih **Berikutnya**.

**Membuat dan melampirkan kebijakan izin**

Karena SageMaker HyperPod memerlukan izin khusus yang tidak tersedia dalam kebijakan AWS terkelola, Anda harus membuat kebijakan khusus.

1. Pilih **Buat kebijakan**. Ini membuka tab browser baru.

1. Pilih tab **JSON**.

1. Ganti kebijakan default dengan yang berikut:

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "sagemaker:BatchAddClusterNodes",
                   "sagemaker:BatchDeleteClusterNodes"
               ],
               "Resource": "arn:aws:sagemaker:*:*:cluster/*",
               "Condition": {
                   "StringEquals": {
                       "aws:ResourceAccount": "${aws:PrincipalAccount}"
                   }
               }
           },
           {
               "Effect": "Allow",
               "Action": [
                   "kms:CreateGrant",
                   "kms:DescribeKey"
               ],
               "Resource": "arn:aws:kms:*:*:key/*",
               "Condition": {
                   "StringLike": {
                       "kms:ViaService": "sagemaker.*.amazonaws.com"
                   },
                   "Bool": {
                       "kms:GrantIsForAWSResource": "true"
                   },
                   "ForAllValues:StringEquals": {
                       "kms:GrantOperations": [
                           "CreateGrant",
                           "Decrypt",
                           "DescribeKey",
                           "GenerateDataKeyWithoutPlaintext",
                           "ReEncryptTo",
                           "ReEncryptFrom",
                           "RetireGrant"
                       ]
                   }
               }
           }
       ]
   }
   ```

------

1. Pilih **Berikutnya**.

1. Untuk **Nama kebijakan**, masukkan **SageMakerHyperPodKarpenterPolicy**.

1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi untuk kebijakan.

1. Pilih **Buat kebijakan**.

1. Kembali ke tab pembuatan peran dan segarkan daftar kebijakan.

1. Cari dan pilih **SageMakerHyperPodKarpenterPolicy**yang baru saja Anda buat.

1. Pilih **Berikutnya**.

**Beri nama dan buat peran**

1. Untuk **Nama peran**, masukkan `SageMakerHyperPodKarpenterRole`.

1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi untuk peran tersebut.

1. Di bagian **Langkah 1: Pilih entitas tepercaya**, verifikasi bahwa kebijakan kepercayaan menunjukkan prinsip layanan yang benar.

1. Di **Langkah 2: Tambahkan izin** bagian, verifikasi yang `SageMakerHyperPodKarpenterPolicy` terlampir.

1. Pilih **Buat peran**.

**Catat peran ARN**

Setelah peran berhasil dibuat:

1. Dalam daftar **Peran**, pilih nama peran`SageMakerHyperPodKarpenterRole`.

1. Salin **ARN Peran** dari bagian **Ringkasan**. Anda akan membutuhkan ARN ini saat membuat cluster Anda HyperPod.

Peran ARN mengikuti format ini:. `arn:aws:iam::ACCOUNT-ID:role/SageMakerHyperPodKarpenterRole`

# Buat dan konfigurasikan HyperPod cluster dengan autoscaling Karpenter
<a name="sagemaker-hyperpod-eks-autoscaling-cluster"></a>

Dalam langkah-langkah berikut, Anda akan membuat SageMaker HyperPod cluster dengan penyediaan berkelanjutan diaktifkan dan mengonfigurasinya untuk menggunakan penskalaan otomatis berbasis Karpenter.

**Buat HyperPod cluster**

1. Muat konfigurasi lingkungan Anda dan ekstrak nilai dari CloudFormation tumpukan.

   ```
   source .env
   SUBNET1=$(cfn-output $VPC_STACK_NAME PrivateSubnet1)
   SUBNET2=$(cfn-output $VPC_STACK_NAME PrivateSubnet2)
   SUBNET3=$(cfn-output $VPC_STACK_NAME PrivateSubnet3)
   SECURITY_GROUP=$(cfn-output $VPC_STACK_NAME NoIngressSecurityGroup)
   EKS_CLUSTER_ARN=$(cfn-output $EKS_STACK_NAME ClusterArn)
   EXECUTION_ROLE=$(cfn-output $SAGEMAKER_STACK_NAME ExecutionRole)
   SERVICE_ROLE=$(cfn-output $SAGEMAKER_STACK_NAME ServiceRole)
   BUCKET_NAME=$(cfn-output $SAGEMAKER_STACK_NAME Bucket)
   HP_CLUSTER_NAME="hyperpod-eks-test-$(date +%s)"
   EKS_CLUSTER_NAME=$(cfn-output $EKS_STACK_NAME ClusterName)
   HP_CLUSTER_ROLE=$(cfn-output $SAGEMAKER_STACK_NAME ClusterRole)
   ```

1. Unggah skrip inisialisasi node ke bucket Amazon S3 Anda.

   ```
   aws s3 cp lifecyclescripts/on_create_noop.sh s3://$BUCKET_NAME
   ```

1. Buat file konfigurasi cluster dengan variabel lingkungan Anda.

   ```
   cat > cluster_config.json << EOF
   {
       "ClusterName": "$HP_CLUSTER_NAME",
       "InstanceGroups": [
           {
               "InstanceCount": 1,
               "InstanceGroupName": "system",
               "InstanceType": "ml.c5.xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE"
           },
           {
               "InstanceCount": 0,
               "InstanceGroupName": "auto-c5-az1",
               "InstanceType": "ml.c5.xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE"
           },
           {
               "InstanceCount": 0,
               "InstanceGroupName": "auto-c5-4xaz2",
               "InstanceType": "ml.c5.4xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE",
               "OverrideVpcConfig": {
                   "SecurityGroupIds": [
                       "$SECURITY_GROUP"
                   ],
                   "Subnets": [
                       "$SUBNET2"
                   ]
               }
           },
           {
               "InstanceCount": 0,
               "InstanceGroupName": "auto-g5-az3",
               "InstanceType": "ml.g5.xlarge",
               "LifeCycleConfig": {
                   "SourceS3Uri": "s3://$BUCKET_NAME",
                   "OnCreate": "on_create_noop.sh"
               },
               "ExecutionRole": "$EXECUTION_ROLE",
               "OverrideVpcConfig": {
                   "SecurityGroupIds": [
                       "$SECURITY_GROUP"
                   ],
                   "Subnets": [
                       "$SUBNET3"
                   ]
               }
           }
       ],
       "VpcConfig": {
           "SecurityGroupIds": [
               "$SECURITY_GROUP"
           ],
           "Subnets": [
               "$SUBNET1"
           ]
       },
       "Orchestrator": {
           "Eks": {
               "ClusterArn": "$EKS_CLUSTER_ARN"
           }
       },
       "ClusterRole": "$HP_CLUSTER_ROLE",
       "AutoScaling": {
           "Mode": "Enable",
           "AutoScalerType": "Karpenter"
       },
       "NodeProvisioningMode": "Continuous"
   }
   EOF
   ```

1. Jalankan perintah berikut untuk membuat HyperPod cluster Anda.

   ```
   aws sagemaker create-cluster --cli-input-json file://./cluster_config.json
   ```

1. Proses pembuatan cluster memakan waktu sekitar 20 menit. Pantau status cluster hingga keduanya ClusterStatus dan AutoScaling .Status ditampilkan InService.

1. Simpan ARN cluster untuk operasi selanjutnya.

   ```
   HP_CLUSTER_ARN=$(aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME \
      --output text --query ClusterArn)
   ```

**Aktifkan penskalaan otomatis Karpenter**

1. Jalankan perintah berikut untuk mengaktifkan penskalaan otomatis berbasis Karpenter pada cluster yang sudah ada sebelumnya yang memiliki mode penyediaan node berkelanjutan.

   ```
   aws sagemaker update-cluster \
       --cluster-name $HP_CLUSTER_NAME \
       --auto-scaling Mode=Enable,AutoScalerType=Karpenter \
       --cluster-role $HP_CLUSTER_ROLE
   ```

1. Verifikasi bahwa Karpenter telah berhasil diaktifkan:

   ```
   aws sagemaker describe-cluster --cluster-name $HP_CLUSTER_NAME --query 'AutoScaling'
   ```

1. Keluaran yang diharapkan

   ```
   {
       "Mode": "Enable",
       "AutoScalerType": "Karpenter",
       "Status": "InService"
   }
   ```

Tunggu `Status` hingga ditampilkan `InService` sebelum melanjutkan untuk mengkonfigurasi NodeClass dan NodePool.

# Buat NodeClass
<a name="sagemaker-hyperpod-eks-autoscaling-nodeclass"></a>

**penting**  
Anda harus mulai dengan 0 node di grup instans Anda dan biarkan Karpenter menangani penskalaan otomatis. Jika Anda mulai dengan lebih dari 0 node, Karpenter akan menskalakannya menjadi 0.

Kelas node (`NodeClass`) mendefinisikan setelan tingkat infrastruktur yang berlaku untuk grup node di kluster Amazon EKS Anda, termasuk konfigurasi jaringan, pengaturan penyimpanan, dan penandaan sumber daya. A `HyperPodNodeClass` adalah kustom `NodeClass` yang memetakan ke grup instans yang telah dibuat sebelumnya SageMaker HyperPod, menentukan batasan di sekitar jenis instance dan Availability Zone mana yang didukung untuk keputusan penskalaan otomatis Karpenter.

**Pertimbangan untuk membuat kelas node**
+ Anda dapat menentukan hingga 10 grup instans dalam file`NodeClass`.
+ Saat menggunakan partisi GPU dengan MIG (Multi-Instance GPU), Karpenter dapat secara otomatis menyediakan node dengan grup instance berkemampuan MiG. Pastikan grup instans Anda menyertakan tipe instans yang didukung MiG (ml.p4d.24xlarge, ml.p5.48xlarge, atau ml.p5e/p5en.48xlarge) dan konfigurasikan label MIG yang sesuai selama pembuatan klaster. Untuk informasi selengkapnya tentang mengonfigurasi partisi GPU, lihat. [Menggunakan partisi GPU di Amazon SageMaker HyperPod](sagemaker-hyperpod-eks-gpu-partitioning.md)
+ Jika label kustom diterapkan ke grup instance, Anda dapat melihatnya di `desiredLabels` bidang saat menanyakan `HyperpodNodeClass` status. Ini termasuk label konfigurasi MIG seperti`nvidia.com/mig.config`. Saat pekerjaan yang masuk meminta sumber daya MIG, Karpenter akan secara otomatis menskalakan instance dengan label MIG yang sesuai diterapkan.
+ Jika Anda memilih untuk menghapus grup instans, kami sarankan untuk menghapusnya dari grup Anda `NodeClass` sebelum menghapusnya dari HyperPod cluster Anda. Jika grup instans dihapus saat digunakan dalam a`NodeClass`, grup `NodeClass` akan ditandai sebagai bukan `Ready` untuk penyediaan dan tidak akan digunakan untuk operasi penskalaan berikutnya sampai grup instans dihapus. `NodeClass`
+ Saat Anda menghapus grup instance dari a`NodeClass`, Karpenter akan mendeteksi penyimpangan pada node yang dikelola oleh Karpenter di grup instance dan mengganggu node berdasarkan kontrol anggaran gangguan Anda.
+ Subnet yang digunakan oleh grup instance harus milik AZ yang sama. Subnet ditentukan baik menggunakan `OverrideVpcConfig` pada tingkat grup instance atau tingkat cluster. `VpcConfig`digunakan secara default.
+ Hanya kapasitas sesuai permintaan yang didukung saat ini. Grup instans dengan rencana Pelatihan atau kapasitas cadangan tidak didukung.
+ Grup instans `DeepHealthChecks (DHC)` dengan tidak didukung. Ini karena DHC membutuhkan waktu sekitar 60-90 menit untuk menyelesaikannya dan pod akan tetap dalam status tertunda selama waktu itu yang dapat menyebabkan penyediaan berlebih.

Langkah-langkah berikut mencakup cara membuat`NodeClass`.

1. Buat file YAMG (misalnya, nodeclass.yaml) dengan konfigurasi Anda. `NodeClass`

1. Terapkan konfigurasi ke klaster Anda menggunakan kubectl.

1. Referensi `NodeClass` dalam `NodePool` konfigurasi Anda.

1. Berikut contoh `NodeClass` yang menggunakan jenis instance ml.c5.xlarge dan ml.c5.4xlarge:

   ```
   apiVersion: karpenter.sagemaker.amazonaws.com/v1
   kind: HyperpodNodeClass
   metadata:
     name: sample-nc
   spec:
     instanceGroups:
       # name of InstanceGroup in HyperPod cluster. InstanceGroup needs to pre-created
       # MaxItems: 10
       - auto-c5-xaz1
       - auto-c5-4xaz2
   ```

1. Terapkan konfigurasi:

   ```
   kubectl apply -f nodeclass.yaml
   ```

1. Pantau NodeClass status untuk memastikan kondisi Siap dalam status disetel ke True:

   ```
   kubectl get hyperpodnodeclass sample-nc -o yaml
   ```

   ```
   apiVersion: karpenter.sagemaker.amazonaws.com/v1
   kind: HyperpodNodeClass
   metadata:
     creationTimestamp: "<timestamp>"
     name: sample-nc
     uid: <resource-uid>
   spec:
     instanceGroups:
     - auto-c5-az1
     - auto-c5-4xaz2
   status:
     conditions:
     // true when all IGs in the spec are present in SageMaker cluster, false otherwise
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 3
       reason: InstanceGroupReady
       status: "True"
       type: InstanceGroupReady
     // true if subnets of IGs are discoverable, false otherwise
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 3
       reason: SubnetsReady
       status: "True"
       type: SubnetsReady
     // true when all dependent resources are Ready [InstanceGroup, Subnets]
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 3
       reason: Ready
       status: "True"
       type: Ready
     instanceGroups:
     - desiredLabels:
       - key: <custom_label_key>
         value: <custom_label_value>
       - key: nvidia.com/mig.config
         value: all-1g.5gb
       instanceTypes:
       - ml.c5.xlarge
       name: auto-c5-az1
       subnets:
       - id: <subnet-id>
         zone: <availability-zone-a>
         zoneId: <zone-id-a>
     - instanceTypes:
       - ml.c5.4xlarge
       name: auto-c5-4xaz2
       subnets:
       - id: <subnet-id>
         zone: <availability-zone-b>
         zoneId: <zone-id-b>
   ```

# Buat NodePool
<a name="sagemaker-hyperpod-eks-autoscaling-nodepool"></a>

`NodePool`Set kendala pada node yang dapat dibuat oleh Karpenter dan pod yang dapat berjalan pada node tersebut. `NodePool`Dapat dikonfigurasi untuk melakukan hal-hal seperti:
+ Batasi pembuatan node ke zona tertentu, tipe instance, dan arsitektur komputer.
+ Tentukan label atau taint untuk membatasi pod yang dapat berjalan pada node yang dibuat Karpenter.

**catatan**  
HyperPod penyedia mendukung serangkaian persyaratan Kubernetes dan Karpenter terkenal yang dijelaskan di bawah ini. 

Langkah-langkah berikut mencakup cara membuat file`NodePool`.

1. Buat file YAMG bernama nodepool.yaml dengan konfigurasi yang Anda inginkan. `NodePool`

1. Anda dapat menggunakan konfigurasi sampel di bawah ini.

   Cari `Ready` di bawah `Conditions` untuk menunjukkan semua sumber daya dependen berfungsi dengan baik.

   ```
   apiVersion: karpenter.sh/v1
   kind: NodePool
   metadata:
    name: sample-np
   spec:
    template:
      spec:
        nodeClassRef:
         group: karpenter.sagemaker.amazonaws.com
         kind: HyperpodNodeClass
         name: multiazc5
        expireAfter: Never
        requirements:
           - key: node.kubernetes.io/instance-type
             operator: Exists
   ```

1. Terapkan `NodePool` ke cluster Anda:

   ```
   kubectl apply -f nodepool.yaml
   ```

1. Pantau `NodePool` status untuk memastikan `Ready` kondisi dalam status diatur ke`True`:

   ```
   kubectl get nodepool sample-np -oyaml
   ```

   ```
   apiVersion: karpenter.sh/v1
   kind: NodePool
   metadata:
     name: <nodepool-name>
     uid: <resource-uid>
     ...
   spec:
     disruption:
       budgets:
       - nodes: 90%
       consolidateAfter: 0s
       consolidationPolicy: WhenEmptyOrUnderutilized
     template:
       spec:
         expireAfter: 720h
         nodeClassRef:
           group: karpenter.sagemaker.amazonaws.com
           kind: HyperpodNodeClass
           name: <nodeclass-name>
         requirements:
         - key: node.kubernetes.io/instance-type
           operator: Exists
   status:
     conditions:
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 2
       reason: ValidationSucceeded
       status: "True"
       type: ValidationSucceeded
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 2
       reason: NodeClassReady
       status: "True"
       type: NodeClassReady
     - lastTransitionTime: "<timestamp>"
       message: ""
       observedGeneration: 2
       reason: Ready
       status: "True"
       type: Ready
   ```

**Label yang Didukung untuk Penyedia Karpenter HyperPod**

Ini adalah batasan dan persyaratan opsional yang dapat Anda tentukan dalam konfigurasi Anda. `NodePool`


|  Jenis Kebutuhan  |  Tujuan  |  Gunakan Case/Supported Nilai  |  Rekomendasi  | 
| --- | --- | --- | --- | 
|  Jenis Instance (`node.kubernetes.io/instance-type`)  |  Mengontrol jenis SageMaker instance mana yang dapat dipilih Karpenter  |  Alih-alih membatasi hanya ml.c5.xlarge, biarkan Karpenter memilih dari semua jenis yang tersedia di grup instance Anda  |  Biarkan ini tidak terdefinisi atau gunakan operator Exists untuk memberi Karpenter fleksibilitas maksimum dalam memilih jenis instans hemat biaya  | 
|  Zona Ketersediaan (`topology.kubernetes.io/zone`)  |  Mengontrol node zona AWS ketersediaan mana yang dapat dibuat  |  Nama zona tertentu seperti us-east-1c. Gunakan saat Anda membutuhkan pod untuk berjalan di zona tertentu karena alasan latensi atau kepatuhan  | T/A | 
|  Arsitektur (`kubernetes.io/arch`)  |  Menentukan arsitektur CPU  |  Hanya amd64 (saat ini tidak ada dukungan ARM)  |  T/A  | 

# Menerapkan beban kerja
<a name="sagemaker-hyperpod-eks-autoscaling-workload"></a>

Contoh berikut menunjukkan bagaimana HyperPod penskalaan otomatis dengan Karpenter secara otomatis menyediakan node sebagai respons terhadap tuntutan beban kerja. Contoh-contoh ini menunjukkan perilaku penskalaan dasar dan pola distribusi zona multi-ketersediaan.

**Menyebarkan beban kerja sederhana**

1. Penerapan Kubernetes berikut mencakup pod yang meminta 1 CPU dan memori 256 juta per replika atau pod. Dalam skenario ini, pod belum berputar.

   ```
   kubectl apply -f https://raw.githubusercontent.com/aws/karpenter-provider-aws/refs/heads/main/examples/workloads/inflate.yaml
   ```

1. Untuk menguji proses penskalaan, jalankan perintah berikut. Karpenter akan menambahkan node baru ke cluster.

   ```
   kubectl scale deployment inflate --replicas 10
   ```

1. Untuk menguji proses penurunan skala, jalankan perintah berikut. Karpenter akan menghapus node dari cluster.

   ```
   kubectl scale deployment inflate --replicas 0
   ```

**Menerapkan beban kerja di beberapa AZs**

1. Jalankan perintah berikut untuk menerapkan beban kerja yang menjalankan penerapan Kubernetes di mana pod dalam penerapan perlu menyebar secara merata di berbagai zona ketersediaan dengan Kemiringan maksimal 1.

   ```
   kubectl apply -f https://raw.githubusercontent.com/aws/karpenter-provider-aws/refs/heads/main/examples/workloads/spread-zone.yaml
   ```

1. Jalankan perintah berikut untuk menyesuaikan jumlah pod:

   ```
   kubectl scale deployment zone-spread --replicas 15
   ```

   Karpenter akan menambahkan node baru ke cluster dengan setidaknya satu node itu zona ketersediaan yang berbeda.

Untuk contoh lainnya, lihat [Karpenter contoh beban kerja](https://github.com/aws/karpenter-provider-aws/tree/main/examples/workloads) pada. GitHub