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

Implementa Ray acelerado por GPU para cargas de trabajo de IA en GKE

Autopilot Estándar

En esta página, se muestra cómo configurar y ejecutar un clúster de Ray habilitado para GPU en Google Kubernetes Engine (GKE) para escalar tus cargas de trabajo de IA/AA.

¿Por qué usar Ray?

Usar Ray en GKE, con la ayuda de KubeRay, te permite escalar aplicaciones de Python y de IA. Ray controla el escalamiento de la aplicación, y GKE administra los servidores y recursos subyacentes.

Esta combinación facilita la administración de recursos, el ajuste automático de la capacidad, la garantía de confiabilidad y la implementación de tus aplicaciones en diversos entornos. Si conectas tus aplicaciones de Ray distribuidas con tu infraestructura y herramientas de nube existentes en GKE, puedes simplificar las operaciones y aprovisionar una plataforma sólida y escalable para tareas complejas con métodos estándar de Kubernetes.

Para obtener más información, consulta la entrada de blog Why GKE for your Ray AI workloads.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

In the Google Cloud console, on the project selector page, select or create 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.

Go to project selector
Make sure that billing is enabled for your Google Cloud project.
Enable the GKE API.
Enable the API

Install the Google Cloud CLI.
Configura gcloud CLI para usar tu identidad federada.

Para obtener más información, consulta Accede a gcloud CLI con tu identidad federada.
Para inicializar la CLI de gcloud, ejecuta el siguiente comando:
```
gcloud init
```
Instala kubectl: kubectl es la principal herramienta de línea de comandos para interactuar con los clústeres de GKE. Si usas Cloud Shell, kubectl ya está instalado. De lo contrario, instálalo en tu terminal ejecutando el comando gcloud components install kubectl.
Para verificar la instalación, ejecuta este comando: kubectl version --client
Instala Ray: Te recomendamos que crees y accedas a un entorno virtual de Python (venv) antes de instalar Ray para que puedas aislar sus dependencias.
1. Instala Python.
2. Crea y activa un entorno virtual nuevo.
3. Ejecuta este comando dentro de tu entorno virtual para instalar la versión estable más reciente de Ray: pip install -U "ray[default]".
4. Para verificar la instalación, ejecuta este comando: ray --version. Observa la versión de Ray (por ejemplo, 2.44.1) en el resultado.
Asegúrate de que tu proyecto Google Cloud tenga la cuota suficiente para las GPU L4. Para obtener más información, consulta Acerca de las GPUs y Cuotas de asignación.

Crea un clúster de GKE

Puedes implementar tu carga de trabajo en un clúster de GKE Autopilot o Standard. Te recomendamos que uses un clúster de Autopilot para una experiencia de Kubernetes completamente administrada. Para elegir el modo de operación de GKE que se adapte mejor a tus cargas de trabajo, consulta Elige un modo de operación de GKE.

Autopilot

En el modo Autopilot, Google administra la configuración de tu clúster, incluido el escalamiento, la seguridad y otros parámetros de configuración ya establecidos. Los clústeres de Autopilot están optimizados para ejecutar la mayoría de las cargas de trabajo de producción y aprovisionar recursos de procesamiento según tus manifiestos de Kubernetes.

En la terminal, ejecuta el siguiente 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 de Google Cloud CLI crea un clúster de Autopilot llamado my-ray-enabled-cluster con los siguientes parámetros de configuración:
- --enable-ray-operator: Instala el operador de Ray en el clúster, lo que simplifica la administración de clústeres de Ray en Kubernetes.
- --enable-ray-cluster-monitoring: Configura la integración con Cloud Monitoring para las métricas del clúster de Ray.
- --enable-ray-cluster-logging: Configura la integración con Cloud Logging para recopilar registros de tu clúster de Ray.
- --location=us-central1: Especifica la región geográfica en la que se creará el clúster de GKE. Ten en cuenta que la disponibilidad de los aceleradores y los tipos admitidos varían según la ubicación. Para obtener más información, consulta Regiones y zonas de GPU.
Los clústeres de Autopilot aprovisionan y escalan nodos automáticamente (incluidos los que tienen GPU habilitadas y usan clases de procesamiento) según las demandas de la carga de trabajo, lo que optimiza tanto el uso como el costo. Este aprovisionamiento y ajuste de escala automáticos de recursos en los clústeres de Autopilot simplifica la administración de recursos y te permite enfocarte en tus modelos en lugar de en la infraestructura.

Si usas un clúster de GKE Standard, es posible que las marcas y la configuración para habilitar Ray sean diferentes. Para obtener más información, consulta Habilita el operador de Ray en GKE.

Configura kubectl para comunicarse con tu clúster:

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

Estándar

En el modo Standard, tienes más control sobre la infraestructura subyacente de tu clúster de GKE. Administras los grupos de nodos, los tamaños de los nodos y otros parámetros de configuración directamente, lo que permite una mayor personalización. Los clústeres estándar son adecuados para cargas de trabajo que necesitan configuraciones específicas o un control estricto sobre los recursos.

