O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Gerenciar cargas de trabalho de contêineres de GPU

Compartilhado Padrão

É possível ativar e gerenciar recursos de unidade de processamento gráfico (GPU) nos contêineres. Por exemplo, talvez você prefira executar notebooks de inteligência artificial (IA) e machine learning (ML) em um ambiente de GPU. Para executar cargas de trabalho de contêiner de GPU, é necessário ter um cluster do Kubernetes que ofereça suporte a dispositivos de GPU. O suporte a GPU é ativado por padrão para clusters do Kubernetes que têm máquinas de GPU provisionadas.

Este documento é destinado a desenvolvedores de aplicativos no grupo de operadores de aplicativos responsáveis por criar cargas de trabalho de aplicativos para a organização. Para mais informações, consulte Públicos-alvo da documentação do GDC com isolamento físico.

Antes de começar

Para concluir as tarefas neste documento, solicite as permissões necessárias e prepare seu ambiente.

Solicitar papéis do IAM

É necessário ter papéis específicos para receber as permissões necessárias para implantar GPUs nos contêineres. Os papéis necessários dependem de você estar trabalhando em um cluster compartilhado com escopo da organização ou em um cluster padrão com escopo do projeto. Para mais informações, consulte Configurações de cluster do Kubernetes .

Papéis de cluster compartilhado

Para verificar pools de nós com suporte a GPU e implantar cargas de trabalho de GPU em um cluster compartilhado, solicite os seguintes papéis com base na tarefa a ser realizada:

Administrador do cluster de usuário (user-cluster-admin): cria, exclui, edita ou visualiza os recursos de um cluster compartilhado hospedado no servidor da API de gerenciamento. Esse papel permite verificar as GPUs no cluster compartilhado e não está vinculado ao namespace do projeto.
Administrador do namespace (namespace-admin): cria, exclui, edita ou visualiza os recursos de um cluster compartilhado hospedado no projeto. Esse papel permite implantar cargas de trabalho de GPU em um cluster padrão e está vinculado ao namespace do projeto.

Papéis de cluster padrão

Para verificar pools de nós com suporte a GPU e implantar cargas de trabalho de GPU em um cluster padrão, peça ao administrador do IAM do projeto para conceder os seguintes papéis:

Administrador do cluster padrão (standard-cluster-admin): cria, exclui, edita ou visualiza os recursos de um cluster padrão hospedado no servidor da API de gerenciamento. Esse papel permite verificar as GPUs no cluster compartilhado e está vinculado ao namespace do projeto.
Desenvolvedor de cluster (cluster-developer): cria, exclui, edita ou visualiza um cluster padrão. Esse papel permite implantar cargas de trabalho de GPU em um cluster padrão, fornecendo acesso às APIs do plano de dados hospedadas no cluster padrão. Esse papel está vinculado ao namespace do projeto.

Preparar o ambiente

Para configurar um contêiner para usar recursos de GPU, verifique se você tem os seguintes recursos:

Um cluster do Kubernetes com uma classe de máquina de GPU. Para mais informações, consulte a seção de placas de GPU com suporte.
Localize o nome do cluster do Kubernetes ou pergunte a um membro do grupo de administradores da plataforma qual é o nome do cluster.
Faça login e gere o arquivo kubeconfig do cluster do Kubernetes.
Use o caminho kubeconfig do cluster do Kubernetes para substituir KUBERNETES_CLUSTER_KUBECONFIG nestas instruções.
Faça login e gere o arquivo kubeconfig do servidor da API de gerenciamento zonal que hospeda o cluster do Kubernetes. Use esse caminho para substituir MANAGEMENT_API_SERVER nestas instruções.
Faça login e gere o arquivo kubeconfig do cluster de infraestrutura da organização na zona destinada a hospedar suas GPUs.

Configurar um contêiner para usar recursos de GPU

Para usar essas GPUs em um contêiner, siga estas etapas:

