Implementa una aplicación de Ray Serve con un modelo de dispersión estable en Google Kubernetes Engine (GKE)

Autopilot estándar

Implementa y entrega un modelo de difusión estable en Google Kubernetes Engine (GKE) con Ray Serve y el complemento de operador de Ray. Esta solución te ayuda a compilar aplicaciones de inferencia de IA generativa escalables y de alta disponibilidad. GKE ofrece una plataforma flexible y rentable para ejecutar tus cargas de trabajo de IA/AA alojadas en contenedores. Ray Serve proporciona funciones como actualizaciones in situ y actualizaciones sin tiempo de inactividad. Estas capacidades son fundamentales para administrar modelos de IA distribuidos y mantener una entrega eficiente y confiable en entornos de producción en GKE.

Información acerca de Ray y Ray Serve

Ray es un framework de procesamiento escalable de código abierto para aplicaciones de IA/AA. Ray Serve es una biblioteca de entrega de modelos para Ray que se usa para el escalamiento y la entrega de modelos en un entorno distribuido. Para obtener más información, consulta Ray Serve en la documentación de Ray.

Puedes usar un recurso de RayCluster o RayService para implementar tus aplicaciones de Ray Serve. Debes usar un recurso de RayService en producción por los siguientes motivos:

• Actualizaciones locales para aplicaciones de RayService
• Actualización con tiempo de inactividad cero para recursos de RayCluster
• Aplicaciones de Ray Serve con alta disponibilidad

Objetivos

Esta guía está dirigida a clientes de IA generativa, usuarios nuevos o existentes de GKE, ingenieros de AA, ingenieros de MLOps (DevOps) o administradores de plataformas que estén interesados en el uso de las capacidades de organización de contenedores de Kubernetes para entregar modelos con Ray.

• Crea un clúster de GKE con un grupo de nodos de GPU.
• Crea un clúster de Ray con el recurso personalizado de RayCluster.
• Ejecuta una aplicación de Ray Serve.
• Implementa un recurso personalizado de RayService.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

• GKE

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios de Google Cloud nuevos cumplan con los requisitos para acceder a una prueba gratuita.

Cuando completes las tareas que se describen en este documento, podrás borrar los recursos que creaste para evitar que se te siga facturando. Para obtener más información, consulta Realiza una limpieza.

Antes de comenzar

Cloud Shell tiene preinstalado el software que necesitas para este instructivo, incluidos kubectl y gcloud CLI. Si no usas Cloud Shell, debes instalar gcloud CLI.

Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Instala Google Cloud CLI.

Nota: Si ya instalaste gcloud CLI, ejecuta gcloud components update para asegurarte de tener la versión más reciente.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un Google Cloud proyecto.

Roles necesarios para seleccionar o crear un proyecto

• Selecciona un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
• Crear un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

• Crea un Google Cloud proyecto:

  gcloud projects create PROJECT_ID

  Reemplaza PROJECT_ID por un nombre para el proyecto Google Cloud que estás creando.

• Selecciona el proyecto Google Cloud que creaste:

  gcloud config set project PROJECT_ID

  Reemplaza PROJECT_ID por el nombre de tu proyecto de Google Cloud .

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita la API de GKE:

Roles necesarios para habilitar las APIs

Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.

gcloud services enable container.googleapis.com

Instala Google Cloud CLI.

Nota: Si ya instalaste gcloud CLI, ejecuta gcloud components update para asegurarte de tener la versión más reciente.

Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Crea o selecciona un Google Cloud proyecto.

Roles necesarios para seleccionar o crear un proyecto

• Selecciona un proyecto: Para seleccionar un proyecto, no se requiere un rol de IAM específico. Puedes seleccionar cualquier proyecto en el que se te haya otorgado un rol.
• Crear un proyecto: Para crear un proyecto, necesitas el rol de Creador de proyectos (roles/resourcemanager.projectCreator), que contiene el permiso resourcemanager.projects.create. Obtén más información para otorgar roles.

Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

• Crea un Google Cloud proyecto:

  gcloud projects create PROJECT_ID

  Reemplaza PROJECT_ID por un nombre para el proyecto Google Cloud que estás creando.

• Selecciona el proyecto Google Cloud que creaste:

  gcloud config set project PROJECT_ID

  Reemplaza PROJECT_ID por el nombre de tu proyecto de Google Cloud .

