Crea y ejecuta un trabajo que use GPUs

En este documento, se explica cómo crear y ejecutar un trabajo que usa una unidad de procesamiento de gráficos (GPU). Para obtener más información sobre las funciones y restricciones de las GPU, consulta Acerca de las GPU en la documentación de Compute Engine.

Cuando creas un trabajo por lotes, puedes usar GPUs de forma opcional para acelerar cargas de trabajo específicas. Los casos de uso comunes para los trabajos que usan GPUs incluyen el procesamiento intensivo de datos y las cargas de trabajo de inteligencia artificial (IA), como el aprendizaje automático (AA).

Antes de comenzar

  1. Si nunca usaste Batch, consulta Comienza a usar Batch y habilita Batch completando los requisitos previos para proyectos y usuarios.

  2. Para obtener los permisos que necesitas para crear un trabajo, pídele a tu administrador que te otorgue los siguientes roles de IAM:

    Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

    También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Crea un trabajo que use GPUs

Para crear un trabajo que use GPUs, haz lo siguiente:

  1. Planifica los requisitos para un trabajo que usa GPUs.
  2. Crea un trabajo con los requisitos y los métodos que identificaste. Para ver ejemplos de cómo crear un trabajo con las opciones recomendadas, consulta Crea un trabajo de ejemplo que use GPUs en este documento.

Planifica los requisitos para un trabajo que usa GPUs

Antes de crear un trabajo que use GPUs, planifica los requisitos del trabajo como se explica en las siguientes secciones:

  1. Selecciona el tipo de máquina de GPU y la opción de consumo
  2. Instala los controladores de GPU
  3. Define recursos de VM compatibles

Paso 1: Selecciona el tipo de máquina de GPU y la opción de consumo

Los requisitos de un trabajo varían según el tipo de máquina con GPU y la opción de consumo que prefieras, y las opciones de cada uno pueden ser interdependientes.

Para seleccionar el tipo de máquina de GPU y la opción de consumo para tu trabajo, completa los siguientes pasos:

  1. Identifica y selecciona tu prioridad:

  2. Realiza la selección restante según lo que sea compatible con tu primera selección.

    1. Para identificar las opciones compatibles con tu primera selección, consulta Disponibilidad de opciones de consumo por tipo de máquina en la documentación de Compute Engine.

    2. Consulta la sección restante para Selecciona la opción de consumo o Selecciona el tipo de máquina con GPU, respectivamente.

Selecciona el tipo de máquina de GPU

Para seleccionar el tipo de máquina con GPU para un trabajo y comprender sus requisitos, completa los siguientes pasos:

  1. Selecciona un tipo de máquina con GPU: Para revisar los tipos de máquinas con GPU disponibles (las combinaciones válidas de tipo de GPU, cantidad de GPU y tipo de máquina [CPU virtuales y memoria]) y sus casos de uso recomendados, consulta Tipos de máquinas con GPU y Familia de máquinas optimizadas para aceleradores en la documentación de Compute Engine.

  2. Comprende los requisitos del trabajo para tu tipo de máquina con GPU: Los campos necesarios para que un trabajo especifique un tipo de máquina con GPU varían según las categorías de la siguiente tabla:

    Tipos de máquinas con GPU y sus requisitos de trabajo

    GPUs para VMs optimizadas para aceleradores: Las VMs con un tipo de máquina de la familia de máquinas optimizadas para aceleradores tienen un tipo y una cantidad específicos de estas GPUs conectadas automáticamente.

    Para usar GPUs en VMs optimizadas para aceleradores, te recomendamos que especifiques el tipo de máquina. Cada tipo de máquina optimizada para aceleradores solo admite un tipo y una cantidad específicos de GPUs, por lo que es funcionalmente equivalente si especificas o no esos valores además del tipo de máquina optimizada para aceleradores.

    Específicamente, Batch también admite especificar solo el tipo y la cantidad de GPU para las VMs optimizadas para aceleradores, pero las opciones de CPU virtuales y memoria resultantes suelen ser muy limitadas. Por lo tanto, te recomendamos que verifiques que las opciones de CPU virtual y memoria disponibles sean compatibles con los requisitos de la tarea del trabajo.

    GPUs para VMs N1: Estas GPUs requieren que especifiques el tipo y la cantidad que se adjuntarán a cada VM, y deben adjuntarse a VMs con un tipo de máquina de la serie de máquinas N1.

    Para usar GPUs en VMs de N1, te recomendamos que especifiques, al menos, el tipo y la cantidad de GPUs. Asegúrate de que la combinación de valores coincida con una de las opciones de GPU válidas para los tipos de máquinas N1. Las opciones de CPU virtuales y memoria para las VMs de N1 que usan cualquier tipo y cantidad específicos de GPUs son bastante flexibles. A menos que crees el trabajo con la consola de Google Cloud , puedes permitir que Batch seleccione automáticamente un tipo de máquina que cumpla con los requisitos de las tareas del trabajo.
