Implantar o Ray acelerado por GPU para cargas de trabalho de IA no GKE

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the GKE API.

   Enable the API

4. Install the Google Cloud CLI.

5. Configure a CLI gcloud para usar sua identidade federada.

   Para mais informações, consulte Fazer login na gcloud CLI com sua identidade federada.

6. Para inicializar a CLI gcloud, execute o seguinte comando:

   gcloud init

7. Instale kubectl: kubectl é a principal ferramenta de linha de comando para interagir com clusters do GKE. Se você usa o Cloud Shell, o kubectl já está instalado. Caso contrário, instale no terminal executando o comando gcloud components install kubectl.

   Para verificar a instalação, execute este comando: kubectl version --client

8. Instale o Ray: recomendamos que você crie e acesse um ambiente virtual Python (venv) antes de instalar o Ray para isolar as dependências dele.
   1. Instale o Python.
   2. Crie e ative um novo ambiente virtual.
   3. Instale a versão estável mais recente do Ray executando este comando no seu ambiente virtual: pip install -U "ray[default]".
   4. Para verificar a instalação, execute este comando: ray --version. Observe a versão do Ray (por exemplo, 2.44.1) na saída.
9. Verifique se o projeto Google Cloud tem cota suficiente para GPUs L4. Para mais informações, consulte Sobre GPUs e Cotas de alocação.

Criar um cluster do GKE

É possível implantar sua carga de trabalho em um cluster do GKE Autopilot ou Standard. Recomendamos que você use um cluster do Autopilot para ter uma experiência totalmente gerenciada do Kubernetes. Para escolher o modo de operação do GKE mais adequado para suas cargas de trabalho, consulte Escolher um modo de operação do GKE.

Piloto automático

No modo Autopilot, o Google gerencia a configuração do cluster, incluindo escalonamento, segurança e outras configurações pré-configuradas. Os clusters do Autopilot são otimizados para executar a maioria das cargas de trabalho de produção e provisionar recursos de computação com base nos manifestos do Kubernetes.

1. No terminal, execute o seguinte comando gcloud container clusters create-auto:

   gcloud container clusters create-auto my-ray-enabled-cluster \
       --enable-ray-operator \
       --enable-ray-cluster-monitoring \
       --enable-ray-cluster-logging \
       --location=us-central1
   

   Esse comando da Google Cloud CLI cria um cluster do Autopilot chamado my-ray-enabled-cluster com estas configurações:

   • --enable-ray-operator: instala o operador do Ray no cluster, o que simplifica o gerenciamento de clusters do Ray no Kubernetes.
   • --enable-ray-cluster-monitoring: configura a integração com o Cloud Monitoring para métricas de cluster do Ray.
   • --enable-ray-cluster-logging: configura a integração com o Cloud Logging para coletar registros do seu cluster do Ray.
   • --location=us-central1: especifica a região geográfica em que o cluster do GKE será criado. A disponibilidade e os tipos de aceleradores variam de acordo com o local. Para mais informações, consulte Regiões e zonas de GPU.

   Os clusters do Autopilot provisionam e escalonam nós automaticamente (incluindo aqueles habilitados para GPU que usam classes de computação) com base nas demandas de carga de trabalho, otimizando a utilização e o custo. Esse provisionamento e escalonamento automáticos de recursos em clusters do Autopilot simplificam o gerenciamento de recursos e permitem que você se concentre nos seus modelos em vez da infraestrutura.

   Se você usa um cluster GKE Standard, as flags e as configurações para ativar o Ray podem ser diferentes. Para mais informações, consulte Ativar o operador Ray no GKE.

2. Configure kubectl para se comunicar com o cluster:

   gcloud container clusters get-credentials my-ray-enabled-cluster \
       --region=us-central1
   

Padrão

No modo padrão, você tem mais controle sobre a infraestrutura subjacente do cluster do GKE. Você gerencia pools de nós, tamanhos de nós e outras configurações diretamente, permitindo maior personalização. Os clusters padrão são adequados para cargas de trabalho que precisam de configurações específicas ou controle rígido sobre os recursos.

1. No terminal, execute o seguinte comando gcloud container clusters create:

   gcloud container clusters create my-ray-enabled-cluster \
       --addons=RayOperator \
       --enable-ray-cluster-monitoring \
       --enable-ray-cluster-logging \
       --region=us-central1 \
       --enable-autoprovisioning \
       --max-cpu=10 \
       --max-memory=64
   

   Esse comando da CLI do Google Cloud cria um cluster Standard chamado my-ray-enabled-cluster, com estas configurações:

   • --addons=RayOperator: instala o operador do Ray no cluster, o que simplifica o gerenciamento de clusters do Ray no Kubernetes.
   • --enable-ray-cluster-monitoring: configura a integração com o Cloud Monitoring para métricas de cluster do Ray.
   • --enable-ray-cluster-logging: configura a integração com o Cloud Logging para coletar registros do seu cluster do Ray.
   • --region=us-central1: especifica a região geográfica em que o cluster do GKE será criado. A disponibilidade e os tipos de aceleradores variam de acordo com o local. Para mais informações, consulte Regiões e zonas de GPU.
   • --enable-autoprovisioning: cria e exclui automaticamente pools de nós e escalona nós nesses pools com base nas demandas da carga de trabalho.
   • --max-cpu: número máximo de núcleos para os quais o cluster pode ser escalonado.
   • --max-memory: número máximo de gigabytes de memória para que o cluster possa ser escalonado.

