Ejecuta una carga de trabajo por lotes de Apache Spark

Aprende a usar Dataproc sin servidores para enviar una carga de trabajo por lotes en una infraestructura de procesamiento administrada por Dataproc que escale los recursos según sea necesario.

Antes de comenzar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Dataproc API.

    Enable the API

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Dataproc API.

    Enable the API

    8.
  8. Asegúrate de que la subred de VPC regional en la que ejecutarás tu carga de trabajo tenga habilitado el Acceso privado a Google. Para obtener más información, consulta Cómo enviar una carga de trabajo por lotes de Spark.

Envía una carga de trabajo por lotes de Spark

Puedes usar la consola de Google Cloud, Google Cloud CLI o la API de Dataproc sin servidores para crear y enviar una carga de trabajo por lotes de Dataproc sin servidores para Spark.

Console

  1. En la consola de Google Cloud, ve a Dataproc Batches.

  2. Haz clic en Crear.

  3. Para enviar una carga de trabajo por lotes de Spark que calcule el valor aproximado de pi, selecciona y completa los siguientes campos:

    • Información del lote:
      • ID del lote: Especifica un ID para tu carga de trabajo por lotes. Este valor debe tener entre 4 y 63 caracteres en minúsculas. Los caracteres válidos son /[a-z][0-9]-/.
      • Región: Selecciona una región en la que se ejecutará tu carga de trabajo.
    • Contenedor:
      • Tipo de lote: Spark
      • Versión del entorno de ejecución: Se selecciona la versión predeterminada del entorno de ejecución. De manera opcional, puedes especificar una versión del entorno de ejecución de Dataproc Serverless no predeterminada.
      • Clase principal: 
        org.apache.spark.examples.SparkPi
      • Archivos JAR (este archivo está preinstalado en el entorno de ejecución de Spark de Dataproc Serverless). 
        file:///usr/lib/spark/examples/jars/spark-examples.jar
      • Argumentos: 1000.
    • Configuración de ejecución: Puedes especificar una cuenta de servicio para usarla y ejecutar tu carga de trabajo. Si no especificas una cuenta de servicio, la carga de trabajo se ejecuta con la cuenta de servicio predeterminada de Compute Engine. Tu cuenta de servicio debe tener el rol de trabajador de Dataproc.

    • Configuración de la red: La subred de VPC que ejecuta cargas de trabajo de Dataproc Serverless para Spark debe estar habilitada para PGA de acceso privado de Google y cumplir con los otros requisitos que se indican en Configuración de la red de Dataproc Serverless para Spark.

      Los selectores Red principal y subred muestran las redes con subredes en la región de carga de trabajo seleccionada que tienen habilitado el Acceso privado a Google. Selecciona una red y una subred de la lista. Si no se muestran redes ni subredes, puedes habilitar el Acceso privado a Google en una subred de VPC en la región de la carga de trabajo seleccionada actualmente o cambiar la región de la carga de trabajo a una región con una subred habilitada para el PGA y, luego, seleccionar esa red y subred.

    • Propiedades: Ingresa Key (nombre de la propiedad) y Value de las propiedades de Spark compatibles para configurar en tu carga de trabajo por lotes de Spark. Nota: A diferencia de las propiedades del clúster de Dataproc en Compute Engine, las propiedades de carga de trabajo de Dataproc sin servidores para Spark no incluyen un prefijo spark:.

    • Otras opciones:

  4. Haz clic en Enviar para ejecutar la carga de trabajo por lotes de Spark.

gcloud

Para enviar una carga de trabajo por lotes de Spark para calcular el valor aproximado de pi, ejecuta el siguiente comando de gcloud CLI gcloud dataproc batches submit spark de manera local en una ventana de la terminal o en Cloud Shell.

gcloud dataproc batches submit spark \
    --region=REGION \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    --class=org.apache.spark.examples.SparkPi \
    -- 1000

