Grupos de nodos de controlador de Dataproc

Un recurso NodeGroup de Dataproc es un grupo de nodos de clúster de Dataproc que ejecutan un rol asignado. En esta página, se describe el grupo de nodos controladores, que es un grupo de VMs de Compute Engine a las que se les asigna el rol de Driver para ejecutar controladores de trabajos en el clúster de Dataproc.

que existen durante el ciclo de vida de un solo trabajo.

Cuándo usar grupos de nodos de controladores

  • Usa grupos de nodos controladores solo cuando necesites ejecutar muchos trabajos simultáneos en un clúster compartido.
  • Aumenta los recursos del nodo principal antes de usar grupos de nodos de controladores para evitar las limitaciones de los grupos de nodos de controladores.

Cómo los nodos de controlador te ayudan a ejecutar trabajos simultáneos

Dataproc inicia un proceso de controlador de trabajos en un nodo instancia principal del clúster de Dataproc para cada trabajo. A su vez, el proceso del controlador ejecuta un controlador de aplicación, como spark-submit, como su proceso secundario. Sin embargo, la cantidad de trabajos simultáneos que se ejecutan en el nodo principal está limitada por los recursos disponibles en el nodo principal. Dado que los nodos principales de Dataproc no se pueden escalar, un trabajo puede fallar o limitarse cuando los recursos del nodo principal son insuficientes para ejecutarlo.

Los grupos de nodos de controladores son grupos de nodos especiales que administra YARN, por lo que la simultaneidad de los trabajos no está limitada por los recursos del nodo principal. En los clústeres con un grupo de nodos de controlador, los controladores de aplicaciones se ejecutan en los nodos de controlador. Cada nodo de controlador puede ejecutar varios controladores de aplicaciones si tiene suficientes recursos.

Beneficios

Usar un clúster de Dataproc con un grupo de nodos controladores te permite hacer lo siguiente:

  • Ajusta horizontalmente la escala de los recursos del controlador de trabajos para ejecutar más trabajos simultáneos
  • Ajusta los recursos del controlador por separado de los recursos del trabajador
  • Obtén una reducción más rápida en los clústeres de imágenes de Dataproc 2.0 y versiones posteriores. En estos clústeres, el administrador de la aplicación se ejecuta dentro de un controlador de Spark en un grupo de nodos de controlador (spark.yarn.unmanagedAM.enabled se establece en true de forma predeterminada).
  • Personaliza el inicio del nodo del controlador. Puedes agregar {ROLE} == 'Driver' en una secuencia de comandos de inicialización para que la secuencia de comandos realice acciones para un grupo de nodos controladores en la selección de nodos.

Limitaciones

  • Los grupos de nodos no son compatibles con las plantillas de flujo de trabajo de Dataproc.
  • Los clústeres de grupos de nodos no se pueden detener, reiniciar ni ajustar su escala automáticamente.
  • El administrador de la app de MapReduce se ejecuta en los nodos trabajadores. La reducción de escala de los nodos trabajadores puede ser lenta si habilitas el retiro ordenado.
  • La simultaneidad de los trabajos se ve afectada por la propiedad del clúster dataproc:agent.process.threads.job.max. Por ejemplo, con tres maestros y esta propiedad establecida en el valor predeterminado de 100, la simultaneidad máxima de trabajos a nivel del clúster es 300.

Comparación del grupo de nodos del controlador con el modo de clúster de Spark

Función Modo de clúster de Spark Grupo de nodos del controlador
Reducción de la escala del nodo trabajador Los controladores de larga duración se ejecutan en los mismos nodos trabajadores que los contenedores de corta duración, por lo que la reducción de la cantidad de trabajadores con la baja gradual es lenta. Los nodos trabajadores se reducen más rápido cuando los controladores se ejecutan en grupos de nodos.
Salida del controlador transmitida Se requiere buscar en los registros de YARN para encontrar el nodo en el que se programó el controlador. El resultado del controlador se transmite a Cloud Storage y se puede ver en la consola de Google Cloud y en el resultado del comandogcloud dataproc jobs waitdespués de que se completa un trabajo.

Permisos de IAM del grupo de nodos del controlador

Los siguientes permisos de IAM están asociados con las acciones relacionadas con los grupos de nodos de Dataproc.