Selecciona la opción de consumo

En esta sección, se resume cómo seleccionar la opción de consumo para un trabajo y los requisitos del trabajo para cada opción.

En la siguiente tabla, se explican las opciones de consumo disponibles para Batch y sus requisitos, y se enumeran según sus casos de uso, desde la disponibilidad de recursos más alta hasta la más baja.

En resumen, recomendamos que la mayoría de los usuarios seleccionen la opción de consumo para un trabajo de la siguiente manera:

  • A menos que se cumpla alguna de las otras condiciones, usa VMs de inicio flexible (versión preliminar) (preferidas si cumplen con tus requisitos) o a pedido.
  • Si tu trabajo requiere una garantía muy alta de disponibilidad de recursos o si tienes reservas sin usar que no puedes borrar, usa reservas en modo de calendario (versión preliminar) (preferidas si cumplen con tus requisitos) o reservas.
  • (Opcional) Si tu carga de trabajo es muy tolerante a errores, es posible que puedas reducir los costos si intentas usar VMs Spot.
Opciones de consumo y sus requisitos de trabajo

Reservas

  • Caso de uso: Recomendamos las reservas para los trabajos si deseas un nivel muy alto de garantía de disponibilidad de recursos y no puedes usar reservas en modo de calendario, o si ya tienes reservas existentes que podrían no usarse.

  • Detalles: Después de crear una reserva, se incurren en los costos de las VM especificadas al mismo precio que si se ejecutaran las VM hasta que borres la reserva. Las VMs que consumen una reserva no generan costos independientes, pero las reservas sí generan costos independientemente del consumo.

    Obtén más información sobre las reservas en la documentación de Compute Engine.

Batch usa reservas para los trabajos que pueden consumir VMs reservadas no utilizadas. Para obtener más información sobre los requisitos del trabajo para consumir reservas, consulta la página Garantiza la disponibilidad de recursos con VM VMs.

Reservas en modo de calendario (versión preliminar)

  • Caso de uso: Recomendamos las reservas en modo de calendario para los trabajos si deseas usar un tipo de máquina con GPU que admita reservas en modo de calendario y necesitas un nivel muy alto de garantía de disponibilidad de recursos durante al menos 1 día y hasta 90 días.

  • Detalles: Antes de crear un trabajo, debes solicitar o identificar una reserva en modo de calendario que puedas consumir. Si Compute Engine cumple con una solicitud de reserva futura en modo de calendario, la reserva en modo de calendario creada automáticamente incurre en el mismo costo que ejecutar las VM especificadas durante todo el período de reserva con los precios del Programador de cargas de trabajo dinámicas, que ofrece descuentos de hasta el 53% sobre los precios según demanda. Después de identificar una reserva en modo de calendario creada automáticamente que puedes usar, crear un trabajo que consuma una reserva en modo de calendario es muy similar a crear un trabajo que consuma una reserva.

    Obtén más información sobre las reservas en modo de calendario en la documentación de Compute Engine.

Batch usa reservas en modo de calendario para los trabajos que cumplen con todos los siguientes requisitos:

VMs de inicio flexible (vista previa)

  • Caso de uso: Recomendamos las VMs de inicio flexible si tu trabajo puede tolerar la disponibilidad con el mayor esfuerzo posible a cambio de precios con descuento y hasta 7 días para finalizar la ejecución.

    En comparación con las VMs Spot y según demanda, las VMs con inicio flexible pueden facilitar el acceso simultáneo a muchos recursos de GPU. Por ejemplo, las VMs de inicio flexible pueden ser útiles para la programación de trabajos, ya que mitigan los retrasos o los problemas causados por la falta de disponibilidad de recursos.

  • Detalles: Si se cumple una solicitud para crear un trabajo que usa VMs de inicio flexible, las VMs se cobran según los precios del programador dinámico de cargas de trabajo, que ofrece descuentos de hasta el 53% en comparación con los precios a pedido.

    Obtén más información sobre las VMs con inicio flexible en la documentación de Compute Engine.