Notas:

  • REGION: Especifica la región en la que se ejecutará tu carga de trabajo.
  • Subred: La subred de VPC que ejecuta cargas de trabajo de Dataproc Serverless para Spark debe estar habilitada para el Acceso privado a Google y cumplir con los otros requisitos que se indican en Configuración de la red de Dataproc Serverless para Spark. Si la subred de la red default para la región especificada en el comando gcloud dataproc batches submit no está habilitada para el Acceso privado a Google, debes hacer una de las siguientes acciones:
    • Habilita la subred de la red predeterminada para la región del Acceso privado a Google.
    • Usa la marca --subnet=SUBNET_URI para especificar una subred que tenga habilitado el Acceso privado a Google. Puedes ejecutar el comando gcloud compute networks describe <var>NETWORK_NAME</var> para enumerar los URIs de las subredes de una red.
  • --jars: El archivo JAR de ejemplo está preinstalado en el entorno de ejecución de Spark. El argumento del comando 1000 que se pasa a la carga de trabajo de SparkPi especifica 1,000 iteraciones de la lógica de estimación de pi (los argumentos de entrada de la carga de trabajo se incluyen después de “-- ").
  • --properties: Puedes agregar esta marca para ingresar propiedades de Spark compatibles para que las use tu carga de trabajo por lotes de Spark.
  • --deps-bucket: Puedes agregar esta marca para especificar un bucket de Cloud Storage en el que Dataproc Serverless subirá las dependencias de la carga de trabajo. No se requiere el prefijo de URI gs:// del bucket. Puedes especificar la ruta de acceso o el nombre del bucket, por ejemplo, “mybucketname”. Dataproc Serverless para Spark sube los archivos locales a una carpeta /dependencies en el bucket antes de ejecutar la carga de trabajo por lotes. Nota: Esta marca es obligatoria si tu carga de trabajo por lotes hace referencia a archivos en tu máquina local.
  • --ttl: Puedes agregar la marca --ttl para especificar la duración del ciclo de vida del lote. Cuando la carga de trabajo supera esta duración, se finaliza de forma incondicional sin esperar a que finalice el trabajo en curso. Especifica la duración con un sufijo s, m, h o d (segundos, minutos, horas o días). El valor mínimo es de 10 minutos (10m) y el máximo es de 14 días (14d).
    • Ejecuciones por lotes del entorno de ejecución 1.1 o 2.0: Si no se especifica --ttl para una carga de trabajo por lotes del entorno de ejecución 1.1 o 2.0, la carga de trabajo puede ejecutarse hasta que se cierre de forma natural (o ejecutarse para siempre si no se cierra).
    • Ejecuciones por lotes del entorno de ejecución 2.1 y versiones posteriores: Si no se especifica --ttl para una carga de trabajo por lotes del entorno de ejecución 2.1 o versiones posteriores, se establece de forma predeterminada en 4h.
  • --service-account: Puedes especificar una cuenta de servicio para ejecutar tu carga de trabajo. Si no especificas una cuenta de servicio, la carga de trabajo se ejecuta con la cuenta de servicio predeterminada de Compute Engine. Tu cuenta de servicio debe tener el rol de trabajador de Dataproc.
  • Otras opciones: Puedes agregar marcas gcloud dataproc batches submit spark para especificar otras opciones de carga de trabajo y propiedades de Spark.
    • Almacén de metadatos de Hive: El siguiente comando configura una carga de trabajo por lotes para usar un almacén de metadatos de Hive autoadministrado externo con una configuración estándar de Spark. 
      gcloud dataproc batches submit spark\
    --properties=spark.sql.catalogImplementation=hive,spark.hive.metastore.uris=METASTORE_URI,spark.hive.metastore.warehouse.dir=WAREHOUSE_DIR> \
    other args ...
    • Servidor de historial persistente:
      1. El siguiente comando crea un PHS en un clúster de un solo nodo de Dataproc. El PHS debe estar ubicado en la región donde ejecutas cargas de trabajo por lotes, y el bucket-name de Cloud Storage debe existir. 
        gcloud dataproc clusters create PHS_CLUSTER_NAME \
    --region=REGION \
    --single-node \
    --enable-component-gateway \
    --properties=spark:spark.history.fs.logDirectory=gs://bucket-name/phs/*/spark-job-history
      2. Envía una carga de trabajo por lotes en la que especifiques tu servidor de historial persistente en ejecución. 
        gcloud dataproc batches submit spark \
    --region=REGION \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    --class=org.apache.spark.examples.SparkPi \
    --history-server-cluster=projects/project-id/regions/region/clusters/PHS-cluster-name \
    -- 1000
    • Versión del entorno de ejecución: Usa la marca --version para especificar la versión del entorno de ejecución de Dataproc Serverless para la carga de trabajo. 
      gcloud dataproc batches submit spark \
    --region=REGION \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    --class=org.apache.spark.examples.SparkPi \
    --version=VERSION
    -- 1000

API

En esta sección, se muestra cómo crear una carga de trabajo por lotes para calcular el valor aproximado de pi con batches.create` de Dataproc Serverless para Spark.

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

  • project-id: Un ID del proyecto de Google Cloud.
  • region: Es una región de Compute Engine en la que Dataproc Serverless ejecutará la carga de trabajo.
    • Notas:

    Método HTTP y URL: 

    POST https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches

    Cuerpo JSON de la solicitud:

    {
  "sparkBatch":{
    "args":[
      "1000"
    ],
    "jarFileUris":[
      "file:///usr/lib/spark/examples/jars/spark-examples.jar"
    ],
    "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:

    {
"name":"projects/project-id/locations/region/batches/batch-id",
  "uuid":",uuid",
  "createTime":"2021-07-22T17:03:46.393957Z",
  "sparkBatch":{
    "mainClass":"org.apache.spark.examples.SparkPi",
    "args":[
      "1000"
    ],
    "jarFileUris":[
      "file:///usr/lib/spark/examples/jars/spark-examples.jar"
    ]
  },
  "runtimeInfo":{
    "outputUri":"gs://dataproc-.../driveroutput"
  },
  "state":"SUCCEEDED",
  "stateTime":"2021-07-22T17:06:30.301789Z",
  "creator":"account-email-address",
  "runtimeConfig":{
    "properties":{
      "spark:spark.executor.instances":"2",
      "spark:spark.driver.cores":"2",
      "spark:spark.executor.cores":"2",
      "spark:spark.app.name":"projects/project-id/locations/region/batches/batch-id"
    }
  },
  "environmentConfig":{
    "peripheralsConfig":{
      "sparkHistoryServerConfig":{
      }
    }
  },
  "operation":"projects/project-id/regions/region/operation-id"
}

Estima los costos de la carga de trabajo

Las cargas de trabajo de Dataproc sin servidores para Spark consumen unidades de procesamiento de datos (DCU) y recursos de almacenamiento de shuffle. Para ver un ejemplo que genera UsageMetrics de Dataproc para estimar el consumo y los costos de recursos de la carga de trabajo, consulta Precios de Dataproc sin servidores.

¿Qué sigue?

Obtén más información acerca de los siguientes temas: