Crear y ejecutar un trabajo que use GPUs

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

Cuando creas un trabajo de Batch, puedes usar GPUs para acelerar cargas de trabajo específicas. Entre los casos prácticos habituales de las tareas que usan GPUs se incluyen el procesamiento de datos intensivo y las cargas de trabajo de inteligencia artificial (IA), como el aprendizaje automático.

Antes de empezar

  1. Si no has usado Batch antes, consulta el artículo Empezar 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, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos:

    Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

    También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Crear un trabajo que use GPUs

Para crear un trabajo que use GPUs, sigue estos pasos:

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

Planificar los requisitos de un trabajo que use GPUs

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

  1. Seleccionar el tipo de máquina con GPU y la opción de consumo
  2. Instalar los controladores de la GPU
  3. Definir recursos de máquina virtual compatibles

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

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

Para seleccionar el tipo de máquina con GPU y la opción de consumo de tu trabajo, sigue estos pasos:

  1. Identifica y selecciona tu prioridad:

  2. Haz el resto de las selecciones en función de lo que sea compatible con la primera.

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

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

Selecciona el tipo de máquina con GPU

Para seleccionar el tipo de máquina con GPU de un trabajo y conocer sus requisitos, sigue estos pasos:

  1. Selecciona un tipo de máquina con GPU: para consultar los tipos de máquinas con GPU disponibles (las combinaciones válidas de tipo de GPU, número de GPUs y tipo de máquina [vCPUs 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. Conoce los requisitos de los trabajos 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 en función de 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 un número 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 un número específicos de GPUs, por lo que es funcionalmente equivalente tanto si especificas esos valores como si no, además del tipo de máquina optimizada para aceleradores.

    En concreto, Batch también permite especificar solo el tipo y el número de GPUs de las VMs optimizadas para aceleradores, pero las opciones de vCPU y memoria resultantes suelen ser muy limitadas. Por lo tanto, te recomendamos que verifiques que las opciones de vCPU y memoria disponibles sean compatibles con los requisitos de las tareas del trabajo.

    GPUs para máquinas virtuales N1: estas GPUs requieren que especifiques el tipo y la cantidad que se va a asociar a cada máquina virtual. Además, deben asociarse a máquinas virtuales con un tipo de máquina de la serie de máquinas N1.

    Para usar GPUs en máquinas virtuales N1, te recomendamos que especifiques al menos el tipo y el número 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 vCPU y memoria de las VMs N1 que usan cualquier tipo y número de GPUs son bastante flexibles. A menos que crees el trabajo con la Google Cloud consola, puedes dejar que Batch seleccione automáticamente un tipo de máquina que cumpla 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 de un trabajo y los requisitos de cada opción.

En la siguiente tabla se explican las opciones de consumo disponibles para Batch y sus requisitos. Se enumeran en función de sus casos prácticos, de mayor a menor disponibilidad de recursos.

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 máquinas virtuales de inicio flexible (vista previa) (opción preferida si cumple tus requisitos) o bajo demanda.
  • Si tu trabajo requiere una garantía muy alta de disponibilidad de recursos o si tienes reservas sin usar que no puedes eliminar, utiliza las reservas en modo calendario (vista previa) (opción preferida si cumple tus requisitos) o las reservas.
  • Opcional: Si tu carga de trabajo es muy tolerante a fallos, puedes reducir los costes probando a usar máquinas virtuales de acceso puntual.
Opciones de consumo y sus requisitos de trabajo

Reservas

  • Caso práctico: te recomendamos que uses reservas para trabajos si quieres tener una certeza muy alta de la disponibilidad de recursos y no puedes usar reservas en modo calendario, o si ya tienes reservas que podrían no utilizarse.

  • Detalles: Una vez creada una reserva, se incurre en los costes de las VMs especificadas al mismo precio que si se ejecutaran las VMs hasta que se elimine la reserva. Las VMs que consumen una reserva no tienen costes independientes, pero las reservas sí tienen costes independientemente del consumo.

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

Por lotes usa reservas para tareas que pueden consumir máquinas virtuales reservadas que no se han usado. Para obtener más información sobre los requisitos de los trabajos para consumir reservas, consulta la página Asegurar la disponibilidad de recursos mediante reservas de VMs.

Reservas en modo Calendario (Vista previa)

  • Caso práctico: recomendamos las reservas en modo calendario para las tareas si quieres usar un tipo de máquina con GPU que admita reservas en modo calendario y necesitas un nivel de garantía muy alto 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 calendario que puedas usar. Si Compute Engine cumple una solicitud de reserva futura en modo calendario, la reserva en modo calendario que se crea automáticamente tiene el mismo coste que ejecutar las VMs especificadas durante todo el periodo de reserva con los precios de Dynamic Workload Scheduler, que ofrece descuentos de hasta el 53% sobre los precios bajo demanda. Una vez que hayas identificado una reserva en modo calendario creada automáticamente que puedas usar, crear un trabajo que consuma una reserva en modo calendario es muy similar a crear un trabajo que consuma una reserva.

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

Batch usa reservas en modo calendario para las tareas que cumplen todos los requisitos siguientes:

Máquinas virtuales de inicio flexible (vista previa)

  • Caso práctico: te recomendamos que uses máquinas virtuales de inicio flexible si tu trabajo puede tolerar la disponibilidad con el mejor esfuerzo posible a cambio de precios con descuento y hasta 7 días para finalizar la ejecución.

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

  • Detalles: si se completa una solicitud para crear un trabajo que use máquinas virtuales de inicio flexible, se cobrarán las máquinas virtuales según los precios de Dynamic Workload Scheduler, que ofrece descuentos de hasta el 53% sobre los precios bajo demanda.

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

Batch usa VMs de inicio flexible para las tareas que cumplen todos los requisitos siguientes:

Bajo demanda

  • Caso práctico: te recomendamos que uses la opción de bajo demanda para la mayoría de los demás trabajos de forma predeterminada.1

  • Detalles: el acceso a las VMs de Compute Engine suele ser bajo demanda de forma predeterminada. La función bajo demanda te permite acceder a los recursos (si están disponibles) cuando los solicitas. Los recursos se eliminan hasta que finaliza el trabajo o se alcanza el límite de tiempo de ejecución.

Batch usa el modelo bajo demanda para la mayoría de los demás trabajos de forma predeterminada. Si quieres asegurarte de que un trabajo usa recursos bajo demanda, haz lo siguiente:1

  • Asigna el valor STANDARD al campo provisioningModel.
  • Bloquear reservas Para evitar que un trabajo consuma automáticamente recursos mediante reservas compatibles, asigna el valor NO_RESERVATION al campo reservation. Para obtener más información, consulta Crear y ejecutar un trabajo que no pueda consumir VMs reservadas.

1Excepción: En las tareas que usan la serie de máquinas A3, el comportamiento predeterminado es único. Te recomendamos que no uses máquinas virtuales bajo demanda y que no dejes el campo provisioningModel sin definir. En su lugar, consulta los requisitos de las tareas para las máquinas virtuales de inicio flexible. No se recomienda usar la opción bajo demanda en la serie de máquinas A3 debido a la baja disponibilidad de recursos. Por lo tanto, si una tarea usa la serie de máquinas A3, bloquea las reservas y el campo provisioningModel no está definido o tiene el valor STANDARD, la opción de consumo predeterminada es única: el comportamiento es similar al de las máquinas virtuales de inicio flexible, que limita el tiempo de ejecución a 7 días. Sin embargo, no se recomienda porque estas tareas no reciben descuentos de los precios de Dynamic Workload Scheduler. Si tu trabajo con VMs A3 puede tolerar un límite de tiempo de ejecución de 7 días, te recomendamos que utilices VMs de inicio flexible en lugar de VMs bajo demanda. De lo contrario, no podrás asegurarte de que los trabajos con VMs A3 usen recursos bajo demanda, a menos que definas provisioningModel como STANDARD y verifiques manualmente que el trabajo no puede consumir reservas sin definir el campo reservation como NO_RESERVATION.

Máquinas virtuales de acceso puntual

  • Caso práctico: te recomendamos que pruebes a usar máquinas virtuales de Spot para reducir los costes de las cargas de trabajo tolerantes a fallos.

  • Detalles: si se completa una solicitud para crear un trabajo que use máquinas virtuales de Spot, se cobrarán las máquinas virtuales según los precios de las máquinas virtuales de Spot, que pueden cambiar a menudo y ofrecer el mayor descuento, de hasta el 91 % sobre los precios bajo demanda. Sin embargo, es posible que las máquinas virtuales de acceso puntual no siempre estén disponibles y se puedan interrumpir en cualquier momento.

    Consulta más información sobre las VMs de acceso puntual en la documentación de Compute Engine.

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

  • Asigna el valor SPOT al campo provisioningModel.
  • (Opcional) Bloquea las reservas. No puedes usar máquinas virtuales de Spot con reservas. En concreto, el trabajo puede definir de forma opcional el campo reservation en NO_RESERVATION. Para obtener más información, consulta Crear y ejecutar un trabajo que no pueda consumir VMs reservadas.

Paso 2: Instala los controladores de la GPU

Para usar las 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 los 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 de trabajo.

En resumen, debes hacer lo siguiente al definir los recursos de VM para un trabajo que utilice 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 la sección Disponibilidad de aceleradores de la documentación de Compute Engine.

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

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

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

Crear 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. En concreto, los trabajos de ejemplo usan las opciones recomendadas: todos instalan automáticamente los controladores de GPU y todos definen directamente los recursos de la VM.

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

Garantizar la disponibilidad de recursos con reservas de VMs
Máquinas virtuales de inicio flexible (vista previa)

Usar GPUs y máquinas virtuales de inicio flexible
Máquinas virtuales bajo demanda o de acceso puntual

Selecciona una de las siguientes opciones en función del tipo de máquina con GPU:

Usar GPUs y máquinas virtuales de inicio flexible

Puedes crear un trabajo que use GPUs para máquinas virtuales A3 a través de Dynamic Workload Scheduler con la CLI de gcloud o la API Batch.

gcloud

  1. Crea un archivo JSON que instale controladores de GPU, especifique un tipo de máquina con GPU que admita máquinas virtuales 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 máquinas virtuales de inicio flexible y GPUs para máquinas virtuales 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"
    }
}

    Haz los cambios siguientes:

    • INSTALL_GPU_DRIVERS: si se le asigna el valor true, Batch obtiene los controladores necesarios para el tipo de GPU que especifiques en el campo policy de una ubicación de terceros y los instala en tu nombre. Si asignas el valor false (predeterminado) a este campo, tendrás que instalar los controladores de GPU manualmente para usar cualquier GPU en este trabajo.

    • MACHINE_TYPE: un tipo de máquina con GPU que admite máquinas virtuales de inicio flexible. Para obtener más información, consulta el artículo Disponibilidad de la opción de consumo por tipo de máquina de la documentación de Compute Engine.

    • ALLOWED_LOCATIONS: También puedes usar el campo allowedLocations[] para especificar una región o zonas concretas de una región en las que se puedan ejecutar 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 quieras usar en este trabajo. De lo contrario, si omite este campo, asegúrese de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

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

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

    Haz los cambios siguientes:

    • JOB_NAME: el nombre del trabajo.

    • LOCATION: la ubicación del puesto.

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