Verifique se o cluster do Kubernetes tem pools de nós que oferecem suporte a GPUs:
```
kubectl describe clusters.cluster.gdc.goog/KUBERNETES_CLUSTER_NAME \
    -n KUBERNETES_CLUSTER_NAMESPACE \
    --kubeconfig MANAGEMENT_API_SERVER
```
Substitua:
- KUBERNETES_CLUSTER_NAME: o nome do cluster.
- KUBERNETES_CLUSTER_NAMESPACE: o namespace do cluster. Para clusters compartilhados, use o namespace platform. Para clusters padrão, use o namespace do projeto do cluster.
- MANAGEMENT_API_SERVER: o caminho kubeconfig do servidor da API zonal em que o cluster do Kubernetes está hospedado. Se você ainda não gerou um arquivo kubeconfig para o servidor da API na sua zona de destino, consulte Fazer login.
A saída relevante é semelhante ao snippet a seguir:
```
# Several lines of code are omitted here.
spec:
  nodePools:
  - machineTypeName: a2-ultragpu-1g-gdc
    nodeCount: 2
# Several lines of code are omitted here.
```
Para uma lista completa de tipos de máquina de GPU com suporte e perfis de GPU de várias instâncias (MIG) , consulte Tipos de máquina de nó de cluster.
Adicione os campos .containers.resources.requests e .containers.resources.limits à especificação do contêiner. Cada nome de recurso é diferente, dependendo da classe da máquina. Verifique a alocação de recursos de GPU para encontrar os nomes dos recursos de GPU.

Por exemplo, a especificação de contêiner a seguir solicita três partições de uma GPU de um nó a2-ultragpu-1g-gdc:
```
 # Several lines of code are omitted here.
 containers:
 - name: my-container
   image: "my-image"
   resources:
     requests:
       nvidia.com/mig-1g.10gb-NVIDIA_A100_80GB_PCIE: 3
     limits:
       nvidia.com/mig-1g.10gb-NVIDIA_A100_80GB_PCIE: 3
 # Several lines of code are omitted here.
```
Observação: é possível solicitar no máximo sete partições de GPU por pod.
Os contêineres também exigem permissões adicionais para acessar GPUs. Para cada contêiner que solicita GPUs, adicione as seguintes permissões à especificação do contêiner:
```
# Several lines of code are omitted here.
securityContext:
 seLinuxOptions:
   type: unconfined_t
# Several lines of code are omitted here.
```
Aplique o arquivo de manifesto do contêiner:
```
kubectl apply -f CONTAINER_MANIFEST_FILE \
    -n KUBERNETES_CLUSTER_NAMESPACE \
    --kubeconfig KUBERNETES_CLUSTER_KUBECONFIG
```
Substitua:
- CONTAINER_MANIFEST_FILE: o arquivo de manifesto YAML para a carga de trabalho do contêiner.
- KUBERNETES_CLUSTER_NAMESPACE: o namespace do cluster. Para clusters compartilhados, use o namespace platform. Para clusters padrão, use o namespace do projeto do cluster.
- KUBERNETES_CLUSTER_KUBECONFIG: o caminho kubeconfig do cluster.

Verificar a alocação de recursos de GPU

Para verificar a alocação de recursos de GPU, use o seguinte comando:

kubectl describe nodes NODE_NAME --kubeconfig KUBERNETES_CLUSTER_KUBECONFIG

Substitua:

NODE_NAME: o nó que gerencia as GPUs que você quer inspecionar.
KUBERNETES_CLUSTER_KUBECONFIG: o caminho kubeconfig do cluster.

A saída relevante é semelhante ao snippet a seguir:

# Several lines of code are omitted here.
Capacity:
  nvidia.com/mig-1g.10gb-NVIDIA_A100_80GB_PCIE: 7
Allocatable:
  nvidia.com/mig-1g.10gb-NVIDIA_A100_80GB_PCIE: 7
# Several lines of code are omitted here.

Anote os nomes dos recursos das GPUs. É necessário especificá-los ao configurar um contêiner para usar recursos de GPU.