En la terminal, ejecuta el siguiente comando gcloud container clusters create:
```
gcloud container clusters create my-ray-enabled-cluster \
    --addons=RayOperator \
    --enable-ray-cluster-monitoring \
    --enable-ray-cluster-logging \
    --region=us-central1 \
    --enable-autoprovisioning \
    --max-cpu=10 \
    --max-memory=64
```
Este comando de Google Cloud CLI crea un clúster estándar llamado my-ray-enabled-cluster con los siguientes parámetros de configuración:
- --addons=RayOperator: Instala el operador de Ray en el clúster, lo que simplifica la administración de clústeres de Ray en Kubernetes.
- --enable-ray-cluster-monitoring: Configura la integración con Cloud Monitoring para las métricas del clúster de Ray.
- --enable-ray-cluster-logging: Configura la integración con Cloud Logging para recopilar registros de tu clúster de Ray.
- --region=us-central1: Especifica la región geográfica en la que se creará el clúster de GKE. Ten en cuenta que la disponibilidad de los aceleradores y los tipos admitidos varían según la ubicación. Para obtener más información, consulta Regiones y zonas de GPU.
- --enable-autoprovisioning: Crea y borra automáticamente grupos de nodos y ajusta la escala de los nodos dentro de esos grupos según las demandas de tu carga de trabajo.
- --max-cpu: Es la cantidad máxima de núcleos a la que se puede escalar el clúster.
- --max-memory: Es la cantidad máxima de gigabytes de memoria a la que se puede escalar el clúster.

Configura kubectl para comunicarse con tu clúster:

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

Instala el complemento `kubectl ray` de KubeRay

El complemento kubectl ray simplifica los flujos de trabajo comunes de Ray en Kubernetes. Para obtener las instrucciones de instalación más recientes, consulta la documentación de KubeRay.

Ve a la página de versiones y descarga el objeto binario para tu plataforma. Por ejemplo, para instalar la versión 1.3.2 del complemento kubectl ray en Linux amd64, ejecuta los siguientes 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
```
Reemplaza ~/.local/bin por el directorio en tu PATH.
Verifica tu instalación:
```
kubectl ray version
```
Si ves una advertencia como KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace., puedes ignorarla de forma segura. Si la instalación se realizó correctamente, el resultado será la versión del complemento kubectl ray.

Crea la clase de procesamiento personalizada en tu clúster

Una clase de procesamiento personalizada en GKE te permite definir requisitos de hardware específicos, como el tipo y la cantidad de GPU, por prioridad. GKE usa esta prioridad cuando aprovisiona nodos para tus cargas de trabajo.

Para crear la clase de procesamiento personalizada de ejemplo para esta guía, sigue estos pasos:

Guarda la siguiente especificación de la clase de procesamiento 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

Para crear la clase de procesamiento, ejecuta este comando:
```
kubectl apply -f nvidia-l4-compute-class.yaml
```
¿Qué sucede después de que aplicas la clase de procesamiento personalizada? Después de aplicar el archivo YAML de la clase de procesamiento, GKE aprovisionará automáticamente nodos con una GPU NVIDIA L4 cuando tu clúster de Ray los solicite. Priorizará las VMs Spot según se definan en tu manifiesto. El parámetro de configuración whenUnsatisfiable: DoNotScaleUp indica a GKE que no cree nodos que no cumplan con los requisitos especificados.

Crea y verifica el clúster de Ray

Ahora puedes crear tu clúster de Ray en tu clúster de GKE.

Crea el clúster de Ray. Usa el comando kubectl ray create cluster para definir y crear tu clúster de Ray. Este comando simplifica el proceso, ya que controla la creación de recursos subyacentes de 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"
```
El comando kubectl ray create cluster usa el complemento de KubeRay para traducir tus especificaciones en una definición de recurso personalizado RayCluster y la envía a la API de Kubernetes para crear el objeto RayCluster. Este objeto actúa como un plano, ya que le indica al operador de Ray cómo aprovisionar y administrar los componentes reales del clúster de Ray (nodos principales y de trabajo) dentro de GKE. De forma predeterminada, GKE programa el Pod principal en un nodo de la serie de máquinas E2.

El comando de ejemplo usa los siguientes parámetros de configuración:
- kubectl ray create cluster my-ray-cluster: Especifica el nombre del clúster de Ray que deseas crear.
- --worker-node-selectors: Indica a Kubernetes que programe Pods de trabajadores en nodos etiquetados con cloud.google.com/compute-class=gpu-compute-class.
Importante: Para obtener mejores resultados, usa la marca --ray-version con el comando kubectl ray create cluster para que coincidan tus versiones locales de Ray y Python con las versiones correspondientes en el clúster de Ray. Mantener las versiones estrechamente alineadas generalmente mejora la estabilidad.
Verifica el estado del clúster de Ray. Usa estos comandos para verificar que tu clúster de Ray esté en funcionamiento.
- Ejecuta este comando para verificar el recurso de RayCluster:
```
kubectl ray get cluster
```
  Este comando enumera todos los clústeres de Ray en tu espacio de nombres de Kubernetes. Deberías ver my-ray-cluster en la lista. Es posible que el clúster tarde unos minutos en inicializarse.
- Ejecuta este comando para verificar los Pods de Kubernetes:
```
kubectl get pods
```
  Este comando enumera todos los Pods que se ejecutan en tu espacio de nombres de Kubernetes. Deberías ver los Pods relacionados con tu clúster de Ray:
  - Un Pod para el nodo principal de Ray, con un nombre como my-ray-cluster-head-0.
  - Uno o más Pods para los nodos trabajadores de Ray, con nombres como my-ray-cluster-worker-group-0-xxxxx. La cantidad de Pods de trabajadores depende de la configuración inicial de tu clúster de Ray y de cualquier ajuste de escala automático que pueda haber ocurrido.

Envía un trabajo de Ray

Una vez que tu clúster de Ray esté listo, puedes enviar un trabajo de Ray a tu clúster de Ray en ejecución en GKE.

Para ello, usa el comando kubectl ray session para iniciar una sesión interactiva y el comando ray job submit para iniciar la ejecución del trabajo.

Inicia una sesión interactiva de Ray. Para establecer una conexión local con tu clúster de Ray, ejecuta este comando:
```
  kubectl ray session my-ray-cluster
```
Este comando inicia el reenvío de puertos entre tu máquina local y el nodo principal de Ray en tu clúster de GKE. Ten en cuenta que la terminal estará ocupada mientras esta sesión esté activa. Para continuar, abre otra instancia de terminal.

Crea el código de muestra para ejecutarlo. Guarda el siguiente código de ejemplo en un archivo llamado 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"

Abre una terminal nueva y envía el trabajo de Ray.
1. Abre una terminal nueva en la máquina local. Si creaste un entorno virtual para tu instalación de Ray, asegúrate de activarlo también en esta nueva terminal.
2. Navega al directorio en el que guardaste el archivo sample_code.py.
3. Ejecuta el siguiente 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
```
  El comando de ejemplo usa los siguientes parámetros de configuración:
  - --working-dir=.: Especifica el directorio actual como el directorio de trabajo que estará disponible para el trabajo de Ray en el clúster. Lo ideal es que este directorio contenga solo el código fuente de la aplicación que deseas ejecutar en Ray. En nuestro ejemplo, este es el archivo sample_code.py.
  - --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}': Define el entorno de ejecución del trabajo. Especifica la versión de la biblioteca de Python requerida (requests==2.26.0) y establece una variable de entorno (counter_name) para la ejecución del trabajo.
Visualiza el trabajo de Ray. Puedes supervisar el trabajo de una de las siguientes maneras:
- Panel de Ray: Abre tu navegador web y ve a http://localhost:8265. Esta URL abre el panel de Ray, en el que puedes ver información sobre el trabajo en ejecución, incluido su estado, los registros y el uso de recursos.
- Explorador de métricas: Usa los paneles de métricas prediseñados en la consola deGoogle Cloud . Para obtener más información, consulta Recopila y consulta registros y métricas de los clústeres de Ray en GKE.
Finaliza la sesión de Ray. Después de terminar de interactuar con el clúster de Ray o supervisar tu trabajo, puedes finalizar la sesión interactiva presionando Ctrl+C en la terminal en la que ejecutaste el comando kubectl ray session.

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

Si implementaste la guía de inicio rápido en un proyecto Google Cloud nuevo y ya no lo necesitas, sigue estos pasos para borrarlo:

En la consola de Google Cloud , ve a la página Administrar recursos.
En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.
En el diálogo, ingresa el ID del proyecto y haz clic en Cerrar para borrarlo.

Si no creaste un proyecto Google Cloud nuevo y ya no necesitas el clúster de GKE, puedes borrarlo con este comando:

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

¿Qué sigue?

Explora ejemplos, prácticas recomendadas y herramientas adicionales para Ray en GKE: Para obtener más información, consulta el repositorio de GitHub de ai-on-gke.
Obtén más información para usar aceleradores en GKE: Usa GPU para el procesamiento paralelo en tareas de aprendizaje automático y análisis de datos. Usa TPUs para acelerar el entrenamiento y la inferencia de modelos de aprendizaje profundo a gran escala.
Obtén más información sobre el operador de Ray: Para obtener más información sobre cómo usar el operador de Ray para administrar implementaciones de Ray, incluidos los trabajos de Ray, consulta Acerca de Ray en GKE.
Usa Kueue para la cola de trabajos: Descubre cómo Kueue, un sistema de cola de trabajos nativo de Kubernetes, puede ayudarte a administrar y priorizar tus cargas de trabajo de IA/AA, lo que puede mejorar el uso de los recursos. Para obtener más información, consulta Optimiza la utilización de recursos de GKE para cargas de trabajo mixtas de entrenamiento y de inferencia de IA/AA.