Verifica que la facturación esté habilitada para tu proyecto de Google Cloud .

Habilita la API de GKE:

Roles necesarios para habilitar las APIs

Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.

gcloud services enable container.googleapis.com

1. Otorga roles a tu cuenta de usuario. Ejecuta el siguiente comando una vez para cada uno de los siguientes roles de IAM: roles/container.clusterAdmin, roles/container.admin

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

   Reemplaza lo siguiente:

   • PROJECT_ID: ID del proyecto
   • USER_IDENTIFIER: Es el identificador de tu cuenta de usuario de . Por ejemplo, [e-mail].
   • ROLE: Es el rol de IAM que otorgas a tu cuenta de usuario.

Prepara el entorno

Para preparar tu entorno, sigue estos pasos:

1. Para iniciar una sesión de Cloud Shell desde la Google Cloud consola, haz clic en Activar Cloud Shell en la Google Cloud consola. Esto inicia una sesión en el panel inferior de la consola de Google Cloud .

2. Establece las variables de entorno:

   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`
   

   Reemplaza lo siguiente:

   • PROJECT_ID: Es el ID de tu proyecto. Google Cloud
   • CLUSTER_VERSION: la versión de GKE que se usará. Debe ser 1.30.1 o una versión posterior.

3. Clona el repositorio de GitHub:

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

4. Cambia al directorio de trabajo:

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

5. Crea un entorno virtual de Python:

   venv

   python -m venv myenv && \
   source myenv/bin/activate
   

   Conda

   1. Instala Conda.

   2. Ejecuta los siguientes comandos:

      conda create -c conda-forge python=3.9.19 -n myenv && \
      conda activate myenv
      

   Cuando implementas una aplicación de Serve con serve run, Ray espera que la versión de Python del cliente local coincida con la versión que se usa en el clúster de Ray. La imagen de rayproject/ray:2.37.0 usa Python 3.9. Si ejecutas una versión diferente del cliente, selecciona la imagen de Ray adecuada.

6. Instala las dependencias necesarias para ejecutar la aplicación de Serve:

   pip install ray[serve]==2.37.0
   pip install torch
   pip install requests
   

Crea un clúster con un grupo de nodos de GPU

Crea un clúster de GKE Autopilot o Standard con un grupo de nodos de GPU:

Autopilot

Crea un clúster de Autopilot:

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

Estándar

1. Crea un clúster estándar:

   gcloud container clusters create ${CLUSTER_NAME} \
       --addons=RayOperator \
       --cluster-version=${CLUSTER_VERSION}  \
       --machine-type=c3d-standard-8 \
       --location=${COMPUTE_ZONE} \
       --num-nodes=1
   

2. Crea un grupo de nodos de GPU

   gcloud container node-pools create gpu-pool \
       --cluster=${CLUSTER_NAME} \
       --machine-type=g2-standard-8 \
       --location=${COMPUTE_ZONE} \
       --num-nodes=1 \
       --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest
   

Implementa un recurso de RayCluster

Para implementar un recurso de RayCluster, haz lo siguiente:

1. Revisa el siguiente manifiesto:

   apiVersion: ray.io/v1
   kind: RayCluster
   metadata:
     name: stable-diffusion-cluster
   spec:
     rayVersion: '2.37.0'
     headGroupSpec:
       rayStartParams:
         dashboard-host: '0.0.0.0'
       template:
         metadata:
         spec:
           containers:
           - name: ray-head
             image: rayproject/ray:2.37.0
             ports:
             - containerPort: 6379
               name: gcs
             - containerPort: 8265
               name: dashboard
             - containerPort: 10001
               name: client
             - containerPort: 8000
               name: serve
             resources:
               limits:
                 cpu: "2"
                 ephemeral-storage: "15Gi"
                 memory: "8Gi"
               requests:
                 cpu: "2"
                 ephemeral-storage: "15Gi"
                 memory: "8Gi"
           nodeSelector:
             cloud.google.com/machine-family: c3d
     workerGroupSpecs:
     - replicas: 1
       minReplicas: 1
       maxReplicas: 4
       groupName: gpu-group
       rayStartParams: {}
       template:
         spec:
           containers:
           - name: ray-worker
             image: rayproject/ray:2.37.0-gpu
             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

   En este manifiesto, se describe un recurso de RayCluster.

2. Aplica el manifiesto al clúster:

   kubectl apply -f ray-cluster.yaml
   

3. Verifica que el recurso de RayCluster esté listo:

   kubectl get raycluster
   

   El resultado es similar a este:

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

   En este resultado, ready en la columna STATUS indica que el recurso de RayCluster está listo.

Conéctate al recurso de RayCluster

Para conectarte al recurso de RayCluster, sigue estos pasos:

1. Verifica que GKE haya creado el servicio de RayCluster:

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

   El resultado es similar a este:

   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. Establece sesiones de redirección de puertos al encabezado de 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. Verifica que el cliente de Ray pueda conectarse al clúster de Ray con localhost:

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

   El resultado es similar a este:

   ======== 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
   

Ejecuta una aplicación de Ray Serve

Para ejecutar una aplicación de Ray Serve, haz lo siguiente:

1. Ejecuta la aplicación de Ray Serve de Stable Diffusion:

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

   El resultado es similar a este:

   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. Establece una sesión de redirección de puertos al puerto de Ray Serve (8000):

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

3. Ejecuta la secuencia de comandos de Python:

   python generate_image.py
   

   La secuencia de comandos genera una imagen en un archivo llamado output.png. El resultado es similar al siguiente:

   

Implementa un RayService

El recurso personalizado de RayService administra el ciclo de vida de un recurso de RayCluster y la aplicación Ray Serve.

Para obtener más información sobre RayService, consulta Deploy Ray Serve Applications y Production Guide en la documentación de Ray.

Para implementar un recurso de RayService, sigue estos pasos:

1. Revisa el siguiente manifiesto:

   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", "torch", "torchvision", "huggingface_hub==0.25.2", "transformers"]
     rayClusterConfig:
       rayVersion: '2.37.0'
       headGroupSpec:
         rayStartParams:
           dashboard-host: '0.0.0.0'
         template:
           spec:
             containers:
             - name: ray-head
               image:  rayproject/ray:2.37.0
               ports:
               - containerPort: 6379
                 name: gcs
               - containerPort: 8265
                 name: dashboard
               - containerPort: 10001
                 name: client
               - containerPort: 8000
                 name: serve
               resources:
                 limits:
                   cpu: "2"
                   ephemeral-storage: "15Gi"
                   memory: "8Gi"
                 requests:
                   cpu: "2"
                   ephemeral-storage: "15Gi"
                   memory: "8Gi"
             nodeSelector:
               cloud.google.com/machine-family: c3d
       workerGroupSpecs:
       - replicas: 1
         minReplicas: 1
         maxReplicas: 4
         groupName: gpu-group
         rayStartParams: {}
         template:
           spec:
             containers:
             - name: ray-worker
               image: rayproject/ray:2.37.0-gpu
               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

   En este manifiesto, se describe un recurso personalizado de RayService.

2. Aplica el manifiesto al clúster:

   kubectl apply -f ray-service.yaml
   

3. Verifica que el servicio esté listo:

   kubectl get svc stable-diffusion-serve-svc
   

   El resultado es similar a este:

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

4. Configura la redirección de puertos al servicio de Ray Serve:

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

5. Ejecuta la secuencia de comandos de Python de la sección anterior:

   python generate_image.py
   

   La secuencia de comandos genera una imagen similar a la que se generó en la sección anterior.

Observa tus cargas de trabajo de Ray

Para ver los detalles de tus RayJobs, puedes navegar a la sección Kubernetes Engine > AI/ML > Jobs en la consola de Google Cloud .

Ver RayJobs en la Google Cloud consola

Realiza una limpieza

Borra el proyecto

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

• Se borra todo su contenido. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los IDs personalizados de los proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID personalizado del proyecto que desees utilizar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto, en lugar de todo el proyecto.

Si planeas explorar varios instructivos, arquitecturas o guías de inicio rápido, reutilizar proyectos puede ser útil para no exceder los límites de cuota de los proyectos.

Borra un Google Cloud proyecto:

gcloud projects delete PROJECT_ID

Borra los recursos individuales

Para borrar el clúster, escribe lo siguiente:

gcloud container clusters delete ${CLUSTER_NAME}

¿Qué sigue?

• Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.