Esta página se ha traducido con Cloud Translation API.

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

Autopilot Standard

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

¿Por qué usar Ray?

Si usas Ray en GKE, con la ayuda de KubeRay, puedes escalar aplicaciones de Python y de IA. Ray se encarga de escalar la aplicación, mientras que GKE gestiona los servidores y los recursos subyacentes.

Esta combinación facilita la gestión de los recursos, ajusta automáticamente la capacidad, asegura la fiabilidad y despliega tus aplicaciones en varios entornos. Si conectas tus aplicaciones Ray distribuidas con tu infraestructura y herramientas de nube en GKE, podrás simplificar las operaciones y aprovisionar una plataforma robusta y escalable para tareas complejas mediante métodos estándar de Kubernetes.

Para obtener más información, consulta la entrada de blog Why GKE for your Ray AI workloads (Por qué elegir GKE para tus cargas de trabajo de IA de Ray).

Antes de empezar

Antes de empezar, 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.
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.
Configura gcloud CLI para que use tu identidad federada.

Para obtener más información, consulta el artículo Iniciar sesión en la CLI de gcloud con tu identidad federada.
Para inicializar gcloud CLI, ejecuta el siguiente comando:
```
gcloud init
```
Instala kubectl: kubectl es la herramienta de línea de comandos principal para interactuar con clústeres de GKE. Si usas Cloud Shell, kubectl ya está instalado. Si no, 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 poder aislar sus dependencias.
1. Instala Python.
2. Crea y activa un entorno virtual.
3. Instala la última versión estable de Ray ejecutando este comando en tu entorno virtual: pip install -U "ray[default]".
4. Para verificar la instalación, ejecuta este comando: ray --version. Fíjate en la versión de Ray (por ejemplo, 2.44.1) en el resultado.
Comprueba que tu proyecto de Google Cloud tiene suficiente cuota para las GPUs L4. Para obtener más información, consulta Acerca de las GPUs y Cuotas de asignación.

Crear un clúster de GKE

Puedes desplegar tu carga de trabajo en un clúster de Autopilot o Estándar de GKE. Te recomendamos que uses un clúster de Autopilot para disfrutar de una experiencia de Kubernetes totalmente gestionada. Para elegir el modo de funcionamiento de GKE que mejor se adapte a tus cargas de trabajo, consulta Elegir un modo de funcionamiento de GKE.

Autopilot

En el modo Autopilot, Google gestiona la configuración de tu clúster, incluido el escalado, la seguridad y otros ajustes preconfigurados. Los clústeres Autopilot están optimizados para ejecutar la mayoría de las cargas de trabajo de producción y aprovisionar recursos de computación en función de tus manifiestos de Kubernetes.

En el 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 la CLI de Google Cloud crea un clúster de Autopilot llamado my-ray-enabled-cluster con estos ajustes:
- --enable-ray-operator: instala el operador de Ray en el clúster, lo que simplifica la gestión de los clústeres de Ray en Kubernetes.
- --enable-ray-cluster-monitoring: configura la integración con Cloud Monitoring para las métricas de clústeres de Ray.
- --enable-ray-cluster-logging: configura la integración con Cloud Logging para recoger los 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 Autopilot aprovisionan y escalan nodos automáticamente (incluidos los que tienen GPUs y usan clases de computación) en función de las demandas de las cargas de trabajo, lo que optimiza tanto el uso como los costes. El aprovisionamiento y el escalado automáticos de recursos en los clústeres Autopilot simplifican la gestión de recursos y te permiten centrarte en tus modelos en lugar de en la infraestructura.

Si usas un clúster Estándar de GKE, las marcas y los ajustes para habilitar Ray pueden ser diferentes. Para obtener más información, consulta Habilitar el operador Ray en GKE.

Configura kubectl para que se comunique con tu clúster:

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

Estándar

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

En el 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 \
    --location=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 estos ajustes:
- --addons=RayOperator: instala el operador de Ray en el clúster, lo que simplifica la gestión de los clústeres de Ray en Kubernetes.
- --enable-ray-cluster-monitoring: configura la integración con Cloud Monitoring para las métricas de clústeres de Ray.
- --enable-ray-cluster-logging: configura la integración con Cloud Logging para recoger los 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.
- --enable-autoprovisioning: crea y elimina automáticamente grupos de nodos y escala nodos en esos grupos en función de las demandas de tu carga de trabajo.
- --max-cpu: número máximo de núcleos al que se puede escalar el clúster.
- --max-memory: número máximo de gigabytes de memoria a los que se puede escalar el clúster.

Configura kubectl para que se comunique con tu clúster:

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

Instalar el complemento `kubectl ray` de KubeRay

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

Ve a la página de lanzamientos y descarga el archivo binario de 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
```
Sustituye ~/.local/bin por el directorio de tu PATH.
Verifica la 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. Si la instalación se ha completado correctamente, el resultado es la versión del complemento kubectl ray.

Crea la clase de computación personalizada en tu clúster

Una clase de computación personalizada en GKE te permite definir requisitos de hardware específicos, como el tipo y el número de GPUs, por prioridad. GKE usa esta prioridad al aprovisionar nodos para tus cargas de trabajo.

Para crear la clase de cálculo personalizada de ejemplo de esta guía, sigue estos pasos:

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

Crea la clase de cálculo ejecutando este comando:
```
kubectl apply -f nvidia-l4-compute-class.yaml
```
¿Qué ocurre después de aplicar la clase de computación personalizada? Después de aplicar el archivo YAML de la clase de computación, GKE aprovisionará automáticamente nodos con una GPU NVIDIA L4 cuando tu clúster de Ray los solicite. Priorizará las máquinas virtuales de acceso puntual tal como se definen en tu manifiesto. El ajuste whenUnsatisfiable: DoNotScaleUp indica a GKE que no cree nodos que no cumplan los requisitos especificados.

Crear y verificar 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 al gestionar la creación de recursos de Kubernetes subyacentes.
```
  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 KubeRay para traducir tus especificaciones en una definición de recurso personalizado RayCluster y enviarla a la API de Kubernetes para crear el objeto RayCluster. Este objeto actúa como un plano que indica al operador de Ray cómo aprovisionar y gestionar los componentes del clúster de Ray (nodos principales y de trabajador) en GKE. De forma predeterminada, GKE programa el pod principal en un nodo de la serie de máquinas E2.