Permiso Acción
dataproc.nodeGroups.create Crea grupos de nodos de Dataproc. Si un usuario tiene dataproc.clusters.create en el proyecto, se otorga este permiso.
dataproc.nodeGroups.get Obtiene los detalles de un grupo de nodos de Dataproc.
dataproc.nodeGroups.update Cambia el tamaño de un grupo de nodos de Dataproc.

Operaciones del grupo de nodos del controlador

Puedes usar gcloud CLI y la API de Dataproc para crear, obtener, cambiar el tamaño, borrar y enviar un trabajo a un grupo de nodos controladores de Dataproc.

Crea un clúster de grupo de nodos de controlador

Un grupo de nodos controladores se asocia con un clúster de Dataproc. Creas un grupo de nodos como parte de la creación de un clúster de Dataproc. Puedes usar gcloud CLI o la API de REST de Dataproc para crear un clúster de Dataproc con un grupo de nodos controladores.

gcloud

gcloud dataproc clusters create CLUSTER_NAME \
    --region=REGION \
    --driver-pool-size=SIZE \
    --driver-pool-id=NODE_GROUP_ID

Marcas requeridas:

  • CLUSTER_NAME: Es el nombre del clúster, que debe ser único dentro de un proyecto. El nombre debe comenzar con una letra en minúscula y puede contener hasta 51 letras en minúscula, números y guiones. No puede terminar con un guion. Se puede reutilizar el nombre de un clúster borrado.
  • REGION: Es la región en la que se ubicará el clúster.
  • SIZE: Es la cantidad de nodos controladores en el grupo de nodos. La cantidad de nodos necesarios depende de la carga de trabajo y del tipo de máquina del grupo de controladores. La cantidad de nodos de grupos de controladores mínimos es igual a la memoria total o las CPU virtuales que requieren los controladores de trabajo, dividida por la memoria de la máquina o las CPU virtuales de cada grupo de controladores.
  • NODE_GROUP_ID: Es opcional y se recomienda. El ID debe ser único dentro del clúster. Usa este ID para identificar el grupo de controladores en operaciones futuras, como cambiar el tamaño del grupo de nodos. Si no se especifica, Dataproc genera el ID del grupo de nodos.

Marca recomendada:

  • --enable-component-gateway: Agrega esta marca para habilitar la puerta de enlace de componentes de Dataproc, que proporciona acceso a la interfaz web de YARN. En las páginas Application y Scheduler de la IU de YARN, se muestran el estado del clúster y del trabajo, la memoria de la cola de aplicaciones, la capacidad del núcleo y otras métricas.

Marcas adicionales: Las siguientes marcas opcionales de driver-pool se pueden agregar al comando gcloud dataproc clusters create para personalizar el grupo de nodos.

Marcar Valor predeterminado
--driver-pool-id Es un identificador de cadena, generado por el servicio si no se establece con la marca. Este ID se puede usar para identificar el grupo de nodos cuando se realicen operaciones futuras en el grupo de nodos, como cambiar su tamaño.
--driver-pool-machine-type n1-standard-4
--driver-pool-accelerator No hay predeterminado. Cuando se especifica un acelerador, se requiere el tipo de GPU; la cantidad de GPUs es opcional.
--num-driver-pool-local-ssds Sin opción predeterminada
--driver-pool-local-ssd-interface Sin opción predeterminada
--driver-pool-boot-disk-type pd-standard
--driver-pool-boot-disk-size 1000 GB
--driver-pool-min-cpu-platform AUTOMATIC

REST

Completa un AuxiliaryNodeGroup como parte de una solicitud cluster.create de la API de Dataproc.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Obligatorio. ID del proyecto de Google Cloud.
  • REGION: Obligatorio. Región del clúster de Dataproc.
  • CLUSTER_NAME: Obligatorio. Es el nombre del clúster, que debe ser único dentro de un proyecto. El nombre debe comenzar con una letra en minúscula y puede contener hasta 51 letras en minúscula, números y guiones. No puede terminar con un guion. Se puede volver a usar el nombre de un clúster borrado.
  • SIZE: Obligatorio. Es la cantidad de nodos del grupo de nodos.
  • NODE_GROUP_ID: Opcional y recomendado. El ID debe ser único dentro del clúster. Usa este ID para identificar el grupo de controladores en operaciones futuras, como cambiar el tamaño del grupo de nodos. Si no se especifica, Dataproc genera el ID del grupo de nodos.

Opciones adicionales: Consulta NodeGroup.

Método HTTP y URL: 

