Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Scalabilità automatica su EKS SageMaker HyperPod
<a name="sagemaker-hyperpod-eks-autoscaling"></a>

Amazon SageMaker HyperPod fornisce una soluzione gestita di scalabilità automatica dei nodi basata su Karpenter per i cluster creati con l'orchestrazione EKS. [Karpenter](https://karpenter.sh/) è un gestore del ciclo di vita dei nodi Kubernetes open source creato da Kubernetes che ottimizza la scalabilità dei cluster e l'efficienza dei costi. AWS A differenza delle implementazioni Karpenter autogestite, l'implementazione gestita di Karpenter elimina il sovraccarico operativo legato all'installazione, SageMaker HyperPod alla configurazione e alla manutenzione dei controller Karpenter, fornendo al contempo resilienza e tolleranza ai guasti integrate. Questa soluzione di scalabilità automatica gestita si basa sulle funzionalità di [provisioning continuo](sagemaker-hyperpod-scaling-eks.md) di cui dispone e consente di scalare in modo efficiente le risorse HyperPod di calcolo per i carichi di lavoro di addestramento e inferenza con gestione e ripristino automatici degli errori. 

I prezzi sono calcolati solo in base all'uso effettivo. Sei responsabile del pagamento di tutte le istanze di elaborazione il cui provisioning viene eseguito automaticamente tramite la scalabilità automatica in base ai prezzi standard. SageMaker HyperPod Per informazioni dettagliate sui prezzi, consulta [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).

Abilitando la scalabilità automatica basata su Karpenter con HyperPod, hai accesso a:
+ **Ciclo di vita gestito dal servizio**: HyperPod gestisce l'installazione, gli aggiornamenti e la manutenzione di Karpenter, eliminando il sovraccarico operativo.
+ **Provisioning just-in-time**: Karpenter osserverà i pod in sospeso e allocherà le risorse di calcolo necessarie per i carichi di lavoro dal pool on demand.
+ **Riduzione verticale a zero**: riduci verticalmente i nodi a zero senza gestire un’infrastruttura di controller dedicata.
+ **Selezione dei nodi in base al carico di lavoro**: Karpenter sceglie i tipi di istanze ottimali in base ai requisiti dei pod, alle zone di disponibilità e ai prezzi per ridurre al minimo i costi.
+ **Consolidamento automatico dei nodi**: Karpenter valuta regolarmente i cluster per individuare opportunità di ottimizzazione, spostando i carichi di lavoro per eliminare i nodi sottoutilizzati.
+ **Resilienza integrata**: sfrutta i meccanismi integrati di tolleranza agli errori e HyperPod ripristino dei nodi.

I seguenti argomenti spiegano come abilitare la scalabilità HyperPod automatica con Karpenter.

