Envía una carga de trabajo por lotes de Apache Spark

Aprende a enviar una carga de trabajo por lotes en la infraestructura de procesamiento de Managed Service para Apache Spark que escala los recursos según sea necesario.

Antes de comenzar

Configura tu proyecto y, si es necesario, otorga roles de Identity and Access Management.

Configura tu proyecto

Realiza uno o más de los siguientes pasos según sea necesario:

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

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   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

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the Dataproc API, if it is not already enabled.

   Roles required to enable APIs

   To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

   Enable the API

Otorga roles de IAM si es necesario

Se requieren ciertos roles de IAM para ejecutar los ejemplos de esta página. Según las políticas de la organización, es posible que ya se hayan otorgado estos roles. Para verificar las asignaciones de roles, consulta ¿Necesitas otorgar roles?.

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

Funciones de usuario

Para obtener los permisos que necesitas para enviar una carga de trabajo por lotes sin servidores, pídele a tu administrador que te otorgue los siguientes roles de IAM:

• Editor de Dataproc (roles/dataproc.editor) en el proyecto
• Usuario de la cuenta de servicio (roles/iam.serviceAccountUser) en la cuenta de servicio predeterminada de Compute Engine

Función de cuenta de servicio

Para asegurarte de que la cuenta de servicio predeterminada de Compute Engine tenga los permisos necesarios para enviar una carga de trabajo por lotes sin servidores, pídele a tu administrador que otorgue el rol de IAM de trabajador de Dataproc (roles/dataproc.worker) a la cuenta de servicio predeterminada de Compute Engine en el proyecto.

Importante: Debes otorgar este rol a la cuenta de servicio predeterminada de Compute Engine, no a tu cuenta de usuario. Si no se otorga el rol a la principal correcta, se pueden producir errores de permisos.

Envía una carga de trabajo por lotes de Spark

Puedes usar la consola de Google Cloud , Google Cloud CLI o la API de REST para crear y enviar una carga de trabajo por lotes de Managed Service para Apache Spark.

Nota: Puedes usar la página Crear lote a partir de una plantilla en la consola para ejecutar un lote basado en una plantilla guardada. Para obtener más información, consulta Plantillas de Managed Service para Apache Spark.

Console

1. En la consola de Google Cloud , ve a la página Trabajos de Managed Service para Apache Spark.

   Ir a los trabajos de Managed Service para Apache Spark

2. Haz clic en Enviar trabajo para abrir la página Enviar un trabajo.

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

   • Selecciona el tipo de procesamiento para el trabajo: Selecciona Spark sin servidores.
   • Detalles del trabajo sin servidores:
     • ID de tarea: Especifica un ID para tu carga de trabajo por lotes (o acepta el ID predeterminado). Este valor debe tener entre 4 y 63 caracteres en minúscula, comenzar y terminar con una letra minúscula o un número, y contener solo letras minúsculas, números y guiones (/[a-z0-9-]/).
     • Perfil del entorno de ejecución: Selecciona una región en la lista Regiones y selecciona Configuración del servicio predeterminada (o un perfil del entorno de ejecución guardado) en la lista Perfiles del entorno de ejecución.
     • Configura el perfil del entorno de ejecución (opcional): En la tarjeta Resumen, haz clic en Configurar (o haz clic en Crear perfil nuevo en el menú Perfil del entorno de ejecución) para abrir el panel de configuración del perfil del entorno de ejecución, en el que puedes personalizar los siguientes parámetros de configuración y, luego, hacer clic en Usar configuración (o Guardar perfil nuevo):
       • Nivel y Configuración del ejecutor: Selecciona el nivel de procesamiento (Premium o Estándar) y la forma del ejecutor.
       • Configuración adicional:
         • Configuración del entorno de ejecución: Haz clic en Editar para confirmar o seleccionar la versión del entorno de ejecución de Spark de 3.0, o para especificar una imagen de Spark personalizada, un bucket de etapa de pruebas de Cloud Storage o un repositorio de paquetes de Python.
         • Configuración del almacén de metadatos: Haz clic en Editar para configurar la carga de trabajo de modo que use un catálogo de Lakehouse o un Dataproc Metastore autoadministrado externo.
         • Red y seguridad: Haz clic en Editar para seleccionar Cuenta de servicio (de forma predeterminada, la carga de trabajo se ejecuta con la cuenta de servicio predeterminada de Compute Engine, o puedes especificar una cuenta de servicio personalizada con el rol de trabajador de Dataproc) y selecciona una Subred en la región de la carga de trabajo (Managed Service para Apache Spark habilita el Acceso privado a Google (PGA) en la subred especificada; consulta Configuración de red de Managed Service para Apache Spark).
   • Archivos y artefactos:
     • Tipo de trabajo: Selecciona Spark (Scala/Java).
     • Configuración del controlador: Selecciona Clase principal.
     • Clase principal:

       org.apache.spark.examples.SparkPi

     • Argumentos: Ingresa 1000 y presiona Enter.
     • Archivos JAR (este archivo está preinstalado en el entorno de ejecución de Managed Service para Apache Spark):

       file:///usr/lib/spark/examples/jars/spark-examples.jar

   • Ejecución y propiedades del trabajo:
     • Propiedades de Spark: Haz clic en Agregar propiedad para ingresar la Clave (nombre de la propiedad) y el Valor de las propiedades de Spark compatibles que se establecerán en tu carga de trabajo por lotes de Spark. Nota: A diferencia de las propiedades del clúster de Managed Service para Apache Spark, las propiedades de la carga de trabajo de Managed Service para Apache Spark no incluyen un prefijo spark:.
     • Etiquetas: Opcional: Haz clic en Agregar etiqueta para adjuntar pares de etiquetas de Clave y Valor a la carga de trabajo.

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 que calcule el valor aproximado de pi, ejecuta el siguiente comando de gcloud CLI gcloud dataproc batches submit spark de forma local en una ventana de terminal o en Cloud Shell.

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