POST https://dataproc.googleapis.com/v1/projects/PROJECT_ID/regions/REGION/clusters

Cuerpo JSON de la solicitud:

{
  "clusterName":"CLUSTER_NAME",
  "config": {
    "softwareConfig": {
      "imageVersion":""
    },
    "endpointConfig": {
      "enableHttpPortAccess": true
    },
    "auxiliaryNodeGroups": [{
        "nodeGroup":{
            "roles":["DRIVER"],
            "nodeGroupConfig": {
                "numInstances": SIZE
             }
         },
        "nodeGroupId": "NODE_GROUP_ID"
    }]
  }
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "projectId": "PROJECT_ID",
  "clusterName": "CLUSTER_NAME",
  "config": {
    ...
    "auxiliaryNodeGroups": [
      {
        "nodeGroup": {
"name": "projects/PROJECT_ID/regions/REGION/clusters/CLUSTER_NAME/nodeGroups/NODE_GROUP_ID",
          "roles": [
            "DRIVER"
          ],
          "nodeGroupConfig": {
            "numInstances": SIZE,
            "instanceNames": [
              "CLUSTER_NAME-np-q1gp",
              "CLUSTER_NAME-np-xfc0"
            ],
            "imageUri": "https://www.googleapis.com/compute/v1/projects/cloud-dataproc-ci/global/images/dataproc-2-0-deb10-...-rc01",
            "machineTypeUri": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/REGION-a/machineTypes/n1-standard-4",
            "diskConfig": {
              "bootDiskSizeGb": 1000,
              "bootDiskType": "pd-standard"
            },
            "managedGroupConfig": {
              "instanceTemplateName": "dataproc-2a8224d2-...",
              "instanceGroupManagerName": "dataproc-2a8224d2-..."
            },
            "minCpuPlatform": "AUTOMATIC",
            "preemptibility": "NON_PREEMPTIBLE"
          }
        },
        "nodeGroupId": "NODE_GROUP_ID"
      }
    ]
  },
}

Obtén metadatos del clúster del grupo de nodos del controlador

Puedes usar el comando gcloud dataproc node-groups describe o la API de Dataproc para obtener metadatos del grupo de nodos del controlador.

gcloud

gcloud dataproc node-groups describe NODE_GROUP_ID \
    --cluster=CLUSTER_NAME \
    --region=REGION

Marcas requeridas:

  • NODE_GROUP_ID: Puedes ejecutar gcloud dataproc clusters describe CLUSTER_NAME para enumerar el ID del grupo de nodos.
  • CLUSTER_NAME: Es el nombre del clúster.
  • REGION: Es la región del clúster.

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Obligatorio. ID del proyecto de Google Cloud.
  • REGION: Obligatorio. Es la región del clúster.
  • CLUSTER_NAME: Obligatorio. Es el nombre del clúster.
  • NODE_GROUP_ID: Obligatorio. Puedes ejecutar gcloud dataproc clusters describe CLUSTER_NAME para enumerar el ID del grupo de nodos.

Método HTTP y URL: 

GET https://dataproc.googleapis.com/v1/projects/PROJECT_ID/regions/REGION/clusters/CLUSTER_NAMEnodeGroups/Node_GROUP_ID

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/PROJECT_ID/regions/REGION/clusters/CLUSTER_NAME/nodeGroups/NODE_GROUP_ID",
  "roles": [
    "DRIVER"
  ],
  "nodeGroupConfig": {
    "numInstances": 5,
    "imageUri": "https://www.googleapis.com/compute/v1/projects/cloud-dataproc-ci/global/images/dataproc-2-0-deb10-...-rc01",
    "machineTypeUri": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/REGION-a/machineTypes/n1-standard-4",
    "diskConfig": {
      "bootDiskSizeGb": 1000,
      "bootDiskType": "pd-standard"
    },
    "managedGroupConfig": {
      "instanceTemplateName": "dataproc-driver-pool-mcia3j656h2fy",
      "instanceGroupManagerName": "dataproc-driver-pool-mcia3j656h2fy"
    },
    "minCpuPlatform": "AUTOMATIC",
    "preemptibility": "NON_PREEMPTIBLE"
  }
}

Cambia el tamaño de un grupo de nodos de controladores

Puedes usar el comando gcloud dataproc node-groups resize o la API de Dataproc para agregar o quitar nodos controladores de un grupo de nodos controladores del clúster.

