Executar uma pequena carga de trabalho em lote com GPUs e VMs de início flexível

Autopilot Standard

Visualização — início flexível

Este recurso está sujeito aos Termos das Soluções Pré-GA na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Este guia mostra como otimizar o provisionamento de GPU para cargas de trabalho de treinamento de média e pequena escala usando VMs de início flexível. As VMs de início flexível são criadas usando a opção de consumo de início flexível. Neste guia, você usa VMs de início flexível para implantar uma carga de trabalho que consiste em dois jobs do Kubernetes. Cada job requer uma GPU. O GKE provisiona automaticamente um único nó com duas GPUs A100 para executar os dois jobs.

Se a carga de trabalho exigir processamento distribuído de vários nós, use o início flexível com provisionamento enfileirado. Para mais informações, consulte Executar uma carga de trabalho em grande escala com início flexível com provisionamento enfileirado.

Este guia é destinado a engenheiros de aprendizado de máquina (ML), administradores e operadores de plataforma e especialistas em dados e IA interessados em usar os recursos de orquestração de contêineres do Kubernetes para executar cargas de trabalho em lote. Para mais informações sobre papéis comuns e tarefas de exemplo que nós referenciamos no Google Cloud conteúdo, consulte Papéis e tarefas de usuário comuns do GKE.

Preços de início flexível

O início flexível é recomendado se a carga de trabalho exigir recursos provisionados dinamicamente conforme necessário, por até sete dias com reservas de curto prazo, sem gerenciamento complexo de cotas e acesso econômico. O início flexível é desenvolvido pelo Programador dinâmico de cargas de trabalho e é faturado usando os preços do Programador dinâmico de cargas de trabalho:

• Desconto (até 53%) para vCPUs, GPUs e TPUs.
• Você paga conforme o uso.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

• Ativar a API Google Kubernetes Engine.
Ativar a API Google Kubernetes Engine
• Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da CLI gcloud não sejam compatíveis com a execução dos comandos neste documento.
  Observação: Para instalações prévias da CLI gcloud, defina a compute/region propriedade. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, é possível evitar erros na CLI gcloud como: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

• Verifique se você tem um cluster do Autopilot ou um cluster padrão que esteja executando a versão 1.33.0-gke.1712000 ou mais recente.
• Verifique se você conhece as limitações do início flexível.
• Ao usar um cluster padrão, verifique se você mantém pelo menos um pool de nós sem o início flexível ativado para que o cluster funcione corretamente.
• Verifique se você tem cota para GPUs preemptivas nos locais dos nós.

Se você não tiver um cluster ou se ele não atender aos requisitos, você pode criar um cluster regional padrão usando a CLI gcloud. Adicione as flags a seguir para saber mais sobre o início flexível:

--location=us-central1 \
--node-locations=us-central1-a,us-central1-b \
--machine-type=g2-standard-8

Ao criar um pool de nós de início flexível, use as flags mencionadas anteriormente e --accelerator type=nvidia-l4,count=1.

Se você tiver um cluster Standard que atenda aos requisitos, as próximas seções vão orientar você na seleção de um tipo de acelerador de GPU e tipo de máquina para o cluster.

Escolher um tipo de acelerador de GPU

Se você usar um cluster no modo Autopilot, pule esta seção e acesse a seção Executar uma carga de trabalho em lote.

A disponibilidade da GPU é específica para cada zona. É necessário encontrar um tipo de acelerador de GPU disponível em uma zona em que o cluster padrão esteja. Se você tiver um cluster padrão regional, a zona em que o tipo de acelerador de GPU está disponível precisa estar na região em que o cluster está. Ao criar o pool de nós, especifique o tipo de acelerador e as zonas dos nós. Se você especificar um tipo de acelerador que não está disponível no local do cluster, a criação do pool de nós falhará.

Execute os comandos a seguir para acessar o local do cluster e um tipo de acelerador de GPU compatível.

1. Acesse o local em que o cluster está:

   gcloud container clusters list
   

   O resultado será assim:

   NAME                LOCATION  MASTER_VERSION      MASTER_IP     MACHINE_TYPE  NODE_VERSION        NUM_NODES  STATUS   STACK_TYPE
   example-cluster-1   us-west2  1.33.2-gke.1111000  34.102.3.122  e2-medium     1.33.2-gke.1111000  9          RUNNING  IPV4
   

2. Liste os tipos de aceleradores de GPU disponíveis, excluindo as estações de trabalho virtuais no local:

   gcloud compute accelerator-types list | grep CONTROL_PLANE_LOCATION | grep -v "Workstation"
   

   Substitua CONTROL_PLANE_LOCATION pelo local do cluster.

   Por exemplo, para acessar uma lista de tipos de aceleradores de GPU na região us-west2, execute o seguinte comando:

   gcloud compute accelerator-types list | grep us-west2 | grep -v "Workstation"
   

   O resultado será assim:

   nvidia-b200            us-west2-c                 NVIDIA B200 180GB
   nvidia-tesla-p4        us-west2-c                 NVIDIA Tesla P4
   nvidia-tesla-t4        us-west2-c                 NVIDIA T4
   nvidia-tesla-p4        us-west2-b                 NVIDIA Tesla P4
   nvidia-tesla-t4        us-west2-b                 NVIDIA T4
   