Batch usa VMs de inicio flexible para los trabajos que cumplen con todos los siguientes requisitos:

A pedido

  • Caso de uso: Recomendamos el uso a pedido para la mayoría de los demás trabajos de forma predeterminada.1

  • Detalles: Por lo general, el acceso a pedido es la forma predeterminada de acceder a las VMs de Compute Engine. On demand te permite acceder a los recursos (si están disponibles) cuando los solicitas. Los recursos se borran hasta que finaliza el trabajo o se alcanza el límite de tiempo de ejecución.

De forma predeterminada, Batch usa el modo a pedido para la mayoría de los demás trabajos. Si quieres asegurarte de que un trabajo use la opción a pedido, haz lo siguiente:1

  • Configura el campo provisioningModel como STANDARD.
  • Bloquear reservas. Para evitar que un trabajo consuma automáticamente recursos con reservas compatibles, configura el campo reservation como NO_RESERVATION. Para obtener más información, consulta Crea y ejecuta un trabajo que no puede consumir VMs reservadas.

1Excepción: Para los trabajos que usan la serie de máquinas A3, el comportamiento predeterminado es único, y te recomendamos que no uses la opción a pedido y que no dejes el campo provisioningModel sin definir. En su lugar, usa los requisitos del trabajo para las VMs de inicio flexible. No se recomienda usar la opción a pedido para la serie de máquinas A3 debido a la baja disponibilidad de recursos. Por lo tanto, si un trabajo usa la serie de máquinas A3, bloquea las reservas y tiene el campo provisioningModel sin definir o establecido en STANDARD, la opción de consumo predeterminada es única: El comportamiento es similar al de las VMs de inicio flexible, que limitan el tiempo de ejecución a 7 días. Sin embargo, no se recomienda porque estos trabajos no reciben descuentos de los precios del programador dinámico de cargas de trabajo. Si tu trabajo con VMs A3 puede tolerar un límite de tiempo de ejecución de 7 días, te recomendamos que uses VMs de inicio flexible en lugar de VMs a pedido. De lo contrario, no podrás garantizar que los trabajos con VMs A3 usen recursos bajo demanda, a menos que establezcas provisioningModel en STANDARD y verifiques manualmente que el trabajo no pueda consumir reservas, sin establecer el campo reservation en NO_RESERVATION.

VMs Spot

  • Caso de uso: Te recomendamos que intentes usar VMs Spot para reducir los costos de las cargas de trabajo tolerantes a errores.

  • Detalles: Si se cumple una solicitud para crear un trabajo que use VMs Spot, se les cobrará a las VMs el precio de las VMs Spot, que puede cambiar con frecuencia y podría proporcionar el mayor descuento, hasta un 91% de descuento en el precio a pedido. Sin embargo, es posible que las VMs Spot no siempre estén disponibles y se puedan interrumpir en cualquier momento.

    Obtén más información sobre las VMs Spot en la documentación de Compute Engine.

Batch usa VMs Spot para los trabajos que cumplen con todos los siguientes requisitos:

  • Configura el campo provisioningModel como SPOT.
  • (Opcional) Bloquea las reservaciones. No puedes usar VMs Spot con reservas. Específicamente, el trabajo puede establecer de forma opcional el campo reservation en NO_RESERVATION. Para obtener más información, consulta Crea y ejecuta un trabajo que no puede consumir VMs reservadas.

Paso 2: Instala los controladores de GPU

Para usar GPUs en un trabajo, debes instalar los controladores de GPU. Para instalar los controladores de GPU, selecciona uno de los siguientes métodos:

Paso 3: Define recursos de VM compatibles

Para obtener información sobre los requisitos y las opciones para definir los recursos de VM de un trabajo, consulta Recursos del trabajo.