API

Haz una solicitud POST al método v1alpha jobs.create que instale los controladores de GPU, especifique un tipo de máquina con GPU que admita VMs de inicio flexible, bloquee las 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, haz 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"
    }
}

Haz los cambios siguientes:

  • PROJECT_ID: el ID de proyecto de tu proyecto.

  • LOCATION: la ubicación del puesto.

  • JOB_NAME: el nombre del trabajo.

  • INSTALL_GPU_DRIVERS: si se le asigna el valor true, Batch obtiene los controladores necesarios para el tipo de GPU que especifiques en el campo policy de una ubicación de terceros y los instala en tu nombre. Si asignas el valor false (predeterminado) a este campo, tendrás que instalar los controladores de GPU manualmente para usar cualquier GPU en este trabajo.

  • MACHINE_TYPE: un tipo de máquina con GPU que admite máquinas virtuales de inicio flexible. Para obtener más información, consulta el artículo Disponibilidad de la opción de consumo por tipo de máquina de la documentación de Compute Engine.

  • ALLOWED_LOCATIONS: También puedes usar el campo allowedLocations[] para especificar una región o zonas concretas de una región en las que se puedan ejecutar 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 quieras usar en este trabajo. De lo contrario, si omite este campo, asegúrese de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

Usar GPUs en máquinas virtuales optimizadas para aceleradores

