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á.

# Configurando partições de GPU na Amazon SageMaker HyperPod
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup"></a>

**Topics**
+ [Pré-requisitos](#sagemaker-hyperpod-eks-gpu-partitioning-setup-prerequisites)
+ [Criando um cluster com configuração MIG](#sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster)
+ [Adicionar um operador de GPU a um cluster existente](#sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator)
+ [Atualizando a configuração MIG](#sagemaker-hyperpod-eks-gpu-partitioning-setup-update)
+ [Verificando a configuração do MIG](#sagemaker-hyperpod-eks-gpu-partitioning-setup-verify)
+ [Comandos comuns para depuração da configuração MIG](#sagemaker-hyperpod-eks-gpu-partitioning-setup-debug-commands)
+ [Usando o SageMaker AI Console](#sagemaker-hyperpod-eks-gpu-partitioning-setup-console)

## Pré-requisitos
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-prerequisites"></a>
+ HyperPod Cluster Amazon EKS com instâncias de GPU compatíveis
+ Operador de GPU NVIDIA instalado
+ Permissões apropriadas do IAM para gerenciamento de clusters

## Criando um cluster com configuração MIG
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster"></a>

### Usando AWS CLI
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster-cli"></a>

```
aws sagemaker create-cluster \
  --cluster-name my-mig-cluster \
  --orchestrator 'Eks={ClusterArn=arn:aws:eks:{{region}}:{{account}}:cluster/{{cluster-name}}}' \
  --instance-groups '{
    "InstanceGroupName": "gpu-group",
    "InstanceType": "ml.p4d.24xlarge",
    "InstanceCount": 1,
    "LifeCycleConfig": {
       "SourceS3Uri": "s3://{{my-bucket}}",
       "OnCreate": "on_create_script.sh"
    },
    "KubernetesConfig": {
       "Labels": {
          "nvidia.com/mig.config": "all-1g.5gb"
       }
    },
    "ExecutionRole": "arn:aws:iam::{{account}}:role/{{execution-role}}",
    "ThreadsPerCore": 1
  }' \
  --vpc-config '{
     "SecurityGroupIds": ["{{sg-12345}}"],
     "Subnets": ["{{subnet-12345}}"]
  }' \
  --node-provisioning-mode Continuous
```

### Usando CloudFormation
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-create-cluster-cfn"></a>

```
{
  "ClusterName": "my-mig-cluster",
  "InstanceGroups": [
    {
      "InstanceGroupName": "gpu-group",
      "InstanceType": "ml.p4d.24xlarge",
      "InstanceCount": 1,
      "KubernetesConfig": {
        "Labels": {
          "nvidia.com/mig.config": "all-2g.10gb"
        }
      },
      "ExecutionRole": "arn:aws:iam::{{account}}:role/{{execution-role}}"
    }
  ],
  "Orchestrator": {
    "Eks": {
      "ClusterArn": "arn:aws:eks:{{region}}:{{account}}:cluster/{{cluster-name}}"
    }
  },
  "NodeProvisioningMode": "Continuous"
}
```

## Adicionar um operador de GPU a um cluster existente
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator"></a>

### Instalar o operador de GPU
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-install"></a>

`{$AWS_REGION}`Substitua pela região do seu cluster (por exemplo, us-east-1, us-west-2).

```
helm install gpuo helm_chart/HyperPodHelmChart/charts/gpu-operator \
-f helm_chart/HyperPodHelmChart/charts/gpu-operator/regional-values/values-{$AWS_REGION}.yaml \
-n kube-system
```

### Verifique a instalação (aguarde de 2 a 3 minutos)
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-verify"></a>

Verifique se todos os pods de operadores de GPU estão em execução:

```
kubectl get pods -n kube-system | grep -E "(gpu-operator|nvidia-)"
```

**Cápsulas esperadas:**
+ gpu-operator-\* - 1 instância (controlador de cluster)
+ nvidia-device-plugin-daemonset-\* - 1 por nó da GPU (todas as instâncias da GPU)
+ nvidia-mig-manager-\* - 1 por nó compatível com MIG (A100/H100)

### Remover plug-in de dispositivo antigo
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-remove"></a>

Desative o existente nvidia-device-plugin:

```
helm upgrade dependencies helm_chart/HyperPodHelmChart \
--set nvidia-device-plugin.devicePlugin.enabled=false \
-n kube-system
```

### Verifique os recursos da GPU
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-add-operator-verify-gpu"></a>

Confirme se os nós mostram a capacidade da GPU. Ele deve exibir: nvidia.com/gpu: 8 (ou sua contagem real de GPU).

```
kubectl describe nodes | grep "nvidia.com/gpu"
```

## Atualizando a configuração MIG
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update"></a>

**Preparando os nós antes das atualizações do MIG**  
Antes de atualizar as configurações do MIG no seu grupo de instâncias, você deve preparar os nós para evitar a interrupção da carga de trabalho. Siga estas etapas para drenar com segurança as cargas de trabalho dos nós que serão reconfigurados.

### Etapa 1: identificar nós no grupo de instâncias
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-identify"></a>

Primeiro, identifique todos os nós que pertencem ao grupo de instâncias que você quer atualizar:

```
# List all nodes in the instance group
kubectl get nodes -l sagemaker.amazonaws.com/instance-group-name={{INSTANCE_GROUP_NAME}}

# Example:
kubectl get nodes -l sagemaker.amazonaws.com/instance-group-name=p4d-group
```

Esse comando retorna uma lista de todos os nós no grupo de instâncias especificado. Anote o nome de cada nó para as etapas a seguir.

### Etapa 2: isolar e drenar cada nó
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-drain"></a>

Para cada nó identificado na Etapa 1, execute as seguintes ações:

#### Cordon, o Nodo
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-drain-cordon"></a>

O isolamento impede que novos pods sejam programados no nó:

```
# Cordon a single node
kubectl cordon {{NODE_NAME}}

# Example:
kubectl cordon hyperpod-i-014a41a7001adca60
```

#### Drene os pods de carga de trabalho do Node
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-drain-evict"></a>

Drene o nó para despejar todos os módulos de carga de trabalho e, ao mesmo tempo, preservar os módulos do sistema:

```
# Drain the node (ignore DaemonSets and evict pods)
kubectl drain {{NODE_NAME}} \
  --ignore-daemonsets \
  --delete-emptydir-data \
  --force \
  --grace-period=300

# Example:
kubectl drain hyperpod-i-014a41a7001adca60 \
  --ignore-daemonsets \
  --delete-emptydir-data \
  --force \
  --grace-period=300
```

**Explicação das opções de comando:**
+ `--ignore-daemonsets`- Permite que a operação de drenagem continue mesmo se houver DaemonSet cápsulas
+ `--delete-emptydir-data`- Exclui pods usando volumes emptyDir (necessários para que a drenagem seja bem-sucedida)
+ `--force`- Força a exclusão de pods não gerenciados por um controlador (use com cuidado)
+ `--grace-period=300`- Dá 5 minutos para que os pods terminem graciosamente

**Importante**  
A operação de drenagem pode levar vários minutos, dependendo do número de cápsulas e de seus períodos de carência de término.
Os pods do sistema nos seguintes namespaces permanecerão em execução:`kube-system`,,`cert-manager`,`kubeflow`,`hyperpod-inference-system`,`kube-public`,`mpi-operator`,,`gpu-operator`, `aws-hyperpod``jupyter-k8s-system`, e `hyperpod-observability` `kueue-system` `keda`
DaemonSet os pods permanecerão no nó (eles são ignorados pelo design)

### Etapa 3: Verificar se não há pods de carga de trabalho em execução
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-verify"></a>

Depois de drenar, verifique se nenhum pod de carga de trabalho permanece nos nós (excluindo namespaces do sistema):

```
# Check for any remaining pods outside system namespaces
kubectl get pods --all-namespaces --field-selector spec.nodeName={{NODE_NAME}} \
  | grep -v "kube-system" \
  | grep -v "cert-manager" \
  | grep -v "kubeflow" \
  | grep -v "hyperpod-inference-system" \
  | grep -v "kube-public" \
  | grep -v "mpi-operator" \
  | grep -v "gpu-operator" \
  | grep -v "aws-hyperpod" \
  | grep -v "jupyter-k8s-system" \
  | grep -v "hyperpod-observability" \
  | grep -v "kueue-system" \
  | grep -v "keda"

# Example:
kubectl get pods --all-namespaces --field-selector spec.nodeName=hyperpod-i-014a41a7001adca60 \
  | grep -v "kube-system" \
  | grep -v "cert-manager" \
  | grep -v "kubeflow" \
  | grep -v "hyperpod-inference-system" \
  | grep -v "kube-public" \
  | grep -v "mpi-operator" \
  | grep -v "gpu-operator" \
  | grep -v "aws-hyperpod" \
  | grep -v "jupyter-k8s-system" \
  | grep -v "hyperpod-observability" \
  | grep -v "kueue-system" \
  | grep -v "keda"
```

**Saída esperada:** se o nó for drenado adequadamente, esse comando não deverá retornar nenhum resultado (ou mostrar apenas a linha do cabeçalho). Se algum pod ainda estiver funcionando, investigue por que ele não foi despejado e exclua-o manualmente, se necessário.

### Etapa 4: Verificar o status de prontidão do nó
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-readiness"></a>

Antes de prosseguir com a atualização do MIG, confirme se todos os nós estão isolados:

```
# Check node status - should show "SchedulingDisabled"
kubectl get nodes -l sagemaker.amazonaws.com/instance-group-name={{INSTANCE_GROUP_NAME}}
```

Os nós devem aparecer `SchedulingDisabled` na coluna STATUS, indicando que estão isolados e prontos para a atualização do MIG.

### Atualizar o perfil MIG no cluster existente
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-update-change"></a>

Você pode alterar os perfis MIG em clusters existentes:

```
aws sagemaker update-cluster \
  --cluster-name my-mig-cluster \
  --instance-groups '{
    "InstanceGroupName": "gpu-group",
    "InstanceType": "ml.p4d.24xlarge",
    "InstanceCount": 1,
    "KubernetesConfig": {
       "Labels": {
          "nvidia.com/mig.config": "all-3g.20gb"
       }
    },
    "ExecutionRole": "arn:aws:iam::{{account}}:role/{{execution-role}}"
  }'
```

**nota**  
Se os trabalhos já estiverem sendo executados em um nó, o particionamento MIG falhará. O usuário receberá uma mensagem de erro para drenar os nós antes de tentar novamente o particionamento MIG.

## Verificando a configuração do MIG
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-verify"></a>

Após a criação ou atualização do cluster, verifique a configuração do MIG:

```
# Update kubeconfig
aws eks update-kubeconfig --name {{your-eks-cluster}} --region {{us-east-2}}

# Check MIG labels
kubectl get node {{NODE_NAME}} -o=jsonpath='{.metadata.labels}' | grep mig

# Check available MIG resources
kubectl describe node {{NODE_NAME}} | grep -A 10 "Allocatable:"
```

## Comandos comuns para depuração da configuração MIG
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-debug-commands"></a>

Use os comandos a seguir para solucionar problemas e validar a configuração do MIG em seu cluster:

```
# Check GPU Operator status
kubectl get pods -n gpu-operator-resources

# View MIG configuration
kubectl exec -n gpu-operator-resources nvidia-driver-XXXXX -- nvidia-smi mig -lgi

# Check device plugin configuration
kubectl logs -n gpu-operator-resources nvidia-device-plugin-XXXXX

# Monitor node events
kubectl get events --field-selector involvedObject.name={{NODE_NAME}}
```

**nota**  
`nvidia-device-plugin-XXXXX`Substitua `nvidia-driver-XXXXX` e pelos nomes reais dos pods do seu cluster e `NODE_NAME` pelo nome do seu nó.

## Usando o SageMaker AI Console
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-console"></a>

### Criando um novo cluster com o MIG
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-console-create"></a>

1. Navegue até **Amazon SageMaker AI** > **HyperPod Clusters** > **Gerenciamento de clusters** > **Criar HyperPod cluster**

1. Selecione **Orchestrated by EKS**

1. Escolha **Configuração personalizada** e verifique se o **operador de GPU** está ativado por padrão

1. Na seção **Grupos de instâncias**, clique em **Adicionar grupo**

1. Configure o grupo de instâncias e navegue até **Configuração avançada** para ativar a opção **Usar partição GPU** e escolha a configuração **MIG desejada no menu suspenso**.

1. Clique em **Adicionar grupo de instâncias** e conclua a configuração restante do cluster.

1. Clique em **Enviar** para criar o cluster

### Atualizando a configuração MIG em um cluster existente
<a name="sagemaker-hyperpod-eks-gpu-partitioning-setup-console-update"></a>

1. Navegue até **Amazon SageMaker AI** > **HyperPod Clusters** > **Gerenciamento de clusters**

1. Selecione seu cluster existente e clique em **Editar** no grupo de instâncias que você deseja modificar

1. Em **Configuração avançada**, alterne **Usar partição GPU** se ainda não estiver habilitado e selecione uma configuração **MIG** diferente no menu suspenso

1. Clique em **Salvar alterações**