gcloud

gcloud dataproc node-groups resize NODE_GROUP_ID \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --size=SIZE

Marcas requeridas:

  • NODE_GROUP_ID: Puedes ejecutar gcloud dataproc clusters describe CLUSTER_NAME para enumerar el ID del grupo de nodos.
  • CLUSTER_NAME: Es el nombre del clúster.
  • REGION: Es la región del clúster.
  • SIZE: Especifica la nueva cantidad de nodos de controlador en el grupo de nodos.

Marca opcional:

  • --graceful-decommission-timeout=TIMEOUT_DURATION: Cuando reduces la escala de un grupo de nodos, puedes agregar esta marca para especificar un retiro de servicio ordenado TIMEOUT_DURATION y evitar la finalización inmediata de los controladores de trabajos. Recomendación: Establece una duración de tiempo de espera que sea al menos igual a la duración del trabajo más largo que se ejecuta en el grupo de nodos (no se admite la recuperación de controladores con errores).

Ejemplo: Comando de aumento de escala de NodeGroup de gcloud CLI:

gcloud dataproc node-groups resize NODE_GROUP_ID \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --size=4

Ejemplo: Comando de reducción de gcloud CLI NodeGroup:

gcloud dataproc node-groups resize NODE_GROUP_ID \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --size=1 \
    --graceful-decommission-timeout="100s"

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Obligatorio. ID del proyecto de Google Cloud.
  • REGION: Obligatorio. Es la región del clúster.
  • NODE_GROUP_ID: Obligatorio. Puedes ejecutar gcloud dataproc clusters describe CLUSTER_NAME para enumerar el ID del grupo de nodos.
  • SIZE: Obligatorio. Es la nueva cantidad de nodos en el grupo de nodos.
  • TIMEOUT_DURATION: Opcional Cuando reduces la escala de un grupo de nodos, puedes agregar un gracefulDecommissionTimeout al cuerpo de la solicitud para evitar la finalización inmediata de los controladores de trabajos. Recomendación: Establece una duración de tiempo de espera que sea al menos igual a la duración del trabajo más largo que se ejecuta en el grupo de nodos (no se admite la recuperación de los controladores con errores).

    Ejemplo:

    { "size": SIZE,
  "gracefulDecommissionTimeout": "TIMEOUT_DURATION"
}

Método HTTP y URL: 

POST https://dataproc.googleapis.com/v1/projects/PROJECT_ID/regions/REGION/clusters/CLUSTER_NAME/nodeGroups/Node_GROUP_ID:resize

Cuerpo JSON de la solicitud:

{
  "size": SIZE,
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/PROJECT_ID/regions/REGION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.dataproc.v1.NodeGroupOperationMetadata",
    "nodeGroupId": "NODE_GROUP_ID",
    "clusterUuid": "CLUSTER_UUID",
    "status": {
      "state": "PENDING",
      "innerState": "PENDING",
      "stateStartTime": "2022-12-01T23:34:53.064308Z"
    },
    "operationType": "RESIZE",
    "description": "Scale "up or "down" a GCE node pool to SIZE nodes."
  }
}

Borra un clúster de grupo de nodos de controlador

Cuando borras un clúster de Dataproc, se borran los grupos de nodos asociados con el clúster.

Envía un trabajo

Puedes usar el comando gcloud dataproc jobs submit o la API de Dataproc para enviar un trabajo a un clúster con un grupo de nodos controladores.

gcloud

gcloud dataproc jobs submit JOB_COMMAND \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --driver-required-memory-mb=DRIVER_MEMORY \
    --driver-required-vcores=DRIVER_VCORES \
    DATAPROC_FLAGS \
    -- JOB_ARGS

Marcas requeridas:

  • JOB_COMMAND: Especifica el comando del trabajo.
  • CLUSTER_NAME: Es el nombre del clúster.
  • DRIVER_MEMORY: Cantidad de memoria en MB de los controladores de trabajos que se necesita para ejecutar un trabajo (consulta Controles de memoria de Yarn).
  • DRIVER_VCORES: Es la cantidad de CPU virtuales necesarias para ejecutar un trabajo.

Marcas adicionales:

  • DATAPROC_FLAGS: Agrega cualquier marca adicional de gcloud dataproc jobs submit relacionada con el tipo de trabajo.
  • JOB_ARGS: Agrega los argumentos que desees (después de --) para pasar al trabajo.