En resumen, debes hacer todo lo siguiente cuando definas los recursos de VM para un trabajo que use GPUs:

  • Asegúrate de que el tipo de máquina con GPU esté disponible en la ubicación de las VMs de tu trabajo.

    Para saber dónde están disponibles los tipos de máquinas con GPU, consulta Disponibilidad de aceleradores en la documentación de Compute Engine.

  • Si especificas el tipo de máquina del trabajo, asegúrate de que tenga suficientes CPU virtuales y memoria para los requisitos de las tareas del trabajo. Especificar el tipo de máquina del trabajo es obligatorio cuando creas un trabajo con la consola de Google Cloud y se recomienda cuando creas un trabajo que usa GPUs para VMs optimizadas para aceleradores.

  • Asegúrate de definir los recursos de la VM para un trabajo con un método válido:

    • Define los recursos de la VM directamente con el campo instances[].policy (se recomienda si es posible). Este método se muestra en los ejemplos.
    • Define los recursos de la VM a través de una plantilla con el campo instances[].instanceTemplate. Este método es necesario para instalar manualmente los controladores de GPU a través de una imagen personalizada. Para obtener más información, consulta Cómo definir recursos de trabajo con una plantilla de instancia de VM.

Crea un trabajo de ejemplo que use GPUs

En las siguientes secciones, se explica cómo crear un trabajo de ejemplo para cada opción de consumo. Específicamente, los trabajos de ejemplo usan las opciones recomendadas: todos instalan automáticamente los controladores de GPU y todos definen directamente los recursos de VM.

Opción de consumo Ejemplo de instrucciones de trabajo
Reservas o reservas en modo de calendario (vista previa)

Garantiza la disponibilidad de recursos con VM VMs
VMs de inicio flexible (vista previa)

Usa GPUs y VMs con inicio flexible
VMs a pedido o Spot

Selecciona una de las siguientes opciones según el tipo de máquina de GPU:

Usa GPUs y VMs de inicio flexible

Puedes crear un trabajo que use GPUs para VMs A3 a través del programador de cargas de trabajo dinámico con gcloud CLI o la API de Batch.

gcloud

  1. Crea un archivo JSON que instale controladores de GPU, especifique un tipo de máquina con GPU que admita VMs de inicio flexible, bloquee reservas y se ejecute en una ubicación que admita el tipo de máquina con GPU.

    Por ejemplo, para crear un trabajo de secuencia de comandos básico que use VMs de inicio flexible y GPUs para VMs optimizadas para aceleradores, crea un archivo JSON con el siguiente contenido.

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Reemplaza lo siguiente:

    • INSTALL_GPU_DRIVERS: Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy desde una ubicación de terceros y los instala en tu nombre. Si configuras este campo como false (valor predeterminado), debes instalar los controladores de GPU de forma manual para usar cualquier GPU en este trabajo.

    • MACHINE_TYPE: Es un tipo de máquina con GPU que admite VMs de inicio flexible. Para obtener más información, consulta Disponibilidad de opciones de consumo por tipo de máquina en la documentación de Compute Engine.

    • ALLOWED_LOCATIONS: De manera opcional, puedes usar el campo allowedLocations[] para especificar una región o zonas específicas en una región en la que se permite que se ejecuten las VMs de tu trabajo. Por ejemplo, regions/us-central1 permite todas las zonas de la región us-central1. Asegúrate de especificar ubicaciones que ofrezcan el tipo de máquina con GPU que deseas para este trabajo. De lo contrario, si omites este campo, asegúrate de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

  2. Para crear y ejecutar el trabajo, usa el comando gcloud alpha batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.

    • LOCATION: Es la ubicación del trabajo.

    • JSON_CONFIGURATION_FILE: Es la ruta de acceso a un archivo JSON con los detalles de configuración del trabajo.

API

Realiza una solicitud POST al método jobs.create de v1alpha que instale controladores de GPU, especifique un tipo de máquina con GPU que admita VMs de inicio flexible, bloquee reservas y se ejecute en una ubicación que admita el tipo de máquina con GPU.

Por ejemplo, para crear un trabajo de secuencia de comandos básico que use VMs de inicio flexible y GPUs para VMs optimizadas para aceleradores, realiza la siguiente solicitud:

POST https://batch.googleapis.com/v1alpha/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto de tu proyecto.

  • LOCATION: Es la ubicación del trabajo.

  • JOB_NAME: Es el nombre del trabajo.

  • INSTALL_GPU_DRIVERS: Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy desde una ubicación de terceros y los instala en tu nombre. Si configuras este campo como false (valor predeterminado), debes instalar los controladores de GPU de forma manual para usar cualquier GPU en este trabajo.

  • MACHINE_TYPE: Es un tipo de máquina con GPU que admite VMs de inicio flexible. Para obtener más información, consulta Disponibilidad de opciones de consumo por tipo de máquina en la documentación de Compute Engine.

  • ALLOWED_LOCATIONS: De manera opcional, puedes usar el campo allowedLocations[] para especificar una región o zonas específicas en una región en la que se permite que se ejecuten las VMs de tu trabajo. Por ejemplo, regions/us-central1 permite todas las zonas de la región us-central1. Asegúrate de especificar ubicaciones que ofrezcan el tipo de máquina con GPU que deseas para este trabajo. De lo contrario, si omites este campo, asegúrate de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

Usa GPUs para VMs optimizadas para aceleradores

Puedes crear un trabajo que use GPUs para VMs optimizadas para aceleradores con laGoogle Cloud consola, gcloud CLI, la API de Batch, Java, Node.js o Python.

Console

Para crear un trabajo que use GPUs con la Google Cloud consola, haz lo siguiente:

  1. En la consola de Google Cloud , ve a la página Lista de trabajos.

    Ir a la lista de trabajos

  2. Haz clic en Crear. Se abrirá la página Crear trabajo por lotes. En el panel izquierdo, se selecciona la página Detalles del trabajo.

  3. Configura la página Detalles del trabajo:

    1. Opcional: En el campo Nombre del trabajo, personaliza el nombre del trabajo.

      Por ejemplo, ingresa example-gpu-job.

    2. Configura la sección Detalles de la tarea:

      1. En la ventana Nuevo ejecutable, agrega al menos una secuencia de comandos o un contenedor para que se ejecute este trabajo.

        Por ejemplo, para crear un trabajo de secuencia de comandos básico, haz lo siguiente:

        1. Selecciona la casilla de verificación Script. Aparecerá un campo.

        2. En el campo, ingresa la siguiente secuencia de comandos:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Haz clic en Listo.

      2. En el campo Recuento de tareas, ingresa la cantidad de tareas para este trabajo.

        Por ejemplo, ingresa 3.

      3. Opcional: En el campo Paralelismo, ingresa la cantidad de tareas que se ejecutarán de forma simultánea.

        Por ejemplo, ingresa 1 (predeterminado).

  4. Configura la página Especificaciones de recursos:

    1. En el panel izquierdo, haz clic en Especificaciones de recursos. Se abrirá la página Especificaciones de recursos.

    2. En la sección Modelo de aprovisionamiento de VM, selecciona una de las siguientes opciones para la opción de consumo de las VMs de este trabajo:

      • Si tu trabajo puede tolerar la interrupción y deseas VMs Spot con descuento, selecciona Spot.

      • De lo contrario, para usar VMs a pedido, selecciona Estándar (predeterminado).

    3. Selecciona la ubicación para este trabajo.

      1. En el campo Región, selecciona una.

      2. En el campo Zona, realiza una de las siguientes acciones:

        • Si deseas restringir la ejecución de este trabajo a una zona específica, selecciona una zona.

        • De lo contrario, selecciona cualquiera (opción predeterminada).

    4. Selecciona el tipo de máquina de GPU para las VMs de este trabajo:

      1. En las opciones de familia de máquinas, haz clic en GPUs.

      2. En el campo Tipo de GPU, selecciona el tipo de GPU. Luego, en el campo Cantidad de GPU, selecciona la cantidad de GPU para cada VM.

        Si seleccionaste uno de los tipos de GPU para VMs optimizadas para aceleradores, el campo Tipo de máquina solo permite una opción para el tipo de máquina según el tipo y la cantidad de GPU que seleccionaste.

      3. Para instalar automáticamente los controladores de GPU, selecciona Instalación del controlador de GPU (opción predeterminada).

    5. Configura la cantidad de recursos de VM necesarios para cada tarea:

      1. En el campo Núcleos, ingresa la cantidad de vCPUs por tarea.

        Por ejemplo, ingresa 1 (predeterminado).

      2. En el campo Memoria, ingresa la cantidad de RAM en GB por tarea.

        Por ejemplo, ingresa 0.5 (predeterminado).

    6. Haz clic en Listo.

  5. Opcional: Configura los otros campos para este trabajo.

  6. Opcional: Para revisar la configuración del trabajo, en el panel izquierdo, haz clic en Vista previa.

  7. Haz clic en Crear.

    En la página Detalles del trabajo, se muestra el trabajo que creaste.