El comando de ejemplo usa estos ajustes:
- kubectl ray create cluster my-ray-cluster: especifica el nombre del clúster de Ray que quieres crear.
- --worker-node-selectors: indica a Kubernetes que programe pods de trabajo en nodos etiquetados con cloud.google.com/compute-class=gpu-compute-class.
Importante: Para obtener los mejores resultados, usa la marca --ray-version con el comando kubectl ray create cluster para que tus versiones locales de Ray y Python coincidan con las versiones correspondientes del clúster de Ray. Por lo general, mantener las versiones alineadas 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.
- Para comprobar el recurso RayCluster, ejecuta este comando:
```
kubectl ray get cluster
```
  Este comando muestra todos los clústeres de Ray de tu espacio de nombres de Kubernetes. Debería ver my-ray-cluster en la lista. El clúster puede tardar unos minutos en inicializarse.
- Comprueba los pods de Kubernetes ejecutando este comando:
```
kubectl get pods
```
  Este comando muestra todos los pods que se están ejecutando en tu espacio de nombres de Kubernetes. Deberías ver los pods relacionados con tu clúster de Ray:
  - Un pod del nodo principal de Ray, con un nombre como my-ray-cluster-head-0.
  - Uno o varios pods de los nodos de trabajador de Ray, con nombres como my-ray-cluster-worker-group-0-xxxxx. El número de pods de trabajador depende de la configuración inicial de tu clúster de Ray y de cualquier autoescalado que se haya producido.

Enviar una tarea de Ray

Cuando tu clúster de Ray esté listo, podrás enviar un trabajo de Ray al 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 la redirección de puertos entre tu máquina local y el nodo principal de Ray en tu clúster de GKE. Ten en cuenta que tu terminal estará ocupado mientras esta sesión esté activa. Para continuar, abre otra instancia del terminal.

Crea el código de ejemplo que vas a ejecutar. 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 nueva terminal y envía el trabajo de Ray.
1. Abre un nuevo terminal en tu máquina local. Si has creado un entorno virtual para tu instalación de Ray, asegúrate de activarlo también en este nuevo terminal.
2. Ve al directorio donde has guardado 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 estos ajustes:
  - --working-dir=.: especifica el directorio actual como directorio de trabajo que se pondrá a disposición del trabajo de Ray en el clúster. Lo ideal es que este directorio contenga solo el código fuente de la aplicación que quieras ejecutar en Ray. En nuestro ejemplo, se trata del 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 necesaria (requests==2.26.0) y define una variable de entorno (counter_name) para la ejecución del trabajo.
Ver el trabajo de Ray. Puedes monitorizar el trabajo de una de estas formas:
- Panel de control de Ray: abre tu navegador web y ve a http://localhost:8265. Esta URL abre el panel de control de Ray, donde puedes ver información sobre el trabajo en curso, como su estado, los registros y el uso de recursos.
- Explorador de métricas: usa los paneles de control de métricas predefinidos en laGoogle Cloud consola. Para obtener más información, consulta Recoger y ver registros y métricas de clústeres de Ray en GKE.
Finaliza la sesión de Ray. Cuando hayas terminado de interactuar con el clúster de Ray o de monitorizar tu trabajo, puedes finalizar la sesión interactiva pulsando Ctrl+C en la terminal en la que ejecutaste el comando kubectl ray session.

Limpieza

Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos utilizados en esta página, sigue estos pasos.

Si has desplegado la guía de inicio rápido en un proyecto nuevo y ya no lo necesitas, elimínalo siguiendo estos pasos: Google Cloud

En la Google Cloud consola, ve a la página Gestionar recursos.
En la lista de proyectos, selecciona el proyecto que quieras eliminar y haz clic en Eliminar.
En el cuadro de diálogo, introduce el ID del proyecto y haz clic en Cerrar para eliminar el proyecto.

Si no has creado un proyecto y ya no necesitas el clúster de GKE, puedes eliminarlo ejecutando este comando: Google Cloud

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

Siguientes pasos

Consulta más ejemplos, prácticas recomendadas y herramientas de Ray en GKE: para obtener más información, consulta el repositorio de GitHub ai-on-gke.
Más información sobre el uso de aceleradores en GKE: usa GPUs para el procesamiento paralelo en tareas de aprendizaje automático y analíticas de datos. Usa TPUs para acelerar el entrenamiento y la inferencia de modelos de aprendizaje profundo a gran escala.
Más información sobre el operador de Ray: para obtener más información sobre cómo usar el operador de Ray para gestionar implementaciones de Ray, incluidos los trabajos de Ray, consulta Información sobre Ray en GKE.
Utiliza Kueue para poner en cola los trabajos: descubre cómo Kueue, un sistema de colas de trabajos nativo de Kubernetes, puede ayudarte a gestionar y priorizar tus cargas de trabajo de IA y aprendizaje automático, lo que puede mejorar la utilización de los recursos. Para obtener más información, consulta Optimizar la utilización de recursos de GKE para cargas de trabajo mixtas de entrenamiento e inferencia de IA y aprendizaje automático.