Ejemplos: Puedes ejecutar los siguientes ejemplos desde una sesión de terminal SSH en un clúster de grupo de nodos del controlador de Dataproc.

  • Trabajo de Spark para estimar el valor de pi:

    gcloud dataproc jobs submit spark \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --driver-required-memory-mb=2048 \
    --driver-required-vcores=2 \
    --class=org.apache.spark.examples.SparkPi \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    -- 1000

  • Trabajo de conteo de palabras de Spark:

    gcloud dataproc jobs submit spark \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --driver-required-memory-mb=2048 \
    --driver-required-vcores=2 \
    --class=org.apache.spark.examples.JavaWordCount \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    -- 'gs://apache-beam-samples/shakespeare/macbeth.txt'

  • Trabajo de PySpark para estimar el valor de pi:

    gcloud dataproc jobs submit pyspark \
    file:///usr/lib/spark/examples/src/main/python/pi.py \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --driver-required-memory-mb=2048 \
    --driver-required-vcores=2 \
    -- 1000

  • Trabajo TeraGen de MapReduce de Hadoop:

    gcloud dataproc jobs submit hadoop \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --driver-required-memory-mb=2048 \
    --driver-required-vcores=2 \
    --jar file:///usr/lib/hadoop-mapreduce/hadoop-mapreduce-examples.jar \
    -- teragen 1000 \
    hdfs:///gen1/test

REST

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • PROJECT_ID: Obligatorio. ID del proyecto de Google Cloud.
  • REGION: Obligatorio. Región del clúster de Dataproc
  • CLUSTER_NAME: Obligatorio. Es el nombre del clúster, que debe ser único dentro de un proyecto. El nombre debe comenzar con una letra en minúscula y puede contener hasta 51 letras en minúscula, números y guiones. No puede terminar con un guion. Se puede volver a usar el nombre de un clúster borrado.
  • DRIVER_MEMORY: Obligatorio. Cantidad de memoria de los controladores de trabajos en MB necesaria para ejecutar un trabajo (consulta Controles de memoria de Yarn).
  • DRIVER_VCORES: Obligatorio. Es la cantidad de CPU virtuales necesarias para ejecutar un trabajo.
Campos adicionales: Agrega campos adicionales relacionados con el tipo de trabajo y los argumentos del trabajo (la solicitud de muestra incluye los campos necesarios para enviar un trabajo de Spark que estima el valor de pi).

Método HTTP y URL: 

POST https://dataproc.googleapis.com/v1/projects/PROJECT_ID/regions/REGION/jobs:submit

Cuerpo JSON de la solicitud:

{
  "job": {
    "placement": {
    "clusterName": "CLUSTER_NAME",
    },
    "driverSchedulingConfig": {
      "memoryMb]": DRIVER_MEMORY,
      "vcores": DRIVER_VCORES
    },
    "sparkJob": {
      "jarFileUris": "file:///usr/lib/spark/examples/jars/spark-examples.jar",
      "args": [
        "10000"
      ],
      "mainClass": "org.apache.spark.examples.SparkPi"
    }
  }
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "reference": {
    "projectId": "PROJECT_ID",
    "jobId": "job-id"
  },
  "placement": {
    "clusterName": "CLUSTER_NAME",
    "clusterUuid": "cluster-Uuid"
  },
  "sparkJob": {
    "mainClass": "org.apache.spark.examples.SparkPi",
    "args": [
      "1000"
    ],
    "jarFileUris": [
      "file:///usr/lib/spark/examples/jars/spark-examples.jar"
    ]
  },
  "status": {
    "state": "PENDING",
    "stateStartTime": "start-time"
  },
  "jobUuid": "job-Uuid"
}

Python

  1. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el código.
    • Trabajo de Spark para estimar el valor de pi: 
      
import re

from google.cloud import dataproc_v1 as dataproc
from google.cloud import storage