2. Configure kubectl para se comunicar com o cluster:

   gcloud container clusters get-credentials my-ray-enabled-cluster \
       --region=us-central1
   

Instale o plug-in kubectl ray do KubeRay.

O plug-in kubectl ray simplifica fluxos de trabalho comuns do Ray no Kubernetes. Para as instruções de instalação mais recentes, consulte a documentação do KubeRay.

1. Acesse a página de lançamentos e faça o download do binário para sua plataforma. Por exemplo, para instalar a versão 1.3.2 do plug-in kubectl ray no Linux amd64, execute os seguintes comandos:

   curl -LO https://github.com/ray-project/kuberay/releases/download/v1.3.2/kubectl-ray_v1.3.2_linux_amd64.tar.gz
   tar -xvf kubectl-ray_v1.3.2_linux_amd64.tar.gz
   cp kubectl-ray ~/.local/bin
   

   Substitua ~/.local/bin pelo diretório no seu PATH.

2. Verifique a instalação:

   kubectl ray version
   

   Se você vir um aviso como KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace., ignore-o. Se a instalação for bem-sucedida, a saída será a versão do plug-in kubectl ray.

Criar a classe de computação personalizada no cluster

Uma classe de computação personalizada no GKE permite definir requisitos de hardware específicos, como o tipo e a contagem de GPUs, por prioridade. O GKE usa essa prioridade ao provisionar nós para suas cargas de trabalho.

Para criar a classe de computação personalizada de exemplo para este guia, siga estas etapas:

1. Salve a seguinte especificação de classe de computação como nvidia-l4-compute-class.yaml:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: gpu-compute-class
   spec:
     priorities:
     - gpu:
         type: nvidia-l4
         count: 1
       spot: true
     - gpu:
         type: nvidia-l4
         count: 1
       spot: false
     nodePoolAutoCreation:
       enabled: true
     whenUnsatisfiable: DoNotScaleUp
   

2. Crie a classe de computação executando este comando:

   kubectl apply -f nvidia-l4-compute-class.yaml
   

   O que acontece depois que você aplica a classe de computação personalizada? Depois de aplicar o arquivo YAML da classe de computação, o GKE vai provisionar automaticamente nós com uma GPU NVIDIA L4 quando o cluster do Ray solicitar. Ele vai priorizar as VMs do Spot conforme definido no manifesto. A configuração whenUnsatisfiable: DoNotScaleUp instrui o GKE a não criar nós que não atendam aos requisitos especificados.

Criar e verificar o cluster do Ray

Agora você pode criar seu cluster do Ray no cluster do GKE.

1. Crie o cluster do Ray. Use o comando kubectl ray create cluster para definir e criar seu cluster do Ray. Esse comando simplifica o processo ao lidar com a criação de recursos do Kubernetes.

     kubectl ray create cluster my-ray-cluster \
         --worker-replicas=1 \
         --worker-cpu=2 \
         --worker-memory=4Gi \
         --worker-gpu=1 \
         --worker-node-selectors="cloud.google.com/compute-class=gpu-compute-class"
   

   O comando kubectl ray create cluster usa o plug-in KubeRay para traduzir suas especificações em uma definição de recurso personalizado RayCluster e a envia para a API Kubernetes para criar o objeto RayCluster. Esse objeto funciona como um modelo, informando ao operador Ray como provisionar e gerenciar os componentes reais do cluster do Ray (nós principais e de worker) no GKE. Por padrão, o GKE programa o pod principal em um nó da série de máquinas E2.

   O comando de exemplo usa estas configurações:

   • kubectl ray create cluster my-ray-cluster: especifica o nome do cluster do Ray que você quer criar.
   • --worker-node-selectors: informa ao Kubernetes para programar pods de trabalho em nós rotulados com cloud.google.com/compute-class=gpu-compute-class.

2. Verifique o status do cluster do Ray. Use estes comandos para verificar se o cluster do Ray está em execução.

   • Verifique o recurso RayCluster executando este comando:

     kubectl ray get cluster
     

     Esse comando lista todos os clusters do Ray no seu namespace do Kubernetes. Você vai ver my-ray-cluster listado. A inicialização do cluster pode levar alguns minutos.

   • Execute este comando para verificar os pods do Kubernetes:

     kubectl get pods
     

     Esse comando lista todos os pods em execução no namespace do Kubernetes. Você vai encontrar pods relacionados ao cluster do Ray:

     • Um pod para o nó principal do Ray, com um nome como my-ray-cluster-head-0.
     • Um ou mais pods para os nós de trabalho do Ray, com nomes como my-ray-cluster-worker-group-0-xxxxx. O número de pods de worker depende da configuração inicial do cluster do Ray e de qualquer escalonamento automático que possa ter ocorrido.