Escolher um tipo de máquina compatível

Se você usar um cluster no modo Autopilot, pule esta seção e acesse a seção Executar uma carga de trabalho em lote.

Depois de saber quais GPUs estão disponíveis no local do cluster, você pode determinar os tipos de máquinas compatíveis. Google Cloud restringe as GPUs a séries de máquinas específicas. Siga estas etapas para encontrar um tipo de máquina:

1. Consulte a tabela de modelos de GPU disponíveis.
2. Localize a linha do tipo de acelerador de GPU escolhido.
3. Consulte a coluna "Série de máquinas" dessa linha. Essa coluna informa qual série de máquinas você precisa usar.
4. Para conferir os nomes tipo de máquina que podem ser especificados, clique no link da série de máquinas.

A única exceção é a série de máquinas N1, que fornece orientações adicionais sobre quais tipos de máquinas N1 podem ser usados com o tipo de acelerador escolhido.

Antes de usar uma máquina otimizada para aceleradores, verifique se ela é compatível com o modo de provisionamento de início flexível, conforme mostrado em Disponibilidade da opção de consumo por tipo de máquina.

Determinar a contagem de aceleradores

Se você usar um cluster no modo Autopilot, pule esta seção e acesse a seção Executar uma carga de trabalho em lote.

Para criar um pool de nós, é necessário determinar o número de aceleradores a serem anexados a cada nó no pool de nós. Os valores válidos dependem do tipo de acelerador e do tipo de máquina. Cada tipo de máquina tem um limite de quantas GPUs podem ser aceitas. Para determinar qual valor usar (além do padrão de 1):

1. Consulte Tipos de máquinas com GPU.
2. Na tabela, pesquise o tipo de acelerador para o tipo de série de máquinas.
3. Use o valor na coluna "Contagem de GPU".

Criar um pool de nós com início flexível

Se você usar um cluster no modo Autopilot, pule esta seção e acesse a seção Executar uma carga de trabalho em lote.

Para criar um pool de nós com o início flexível ativado em um cluster Standard atual, use a CLI gcloud ou o Terraform.

gcloud

1. Criar um pool de nós com início flexível:

   gcloud container node-pools create NODE_POOL_NAME \
       --cluster CLUSTER_NAME \
       --location CONTROL_PLANE_LOCATION \
       --project PROJECT_ID \
       --accelerator type=ACCELERATOR_TYPE,count=COUNT \
       --machine-type MACHINE_TYPE \
       --max-run-duration MAX_RUN_DURATION \
       --flex-start \
       --node-locations NODE_ZONES \
       --num-nodes 0 \
       --enable-autoscaling \
       --total-min-nodes 0 \
       --total-max-nodes 5 \
       --location-policy ANY \
       --reservation-affinity none \
       --no-enable-autorepair \
       --consolidation-delay=CONSOLIDATION_DELAY
   

   Substitua:

   • NODE_POOL_NAME: o nome escolhido para o pool de nós.
   • CLUSTER_NAME: o nome do cluster padrão que você quer modificar.
   • CONTROL_PLANE_LOCATION: a região de computação do plano de controle do cluster.
   • PROJECT_ID: o ID do projeto.
   • ACCELERATOR_TYPE: o tipo específico de acelerador (por exemplo, nvidia-tesla-t4 para NVIDIA T4) a ser anexado às instâncias.
   • COUNT: o número de aceleradores a serem anexados às instâncias. O valor padrão é 1.
   • MACHINE_TYPE: o tipo de máquina a ser usado para nós.
   • MAX_RUN_DURATION: opcional. O tempo de execução máximo de um nó em segundos, até o padrão de sete dias. O número inserido precisa terminar em s. Por exemplo, para especificar um dia, insira 86400s.
   • CONSOLIDATION_DELAY: opcional. A duração que o escalonador automático de cluster espera antes de poder reduzir escala vertical dos nós subutilizados. Use essa configuração para atrasar a redução e manter o pool de nós para reutilização posterior por outros pods. O número inserido precisa terminar em s. Por exemplo, para especificar uma hora, insira 3600s. Disponível na versão 1.34.1-gke.2364000 e mais recente do GKE.
   • NODE_ZONES: uma lista separada por vírgulas de uma ou mais zonas em que o GKE cria o pool de nós.

   Nesse comando, a flag --flex-start instrui gcloud a criar um pool de nós com VMs de início flexível.

   O GKE cria um pool de nós com nós que contêm duas instâncias do tipo de acelerador especificado. Inicialmente, o pool de nós não tem nós, e o escalonamento automático está ativado.