Puedes crear una tarea que use GPUs para máquinas virtuales optimizadas para aceleradores mediante laGoogle Cloud consola, la CLI de gcloud, la API Batch, Java, Node.js o Python.

Consola

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

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

    Ir a la lista de tareas

  2. Haz clic en Crear. Se abrirá la página Crear tarea por lotes. En el panel de la izquierda, se selecciona la página Detalles de la tarea.

  3. Configura la página Detalles del empleo:

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

      Por ejemplo, escribe example-gpu-job.

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

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

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

        1. Seleccione la casilla Secuencia de comandos. Aparecerá un campo.

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

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Haz clic en Listo.

      2. En el campo Número de tareas, introduce el número de tareas de este trabajo.

        Por ejemplo, escribe 3.

      3. Opcional: En el campo Paralelismo, introduce el número de tareas que se van a ejecutar simultáneamente.

        Por ejemplo, introduce 1 (valor predeterminado).

  4. Configura la página Especificaciones de recursos:

    1. En el panel de la izquierda, haga clic en Especificaciones de recursos. Se abrirá la página Especificaciones de los recursos.

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

      • Si tu trabajo puede tolerar las interrupciones y quieres máquinas virtuales de acceso puntual con descuento, selecciona Spot.

      • De lo contrario, para usar máquinas virtuales bajo demanda, selecciona Estándar (opción predeterminada).

    3. Selecciona la ubicación de este trabajo.

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

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

        • Si quieres que esta tarea solo se ejecute en una zona específica, selecciona una zona.

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

    4. Selecciona el tipo de máquina con 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. A continuación, en el campo Número de GPUs, selecciona el número de GPUs de cada VM.

        Si has seleccionado uno de los tipos de GPU para las VMs optimizadas para aceleradores, el campo Tipo de máquina solo permite una opción para el tipo de máquina en función del tipo y el número de GPUs que hayas seleccionado.

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

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

      1. En el campo Cores (Núcleos), introduce la cantidad de vCPUs por tarea.

        Por ejemplo, introduce 1 (valor predeterminado).

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

        Por ejemplo, introduce 0.5 (valor predeterminado).

    6. Haz clic en Listo.

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

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

  7. Haz clic en Crear.

    En la página Detalles de la tarea se muestra la tarea que has creado.

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 máquinas virtuales 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"
    }
}

    Haz los cambios siguientes:

    • INSTALL_GPU_DRIVERS: si se le asigna el valor true, Batch obtiene los controladores necesarios para el tipo de GPU que especifiques en el campo policy de una ubicación de terceros y los instala en tu nombre. Si asignas el valor false (predeterminado) a este campo, tendrás que instalar los controladores de GPU manualmente para usar cualquier GPU en este trabajo.

    • PROVISIONING_MODEL: el modelo de aprovisionamiento de tu opción de consumo: STANDARD para la opción bajo demanda o SPOT para las máquinas virtuales de acceso puntual.

    • MACHINE_TYPE: un tipo de máquina de la familia de máquinas optimizadas para aceleradores.

    • ALLOWED_LOCATIONS: También puedes usar el campo allowedLocations[] para especificar una región o zonas concretas de una región en las que se puedan ejecutar 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 quieras usar en este trabajo. De lo contrario, si omite este campo, asegúrese de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

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

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

    Haz los cambios siguientes:

    • JOB_NAME: el nombre del trabajo.

    • LOCATION: la ubicación del puesto.

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

