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

Nesta página, mostramos como configurar e executar um cluster do Ray com GPU no Google Kubernetes Engine (GKE) para escalonar suas cargas de trabalho de IA/ML.

Por que usar o Ray?

Usar o Ray no GKE, facilitado pelo KubeRay, permite escalonar aplicativos Python e de IA. O Ray processa o escalonamento de aplicativos, e o GKE gerencia os servidores e recursos subjacentes.

Essa combinação facilita o gerenciamento de recursos, o ajuste automático da capacidade, a garantia de confiabilidade e a implantação de aplicativos em vários ambientes. Ao conectar seus aplicativos distribuídos do Ray com a infraestrutura em nuvem e as ferramentas atuais no GKE, é possível simplificar as operações e provisionar uma plataforma robusta e escalonável para tarefas complexas usando métodos padrão do Kubernetes.

Para mais informações, consulte a postagem do blog Por que usar o GKE para suas cargas de trabalho da Ray AI?.

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.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

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

  3. Enable the GKE API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  4. Install the Google Cloud CLI.

  5. Configure the gcloud CLI to use your federated identity.

    For more information, see Sign in to the gcloud CLI with your federated identity.

  6. To initialize the gcloud CLI, run the following command:

    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-o 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 criar e inserir 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 ambiente virtual: pip install -U "ray[default]".
    4. Para verificar a instalação, execute este comando: ray --version. Anote a versão do Ray (por exemplo, 2.44.1) na saída.
  9. Verifique se o projeto do 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 a 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 CLI do Google Cloud 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 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 com 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 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 do Ray no GKE.

  2. Configure kubectl para se comunicar com o cluster:

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

Padrão

No modo Standard, 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 \
        --location=us-central1 \
        --enable-autoprovisioning \
        --max-cpu=10 \
        --max-memory=64
    

    Esse comando da CLI do Google Cloud cria um cluster padrão 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 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.
    • --enable-autoprovisioning: cria e exclui automaticamente pools de nós e escalona nós nesses pools com base nas demandas da sua 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 \
        --location=us-central1
    

Instalar o plug-in kubectl ray do KubeRay

O plug-in kubectl ray simplifica os fluxos de trabalho comuns do Ray no Kubernetes. Para ver 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 em 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., pode ignorá-lo com segurança. Se a instalação tiver sido bem-sucedida, a saída será a versão do plug-in kubectl ray.

Criar a classe de computação personalizada no cluster

Com uma classe de computação personalizada no GKE, é possível 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 deste 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 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 do KubeRay para traduzir suas especificações em uma definição de recurso personalizado do RayCluster e a envia para a API Kubernetes para criar o objeto RayCluster. Esse objeto atua como um blueprint, informando ao operador Ray como provisionar e gerenciar os componentes reais do cluster do Ray (nós principais e nós de trabalho) 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.

    • Confira 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.

    • Verifique os pods do Kubernetes executando este comando:

      kubectl get pods
      

      Esse comando lista todos os pods em execução no namespace do Kubernetes. Você vai ver 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. Iniciar uma sessão interativa do Ray. Para estabelecer uma conexão local com seu cluster do Ray, execute este comando:

      kubectl ray session my-ray-cluster
    

    Esse comando inicia o encaminhamento de porta entre sua 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 exemplo de código 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 do 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. É possível 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 console doGoogle Cloud . 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 conta do Google Cloud pelos recursos usados nesta página, siga as etapas abaixo.

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

  1. No console do 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.