Esta página foi traduzida pela API Cloud Translation.

Implemente o Ray acelerado pela GPU para cargas de trabalho de IA no GKE

Autopilot Padrão

Esta página mostra como configurar e executar um cluster Ray com GPU ativada no Google Kubernetes Engine (GKE) para dimensionar as suas cargas de trabalho de IA/ML.

Porquê usar o Ray?

A utilização do Ray no GKE, facilitada pelo KubeRay, permite-lhe dimensionar aplicações Python e de IA. O Ray processa o dimensionamento da aplicação e o GKE gere os servidores e os recursos subjacentes.

Esta combinação facilita a gestão de recursos, o ajuste automático da capacidade, a garantia da fiabilidade e a implementação das suas aplicações em vários ambientes. Ao associar as suas aplicações Ray distribuídas à infraestrutura e às ferramentas de nuvem existentes no GKE, pode simplificar as operações e aprovisionar uma plataforma robusta e escalável para tarefas complexas através de métodos Kubernetes padrão.

Para mais informações, consulte a publicação no blogue Por que motivo deve usar o GKE para as suas cargas de trabalho de IA do Ray.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

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 (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the GKE API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API

Install the Google Cloud CLI.
Configure a CLI gcloud para usar a sua identidade federada.

Para mais informações, consulte o artigo Inicie sessão na CLI gcloud com a sua identidade federada.
Para inicializar a CLI gcloud, execute o seguinte comando:
```
gcloud init
```
Instale o kubectl: kubectl é a principal ferramenta de linha de comandos para interagir com clusters do GKE. Se usar o Cloud Shell, o kubectl já está instalado. Caso contrário, instale-o no terminal executando o comando gcloud components install kubectl.
Para validar a instalação, execute este comando: kubectl version --client
Instale o Ray: recomendamos vivamente que crie e introduza um ambiente virtual do Python (venv) antes de instalar o Ray para poder isolar as respetivas dependências.
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 validar a instalação, execute este comando: ray --version. Tenha em atenção a versão do Ray (por exemplo, 2.44.1) na saída.
Certifique-se de que o seu Google Cloud projeto tem quota suficiente para GPUs L4. Para mais informações, consulte os artigos Acerca das GPUs e Quotas de atribuição.

Crie um cluster do GKE

Pode implementar a sua carga de trabalho num cluster do GKE Autopilot ou Standard. Recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.

Piloto automático

No modo de piloto automático, a Google gere a configuração do cluster, incluindo o dimensionamento, a segurança e outras definições pré-configuradas. Os clusters do Autopilot são otimizados para executar a maioria das cargas de trabalho de produção e aprovisionar recursos de computação com base nos seus manifestos do Kubernetes.

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
```
Este comando da CLI gcloud cria um cluster do Autopilot denominado my-ray-enabled-cluster, com estas definições:
- --enable-ray-operator: instala o operador do Ray no cluster, o que simplifica a gestão de clusters do Ray no Kubernetes.
- --enable-ray-cluster-monitoring: configura a integração com o Cloud Monitoring para métricas do cluster Ray.
- --enable-ray-cluster-logging: configura a integração com o Cloud Logging para recolher registos do seu cluster Ray.
- --location=us-central1: especifica a região geográfica onde o cluster do GKE vai ser criado. Tenha em atenção que a disponibilidade e os tipos suportados de aceleradores variam consoante a localização. Para mais informações, consulte o artigo Regiões e zonas de GPUs.
Os clusters do Autopilot aprovisionam e dimensionam automaticamente os nós (incluindo os ativados para GPU que usam classes de computação) com base nas exigências da carga de trabalho, otimizando a utilização e o custo. Este aprovisionamento e escalabilidade automáticos de recursos em clusters do Autopilot simplificam a gestão de recursos e permitem-lhe concentrar-se nos seus modelos em vez da infraestrutura.

Se usar um cluster padrão do GKE, as flags e as definições para ativar o Ray podem ser diferentes. Para mais informações, consulte o artigo Ative o operador Ray no GKE.

Configure kubectl para comunicar com o cluster:

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

Standard

No modo padrão, tem mais controlo sobre a infraestrutura subjacente do seu cluster do GKE. Faz a gestão dos node pools, dos tamanhos dos nós e de outras configurações diretamente, o que permite uma maior personalização. Os clusters padrão são adequados para cargas de trabalho que precisam de configurações específicas ou de um controlo rigoroso sobre os recursos.

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
```
Este comando da CLI gcloud cria um cluster Standard denominado my-ray-enabled-cluster, com estas definições:
- --addons=RayOperator: instala o operador do Ray no cluster, o que simplifica a gestão de clusters do Ray no Kubernetes.
- --enable-ray-cluster-monitoring: configura a integração com o Cloud Monitoring para métricas do cluster Ray.
- --enable-ray-cluster-logging: configura a integração com o Cloud Logging para recolher registos do seu cluster Ray.
- --location=us-central1: especifica a região geográfica onde o cluster do GKE vai ser criado. Tenha em atenção que a disponibilidade e os tipos suportados de aceleradores variam consoante a localização. Para mais informações, consulte o artigo Regiões e zonas de GPUs.
- --enable-autoprovisioning: cria e elimina automaticamente node pools e dimensiona nós nesses pools com base nas exigências da sua carga de trabalho.
- --max-cpu: número máximo de núcleos para os quais o cluster pode ser dimensionado.
- --max-memory: número máximo de gigabytes de memória para os quais o cluster pode ser dimensionado.

Configure kubectl para comunicar com o cluster:

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

Instale o plugin KubeRay `kubectl ray`

O plugin 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.

Aceda à página de lançamentos e transfira o ficheiro binário para a 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.
Valide a instalação:
```
kubectl ray version
```
Se 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 for bem-sucedida, o resultado é a versão do plug-in kubectl ray.

Crie a classe de computação personalizada no cluster

Uma classe de computação personalizada no GKE permite-lhe definir requisitos de hardware específicos, como o tipo e a quantidade de GPUs, por prioridade. O GKE usa esta prioridade quando aprovisiona nós para as suas cargas de trabalho.

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

Guarde a seguinte especificação da 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

Execute este comando para criar a classe de computação:
```
kubectl apply -f nvidia-l4-compute-class.yaml
```
O que acontece depois de aplicar a classe de computação personalizada? Depois de aplicar o ficheiro YAML da classe de computação, o GKE aprovisiona automaticamente nós com uma GPU NVIDIA L4 quando o cluster do Ray os pede. Dá prioridade às VMs de spot, conforme definido no seu manifesto. A definição whenUnsatisfiable: DoNotScaleUp indica ao GKE que não crie nós que não cumpram os requisitos especificados.

Crie e valide o cluster do Ray

Já pode criar o seu cluster do Ray no cluster do GKE.

Crie o cluster do Ray. Use o comando kubectl ray create cluster para definir e criar o seu cluster do Ray. Este comando simplifica o processo ao processar a criação de recursos do Kubernetes subjacente.
```
  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 as suas especificações numa definição de recurso personalizado RayCluster e enviá-la para a API Kubernetes para criar o objeto RayCluster. Este objeto funciona como um projeto, indicando ao operador do Ray como aprovisionar e gerir os componentes reais do cluster do Ray (nós principais e de trabalho) no GKE. Por predefinição, o GKE agenda o pod principal num nó da série de máquinas E2.

O comando de exemplo usa estas definições:
- kubectl ray create cluster my-ray-cluster: especifica o nome do cluster do Ray que quer criar.
- --worker-node-selectors: indica ao Kubernetes para agendar pods de trabalho em nós etiquetados com cloud.google.com/compute-class=gpu-compute-class.
Importante: para obter os melhores resultados, use a flag --ray-version com o comando kubectl ray create cluster para fazer corresponder as versões locais do Ray e do Python às versões correspondentes no cluster do Ray. Geralmente, manter as versões alinhadas melhora a estabilidade.
Valide o estado do cluster Ray. Use estes comandos para verificar se o cluster do Ray está em funcionamento.
- Verifique o recurso RayCluster executando este comando:
```
kubectl ray get cluster
```
  Este comando lista todos os clusters do Ray no seu espaço de nomes do Kubernetes. Deverá ver my-ray-cluster listado. A inicialização do cluster pode demorar alguns minutos.
- Verifique os pods do Kubernetes executando este comando:
```
kubectl get pods
```
  Este comando lista todos os pods em execução no seu espaço de nomes do Kubernetes. Deve ver pods relacionados com o seu 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 trabalhadores depende da configuração inicial do cluster do Ray e de qualquer dimensionamento automático que possa ter ocorrido.

Envie uma tarefa do Ray

Quando o cluster do Ray estiver pronto, pode enviar uma tarefa do Ray para o cluster do Ray em execução no GKE.

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

Inicie uma sessão interativa do Ray. Para estabelecer uma ligação local ao cluster do Ray, execute este comando:
```
  kubectl ray session my-ray-cluster
```
Este comando inicia o encaminhamento de portas entre a sua máquina local e o nó principal do Ray no seu cluster do GKE. Tenha em atenção que o terminal vai estar ocupado enquanto esta sessão estiver ativa. Para continuar, abra uma instância de terminal separada.

Crie o código de exemplo para executar. Guarde o seguinte código de exemplo num ficheiro com o nome 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"

Abra um novo terminal e envie o trabalho do Ray.
1. Abra um novo terminal na sua máquina local. Se criou um ambiente virtual para a instalação do Ray, certifique-se de que o ativa também neste novo terminal.
2. Navegue para o diretório onde guardou o ficheiro sample_code.py.
3. Execute o seguinte 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 definições:
  - --working-dir=.: especifica o diretório atual como o diretório de trabalho a disponibilizar à tarefa do Ray no cluster. Idealmente, este diretório contém apenas o código-fonte da aplicação que quer executar no Ray. No nosso exemplo, este é o ficheiro sample_code.py.
  - --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}': define o ambiente de tempo de execução para a tarefa. 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 trabalho.
Veja a tarefa do Ray. Pode monitorizar a tarefa de uma destas formas:
- Painel de controlo do Ray: abra o navegador de Internet e aceda a http://localhost:8265. Este URL abre o painel de controlo do Ray, onde pode ver informações sobre a tarefa em execução, incluindo o respetivo estado, registos e utilização de recursos.
- Explorador de métricas: use os painéis de controlo de métricas pré-criados na Google Cloud consola. Para mais informações, consulte o artigo Recolha e veja registos e métricas para clusters do Ray no GKE.
Termine a sessão do Ray. Depois de terminar a interação com o cluster do Ray ou a monitorização da tarefa, pode terminar a sessão interativa premindo Ctrl+C no terminal onde executou o comando kubectl ray session.

Limpar

Para evitar incorrer em cobranças na sua Google Cloud conta pelos recursos usados nesta página, siga estes passos.

Se implementou o início rápido num novo Google Cloud projeto e já não precisa do projeto, elimine-o seguindo estes passos:

Na Google Cloud consola, aceda à página de gestão de recursos.
Na lista de projetos, selecione o projeto que quer eliminar e, de seguida, clique em Eliminar.
Na caixa de diálogo, introduza o ID do projeto e clique em Encerrar para eliminar o projeto.

Se não criou um novo Google Cloud projeto e já não precisar do cluster do GKE, pode eliminá-lo executando este comando:

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

O que se segue?

Explore exemplos adicionais, práticas recomendadas e ferramentas para o Ray no GKE: para mais informações, consulte o repositório ai-on-gke GitHub.
Saiba mais sobre a utilização de aceleradores no GKE: use GPUs para o processamento paralelo em tarefas de aprendizagem automática e análise de dados. Use TPUs para acelerar a preparação e a inferência de modelos de aprendizagem avançada em grande escala.
Saiba mais sobre o operador Ray: para mais informações sobre como usar o operador Ray para gerir implementações do Ray, incluindo tarefas do Ray, consulte o artigo Acerca do Ray no GKE.
Use o Kueue para colocar tarefas em fila: descubra como o Kueue, um sistema de colocação de tarefas em fila nativo do Kubernetes, pode ajudar a gerir e dar prioridade às suas cargas de trabalho de IA/ML, o que pode melhorar a utilização de recursos. Para mais informações, consulte o artigo Otimize a utilização de recursos do GKE para cargas de trabalho mistas de preparação e inferência de IA/AA.