API

Envía una solicitud POST al método jobs.create que instala los 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 máquinas virtuales optimizadas para aceleradores, haz 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"
    }
}

Haz los cambios siguientes:

  • PROJECT_ID: el ID de proyecto de tu proyecto.

  • LOCATION: la ubicación del puesto.

  • JOB_NAME: el nombre del trabajo.

  • INSTALL_GPU_DRIVERS: Si se le asigna el valor true, Batch obtiene los controladores necesarios para el tipo de GPU que especifiques en el campo policy de una ubicación de terceros y los instala en tu nombre. Si asignas el valor false (predeterminado) a este campo, tendrás que instalar los controladores de GPU manualmente para usar cualquier GPU en este trabajo.

  • PROVISIONING_MODEL: el modelo de aprovisionamiento de tu opción de consumo: STANDARD para la opción bajo demanda o SPOT para las máquinas virtuales de acceso puntual.

  • MACHINE_TYPE: un tipo de máquina de la familia de máquinas optimizadas para aceleradores.

  • ALLOWED_LOCATIONS: También puedes usar el campo allowedLocations[] para especificar una región o zonas concretas de una región en las que se puedan ejecutar 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 quieras usar en este trabajo. De lo contrario, si omite este campo, asegúrese 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)

Usar GPUs para máquinas virtuales N1

Puedes crear una tarea que use GPUs para máquinas virtuales N1 mediante la Google Cloud consola, la CLI de gcloud, la API Batch, Java, Node.js o Python.

