As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Escalonamento automático no EKS SageMaker HyperPod
<a name="sagemaker-hyperpod-eks-autoscaling"></a>

 SageMaker HyperPod A Amazon fornece uma solução gerenciada de escalonamento automático de nós baseada em Karpenter para clusters criados com a orquestração EKS. O [Karpenter](https://karpenter.sh/) é um gerenciador de ciclo de vida de nós Kubernetes de código aberto criado por AWS ele que otimiza a escalabilidade do cluster e a eficiência de custos. Ao contrário das implantações autogerenciadas SageMaker HyperPod do Karpenter, a implementação gerenciada elimina a sobrecarga operacional de instalação, configuração e manutenção dos controladores Karpenter, ao mesmo tempo em que fornece resiliência integrada e tolerância a falhas. Essa solução gerenciada de escalonamento automático se baseia nos recursos de [provisionamento contínuo HyperPod](sagemaker-hyperpod-scaling-eks.md) da empresa e permite que você escale com eficiência os recursos de computação para treinamento e inferência de cargas de trabalho com tratamento e recuperação automáticos de falhas. 

Você paga somente pelo que usar. Você é responsável por pagar por todas as instâncias de computação que são provisionadas automaticamente por meio do escalonamento automático de acordo com o preço padrão. SageMaker HyperPod Para obter informações detalhadas sobre preços, consulte [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/ai/pricing/).

Ao habilitar o escalonamento automático baseado em Karpenter com HyperPod, você tem acesso a:
+ **Ciclo de vida gerenciado do serviço** - HyperPod gerencia a instalação, as atualizações e a manutenção do Karpenter, eliminando a sobrecarga operacional.
+ **Provisionamento just-in-time**: o Karpenter observará os pods pendentes e provisionará a computação necessária para as workloads a partir usando um grupo sob demanda.
+ **Ajuste de escala para zero**: reduza a escala vertical dos nós para zero sem precisar manter uma infraestrutura de controlador dedicada.
+ **Seleção de nós com reconhecimento de workload**: o Karpenter escolhe os tipos de instância ideais com base nos requisitos do pod, nas zonas de disponibilidade e nos preços para minimizar os custos.
+ **Consolidação automática de nós**: o Karpenter avalia regularmente o cluster em busca de oportunidades de otimização, mudando as workloads para eliminar nós subutilizados.
+ **Resiliência integrada** - aproveita os mecanismos integrados HyperPod de tolerância a falhas e recuperação de nós.

Os tópicos a seguir explicam como ativar o HyperPod escalonamento automático com o Karpenter.

**Topics**
+ [Pré-requisitos](#sagemaker-hyperpod-eks-autoscaling-prereqs)
+ [Crie uma função do IAM para HyperPod escalonamento automático com o Karpenter](sagemaker-hyperpod-eks-autoscaling-iam.md)
+ [Crie e configure um HyperPod cluster com o escalonamento automático do Karpenter](sagemaker-hyperpod-eks-autoscaling-cluster.md)
+ [Crie um NodeClass](sagemaker-hyperpod-eks-autoscaling-nodeclass.md)
+ [Crie um NodePool](sagemaker-hyperpod-eks-autoscaling-nodepool.md)
+ [Implantar uma workload](sagemaker-hyperpod-eks-autoscaling-workload.md)

## Pré-requisitos
<a name="sagemaker-hyperpod-eks-autoscaling-prereqs"></a>
+ Provisionamento contínuo habilitado em seu HyperPod cluster. Ative o provisionamento contínuo configurando como `--node-provisioning-mode` `Continuous` ao criar seu SageMaker HyperPod cluster. Para obter mais informações, consulte [Provisionamento contínuo para operações de cluster aprimoradas no Amazon EKS](sagemaker-hyperpod-scaling-eks.md).
+ O Health Monitoring Agent versão 1.0.742.0\$11.0.241.0 ou posterior está instalado. Necessário para operações e monitoramento de HyperPod clusters. O agente deve ser configurado antes da habilitação do ajuste de escala automático do Karpenter para garantir relatórios adequados de integridade dos clusters e gerenciamento do ciclo de vida dos nós. Para obter mais informações, consulte [Sistema de monitoramento de saúde](sagemaker-hyperpod-eks-resiliency-health-monitoring-agent.md).
+ Somente se o seu cluster Amazon do EKS tiver o Karpenter em execução, as versões `NodePool` e `NodeClaim` do Karpenter precisarão ser v1.
+ `NodeRecovery` definido como automático. Para obter mais informações, consulte [Recuperação automática de nós](sagemaker-hyperpod-eks-resiliency-node-recovery.md).

# Crie uma função do IAM para HyperPod escalonamento automático com o Karpenter
<a name="sagemaker-hyperpod-eks-autoscaling-iam"></a>

Nas etapas a seguir, você criará uma função do IAM que permite SageMaker HyperPod gerenciar os nós do Kubernetes em seu cluster por meio do escalonamento automático baseado em Karpenter. Essa função fornece as permissões necessárias para HyperPod adicionar e remover nós de cluster automaticamente com base na demanda da carga de trabalho.

**Abrir o console do IAM**

1. Faça login Console de gerenciamento da AWS e abra o console do IAM em console.aws.amazon.com.

1. No painel de navegação, escolha **Perfis**.

1. Escolha **Criar Perfil**.

**Configurar a política de confiança**

1. Em **Trusted entity type** (Tipo de entidade confiável), escolha **Custom trust policy** (Política de confiança personalizada).

1. No editor de **política de confiança personalizada**, substitua a política padrão pelo seguinte:

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

****  

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

------

1. Escolha **Próximo**.

**Criar o perfil e anexar a política de permissões a ele**

Como SageMaker HyperPod requer permissões específicas que não estão disponíveis nas políticas AWS gerenciadas, você deve criar uma política personalizada.

1. Selecione **Criar política**. Isso abre uma nova guia do navegador.

1. Selecione a guia **JSON**.

1. Substitua a política padrão pela seguinte:

------
#### [ 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. Escolha **Próximo**.

1. Em **Nome da política**, insira **SageMakerHyperPodKarpenterPolicy**.

1. (Opcional) Em **Descrição**, digite uma descrição para a política.

1. Selecione **Criar política**.

1. Volte para a guia de criação de perfis e atualize a lista de políticas.

1. Pesquise e selecione o **SageMakerHyperPodKarpenterPolicy**que você acabou de criar.

1. Escolha **Próximo**.

**Nomear e criar o perfil**

1. Em **Nome do perfil**, insira `SageMakerHyperPodKarpenterRole`.

1. (Opcional) Em **Descrição**, insira uma descrição para o perfil.

1. Na seção **Etapa 1: Selecionar entidades confiáveis**, verifique se a política de confiança mostra as entidades principais de serviço corretas.

1. Na seção **Etapa 2: Adicionar permissões**, verifique se `SageMakerHyperPodKarpenterPolicy` está anexada.

1. Selecione **Criar perfil**.

**Anote o ARN do perfil.**

Depois que o perfil for criado com êxito:

1. Na lista **Perfis**, escolha o nome de perfil `SageMakerHyperPodKarpenterRole`.

1. Copie o **ARN do perfil** da seção **Resumo**. Você precisará desse ARN ao criar seu HyperPod cluster.

O ARN segue este formato: `arn:aws:iam::ACCOUNT-ID:role/SageMakerHyperPodKarpenterRole`.

# Crie e configure um HyperPod cluster com o escalonamento automático do Karpenter
<a name="sagemaker-hyperpod-eks-autoscaling-cluster"></a>

Nas etapas a seguir, você criará um SageMaker HyperPod cluster com o provisionamento contínuo ativado e o configurará para usar o escalonamento automático baseado em Karpenter.

**Crie um HyperPod cluster**

1. Carregue a configuração do seu ambiente e extraia valores das CloudFormation pilhas.

   ```
   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. Faça upload do script de inicialização do nó em seu bucket do Amazon S3.

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

1. Crie um arquivo de configuração de cluster com suas variáveis de 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. Execute o comando a seguir para criar seu HyperPod cluster.

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

1. O processo de criação do cluster leva aproximadamente 20 minutos. Monitore o status do cluster até que ambos ClusterStatus e AutoScaling .Status sejam exibidos InService.

1. Salve o ARN do cluster para operações subsequentes.

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

**Habilitar o ajuste de escala automático do Karpenter**

1. Execute o comando a seguir para habilitar o ajuste de escala automático baseado no Karpenter em qualquer cluster preexistente que tenha o modo de provisionamento contínuo de nós.

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

1. Verifique se o Karpenter foi habilitado com êxito:

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

1. Saída esperada:

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

Aguarde `Status` até que `InService` apareça antes de continuar com a configuração NodeClass e. NodePool

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

**Importante**  
Você deve começar com 0 nó no seu grupo de instâncias e deixar o Karpenter lidar com o ajuste de escala automático. Se você começar com mais de 0 nó, o Karpenter reduzirá a escala vertical dos nós para 0.

Uma classe de nó (`NodeClass`) define as configurações em nível de infraestrutura que se aplicam a grupos de nós no cluster do Amazon EKS, incluindo configuração de rede, configurações de armazenamento e marcação de recursos. `HyperPodNodeClass`A é um personalizado `NodeClass` que mapeia grupos de instâncias pré-criados em SageMaker HyperPod, definindo restrições em torno de quais tipos de instância e zonas de disponibilidade são compatíveis com as decisões de escalonamento automático da Karpenter.

**Considerações sobre como criar de uma classe de nós**
+ Você pode especificar até dez grupos de instâncias em uma `NodeClass`.
+ Ao usar o particionamento de GPU com MIG (GPU de múltiplas instâncias), o Karpenter pode provisionar automaticamente nós com grupos de instâncias habilitados para MIG. Certifique-se de que seus grupos de instâncias incluam tipos de instância compatíveis com o MIG (ml.p4d.24xlarge, ml.p5.48xlarge ou ml.p5e/p5en.48xlarge) e configure os rótulos MIG apropriados durante a criação do cluster. Para obter mais informações sobre como configurar o particionamento de GPU, consulte. [Usando partições de GPU na Amazon SageMaker HyperPod](sagemaker-hyperpod-eks-gpu-partitioning.md)
+ Se rótulos personalizados forem aplicados a grupos de instâncias, você poderá visualizá-los no `desiredLabels` campo ao consultar o `HyperpodNodeClass` status. Isso inclui rótulos de configuração MIG, como`nvidia.com/mig.config`. Quando os trabalhos recebidos solicitam recursos MIG, o Karpenter escalará automaticamente as instâncias com os rótulos MIG apropriados aplicados.
+ Se você optar por excluir um grupo de instâncias, recomendamos removê-lo do seu `NodeClass` antes de excluí-lo do seu HyperPod cluster. Se um grupo de instâncias for excluído enquanto for usado em uma`NodeClass`, a `NodeClass` será marcada como não `Ready` para provisionamento e não será usada para operações de ajuste de escala subsequentes enquanto o grupo de instâncias não for removido da `NodeClass`.
+ Quando você remove grupos de instâncias de um `NodeClass`, o Karpenter detecta um desvio nos nós que foram gerenciados pelo Karpenter nos grupos de instâncias e interrompe os nós com base em seus controles de orçamento de interrupção.
+ As sub-redes usadas pelo grupo de instâncias devem pertencer à mesma AZ. As sub-redes são especificadas usando `OverrideVpcConfig` em nível de grupo de instâncias ou em nível de cluster. `VpcConfig` é usada por padrão.
+ No momento, só é possível usar a capacidade sob demanda. Não é possível usar grupos de instâncias com plano de treinamento ou capacidade reservada.
+ Não é possível usar grupos de instâncias com `DeepHealthChecks (DHC)`. Isso ocorre porque uma DHC leva cerca de 60 a 90 minutos para ser concluída e os pods permanecem em estado pendente durante esse período, o que pode causar provisionamento excessivo.

As etapas a seguir mostram como criar uma `NodeClass`.

1. Crie um arquivo YAML (por exemplo, nodeclass.yaml) com sua configuração de `NodeClass`.

1. Aplique a configuração ao cluster usando o kubectl.

1. Faça referência à `NodeClass` em sua configuração de `NodePool`.

1. Veja um exemplo de `NodeClass` que usa os tipos de instância 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. Aplique a configuração:

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

1. Monitore o NodeClass status para garantir que a condição Pronto no status esteja definida como Verdadeira:

   ```
   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>
   ```

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

O `NodePool` define restrições nos nós que podem ser criados pelo Karpenter e nos pods que podem ser executados nesses nós. O `NodePool` pode ser configurado para fazer coisas como:
+ Limitar a criação de nós a determinadas zonas, tipos de instância e arquiteturas de computador.
+ Definir rótulos ou taints para limitar os pods que podem ser executados nos nós que o Karpenter cria.

**nota**  
HyperPod O provedor oferece suporte a um conjunto limitado de requisitos conhecidos do Kubernetes e do Karpenter, explicados abaixo. 

As etapas a seguir mostram como criar uma `NodePool`.

1. Crie um arquivo YAML denominado nodepool.yaml com a configuração de `NodePool` desejada.

1. Você pode usar o exemplo de configuração abaixo.

   Procure `Ready` abaixo de `Conditions` para indicar que todos os recursos dependentes estão funcionando corretamente.

   ```
   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. Aplique o `NodePool` ao seu cluster:

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

1. Monitore o status de `NodePool` para garantir que a condição `Ready` no status esteja definida como `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
   ```

**Etiquetas compatíveis com o HyperPod Karpenter Provider**

Essas são as restrições e os requisitos opcionais que você pode especificar em sua configuração de `NodePool`.


|  Tipo de requisito  |  Finalidade  |   Case/Supported Valores de uso  |  Recomendação  | 
| --- | --- | --- | --- | 
|  Tipos de instância (`node.kubernetes.io/instance-type`)  |  Controla quais tipos de SageMaker instância o Karpenter pode escolher  |  Em vez de se restringir apenas a ml.c5.xlarge, deixe o Karpenter escolher entre todos os tipos disponíveis em seus grupos de instâncias.  |  Deixe isso indefinido ou use o operador Exists para dar ao Karpenter a máxima flexibilidade na escolha de tipos de instância econômicos.  | 
|  Zonas de disponibilidade (`topology.kubernetes.io/zone`)  |  Controla AWS em quais zonas de disponibilidade os nós podem ser criados  |  Nomes de zonas específicos, como us-east-1c. Use quando precisar que os pods sejam executados em zonas específicas por motivos de latência ou conformidade.  | n/a | 
|  Arquitetura (`kubernetes.io/arch`)  |  Especifica a arquitetura da CPU.  |  Somente amd64 (no momento, não é possível usar ARM).  |  n/a  | 

# Implantar uma workload
<a name="sagemaker-hyperpod-eks-autoscaling-workload"></a>

Os exemplos a seguir demonstram como o HyperPod escalonamento automático com o Karpenter provisiona automaticamente os nós em resposta às demandas da carga de trabalho. Estes exemplos mostram o comportamento básico de ajuste de escala e os padrões de distribuição de várias zonas de disponibilidade.

**Implementar uma workload simples**

1. A implantação do Kubernetes a seguir inclui pods que solicitam 1 CPU e 256 MB de memória por réplica ou pod. Nesse cenário, os pods ainda não estão prontos.

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

1. Para testar o processo de aumento da escala vertical, execute o comando a seguir. O Karpenter adicionará novos nós ao cluster.

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

1. Para testar o processo de redução da escala vertical, execute o comando a seguir. O Karpenter removerá nós do cluster.

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

**Implemente uma carga de trabalho em várias AZs**

1. Execute o comando a seguir para implantar uma workload que executa uma implantação do Kubernetes em que os pods na implantação precisam se espalhar uniformemente por diferentes zonas de disponibilidade com uma distorção máxima de 1.

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

1. Execute o seguinte comando para ajustar o número de pods:

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

   O Karpenter adicionará novos nós ao cluster com pelo menos um nó em uma zona de disponibilidade diferente.

Para obter mais exemplos, consulte [exemplos de cargas de trabalho do Karpenter](https://github.com/aws/karpenter-provider-aws/tree/main/examples/workloads) em. GitHub