Reemplaza lo siguiente:

• REGION: Especifica la región en la que se ejecutará tu carga de trabajo.
• Otras opciones: Puedes agregar marcas gcloud dataproc batches submit spark para especificar otras opciones de carga de trabajo y propiedades de Spark.
  • --jars: El archivo JAR de ejemplo está preinstalado en el entorno de ejecución de Spark. El argumento de 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 "-- ").
  • --subnet: Puedes agregar esta marca para especificar el nombre de una subred en la región de la sesión. Si no especificas una subred, Managed Service para Apache Spark selecciona la subred default en la región de la sesión. Managed Service para Apache Spark habilita el Acceso privado a Google (PGA) en la subred. Para conocer los requisitos de conectividad de red, consulta Configuración de red de Managed Service para Apache Spark.
  • --tags: Puedes agregar esta marca para especificar etiquetas de red para el control de tráfico. Usa etiquetas de red para limitar la conectividad. En producción, la práctica recomendada es limitar las reglas de firewall a las direcciones IP que usan tus cargas de trabajo de Spark.
  • --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 Managed Service para Apache Spark subirá las dependencias de la carga de trabajo. No se requiere el prefijo de URI gs:// del bucket; puedes especificar la ruta o el nombre del bucket. Managed Service para Apache 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 de tu máquina local.
  • --ttl: Puedes agregar la marca --ttl para especificar la duración del lote. Cuando la carga de trabajo supera esta duración, se finaliza de forma incondicional sin esperar a que termine 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 valor máximo es de 14 días (14d).
    • Lotes de entorno de ejecución 1.1 o 2.0: Si no se especifica --ttl para una carga de trabajo por lotes de entorno de ejecución 1.1 o 2.0, se permite que la carga de trabajo se ejecute hasta que salga de forma natural (o se ejecute de forma indefinida si no sale).
    • Lotes de entorno de ejecución 2.1+: Si no se especifica --ttl para una carga de trabajo por lotes de entorno de ejecución 2.1 o posterior, 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.
  • Hive Metastore: El siguiente comando configura una carga de trabajo por lotes para usar un Hive Metastore autoadministrado externo con una configuración de Spark estándar.

    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. Con el siguiente comando, se crea un PHS en un clúster de Managed Service para Apache Spark de un solo nodo. El PHS debe estar ubicado en la región en la que ejecutas las 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 y especifica 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 Managed Service para Apache Spark 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 el comando batches.create` de Managed Service para Apache Spark.

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

• project-id: Es un ID del proyecto de Google Cloud .
• region: Es una región de Compute Engine en la que Managed Service para Apache Spark ejecutará la carga de trabajo.

Notas:

• PROJECT_ID: Es el ID del proyecto de Google Cloud . Los IDs de proyecto se enumeran en la sección Información del proyecto en el Panel de la consola de Google Cloud .
• REGION: Es la región de la sesión.

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"
    ],
    "runtimeConfig": {
      "version": "2.3",
    },
    "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 gcloud CLI 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 gcloud CLI . 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 gcloud CLI con tu cuenta de usuario a través de 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":{
    "version":"2.3",
    "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 con el método de Montecarlo. Permite generar coordenadas `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 que se generarán; cuantos más pares se generen, mayor será la precisión de la estimación. Para obtener más información, consulta Estimating Pi using the Monte Carlo Method y JavaSparkPi.java en GitHub.

Estima los costos de las cargas de trabajo

Las cargas de trabajo de Managed Service para Apache Spark consumen recursos de unidad de procesamiento de datos (DCU) y almacenamiento de Shuffle. Para ver un ejemplo que genera UsageMetrics de Managed Service para Apache Spark para estimar el consumo de recursos y los costos de las cargas de trabajo, consulta Precios de Managed Service para Apache Spark.

¿Qué sigue?

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

• Administra el ciclo de vida de tus cargas de trabajo de datos en VS Code con Google Cloud Data Agent Kit
• Crea canalizaciones de datos con Data Agent Kit
• Ejecuta código de PySpark en notebooks de BigQuery Studio
• Cuotas de Managed Service para Apache Spark
• Propiedades de Spark