Se usó la API de Cloud Translation para traducir esta página.

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

En esta guía, se proporciona un ejemplo de cómo implementar y entregar un modelo de dispersión estable en Google Kubernetes Engine (GKE) mediante Ray Serve y el complemento Ray Operator como implementación de ejemplo.

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

Prepara el entorno

Para preparar tu entorno, sigue estos pasos:

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 .

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: Tu Google Cloud ID del proyecto.
CLUSTER_VERSION: la versión de GKE que se usará. Debe ser 1.30.1 o una versión posterior.

Clona el repositorio de GitHub:

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

Cambia al directorio de trabajo:

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

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.

Instala las dependencias necesarias para ejecutar la aplicación de servicio:

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

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

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:

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.

Aplica el manifiesto al clúster:
```
kubectl apply -f ray-cluster.yaml
```

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:

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

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 &

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:

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.

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 &

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:

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.

Aplica el manifiesto al clúster:
```
kubectl apply -f ray-service.yaml
```

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

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 &

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.

Implementa una aplicación de Ray Serve con un modelo de dispersión estable en Google Kubernetes Engine (GKE) Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Información acerca de Ray y Ray Serve

Prepara el entorno

venv

Conda

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

Autopilot

Estándar

Implementa un recurso de RayCluster

Conéctate al recurso de RayCluster

Ejecuta una aplicación de Ray Serve

Implementa un RayService

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