Implantar um aplicativo Ray Serve com um modelo de difusão estável no Google Kubernetes Engine (GKE)

Autopilot Standard

---

Este guia fornece um exemplo de como implantar e disponibilizar um modelo de Stable Diffusion no Google Kubernetes Engine (GKE) usando Ray Serve e o complemento Ray Operator como um exemplo de implementação.

Sobre o Ray e o Ray Serve

O Ray é um framework de computação escalonável e de código aberto para aplicativos de IA/ML. O Ray Serve é uma biblioteca de disponibilização de modelos para Ray usado para dimensionar e exibir modelos em um ambiente distribuído. Para mais informações, consulte Ray Serve na documetação do Ray.

Use um recurso do RayCluster ou do RayService para implantar seu aplicativos do Ray Serve. Use um recurso do RayService na produção pelos seguintes motivos:

• Atualizações no local para aplicativos do RayService
• Upgrade sem inatividade para recursos do RayCluster
• Aplicativos do Ray Serve altamente disponíveis

Objetivos

Este guia é destinado a clientes de IA generativa, usuários novos ou atuais do GKE, engenheiros de ML, engenheiros de MLOps (DevOps) ou administradores de plataformas interessados em usar os recursos de orquestração de contêineres do Kubernetes para disponibilizar modelos usando o Ray.

• Criar um cluster do GKE com um pool de nós de GPU
• Crie um cluster do Ray usando o recurso personalizado do RayCluster.
• Execute um aplicativo do Ray Serve.
• Implantar um recurso personalizado do RayService.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

• GKE

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo kubectl e a gcloud CLI. Se você não usa o Cloud Shell, é necessário instalar a gcloud CLI.

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
2. Install the Google Cloud CLI.

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

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

4. Create or select a Google Cloud project.

   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.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

5. Make sure that billing is enabled for your Google Cloud project.

6. Enable the GKE API:

   gcloud services enable container.googleapis.com

7. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.clusterAdmin, roles/container.admin

   gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

   • Replace PROJECT_ID with your project ID.

   • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:[e-mail].

   • Replace ROLE with each individual role.
8. Instale o RayServe.

Prepare o ambiente

Para configurar o ambiente, siga estas etapas:

1. Inicie uma sessão do Cloud Shell no Console do Google Cloud clicando em Ativar o Cloud Shell no Console do Google Cloud. Isso inicia uma sessão no painel inferior do Cloud Console.

2. Defina as variáveis de ambiente:

   export PROJECT_ID=PROJECT_ID
   export CLUSTER_NAME=rayserve-cluster
   export COMPUTE_REGION=us-central1
   export COMPUTE_ZONE=us-central1-c
   export CLUSTER_VERSION=CLUSTER_VERSION
   export TUTORIAL_HOME=`pwd`
   

   Substitua:

   • PROJECT_ID: seuID de projeto no Google Cloud.
   • CLUSTER_VERSION: a versão do GKE a ser usada. Precisa ser 1.30.1 ou mais recente.

3. Clone o repositório do GitHub:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

4. Mude para o diretório de trabalho:

   cd kubernetes-engine-samples/ai-ml/gke-ray/rayserve/stable-diffusion
   

Criar um cluster com um pool de nós de GPU

Crie um cluster do GKE Autopilot ou Standard com um pool de nós de GPU:

Piloto automático Padrão

Criar um cluster do Autopilot:

gcloud container clusters create-auto ${CLUSTER_NAME}  \
    --enable-ray-operator \
    --cluster-version=${CLUSTER_VERSION} \
    --location=${COMPUTE_REGION}

Criar um cluster padrão

gcloud container clusters create ${CLUSTER_NAME} \
    --addons=RayOperator \
    --cluster-version=${CLUSTER_VERSION}  \
    --machine-type=g2-standard-8 \
    --location=${COMPUTE_ZONE} \
    --num-nodes=2 \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest

Implantar um recurso do RayCluster

Para implantar um recurso do RayCluster:

1. Analise o seguinte manifesto:

   apiVersion: ray.io/v1
   kind: RayCluster
   metadata:
     name: stable-diffusion-cluster
   spec:
     rayVersion: '2.9.0'
     headGroupSpec:
       rayStartParams:
         dashboard-host: '0.0.0.0'
       template:
         metadata:
         spec:
           containers:
           - name: ray-head
             image: rayproject/ray-ml:2.9.0
             ports:
             - containerPort: 6379
               name: gcs
             - containerPort: 8265
               name: dashboard
             - containerPort: 10001
               name: client
             - containerPort: 8000
               name: serve
             resources:
               limits:
                 cpu: "2"
                 memory: "8Gi"
               requests:
                 cpu: "2"
                 memory: "8Gi"
     workerGroupSpecs:
     - replicas: 1
       minReplicas: 1
       maxReplicas: 4
       groupName: gpu-group
       rayStartParams: {}
       template:
         spec:
           containers:
           - name: ray-worker
             image: rayproject/ray-ml:2.9.0
             resources:
               limits:
                 cpu: 4
                 memory: "16Gi"
                 nvidia.com/gpu: 1
               requests:
                 cpu: 3
                 memory: "16Gi"
                 nvidia.com/gpu: 1
           nodeSelector:
             cloud.google.com/gke-accelerator: nvidia-l4

   Esse manifesto descreve um recurso do RayCluster.

2. Aplique o manifesto ao cluster:

   kubectl apply -f ray-cluster.yaml
   

3. Verifique se o recurso do RayCluster está pronto:

   kubectl get raycluster
   

   O resultado será assim:

   NAME                       DESIRED WORKERS   AVAILABLE WORKERS   CPUS   MEMORY   GPUS   STATUS   AGE
   stable-diffusion-cluster   2                 2                   6      20Gi     0      ready    33s
   

   Nesta saída, ready na coluna STATUS indica que o recurso do RayCluster está pronto.

Conectar-se ao recurso do RayCluster

Para se conectar ao recurso do RayCluster:

1. Verifique se o GKE criou o serviço RayCluster:

   kubectl get svc stable-diffusion-cluster-head-svc
   

   O resultado será assim:

   NAME                             TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)                                AGE
   pytorch-mnist-cluster-head-svc   ClusterIP   34.118.238.247   <none>        10001/TCP,8265/TCP,6379/TCP,8080/TCP   109s
   

2. Estabeleça sessões de encaminhamento de portas para o head do Ray:

   kubectl port-forward svc/stable-diffusion-cluster-head-svc 8265:8265 2>&1 >/dev/null &
   kubectl port-forward svc/stable-diffusion-cluster-head-svc 10001:10001 2>&1 >/dev/null &
   

3. Verifique se o cliente Ray pode se conectar ao cluster usando localhost:

   ray list nodes --address http://localhost:8265
   

   O resultado será assim:

   ======== List: 2024-06-19 15:15:15.707336 ========
   Stats:
   ------------------------------
   Total: 3
   
   Table:
   ------------------------------
       NODE_ID                                                   NODE_IP     IS_HEAD_NODE    STATE    NODE_NAME    RESOURCES_TOTAL                 LABELS
   0  1d07447d7d124db641052a3443ed882f913510dbe866719ac36667d2  10.28.1.21  False           ALIVE    10.28.1.21   CPU: 2.0                        ray.io/node_id: 1d07447d7d124db641052a3443ed882f913510dbe866719ac36667d2
   # Several lines of output omitted
   

Executar um aplicativo do Ray Serve

Para executar um aplicativo do Ray Serve:

1. Execute o aplicativo Stable Diffusion do Ray Serve:

   serve run stable_diffusion:entrypoint --working-dir=. --runtime-env-json='{"pip": ["torch", "torchvision", "diffusers==0.12.1"]}' --address ray://localhost:10001
   

   O resultado será assim:

   2024-06-19 18:20:58,444 INFO scripts.py:499 -- Running import path: 'stable_diffusion:entrypoint'.
   2024-06-19 18:20:59,730 INFO packaging.py:530 -- Creating a file package for local directory '.'.
   2024-06-19 18:21:04,833 INFO handle.py:126 -- Created DeploymentHandle 'hyil6u9f' for Deployment(name='StableDiffusionV2', app='default').
   2024-06-19 18:21:04,834 INFO handle.py:126 -- Created DeploymentHandle 'xo25rl4k' for Deployment(name='StableDiffusionV2', app='default').
   2024-06-19 18:21:04,836 INFO handle.py:126 -- Created DeploymentHandle '57x9u4fp' for Deployment(name='APIIngress', app='default').
   2024-06-19 18:21:04,836 INFO handle.py:126 -- Created DeploymentHandle 'xr6kt85t' for Deployment(name='StableDiffusionV2', app='default').
   2024-06-19 18:21:04,836 INFO handle.py:126 -- Created DeploymentHandle 'g54qagbz' for Deployment(name='APIIngress', app='default').
   2024-06-19 18:21:19,139 INFO handle.py:126 -- Created DeploymentHandle 'iwuz00mv' for Deployment(name='APIIngress', app='default').
   2024-06-19 18:21:19,139 INFO api.py:583 -- Deployed app 'default' successfully.
   

2. Estabeleça uma sessão de encaminhamento de portas para a porta do Ray Serve (8000):

   kubectl port-forward svc/stable-diffusion-cluster-head-svc 8000:8000 2>&1 >/dev/null &
   

3. Execute o script Python:

   python generate_image.py
   

   O script gera uma imagem para um arquivo chamado output.png. O resultado será assim:

   

Implantar um RayService

O recurso personalizado do RayService gerencia o ciclo de vida de um recurso do RayCluster e do aplicativo do Ray Serve.

Para mais informações sobre o RayService, consulte Implantar aplicativos do Ray Serve e Guia de produção na documentação do Ray.

Para implantar um recurso do RayService, siga estas etapas:

1. Analise o seguinte manifesto:

   apiVersion: ray.io/v1
   kind: RayService
   metadata:
     name: stable-diffusion
   spec:
     serveConfigV2: |
       applications:
         - name: stable_diffusion
           import_path: ai-ml.gke-ray.rayserve.stable-diffusion.stable_diffusion:entrypoint
           runtime_env:
             working_dir: "https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/archive/main.zip"
             pip: ["diffusers==0.12.1"]
     rayClusterConfig:
       rayVersion: '2.9.0'
       headGroupSpec:
         rayStartParams:
           dashboard-host: '0.0.0.0'
         template:
           spec:
             containers:
             - name: ray-head
               image: rayproject/ray-ml:2.9.0
               ports:
               - containerPort: 6379
                 name: gcs
               - containerPort: 8265
                 name: dashboard
               - containerPort: 10001
                 name: client
               - containerPort: 8000
                 name: serve
               resources:
                 limits:
                   cpu: "2"
                   memory: "8Gi"
                 requests:
                   cpu: "2"
                   memory: "8Gi"
       workerGroupSpecs:
       - replicas: 1
         minReplicas: 1
         maxReplicas: 4
         groupName: gpu-group
         rayStartParams: {}
         template:
           spec:
             containers:
             - name: ray-worker
               image: rayproject/ray-ml:2.9.0
               resources:
                 limits:
                   cpu: 4
                   memory: "16Gi"
                   nvidia.com/gpu: 1
                 requests:
                   cpu: 3
                   memory: "16Gi"
                   nvidia.com/gpu: 1
             nodeSelector:
               cloud.google.com/gke-accelerator: nvidia-l4

   Este manifesto descreve um recurso personalizado do RayService.

2. Aplique o manifesto ao cluster:

   kubectl apply -f ray-service.yaml
   

3. Verifique se o serviço está pronto:

   kubectl get svc stable-diffusion-serve-svc
   

   O resultado será assim:

   NAME                         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE 
   
   stable-diffusion-serve-svc   ClusterIP   34.118.236.0   <none>        8000/TCP   31m 
   

4. Configure o encaminhamento de portas para o serviço Ray Serve:

   kubectl port-forward stable-diffusion-serve-svc 8000:8000 
   

5. Execute o script Python da seção anterior:

   python generate_image.py
   

   O script gera uma imagem semelhante à imagem gerada na seção anterior.

Limpar

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Excluir recursos individuais

Para excluir o cluster, digite:

gcloud container clusters delete ${CLUSTER_NAME}

A seguir

• Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.