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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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

Envía una carga de trabajo por lotes de Spark

Console

1. En la consola de Google Cloud, ve a Lotes de Dataproc. Haz clic en Crear. para abrir la página Crear lote.

2. Selecciona y completa los siguientes campos en la página para enviar un lote de Spark que calcule el valor aproximado de pi:

   • Información por lotes:
     • ID de lote: Especifica un ID para tu carga de trabajo por lotes. Este valor debe ser de entre 4 y 63 caracteres en minúscula. 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 un versión no predeterminada del entorno de ejecución de Dataproc Serverless.
     • Clase principal:

       org.apache.spark.examples.SparkPi

     • Archivos jar (este archivo está preinstalado en el entorno de ejecución de Spark sin servidores de Dataproc)

       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.
   • Configuración de la red: 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 la Configuración de la red de Dataproc Serverless para Spark. En la lista de subredes, se muestran las subredes de la red seleccionada que están habilitadas para el Acceso privado a Google.
   • Propiedades: Ingresa el Key (nombre de la propiedad) y el Value de Propiedades de Spark compatibles para configurar en tu carga de trabajo por lotes de Spark. Nota: A diferencia de Dataproc en Compute Engine propiedades del clúster Las propiedades de carga de trabajo de Dataproc Serverless para Spark no incluyen un spark: .
   • Otras opciones:
     • Puedes configurar la carga de trabajo por lotes para usar una red Hive Metastore autoadministrado.
     • Puedes usar un servidor de historial persistente (PHS). El PHS debe estar ubicado en la región en la que ejecutas las cargas de trabajo por lotes.

3. 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 la CLI de gcloud gcloud dataproc batches submit spark de forma local en una ventana de 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:
  • Habilitar la subred de la red predeterminada de la región para el Acceso privado a Google
  • Usa la marca --subnet=[SUBNET_URI] en el comando para especificar una subred que tenga habilitado el Acceso privado a Google. Puedes ejecutar gcloud compute networks describe [NETWORK_NAME] para mostrar los URI de las subredes en 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 la marca --properties para ingresar las propiedades de Spark compatibles que deseas que 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 sin servidor subirá las dependencias de la carga de trabajo. El prefijo de URI gs:// del bucket no es obligatoria; puedes especificar la ruta o el nombre del bucket por ejemplo, “nombredemibucket”. Dataproc Serverless para Spark sube la configuración archivos a una carpeta /dependencies del bucket antes de la ejecución la carga de trabajo por lotes. Nota: Esta marca es obligatoria si los lotes archivos de referencia de la carga de trabajo en tu máquina local.
• --ttl: Puedes agregar el elemento --ttl marca para especificar la duración de la vida útil 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 10 minutos (10m). y el valor 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).
  • Lotes de entorno de ejecución 2.1 o más: si no se especifica --ttl para una carga de trabajo por lotes del entorno de ejecución 2.1 o posterior, el valor predeterminado es 4h.
• Otras opciones: Puedes agregar gcloud dataproc batches submit de comandos para especificar otras opciones de cargas de trabajo y propiedades de Spark.
  • Hive Metastore: El siguiente comando configura una carga de trabajo por lotes para usar una Hive Metastore autoadministrado con una configuración estándar de Spark.

    gcloud dataproc batches submit \
        --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 en la que 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 Dataproc Serverless del entorno de ejecución de 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 sin servidores para Spark.

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

• project-id: Un ID de proyecto de Google Cloud.
• region: Una región de Compute Engine en el que Dataproc Serverless ejecutará la carga de trabajo.
Notas:
• Custom-container-image: Especifica la imagen de contenedor personalizada con el formato de nombre de imagen de Docker: {hostname}/{project-id}/{image}:{tag}, por ejemplo, "gcr.io/my-project-id/my-image:1.0.1". Nota: El contenedor personalizado debe alojarse en Container Registry.
• Subred: La subred de VPC que ejecuta Dataproc Serverless para cargas de trabajo de Spark debe habilitar el Acceso privado a Google y cumplas con los demás requisitos que se mencionan en Dataproc sin servidores para la configuración de redes de Spark. Si la subred de la red default para la región especificada no está habilitada para el Acceso privado a Google, debes hacer una de las siguientes acciones:
  1. Habilita la subred de la red predeterminada de la región para el Acceso privado a Google.
  2. Usa el ExecutionConfig.subnetworkUri para especificar una subred que tenga habilitado el Acceso privado a Google. Puedes ejecutar el comando gcloud compute networks describe [NETWORK_NAME] para enumerar los URIs de las subredes de una red.
• sparkBatch.jarFileUris: El archivo jar de ejemplo está preinstalado en el entorno de ejecución de Spark. El valor “1000” de sparkBatch.args se pasa a la carga de trabajo de SparkPi y especifica 1,000 iteraciones de la lógica de estimación de pi.
• Spark properties: Puedes usar el campo RuntimeConfig.properties para ingresar las propiedades de Spark compatibles que deseas que use tu carga de trabajo por lotes de Spark.
• --ttl: Puedes usar el EnvironmentConfig.ttl para especificar la duración de la vida útil del lote. Cuando la carga de trabajo supera durante este período, se finaliza incondicionalmente sin esperar trabajo en curso para terminar. Especifica la duración como la representación JSON de Duración. El valor mínimo es de 10 minutos y el máximo es de 14 días.
  • 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).
  • Lotes de entorno de ejecución 2.1 o más: si no se especifica --ttl para una carga de trabajo por lotes del entorno de ejecución 2.1 o posterior, el valor predeterminado es de 4 horas.
• Otras opciones:
  • Configura la carga de trabajo por lotes para usar un y externa Hive Metastore autoadministrada.
  • Usar un servidor de historial persistente (PHS) El PHS debe estar ubicado en la región en la que ejecutas las cargas de trabajo por lotes.
  • Usa la RuntimeConfig.version. como parte de la solicitud batches.create para especificar una versión no predeterminada del entorno de ejecución de Dataproc Serverless
  .

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:

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches"

PowerShell (Windows)

Nota: El siguiente comando supone que accediste a la CLI de gcloud con tu cuenta de usuario mediante la ejecución de gcloud init o gcloud auth login. Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://dataproc.googleapis.com/v1/projects/project-id/locations/region/batches" | Select-Object -Expand Content

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

Cómo calcula la carga de trabajo el número pi: La carga de trabajo de Spark calcula un valor aproximado del número pi mediante el método Monte Carlo. Genera puntos "x,y" en un plano cartesiano que da forma a un cuadrado unitario que encierra un círculo. El argumento de entrada (`1000`) determina la cantidad de pares x,y para generar; cuantos más pares se generen, mayor será la exactitud de la estimación. Para obtener más información, consulta Cómo estimar pi con el método de Montecarlo y JavaSparkPi.java en GitHub.

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:

• Cuotas de Dataproc Serverless
• Propiedades de Spark