Enviar um job do Ray

Depois que o cluster do Ray estiver pronto, envie um job do Ray para o cluster do Ray em execução no GKE.

Para fazer isso, use o comando kubectl ray session para iniciar uma sessão interativa e o comando ray job submit para iniciar a execução do job.

1. Inicie uma sessão interativa do Ray. Para estabelecer uma conexão local com o cluster do Ray, execute este comando:

     kubectl ray session my-ray-cluster
   

   Esse comando inicia o encaminhamento de porta entre a máquina local e o nó principal do Ray no cluster do GKE. Observe que o terminal vai ficar ocupado enquanto essa sessão estiver ativa. Para continuar, abra uma instância de terminal separada.

2. Crie o exemplo de código para executar. Salve o código de exemplo a seguir em um arquivo chamado sample_code.py.

     import ray
     import os
     import requests
   
     ray.init()
   
     @ray.remote
     class Counter:
         def __init__(self):
             # Used to verify runtimeEnv
             self.name = os.getenv("counter_name")
             assert self.name == "test_counter"
             self.counter = 0
   
         def inc(self):
             self.counter += 1
   
         def get_counter(self):
             return "{} got {}".format(self.name, self.counter)
   
     counter = Counter.remote()
   
     for _ in range(5):
             ray.get(counter.inc.remote())
             print(ray.get(counter.get_counter.remote()))
   
     # Verify that the correct runtime env was used for the job.
     assert requests.__version__ == "2.26.0"
   

3. Abra um novo terminal e envie o job do Ray.

   1. Abra um novo terminal na máquina local. Se você criou um ambiente virtual para a instalação do Ray, ative-o também neste novo terminal.
   2. Navegue até o diretório em que você salvou o arquivo sample_code.py.

   3. Execute este comando:

        ray job submit \
            --working-dir=. \
            --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}' \
            --address http://localhost:8265 python sample_code.py
      

      O comando de exemplo usa estas configurações:

      • --working-dir=.: especifica o diretório atual como o diretório de trabalho a ser disponibilizado para o job do Ray no cluster. O ideal é que esse diretório contenha apenas o código-fonte do aplicativo que você quer executar no Ray. No nosso exemplo, esse é o arquivo sample_code.py.
      • --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}': define o ambiente de execução para o job. Ele especifica a versão da biblioteca Python necessária (requests==2.26.0) e define uma variável de ambiente (counter_name) para a execução do job.

4. Confira o job do Ray. Você pode monitorar o job de uma destas maneiras:

   • Painel do Ray: abra o navegador da Web e acesse http://localhost:8265. Esse URL abre o painel do Ray, onde é possível ver informações sobre o job em execução, incluindo status, registros e uso de recursos.
   • Metrics Explorer: use os painéis de métricas pré-criados no Google Cloud console. Para mais informações, consulte Coletar e visualizar registros e métricas para clusters do Ray no GKE.

5. Encerre a sessão do Ray. Depois de terminar de interagir com o cluster do Ray ou monitorar seu job, encerre a sessão interativa pressionando Ctrl+C no terminal em que você executou o comando kubectl ray session.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

Se você implantou o guia de início rápido em um novo projeto Google Cloud e não precisa mais dele, exclua-o seguindo estas etapas:

1. No console Google Cloud , acesse a página Gerenciar recursos.
2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
3. Na caixa de diálogo, insira o ID do projeto e clique em Encerrar para excluí-lo.

Se você não criou um novo projeto Google Cloud e não precisa mais do cluster do GKE, exclua-o executando este comando:

gcloud container clusters delete my-ray-enabled-cluster \
    --location=us-central1

A seguir

• Confira mais exemplos, práticas recomendadas e ferramentas para o Ray no GKE:para mais informações, consulte o repositório ai-on-gke no GitHub.
• Saiba mais sobre como usar aceleradores no GKE: use GPUs para processamento paralelo em tarefas de machine learning e análise de dados. Use TPUs para acelerar o treinamento e a inferência de modelos de aprendizado profundo em grande escala.
• Saiba mais sobre o operador Ray: para mais informações sobre como usar o operador Ray para gerenciar implantações do Ray, incluindo jobs do Ray, consulte Sobre o Ray no GKE.
• Use o Kueue para enfileiramento de jobs:descubra como o Kueue, um sistema de enfileiramento de jobs nativo do Kubernetes, pode ajudar a gerenciar e priorizar suas cargas de trabalho de IA/ML, o que pode melhorar a utilização de recursos. Para mais informações, consulte Otimizar a utilização de recursos do GKE para cargas de trabalho mistas de treinamento e inferência de IA/ML.