def submit_job(project_id: str, region: str, cluster_name: str) -> None:
    """Submits a Spark job to the specified Dataproc cluster with a driver node group and prints the output.

    Args:
        project_id: The Google Cloud project ID.
        region: The Dataproc region where the cluster is located.
        cluster_name: The name of the Dataproc cluster.
    """
    # Create the job client.
    with dataproc.JobControllerClient(
        client_options={"api_endpoint": f"{region}-dataproc.googleapis.com:443"}
    ) as job_client:

        driver_scheduling_config = dataproc.DriverSchedulingConfig(
            memory_mb=2048,  # Example memory in MB
            vcores=2,  # Example number of vcores
        )

        # Create the job config. 'main_jar_file_uri' can also be a
        # Google Cloud Storage URL.
        job = {
            "placement": {"cluster_name": cluster_name},
            "spark_job": {
                "main_class": "org.apache.spark.examples.SparkPi",
                "jar_file_uris": ["file:///usr/lib/spark/examples/jars/spark-examples.jar"],
                "args": ["1000"],
            },
            "driver_scheduling_config": driver_scheduling_config
        }

        operation = job_client.submit_job_as_operation(
            request={"project_id": project_id, "region": region, "job": job}
        )

        response = operation.result()

        # Dataproc job output gets saved to the Cloud Storage bucket
        # allocated to the job. Use a regex to obtain the bucket and blob info.
        matches = re.match("gs://(.*?)/(.*)", response.driver_output_resource_uri)
        if not matches:
            print(f"Error: Could not parse driver output URI: {response.driver_output_resource_uri}")
            raise ValueError

        output = (
            storage.Client()
            .get_bucket(matches.group(1))
            .blob(f"{matches.group(2)}.000000000")
            .download_as_bytes()
            .decode("utf-8")
        )

        print(f"Job finished successfully: {output}")
    • Trabajo de PySpark para imprimir "hello world": 
      
import re

from google.cloud import dataproc_v1 as dataproc
from google.cloud import storage


def submit_job(project_id, region, cluster_name):
    """Submits a PySpark job to a Dataproc cluster with a driver node group.

    Args:
        project_id (str): The ID of the Google Cloud project.
        region (str): The region where the Dataproc cluster is located.
        cluster_name (str): The name of the Dataproc cluster.
    """
    # Create the job client.
    job_client = dataproc.JobControllerClient(
        client_options={"api_endpoint": f"{region}-dataproc.googleapis.com:443"}
    )

    driver_scheduling_config = dataproc.DriverSchedulingConfig(
        memory_mb=2048,  # Example memory in MB
        vcores=2,  # Example number of vcores
    )

    # Create the job config. The main Python file URI points to the script in
    # a Google Cloud Storage bucket.
    job = {
        "placement": {"cluster_name": cluster_name},
        "pyspark_job": {
            "main_python_file_uri": "gs://dataproc-examples/pyspark/hello-world/hello-world.py"
        },
        "driver_scheduling_config": driver_scheduling_config,
    }

    operation = job_client.submit_job_as_operation(
        request={"project_id": project_id, "region": region, "job": job}
    )
    response = operation.result()

    # Dataproc job output gets saved to the Google Cloud Storage bucket
    # allocated to the job. Use a regex to obtain the bucket and blob info.
    matches = re.match("gs://(.*?)/(.*)", response.driver_output_resource_uri)
    if not matches:
        raise ValueError(
            f"Unexpected driver output URI: {response.driver_output_resource_uri}"
        )

    output = (
        storage.Client()
        .get_bucket(matches.group(1))
        .blob(f"{matches.group(2)}.000000000")
        .download_as_bytes()
        .decode("utf-8")
    )

    print(f"Job finished successfully: {output}")

Ver registros de trabajos

Para ver el estado del trabajo y ayudar a depurar los problemas relacionados con él, puedes consultar los registros del controlador con gcloud CLI o la consola de Google Cloud .

gcloud

Los registros del controlador del trabajo se transmiten al resultado de gcloud CLI o a la consola deGoogle Cloud durante la ejecución del trabajo. Los registros del controlador persisten en el bucket de staging del clúster de Dataproc en Cloud Storage.

Ejecuta el siguiente comando de gcloud CLI para enumerar la ubicación de los registros del controlador en Cloud Storage:

gcloud dataproc jobs describe JOB_ID \
    --region=REGION

La ubicación de Cloud Storage de los registros del conductor se muestra como driverOutputResourceUri en el resultado del comando con el siguiente formato:

driverOutputResourceUri: gs://CLUSTER_STAGING_BUCKET/google-cloud-dataproc-metainfo/CLUSTER_UUID/jobs/JOB_ID

Console

Para ver los registros del clúster del grupo de nodos, haz lo siguiente:

  1. Habilita el registro.

  2. Puedes usar el siguiente formato de consulta del Explorador de registros para encontrar registros: 

    resource.type="cloud_dataproc_cluster"
