Ejecuta una pequeña carga de trabajo por lotes con GPU y el modo de aprovisionamiento de inicio flexible

Autopilot estándar

---

Vista previa — flex-start

Esta función está sujeta a las "Condiciones de la oferta de la fase previa a la DG" en la sección Condiciones Generales del Servicio de las Condiciones Específicas del Servicio. Las funciones de la fase previa a la DG están disponibles "sin modificaciones" y pueden tener asistencia limitada. Para obtener más información, consulta las descripciones de la etapa de lanzamiento.

En esta guía, se muestra cómo optimizar el aprovisionamiento de GPU para cargas de trabajo de entrenamiento a pequeña y mediana escala con el modo de aprovisionamiento de inicio flexible. En esta guía, usarás flex-start para implementar una carga de trabajo que consta de dos trabajos de Kubernetes. Cada trabajo requiere una GPU. GKE aprovisiona automáticamente un solo nodo con dos GPUs A100 para ejecutar ambos trabajos.

Si tu carga de trabajo requiere procesamiento distribuido de varios nodos, considera usar flex-start con aprovisionamiento en cola. Para obtener más información, consulta Ejecuta una carga de trabajo a gran escala con inicio flexible y aprovisionamiento en cola.

Esta guía está dirigida a ingenieros de aprendizaje automático (AA), administradores y operadores de plataformas, y especialistas en datos y en IA que estén interesados en usar las capacidades de organización de contenedores de Kubernetes para ejecutar cargas de trabajo por lotes. Para obtener más información sobre los roles y las tareas de ejemplo comunes a los que hacemos referencia en el contenido de Google Cloud , consulta Roles de usuario y tareas comunes de GKE Enterprise.

Precios de inicio flexible

Se recomienda el inicio flexible si tu carga de trabajo requiere recursos aprovisionados de forma dinámica según sea necesario, por hasta siete días con reservas a corto plazo, sin administración compleja de cuotas y con acceso rentable. El inicio flexible cuenta con la tecnología del programador dinámico de cargas de trabajo y se factura según los precios del programador dinámico de cargas de trabajo:

• Descuento (hasta un 53%) en CPU virtuales, GPU y TPU.
• Pagas por lo que usas.

Antes de comenzar

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

• Habilita la API de Google Kubernetes Engine.
Habilitar la API de Google Kubernetes Engine
• Si quieres usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
  Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la propiedad compute/region. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

• Verifica que tengas un clúster de Autopilot o un clúster estándar que ejecute la versión 1.33.0-gke.1712000 o posterior.
• Verifica que conozcas las limitaciones de flex-start.
• Cuando uses un clúster estándar, verifica que mantengas al menos un grupo de nodos sin el inicio flexible habilitado para que el clúster funcione correctamente.
• Verifica que tengas cuota para las GPUs interrumpibles en las ubicaciones de tus nodos.

Crea un grupo de nodos con inicio flexible

Para crear un grupo de nodos con flex-start habilitado en un clúster estándar existente, puedes usar gcloud CLI o Terraform.

Si usas un clúster en modo Autopilot, omite esta sección y ve a la sección Ejecuta una carga de trabajo por lotes.

gcloud

1. Crea un grupo de nodos con flex-start:

   gcloud container node-pools create NODE_POOL_NAME \
       --cluster CLUSTER_NAME \
       --location LOCATION_NAME \
       --project PROJECT_ID \
       --accelerator type=nvidia-a100-80gb,count=2 \
       --machine-type a2-ultragpu-2g \
       --max-run-duration MAX_RUN_DURATION \
       --flex-start \
       --num-nodes 0 \
       --enable-autoscaling \
       --total-min-nodes 0 \
       --total-max-nodes 5 \
       --location-policy ANY \
       --reservation-affinity none \
       --no-enable-autorepair
   

   Reemplaza lo siguiente:

   • NODE_POOL_NAME: es el nombre que eliges para el grupo de nodos.
   • LOCATION_NAME: Es la región de procesamiento del plano de control del clúster.
   • PROJECT_ID: el ID de tu proyecto
   • CLUSTER_NAME: Es el nombre del clúster estándar que deseas modificar.
   • MAX_RUN_DURATION: es opcional. Es el tiempo de ejecución máximo de un nodo en segundos, hasta el valor predeterminado de siete días.

   En este comando, la marca --flex-start le indica a gcloud que cree un grupo de nodos con el inicio flexible habilitado.

   GKE crea un grupo de nodos con nodos que contienen dos GPUs A100 (a2-ultragpu-2g). Este grupo de nodos ajusta automáticamente la escala de los nodos de cero a un máximo de cinco nodos.

2. Verifica el estado de flex-start en el grupo de nodos:

   gcloud container node-pools describe NODE_POOL_NAME \
       --cluster CLUSTER_NAME \
       --location LOCATION_NAME \
       --format="get(config.flexStart)"
   

   Si el inicio flexible está habilitado en el grupo de nodos, el campo flexStart se establece en True.

Terraform

Puedes usar flex-start con GPUs a través de un módulo de Terraform.

1. Agrega el siguiente bloque a la configuración de Terraform:

```hcl
resource "google_container_node_pool" " "gpu_dws_pool" {
name = "gpu-dws-pool"

queued_provisioning {
    enabled = false
}

}
node_config {
    machine_type = "a3-highgpu-8g"
    flex_start = true
}
```

Terraform llama a las APIs de Google Cloud para crear un clúster con un grupo de nodos que usa flex-start con GPUs. En un principio, el grupo de nodos no tiene nodos y el ajuste de escala automático está habilitado. Para obtener más información sobre Terraform, consulta las especificaciones del recurso google_container_node_pool en terraform.io.

Ejecuta una carga de trabajo por lotes

En esta sección, crearás dos Jobs de Kubernetes que requieren una GPU cada uno. Un controlador de Job en Kubernetes crea uno o más Pods y garantiza que ejecuten correctamente una tarea específica.

1. En la Google Cloud consola, haz clic en Activar Cloud Shell para iniciar una sesión de Cloud Shell. Se abrirá una sesión en el panel inferior de la consola de Google Cloud .

2. Crea un archivo llamado dws-flex-start.yaml:

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: job-1
   spec:
     template:
       spec:
         nodeSelector:
           cloud.google.com/gke-flex-start: "true"
         containers:
         - name: container-1
           image: gcr.io/k8s-staging-perf-tests/sleep:latest
           args: ["10s"] # Sleep for 10 seconds
           resources:
             requests:
                 nvidia.com/gpu: 1
             limits:
                 nvidia.com/gpu: 1
         restartPolicy: OnFailure
   ---
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: job-2
   spec:
     template:
       spec:
         nodeSelector:
           cloud.google.com/gke-flex-start: "true"
         containers:
         - name: container-2
           image: gcr.io/k8s-staging-perf-tests/sleep:latest
           args: ["10s"] # Sleep for 10 seconds
           resources:
             requests:
                 nvidia.com/gpu: 1
             limits:
                 nvidia.com/gpu: 1
         restartPolicy: OnFailure
   

3. Aplica el manifiesto dws-flex-start.yaml:

   kubectl apply -f dws-flex-start.yaml
   

4. Verifica que los trabajos se ejecuten en el mismo nodo:

   kubectl get pods -l "job-name in (job-1,job-2)" -o wide
   

   El resultado es similar a este:

   NAME    READY   STATUS      RESTARTS   AGE   IP       NODE               NOMINATED NODE   READINESS GATES
   job-1   0/1     Completed   0          19m   10.(...) gke-flex-zonal-a2  <none>           <none>
   job-2   0/1     Completed   0          19m   10.(...) gke-flex-zonal-a2  <none>           <none>
   

Completado correctamente: Implementaste correctamente dos trabajos en el mismo nodo con flex-start. GKE implementó dos objetos Job en un nodo de inicio flexible aprovisionado recientemente.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene las siguientes consecuencias:
• Se borra todo en el proyecto. 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 del proyecto personalizado 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.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Borra el recurso individual

1. Borra los trabajos:

   kubectl delete job -l "job-name in (job-1,job-2)"
   

2. Borra el grupo de nodos:

   gcloud container node-pools delete NODE_POOL_NAME \
         --location LOCATION_NAME
   

3. Borra el clúster:

   gcloud container clusters delete CLUSTER_NAME
   

¿Qué sigue?

• Obtén más información sobre las GPU en GKE.
• Obtén más información sobre el aprovisionamiento automático de nodos.
• Obtén más información sobre las prácticas recomendadas para ejecutar cargas de trabajo por lotes en GKE.