Consola

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

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

    Ir a la lista de tareas

  2. Haz clic en Crear. Se abrirá la página Crear tarea por lotes. En el panel de la izquierda, se selecciona la página Detalles de la tarea.

  3. Configura la página Detalles del empleo:

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

      Por ejemplo, escribe example-gpu-job.

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

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

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

        1. Seleccione la casilla Secuencia de comandos. Aparecerá un campo.

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

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Haz clic en Listo.

      2. En el campo Número de tareas, introduce el número de tareas de este trabajo.

        Por ejemplo, escribe 3.

      3. Opcional: En el campo Paralelismo, introduce el número de tareas que se van a ejecutar simultáneamente.

        Por ejemplo, introduce 1 (valor predeterminado).

  4. Configura la página Especificaciones de recursos:

    1. En el panel de la izquierda, haga clic en Especificaciones de recursos. Se abrirá la página Especificaciones de los recursos.

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

      • Si tu trabajo puede tolerar las interrupciones y quieres máquinas virtuales de acceso puntual con descuento, selecciona Spot.

      • De lo contrario, para usar máquinas virtuales bajo demanda, selecciona Estándar (opción predeterminada).

    3. Selecciona la ubicación de este trabajo.

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

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

        • Si quieres que esta tarea solo se ejecute en una zona específica, selecciona una zona.

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

    4. Selecciona el tipo de máquina con 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 has seleccionado uno de los tipos de GPU para máquinas virtuales N1, el campo Serie se define como N1.

      3. En el campo Número de GPUs, selecciona el número de GPUs de cada VM.

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

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

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

      1. En el campo Cores (Núcleos), introduce la cantidad de vCPUs por tarea.

        Por ejemplo, introduce 1 (valor predeterminado).

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

        Por ejemplo, introduce 0.5 (valor predeterminado).

    6. Haz clic en Listo.

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

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

  7. Haz clic en Crear.

    En la página Detalles de la tarea se muestra la tarea que has creado.

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"
    }
}

    Haz los cambios siguientes:

    • INSTALL_GPU_DRIVERS: si se le asigna el valor true, Batch obtiene los controladores necesarios para el tipo de GPU que especifiques en el campo policy de una ubicación de terceros y los instala en tu nombre. Si asignas el valor false (predeterminado) a este campo, tendrás que instalar los controladores de GPU manualmente para usar cualquier GPU en este trabajo.

    • PROVISIONING_MODEL: el modelo de aprovisionamiento de tu opción de consumo: STANDARD para la opción bajo demanda o SPOT para las máquinas virtuales de acceso puntual.

    • GPU_TYPE: el tipo de GPU. Para ver una lista de los tipos de GPU disponibles, usa el comando gcloud compute accelerator-types list. Solo se debe usar este campo para las GPUs de las VMs N1.

    • GPU_COUNT: número de GPUs del tipo especificado. Para obtener más información sobre las opciones válidas, consulta los tipos de máquinas con GPU de la serie de máquinas N1. Solo se debe usar este campo para las GPUs de las VMs N1.

    • ALLOWED_LOCATIONS: También puedes usar el campo allowedLocations[] para especificar una región o zonas concretas de una región en las que se puedan ejecutar 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 quieras usar en este trabajo. De lo contrario, si omite este campo, asegúrese de que la ubicación del trabajo ofrezca el tipo de máquina con GPU.

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

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

    Haz los cambios siguientes:

    • JOB_NAME: el nombre del trabajo.

    • LOCATION: la ubicación del puesto.

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

API

Haz 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 una tarea de script básica que use GPUs para máquinas virtuales N1 y permita que Batch seleccione el tipo de máquina N1 exacto, haz 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"
    }
}

Haz los cambios siguientes:

  • PROJECT_ID: el ID de proyecto de tu proyecto.

  • LOCATION: la ubicación del puesto.

  • JOB_NAME: el nombre del trabajo.

  • INSTALL_GPU_DRIVERS: Si se le asigna el valor true, Batch obtiene los controladores necesarios para el tipo de GPU que especifiques en el campo policy de una ubicación de terceros y los instala en tu nombre. Si asignas el valor false (predeterminado) a este campo, tendrás que instalar los controladores de GPU manualmente para usar cualquier GPU en este trabajo.

  • PROVISIONING_MODEL: el modelo de aprovisionamiento de tu opción de consumo: STANDARD para la opción bajo demanda o SPOT para las máquinas virtuales de acceso puntual.

  • GPU_TYPE: el tipo de GPU. Para ver una lista de los tipos de GPU disponibles, usa el comando gcloud compute accelerator-types list. Solo se debe usar este campo para las GPUs de las VMs N1.

  • GPU_COUNT: número 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 se debe usar este campo para las GPUs de las VMs N1.

  • ALLOWED_LOCATIONS: También puedes usar el campo allowedLocations[] para especificar una región o zonas concretas de una región en las que se puedan ejecutar 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 quieras usar en este trabajo. De lo contrario, si omite este campo, asegúrese 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)

Siguientes pasos