Terraform

É possível usar o início flexível com GPUs usando um módulo do Terraform.

1. Adicione o seguinte bloco à configuração do Terraform:

resource "google_container_node_pool" " "gpu_dws_pool" {
name = "gpu-dws-pool"

queued_provisioning {
    enabled = false
}

}
node_config {
    machine_type = "MACHINE_TYPE"
    accelerator_type = "ACCELERATOR_TYPE"
    accelerator_count = COUNT
    node_locations = ["NODE_ZONES"]
    flex_start = true
}

Substitua:

• MACHINE_TYPE: o tipo de máquina a ser usado para nós.
• ACCELERATOR_TYPE: o tipo específico de acelerador (por exemplo, nvidia-tesla-t4 para NVIDIA T4) a ser anexado às instâncias.
• COUNT: o número de aceleradores a serem anexados a instâncias. O valor padrão é 1.
• NODE_ZONES: a lista separada por vírgulas de uma ou mais zonas em que o GKE cria o pool de nós.

O Terraform chama Google Cloud APIs para criar um cluster com um pool de nós que usa VMs de início flexível com GPUs. Inicialmente, o pool de nós não tem nós, e o escalonamento automático está ativado. Para saber mais sobre o Terraform, consulte as google_container_node_pool especificações de recursos em terraform.io.

Verificar o status do início flexível no pool de nós

Execute este comando:

gcloud container node-pools describe NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --location CONTROL_PLANE_LOCATION \
    --format="get(config.flexStart)"

Se o início flexível estiver ativado no pool de nós, o campo flexStart será definido como True.

Executar uma carga de trabalho em lote

Nesta seção, você vai criar dois jobs do Kubernetes que exigem uma GPU cada. Um controlador de jobs no Kubernetes cria um ou mais pods e ajuda a garantir que eles executem uma tarefa específica.

1. No Google Cloud console, inicie uma sessão do Cloud Shell clicando em Ativar o Cloud Shell. Uma sessão será aberta no painel inferior do Google Cloud console.

2. Crie um arquivo chamado dws-flex-start.yaml:

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: job-1
   spec:
     template:
       spec:
         nodeSelector:
           cloud.google.com/gke-flex-start: "true"
           cloud.google.com/gke-accelerator: ACCELERATOR_TYPE
         containers:
         - name: container-1
           image: gcr.io/k8s-staging-perf-tests/sleep:latest
           args: ["10s"] # Sleep for 10 seconds
           resources:
             requests:
                 nvidia.com/gpu: 1
             limits:
                 nvidia.com/gpu: 1
         restartPolicy: OnFailure
   ---
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: job-2
   spec:
     template:
       spec:
         nodeSelector:
           cloud.google.com/gke-flex-start: "true"
           cloud.google.com/gke-accelerator: ACCELERATOR_TYPE
         containers:
         - name: container-2
           image: gcr.io/k8s-staging-perf-tests/sleep:latest
           args: ["10s"] # Sleep for 10 seconds
           resources:
             requests:
                 nvidia.com/gpu: 1
             limits:
                 nvidia.com/gpu: 1
         restartPolicy: OnFailure
   

3. Aplique o manifesto dws-flex-start.yaml:

   kubectl apply -f dws-flex-start.yaml
   

4. Verifique se os jobs estão em execução no mesmo nó:

   kubectl get pods -l "job-name in (job-1,job-2)" -o wide
   

   O resultado será assim:

   NAME    READY   STATUS      RESTARTS   AGE   IP       NODE               NOMINATED NODE   READINESS GATES
   job-1   0/1     Completed   0          19m   10.(...) gke-flex-zonal-a2  <none>           <none>
   job-2   0/1     Completed   0          19m   10.(...) gke-flex-zonal-a2  <none>           <none>
   

Sucesso: você implantou dois jobs no mesmo nó usando VMs de início flexível. O GKE implantou dois jobs em uma VM flex-start recém-provisionada.

Limpar

Para evitar cobranças na sua Google Cloud conta do pelos recursos usados nesta página, exclua o projeto que contém os recursos ou mantenha o projeto e exclua os recursos individuais.

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:
• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um appspot.com URL, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.
1. No Google Cloud console, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
3. Na caixa de diálogo, digite o ID do projeto e clique em Desligar para excluir o projeto.

Excluir o recurso individual

1. Exclua os jobs:

   kubectl delete job -l "job-name in (job-1,job-2)"
   

2. Exclua o pool de nós:

   gcloud container node-pools delete NODE_POOL_NAME \
         --location CONTROL_PLANE_LOCATION
   

3. Exclua o cluster:

   gcloud container clusters delete CLUSTER_NAME
   

A seguir

• Saiba mais sobre GPUs no GKE.
• Saiba mais sobre provisionamento automático de nós.
• Saiba mais sobre as práticas recomendadas para executar cargas de trabalho em lote no GKE.