gcloud

  1. Crea un archivo JSON que instale controladores de GPU, especifique un tipo de máquina de la familia de máquinas optimizadas para aceleradores y se ejecute en una ubicación que tenga el tipo de máquina de GPU.

    Por ejemplo, para crear un trabajo de secuencia de comandos básico que use GPUs para VMs optimizadas para aceleradores, crea un archivo JSON con el siguiente contenido:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Reemplaza lo siguiente:

    • INSTALL_GPU_DRIVERS: Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy desde una ubicación de terceros y los instala en tu nombre. Si configuras este campo como false (valor predeterminado), debes instalar los controladores de GPU de forma manual para usar cualquier GPU en este trabajo.

    • PROVISIONING_MODEL: Es el modelo de aprovisionamiento de tu opción de consumo: puede ser STANDARD para las VMs a pedido o SPOT para las VMs Spot.

    • MACHINE_TYPE: Es un tipo de máquina de la familia de máquinas con optimización de acelerador.

    • ALLOWED_LOCATIONS: De manera opcional, puedes usar el campo allowedLocations[] para especificar una región o zonas específicas en una región en la que se permite que se ejecuten las VMs de tu trabajo. Por ejemplo, regions/us-central1 permite todas las zonas de la región us-central1. Asegúrate de especificar ubicaciones que ofrezcan el tipo de máquina con GPU que deseas para este trabajo. De lo contrario, si omites este campo, asegúrate de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

  2. Para crear y ejecutar el trabajo, usa el comando gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.

    • LOCATION: Es la ubicación del trabajo.

    • JSON_CONFIGURATION_FILE: Es la ruta de acceso a un archivo JSON con los detalles de configuración del trabajo.

API

Realiza una solicitud POST al método jobs.create que instala controladores de GPU, especifica un tipo de máquina de la familia de máquinas optimizadas para aceleradores y se ejecuta en una ubicación que tiene el tipo de máquina de GPU.

Por ejemplo, para crear un trabajo de secuencia de comandos básico que use GPUs para VMs optimizadas para aceleradores, realiza la siguiente solicitud:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto de tu proyecto.

  • LOCATION: Es la ubicación del trabajo.

  • JOB_NAME: Es el nombre del trabajo.

  • INSTALL_GPU_DRIVERS: Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy desde una ubicación de terceros y los instala en tu nombre. Si configuras este campo como false (valor predeterminado), debes instalar los controladores de GPU de forma manual para usar cualquier GPU en este trabajo.

  • PROVISIONING_MODEL: Es el modelo de aprovisionamiento de tu opción de consumo: STANDARD para las VMs a pedido o SPOT para las VMs Spot.

  • MACHINE_TYPE: Es un tipo de máquina de la familia de máquinas con optimización de acelerador.

  • ALLOWED_LOCATIONS: De manera opcional, puedes usar el campo allowedLocations[] para especificar una región o zonas específicas en una región en la que se permite que se ejecuten las VMs de tu trabajo. Por ejemplo, regions/us-central1 permite todas las zonas de la región us-central1. Asegúrate de especificar ubicaciones que ofrezcan el tipo de máquina con GPU que deseas para este trabajo. De lo contrario, si omites este campo, asegúrate de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJob {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // Accelerator-optimized machine types are available to Batch jobs. See the list
    // of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
    String machineType = "g2-standard-4";

    createGpuJob(projectId, region, jobName, installGpuDrivers, machineType);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String machineType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType(machineType).build();  

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(instancePolicy)
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-l4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'g2-standard-4';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJob();

Python 

from google.cloud import batch_v1


def create_gpu_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "g2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "g2-standard-4"

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Usa GPUs para VMs N1

Puedes crear un trabajo que use GPUs para VMs N1 con la Google Cloud consola, gcloud CLI, la API de Batch, Java, Node.js o Python.

Console

Para crear un trabajo que use GPUs con la Google Cloud consola, haz lo siguiente:

  1. En la consola de Google Cloud , ve a la página Lista de trabajos.

    Ir a la lista de trabajos

  2. Haz clic en Crear. Se abrirá la página Crear trabajo por lotes. En el panel izquierdo, se selecciona la página Detalles del trabajo.

  3. Configura la página Detalles del trabajo:

    1. Opcional: En el campo Nombre del trabajo, personaliza el nombre del trabajo.

      Por ejemplo, ingresa example-gpu-job.

    2. Configura la sección Detalles de la tarea:

      1. En la ventana Nuevo ejecutable, agrega al menos una secuencia de comandos o un contenedor para que se ejecute este trabajo.

        Por ejemplo, para crear un trabajo de secuencia de comandos básico, haz lo siguiente:

        1. Selecciona la casilla de verificación Script. Aparecerá un campo.

        2. En el campo, ingresa la siguiente secuencia de comandos:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Haz clic en Listo.

      2. En el campo Recuento de tareas, ingresa la cantidad de tareas para este trabajo.

        Por ejemplo, ingresa 3.

      3. Opcional: En el campo Paralelismo, ingresa la cantidad de tareas que se ejecutarán de forma simultánea.

        Por ejemplo, ingresa 1 (predeterminado).

  4. Configura la página Especificaciones de recursos:

    1. En el panel izquierdo, haz clic en Especificaciones de recursos. Se abrirá la página Especificaciones de recursos.

    2. En la sección Modelo de aprovisionamiento de VM, selecciona una de las siguientes opciones para la opción de consumo de las VMs de este trabajo:

      • Si tu trabajo puede tolerar la interrupción y deseas VMs Spot con descuento, selecciona Spot.

      • De lo contrario, para usar VMs a pedido, selecciona Estándar (predeterminado).

    3. Selecciona la ubicación para este trabajo.

      1. En el campo Región, selecciona una.

      2. En el campo Zona, realiza una de las siguientes acciones:

        • Si deseas restringir la ejecución de este trabajo a una zona específica, selecciona una zona.

        • De lo contrario, selecciona cualquiera (opción predeterminada).

    4. Selecciona el tipo de máquina de GPU para las VMs de este trabajo:

      1. En las opciones de familia de máquinas, haz clic en GPUs.

      2. En el campo Tipo de GPU, selecciona el tipo de GPU.

        Si seleccionaste uno de los tipos de GPU para VMs N1, el campo Serie se establece en N1.

      3. En el campo Cantidad de GPU, selecciona la cantidad de GPU para cada VM.

      4. En el campo Tipo de máquina, selecciona el tipo de máquina.

      5. Para instalar automáticamente los controladores de GPU, selecciona Instalación del controlador de GPU (opción predeterminada).

    5. Configura la cantidad de recursos de VM necesarios para cada tarea:

      1. En el campo Núcleos, ingresa la cantidad de vCPUs por tarea.

        Por ejemplo, ingresa 1 (predeterminado).

      2. En el campo Memoria, ingresa la cantidad de RAM en GB por tarea.

        Por ejemplo, ingresa 0.5 (predeterminado).

    6. Haz clic en Listo.

  5. Opcional: Configura los otros campos para este trabajo.

  6. Opcional: Para revisar la configuración del trabajo, en el panel izquierdo, haz clic en Vista previa.

  7. Haz clic en Crear.

    En la página Detalles del trabajo, se muestra el trabajo que creaste.

gcloud

  1. Crea un archivo JSON que instale controladores de GPU, defina los subcampos type y count del campo accelerators[] y se ejecute en una ubicación que tenga el tipo de máquina de GPU.

    Por ejemplo, para crear un trabajo de secuencia de comandos básico que use GPUs para VMs N1 y permita que Batch seleccione el tipo de máquina N1 exacto, crea un archivo JSON con el siguiente contenido:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Reemplaza lo siguiente:

    • INSTALL_GPU_DRIVERS: Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy desde una ubicación de terceros y los instala en tu nombre. Si configuras este campo como false (valor predeterminado), debes instalar los controladores de GPU de forma manual para usar cualquier GPU en este trabajo.

    • PROVISIONING_MODEL: Es el modelo de aprovisionamiento de tu opción de consumo: puede ser STANDARD para las VMs a pedido o SPOT para las VMs Spot.

    • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Solo usa este campo para las GPUs de las VMs N1.

    • GPU_COUNT: Es la cantidad de GPUs del tipo especificado. Para obtener más información sobre las opciones válidas, consulta Tipos de máquinas con GPU para la serie de máquinas N1. Solo usa este campo para las GPUs de las VMs N1.

    • ALLOWED_LOCATIONS: De manera opcional, puedes usar el campo allowedLocations[] para especificar una región o zonas específicas en una región en la que se permite que se ejecuten las VMs de tu trabajo. Por ejemplo, regions/us-central1 permite todas las zonas de la región us-central1. Asegúrate de especificar ubicaciones que ofrezcan el tipo de máquina con GPU que deseas para este trabajo. De lo contrario, si omites este campo, asegúrate de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

  2. Para crear y ejecutar el trabajo, usa el comando gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.

    • LOCATION: Es la ubicación del trabajo.

    • JSON_CONFIGURATION_FILE: Es la ruta de acceso a un archivo JSON con los detalles de configuración del trabajo.

API

Realiza una solicitud POST al método jobs.create que instala los controladores de GPU, define los subcampos type y count del campo accelerators[] y usa una ubicación que tenga el tipo de máquina de GPU.

Por ejemplo, para crear un trabajo de secuencia de comandos básico que use GPUs para VMs de N1 y permita que Batch seleccione el tipo de máquina N1 exacto, realiza la siguiente solicitud:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto de tu proyecto.

  • LOCATION: Es la ubicación del trabajo.

  • JOB_NAME: Es el nombre del trabajo.

  • INSTALL_GPU_DRIVERS: Cuando se establece en true, Batch recupera los controladores necesarios para el tipo de GPU que especificas en el campo policy desde una ubicación de terceros y los instala en tu nombre. Si configuras este campo como false (valor predeterminado), debes instalar los controladores de GPU de forma manual para usar cualquier GPU en este trabajo.

  • PROVISIONING_MODEL: Es el modelo de aprovisionamiento de tu opción de consumo: STANDARD para las VMs a pedido o SPOT para las VMs Spot.

  • GPU_TYPE: Es el tipo de GPU. Puedes ver una lista de los tipos de GPU disponibles con el comando gcloud compute accelerator-types list. Solo usa este campo para las GPUs de las VMs N1.

  • GPU_COUNT: Es la cantidad de GPUs del tipo especificado. Para obtener más información sobre las opciones válidas, consulta Tipos de máquinas con GPU para la serie de máquinas N1. Solo usa este campo para las GPUs de las VMs N1.

  • ALLOWED_LOCATIONS: De manera opcional, puedes usar el campo allowedLocations[] para especificar una región o zonas específicas en una región en la que se permite que se ejecuten las VMs de tu trabajo. Por ejemplo, regions/us-central1 permite todas las zonas de la región us-central1. Asegúrate de especificar ubicaciones que ofrezcan el tipo de máquina con GPU que deseas para este trabajo. De lo contrario, si omites este campo, asegúrate de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJobN1 {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // The GPU type. You can view a list of the available GPU types
    // by using the `gcloud compute accelerator-types list` command.
    String gpuType = "nvidia-tesla-t4";
    // The number of GPUs of the specified type.
    int gpuCount = 2;

    createGpuJob(projectId, region, jobName, installGpuDrivers, gpuType, gpuCount);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String gpuType, int gpuCount)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Accelerator describes Compute Engine accelerators to be attached to the VM.
      Accelerator accelerator = Accelerator.newBuilder()
          .setType(gpuType)
          .setCount(gpuCount)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(InstancePolicy.newBuilder().addAccelerators(accelerator))
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job-n1';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-tesla-t4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'n1-standard-16';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});
// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchGPUJobN1() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateBatchGPUJobN1();

Python 

from google.cloud import batch_v1


def create_gpu_job(
    project_id: str, region: str, zone: str, job_name: str
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        zone: name of the zone you want to use to run the job. Important in regard to GPUs availability.
            GPUs availability can be found here: https://cloud.google.com/compute/docs/gpus/gpu-regions-zones
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-16"

    accelerator = batch_v1.AllocationPolicy.Accelerator()
    # Note: not every accelerator is compatible with instance type
    # Read more here: https://cloud.google.com/compute/docs/gpus#t4-gpus
    accelerator.type_ = "nvidia-tesla-t4"
    accelerator.count = 1

    policy.accelerators = [accelerator]
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = ["zones/us-central1-b"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

¿Qué sigue?