resource.labels.project_id="PROJECT_ID"
resource.labels.cluster_name="CLUSTER_NAME"
log_name="projects/PROJECT_ID/logs/LOG_TYPE>"
    Reemplaza lo siguiente:

    • PROJECT_ID: Google Cloud ID del proyecto.
    • CLUSTER_NAME: Es el nombre del clúster.
    • LOG_TYPE:
      • Registros de usuarios de Yarn: yarn-userlogs
      • Registros del administrador de recursos de Yarn: hadoop-yarn-resourcemanager
      • Registros del administrador de nodos de Yarn: hadoop-yarn-nodemanager

Supervisa las métricas

Los controladores de trabajos de grupos de nodos de Dataproc se ejecutan en una cola secundaria dataproc-driverpool-driver-queue en una partición dataproc-driverpool.

Métricas del grupo de nodos de controladores

En la siguiente tabla, se enumeran las métricas asociadas del controlador del grupo de nodos, que se recopilan de forma predeterminada para los grupos de nodos del controlador.

Métrica del grupo de nodos de la variable de conducción Descripción
yarn:ResourceManager:DriverPoolsQueueMetrics:AvailableMB Cantidad de memoria disponible en mebibytes en dataproc-driverpool-driver-queue en la partición dataproc-driverpool.
yarn:ResourceManager:DriverPoolsQueueMetrics:PendingContainers Cantidad de contenedores pendientes (en cola) en dataproc-driverpool-driver-queue en la partición dataproc-driverpool.

Métricas de la cola secundaria

En la siguiente tabla, se enumeran las métricas de la cola secundaria. Las métricas se recopilan de forma predeterminada para los grupos de nodos controladores y se pueden habilitar para la recopilación en cualquier clúster de Dataproc.

Métrica de la cola secundaria Descripción
yarn:ResourceManager:ChildQueueMetrics:AvailableMB Cantidad de memoria disponible en mebibytes en esta cola en la partición predeterminada.
yarn:ResourceManager:ChildQueueMetrics:PendingContainers Cantidad de contenedores pendientes (en cola) en esta cola en la partición predeterminada.
yarn:ResourceManager:ChildQueueMetrics:running_0 Es la cantidad de trabajos con un tiempo de ejecución entre 0 y 60 minutos en esta cola en todas las particiones.
yarn:ResourceManager:ChildQueueMetrics:running_60 Es la cantidad de trabajos con un tiempo de ejecución entre 60 y 300 minutos en esta cola en todas las particiones.
yarn:ResourceManager:ChildQueueMetrics:running_300 Es la cantidad de trabajos con un tiempo de ejecución entre 300 y 1440 minutos en esta cola en todas las particiones.
yarn:ResourceManager:ChildQueueMetrics:running_1440 Es la cantidad de trabajos con un tiempo de ejecución superior a 1440 minutos en esta cola en todas las particiones.
yarn:ResourceManager:ChildQueueMetrics:AppsSubmitted Cantidad de solicitudes enviadas a esta cola en todas las particiones.

Para ver YARN ChildQueueMetrics y DriverPoolsQueueMetrics en la consola deGoogle Cloud , haz lo siguiente:

Depura el controlador del trabajo del grupo de nodos

En esta sección, se proporcionan las condiciones y los errores del grupo de nodos del controlador, junto con recomendaciones para corregirlos.

Condiciones

  • Condición: yarn:ResourceManager:DriverPoolsQueueMetrics:AvailableMB se acerca a 0. Esto indica que las filas de los grupos de conductores del clúster se están quedando sin memoria.

    Recomendación: Aumenta el tamaño del grupo de conductores.

  • Condición: yarn:ResourceManager:DriverPoolsQueueMetrics:PendingContainers es mayor que 0. Esto puede indicar que las colas de grupos de controladores del clúster se están quedando sin memoria y que YARN está poniendo en cola los trabajos.

    Recomendación: Aumenta el tamaño del grupo de conductores.

Errores

  • Error: Cluster <var>CLUSTER_NAME</var> requires driver scheduling config to run SPARK job because it contains a node pool with role DRIVER. Positive values are required for all driver scheduling config values.

    Recomendación: Establece driver-required-memory-mb y driver-required-vcores con números positivos.

  • Error: Container exited with a non-zero exit code 137.

    Recomendación: Aumenta driver-required-memory-mb al uso de memoria del trabajo.