**Topics**
+ [Prerequisiti](#sagemaker-hyperpod-eks-autoscaling-prereqs)
+ [Crea un ruolo IAM per la HyperPod scalabilità automatica con Karpenter](sagemaker-hyperpod-eks-autoscaling-iam.md)
+ [Crea e configura un HyperPod cluster con la scalabilità automatica di Karpenter](sagemaker-hyperpod-eks-autoscaling-cluster.md)
+ [Crea un NodeClass](sagemaker-hyperpod-eks-autoscaling-nodeclass.md)
+ [Crea un NodePool](sagemaker-hyperpod-eks-autoscaling-nodepool.md)
+ [Implementazione di un carico di lavoro](sagemaker-hyperpod-eks-autoscaling-workload.md)

## Prerequisiti
<a name="sagemaker-hyperpod-eks-autoscaling-prereqs"></a>
+ Il provisioning continuo è abilitato sul cluster. HyperPod Abilita il provisioning continuo impostando su `--node-provisioning-mode` al `Continuous` momento della creazione del cluster SageMaker HyperPod . Per ulteriori informazioni, consulta [Provisioning continuo per operazioni cluster avanzate su Amazon EKS](sagemaker-hyperpod-scaling-eks.md).
+ Deve essere installata la versione 1.0.742.0\$11.0.241.0 o successiva dell’agente di monitoraggio dell’integrità. Necessario per le operazioni e il monitoraggio del HyperPod cluster. L’agente deve essere configurato prima di abilitare il dimensionamento automatico di Karpenter per garantire la creazione di report corretti sull’integrità del cluster e la gestione del ciclo di vita dei nodi. Per ulteriori informazioni, consulta [Sistema di monitoraggio della salute](sagemaker-hyperpod-eks-resiliency-health-monitoring-agent.md).
+ Solo se sul cluster Amazon EKS è in esecuzione Karpenter, le versioni di `NodePool` e `NodeClaim` di Karpenter devono essere v1.
+ `NodeRecovery` deve essere impostato su automatico. Per ulteriori informazioni, consulta [Ripristino automatico del nodo](sagemaker-hyperpod-eks-resiliency-node-recovery.md).

# Crea un ruolo IAM per la HyperPod scalabilità automatica con Karpenter
<a name="sagemaker-hyperpod-eks-autoscaling-iam"></a>

Nei passaggi seguenti, creerai un ruolo IAM che consenta di gestire i nodi Kubernetes nel tuo cluster SageMaker HyperPod tramite la scalabilità automatica basata su Karpenter. Questo ruolo fornisce le autorizzazioni necessarie per aggiungere e rimuovere automaticamente i nodi del cluster in base HyperPod alla richiesta del carico di lavoro.

**Apertura della console IAM**

1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo console.aws.amazon.com.

1. Nel pannello di navigazione, seleziona **Roles** (Ruoli).

1. Selezionare **Create role (Crea ruolo)**.

**Configurazione della policy di attendibilità**

1. Per **Trusted entity type** (Tipo di entità attendibile), scegli **Custom trust policy** (Policy di attendibilità personalizzata).

1. Nell’editor **Policy di attendibilità personalizzata**, sostituisci la policy predefinita con la seguente:

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

****  

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

------

1. Scegli **Next (Successivo)**.

**Creazione e collegamento della policy di autorizzazione**

Poiché SageMaker HyperPod richiede autorizzazioni specifiche che non sono disponibili nelle politiche AWS gestite, devi creare una politica personalizzata.

1. Scegli **Crea policy**. Si apre una nuova scheda del browser.

1. Scegli la scheda **JSON**.

1. Sostituisci la policy predefinita con la policy seguente:

------
#### [ 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. Scegli **Next (Successivo)**.

1. In **Policy name** (Nome policy), inserisci **SageMakerHyperPodKarpenterPolicy**.

1. (Facoltativo) In **Descrizione**, inserisci una descrizione per la policy.

1. Scegliere **Create Policy (Crea policy)**.

1. Torna alla scheda di creazione del ruolo e aggiorna l’elenco delle policy.

1. Cerca e seleziona **SageMakerHyperPodKarpenterPolicy**quello che hai appena creato.

1. Scegli **Next (Successivo)**.

**Assegnazione di un nome e creazione del ruolo**

1. Per **Nome ruolo**, inserisci `SageMakerHyperPodKarpenterRole`.

1. (Facoltativo) In **Descrizione**, inserisci una descrizione per il ruolo.

1. Nella sezione **Fase 1. Seleziona le entità attendibili**, verifica che la policy di attendibilità indichi i principali dei servizi corretti.

1. Nella sezione **Fase 2. Aggiungi autorizzazioni**, verifica che `SageMakerHyperPodKarpenterPolicy` sia collegato.

1. Scegli **Crea ruolo**.

**Registrazione dell’ARN del ruolo**

Dopo aver creato correttamente il ruolo:

1. Nell’elenco **Ruoli**, seleziona il ruolo chiamato `SageMakerHyperPodKarpenterRole`.

1. Copia l’**ARN del ruolo** dalla sezione **Riepilogo**. Avrai bisogno di questo ARN per creare il tuo HyperPod cluster.

L’ARN del ruolo ha questo formato: `arn:aws:iam::ACCOUNT-ID:role/SageMakerHyperPodKarpenterRole`.

# Crea e configura un HyperPod cluster con la scalabilità automatica di Karpenter
<a name="sagemaker-hyperpod-eks-autoscaling-cluster"></a>

Nei passaggi seguenti, creerai un SageMaker HyperPod cluster con il provisioning continuo abilitato e lo configurerai per utilizzare la scalabilità automatica basata su Karpenter.

**Crea un cluster HyperPod**

1. Carica la configurazione dell'ambiente ed estrai i valori dagli CloudFormation stack.

   ```
   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. Carica lo script di inizializzazione del nodo sul tuo bucket Amazon S3.

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

1. Crea un file di configurazione del cluster con le variabili di ambiente.

   ```
   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. Esegui il comando seguente per creare il tuo HyperPod cluster.

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

1. La procedura di creazione del cluster richiede circa 20 minuti. Monitora lo stato del cluster fino alla visualizzazione sia ClusterStatus di .Status che di AutoScaling .Status. InService

1. Salva l’ARN del cluster per le operazioni successive.

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

**Abilitazione del dimensionamento automatico Karpenter**

1. Utilizza il comando seguente per abilitare il dimensionamento automatico basato su Karpenter su qualsiasi cluster preesistente con la modalità di provisioning continuo dei nodi.

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

1. Verifica che Karpenter sia stato abilitato correttamente:

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

1. Output previsto:

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

Attendi che `Status` venga visualizzato `InService` prima di procedere alla configurazione NodeClass e. NodePool

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

**Importante**  
È necessario iniziare con 0 nodi nel gruppo di istanze e lasciare che Karpenter gestisca il dimensionamento automatico. Se inizi con più di 0 nodi, Karpenter li ridurrà verticalmente fino a 0.

Una classe di nodi (`NodeClass`) definisce le impostazioni a livello di infrastruttura che si applicano ai gruppi di nodi del cluster Amazon EKS, tra cui la configurazione di rete, le impostazioni di archiviazione e il tagging delle risorse. A `HyperPodNodeClass` è una personalizzazione `NodeClass` che si associa a gruppi di istanze precreati e definisce i vincoli relativi ai tipi di istanze e alle zone di disponibilità supportati per le decisioni di scalabilità automatica di Karpenter. SageMaker HyperPod

**Considerazioni sulla creazione di una classe di nodi**
+ Puoi specificare fino a 10 gruppi di istanze in `NodeClass`.
+ Quando si utilizza il partizionamento GPU con MIG (Multi-Instance GPU), Karpenter può fornire automaticamente ai nodi gruppi di istanze abilitati per Mig. Assicurati che i tuoi gruppi di istanze includano tipi di istanze supportati da Mig (ml.p4d.24xlarge, ml.p5.48xlarge o ml.p5e/p5en.48xlarge) e configura le etichette MIG appropriate durante la creazione del cluster. Per ulteriori informazioni sulla [Utilizzo delle partizioni GPU in Amazon SageMaker HyperPod](sagemaker-hyperpod-eks-gpu-partitioning.md) configurazione del partizionamento GPU, consulta.
+ Se vengono applicate etichette personalizzate ai gruppi di istanze, è possibile visualizzarle sul `desiredLabels` campo quando si interroga lo stato. `HyperpodNodeClass` Ciò include etichette di configurazione MIG come. `nvidia.com/mig.config` Quando i lavori in entrata richiedono risorse MIG, Karpenter ridimensionerà automaticamente le istanze applicando le etichette MIG appropriate.
+ Se scegli di eliminare un gruppo di istanze, ti consigliamo di rimuoverlo dal tuo `NodeClass` prima di eliminarlo dal cluster. HyperPod Se un gruppo di istanze viene eliminato mentre è utilizzato in `NodeClass`, `NodeClass` viene contrassegnato come non pronto (`Ready`) per il provisioning e non verrà utilizzato per le successive operazioni di dimensionamento finché il gruppo di istanze non viene rimosso da `NodeClass`.
+ Quando rimuovi i gruppi di istanze da `NodeClass`, Karpenter rileva una deriva nei nodi gestiti da Karpenter in uno o più gruppi di istanze e arresta i nodi in base ai controlli del budget di interruzione.
+ Le sottoreti utilizzate dal gruppo di istanze devono appartenere alla stessa AZ. Le sottoreti vengono specificate a livello di cluster o utilizzando `OverrideVpcConfig` a livello di gruppo di istanze. `VpcConfig` viene utilizzato per impostazione predefinita.
+ Al momento è supportata solo la capacità on demand. I gruppi di istanze con piano di addestramento o capacità riservata non sono supportati.
+ I gruppi di istanze con `DeepHealthChecks (DHC)` non sono supportati. Questo dipende dal fatto che un DHC richiede circa 60-90 minuti per essere completato e durante questo periodo i pod restano in sospeso, causando potenzialmente un provisioning eccessivo.

La procedura che segue illustra come creare `NodeClass`.

1. Crea un file YAML (ad esempio, nodeclass.yaml) con la configurazione `NodeClass`.

1. Applica la configurazione al cluster utilizzando kubectl.

1. Fai riferimento a `NodeClass` nella configurazione `NodePool`.

1. Ecco un esempio di `NodeClass` che utilizza i tipi di istanze ml.c5.xlarge e 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. Applica la configurazione:

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

1. Monitora lo NodeClass stato per assicurarti che la condizione Ready in status sia impostata su 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>
   ```

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

`NodePool` imposta i vincoli sui nodi che possono essere creati da Karpenter e sui pod che possono essere eseguiti su tali nodi. `NodePool` può essere configurato per:
+ Limitare la creazione di nodi a determinate zone, tipi di istanze e architetture informatiche.
+ Definire le etichette o i taint per limitare i pod che possono essere eseguiti sui nodi creati da Karpenter.

**Nota**  
HyperPod il provider supporta una serie limitata di requisiti noti di Kubernetes e Karpenter spiegati di seguito. 

La procedura che segue illustra come creare `NodePool`.

1. Crea un file YAML denominato nodepool.yaml con la configurazione `NodePool` desiderata.

1. Puoi utilizzare la configurazione di esempio seguente.

   Cerca `Ready` in `Conditions` per verificare che tutte le risorse dipendenti funzionino correttamente.

   ```
   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. Applica `NodePool` al cluster:

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

1. Monitora lo stato di `NodePool` per assicurarti che la condizione `Ready` nello stato sia impostata su `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
   ```

**Etichette supportate per Karpenter Provider HyperPod**

Questi sono i vincoli e i requisiti facoltativi che puoi specificare nella tua configurazione `NodePool`.


|  Tipo di requisito  |  Scopo  |  Usa valori Case/Supported   |  Raccomandazione  | 
| --- | --- | --- | --- | 
|  Tipi di istanza (`node.kubernetes.io/instance-type`)  |  Controlla i tipi di SageMaker istanza tra cui Karpenter può scegliere  |  Invece di limitarti a ml.c5.xlarge, lascia che Karpenter scelga tra tutti i tipi disponibili nei tuoi gruppi di istanze.  |  Lascia questo campo indefinito o utilizza l’operatore Exists per dare a Karpenter la massima flessibilità nella scelta di tipi di istanze più convenienti.  | 
|  Zone di disponibilità (`topology.kubernetes.io/zone`)  |  Controlla in quali zone di AWS disponibilità possono essere creati i nodi  |  Nomi di zone specifici come us-east-1c. Da utilizzare se i pod devono funzionare in zone specifiche per motivi di latenza o conformità.  | N/A | 
|  Architettura (`kubernetes.io/arch`)  |  Specifica l’architettura della CPU.  |  Solo amd64 (attualmente ARM non è supportato).  |  N/A  | 

# Implementazione di un carico di lavoro
<a name="sagemaker-hyperpod-eks-autoscaling-workload"></a>

Gli esempi seguenti mostrano come la HyperPod scalabilità automatica con Karpenter effettua automaticamente il provisioning dei nodi in risposta alle richieste del carico di lavoro. Questi esempi mostrano il comportamento di dimensionamento di base e i modelli di distribuzione in più zone di disponibilità.

**Implementazione di un carico di lavoro semplice**

1. La seguente implementazione di Kubernetes include pod che richiedono 1 CPU e 256 M di memoria per ogni replica o pod. In questo scenario, i pod non sono ancora stati attivati.

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

1. Per testare il processo di aumento verticale, utilizza il comando seguente. Karpenter aggiungerà nuovi nodi al cluster.

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

1. Per testare il processo di riduzione verticale, utilizza il comando seguente. Karpenter rimuoverà i nodi dal cluster.

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

**Implementa un carico di lavoro su più AZs**

1. Utilizza il comando seguente per implementare un carico di lavoro che esegua un’implementazione di Kubernetes in cui i pod in fase di implementazione devono essere distribuiti uniformemente tra diverse zone di disponibilità con una differenza massima di 1.

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

1. Utilizza il comando seguente per regolare il numero di pod:

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

   Karpenter aggiungerà nuovi nodi al cluster con almeno un nodo in una zona di disponibilità diversa.

Per altri esempi, consulta [Karpenter](https://github.com/aws/karpenter-provider-aws/tree/main/examples/workloads) example workloads on. GitHub