Esta página se ha traducido con Cloud Translation API.

Acelera las cargas de trabajo por lotes y las sesiones interactivas con la ejecución de consultas nativas

En este documento se describe cuándo y cómo habilitar la ejecución de consultas nativas para acelerar las cargas de trabajo por lotes y las sesiones interactivas de Serverless para Apache Spark.

Requisitos de ejecución de consultas nativas

La ejecución de consultas nativas de Serverless para Apache Spark solo está disponible con cargas de trabajo por lotes y sesiones interactivas que usen 1.2.26+, 2.2.26+ o una versión del entorno de ejecución de Spark premium posterior de Serverless para Apache Spark. Los precios del nivel Premium son más altos que los del nivel Estándar, pero no se aplican cargos adicionales por la ejecución de consultas nativas. Para obtener información sobre los precios, consulta la página Precios de Serverless para Apache Spark.

Propiedades de ejecución de consultas nativas

En esta sección se enumeran las propiedades de asignación de recursos de Spark obligatorias y opcionales que puedes usar para habilitar y personalizar la ejecución de consultas nativas en tu carga de trabajo por lotes o sesión interactiva.

Configuración de propiedad obligatoria

spark.dataproc.runtimeEngine=native: El motor de tiempo de ejecución de la carga de trabajo debe definirse como native para anular el motor de tiempo de ejecución spark predeterminado.
spark.dataproc.spark.driver.compute.tier=premium y spark.dataproc.executor.compute.tier=premium: estas propiedades de nivel de precios deben configurarse en el nivel de precios premium.

Propiedades de asignación de recursos opcionales

spark.dataproc.driver.disk.tier, spark.dataproc.driver.disk.size, spark.dataproc.executor.disk.tier y spark.dataproc.executor.disk.size: usa estas propiedades para definir y configurar el nivel y el tamaño del disco premium para los procesos del controlador y del ejecutor de Spark.

Los niveles de disco Premium usan el método de orden aleatorio por columnas en lugar del método por filas para ofrecer un mejor rendimiento. Para mejorar el rendimiento de E/S de la aleatorización, usa los niveles premium de disco del controlador y del ejecutor con un tamaño de disco lo suficientemente grande como para alojar los archivos de aleatorización.

spark.driver.memory, spark.driver.memoryOverhead, spark.executor.memory, spark.executor.memoryOverhead y spark.memory.offHeap.size: usa estas propiedades para ajustar la memoria proporcionada a los procesos del controlador y del ejecutor de Spark.

Puedes configurar la memoria de una de las siguientes formas:

Opción 1: Configurar solo la memoria fuera del montículo (spark.memory.offHeap.size) con un valor especificado. La ejecución de consultas nativas usará el valor especificado como memoria fuera del montículo y asignará 1/7th adicionales del valor de la memoria fuera del montículo como memoria en el montículo (spark.executor.memory).
Opción 2: Configura tanto la memoria en el montículo (spark.executor.memory) como la memoria fuera del montículo (spark.memory.offHeap.size). La cantidad que asignes a la memoria fuera del montículo debe ser mayor que la que asignes a la memoria en el montículo.

Si no configuras la memoria fuera del montículo (spark.memory.offHeap.size) ni la memoria en el montículo (spark.executor.memory), el motor de ejecución de consultas nativas dividirá una cantidad de memoria predeterminada 4g en una proporción 6:1 entre la memoria fuera del montículo y la memoria en el montículo.

Recomendación: Asigna memoria fuera del montículo a la memoria del montículo en una proporción de 6:1.

Ejemplos:

Configuración de la memoria sin ejecución de consultas nativas	Configuración de memoria recomendada con la ejecución de consultas nativas
`spark.executor.memory`	`spark.memory.offHeap.size`	`spark.executor.memory`
7g	6G	1G
14g	12 g	2G
28 g	24g	4G
56 g	48 g	8g

Ejecutar la herramienta de cualificación

Para identificar las cargas de trabajo por lotes que pueden conseguir tiempos de ejecución más rápidos con la ejecución de consultas nativas (NQE), puedes usar la herramienta de cualificación. La herramienta analiza los registros de eventos de Spark para estimar el posible ahorro de tiempo de ejecución e identificar las operaciones que no son compatibles con el motor NQE.

Google Cloud proporciona dos métodos para ejecutar el análisis de la cualificación: trabajo de cualificación y secuencia de comandos de cualificación. El enfoque recomendado para la mayoría de los usuarios es el trabajo de cualificación, que automatiza la detección y el análisis de las cargas de trabajo por lotes. El script de cualificación alternativo está disponible para el caso de uso específico de analizar un archivo de registro de eventos conocido. Elige el método que mejor se adapte a tu caso práctico:

Tarea de cualificación (recomendada): este es el método principal y recomendado. Se trata de un trabajo de PySpark que descubre y analiza automáticamente las cargas de trabajo por lotes recientes en uno o varios Google Cloud proyectos y regiones. Utiliza este método cuando quieras realizar un análisis amplio sin tener que localizar manualmente archivos de registro de eventos individuales. Este enfoque es ideal para evaluar a gran escala la idoneidad de NQE.
Script de cualificación (alternativa): es un método alternativo para casos prácticos avanzados o específicos. Se trata de un script de shell que analiza un único archivo de registro de eventos de Spark o todos los registros de eventos de un directorio específico de Cloud Storage. Utilice este método si tiene la ruta de Cloud Storage a los registros de eventos que quiere analizar.

Tarea de cualificación

El trabajo de cualificación simplifica el análisis a gran escala al buscar de forma programática cargas de trabajo por lotes de Serverless para Apache Spark y enviar un trabajo de análisis distribuido. La herramienta evalúa los trabajos de toda tu organización, por lo que no es necesario buscar y especificar manualmente las rutas de los registros de eventos.

Otorgar roles de gestión de identidades y accesos

Para que el trabajo de cualificación pueda acceder a los metadatos de la carga de trabajo por lotes y leer los registros de eventos de Spark en Cloud Logging, la cuenta de servicio que ejecuta la carga de trabajo debe tener los siguientes roles de gestión de identidades y accesos concedidos en todos los proyectos que se van a analizar:

Enviar la tarea de cualificación

Envía el trabajo de cualificación mediante la herramienta gcloud CLI. El trabajo incluye una secuencia de comandos de PySpark y un archivo JAR alojados en un segmento público de Cloud Storage.

Puedes ejecutar el trabajo en cualquiera de los siguientes entornos de ejecución:

Como carga de trabajo por lotes de Serverless para Apache Spark. Se trata de una ejecución de trabajos sencilla e independiente.
Como una tarea que se ejecuta en un clúster de Dataproc en Compute Engine. Este enfoque puede ser útil para integrar el trabajo en un flujo de trabajo.

Argumentos de las tareas

Argumento	Descripción	¿Es obligatorio?	Valor predeterminado
`--project-ids`	Un único ID de proyecto o una lista de IDs de proyectos de Google Cloud separados por comas para buscar cargas de trabajo por lotes.	No	El proyecto en el que se está ejecutando la tarea de cualificación.
`--regions`	Una sola región o una lista de regiones separadas por comas que se analizarán en los proyectos especificados.	No	Todas las regiones de los proyectos especificados.
`--start-time`	Fecha de inicio para filtrar lotes. Solo se analizarán los lotes creados a partir de esta fecha (formato: AAAA-MM-DD).	No	No se ha aplicado ningún filtro de fecha de inicio.
`--end-time`	Fecha de finalización para filtrar lotes. Solo se analizarán los lotes creados en esta fecha o antes (formato: AAAA-MM-DD).	No	No se aplica ningún filtro de fecha de finalización.
`--limit`	Número máximo de lotes que se analizarán por región. Los lotes más recientes se analizan primero.	No	Se analizan todos los lotes que coincidan con los demás criterios de filtro.
`--output-gcs-path`	La ruta de Cloud Storage (por ejemplo, `gs://your-bucket/output/`) en la que se escribirán los archivos de resultados.	Sí	Ninguno
`--input-file`	Ruta de Cloud Storage a un archivo de texto para el análisis en bloque. Si se proporciona, este argumento anula todos los demás argumentos que definen el ámbito (`--project-ids`, `--regions`, `--start-time`, `--end-time` y `--limit`).	No	Ninguno

Ejemplos de trabajos de cualificación

Una tarea por lotes de Serverless para Apache Spark para realizar análisis sencillos y ad hoc. Los argumentos de la tarea se indican después del separador --.

gcloud dataproc batches submit pyspark gs://qualification-tool/performance-boost-qualification.py \
    --project=PROJECT_ID \
    --region=REGION \
    --jars=gs://qualification-tool/dataproc-perfboost-qualification-1.2.jar \
    -- \
    --project-ids=COMMA_SEPARATED_PROJECT_IDS \
    --regions=COMMA_SEPARATED_REGIONS \
    --limit=MAX_BATCHES \
    --output-gcs-path=gs://BUCKET

Un trabajo por lotes de Serverless para Apache Spark que analiza hasta 50 de los lotes más recientes encontrados en sample_project en la región us-central1. Los resultados se escriben en un segmento de Cloud Storage. Los argumentos de la tarea se indican después del separador --.

gcloud dataproc batches submit pyspark gs://qualification-tool/performance-boost-qualification.py \
    --project=PROJECT_ID \
    --region=US-CENTRAL1 \
    --jars=gs://qualification-tool/dataproc-perfboost-qualification-1.2.jar \
    -- \
    --project-ids=PROJECT_ID \
    --regions=US-CENTRAL1 \
    --limit=50 \
    --output-gcs-path=gs://BUCKET/

Un trabajo de Dataproc en Compute Engine enviado a un clúster de Dataproc para realizar análisis en bloque en un flujo de trabajo de análisis a gran escala, repetible o automatizado. Los argumentos de los trabajos se colocan en un INPUT_FILE que se sube a un BUCKET en Cloud Storage. Este método es ideal para analizar diferentes intervalos de fechas o límites de lotes en distintos proyectos y regiones en una sola ejecución.
```
gcloud dataproc jobs submit pyspark gs://qualification-tool/performance-boost-qualification.py \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --jars=gs://qualification-tool/dataproc-perfboost-qualification-1.2.jar \
    -- \
    --input-file=gs://INPUT_FILE \
    --output-gcs-path=gs://BUCKET
```
Notas:

INPUT_FILE: cada línea del archivo representa una solicitud de análisis distinta y usa un formato de marcas de una sola letra seguidas de sus valores, como -p PROJECT-ID -r REGION -s START_DATE -e END_DATE -l LIMITS.

Ejemplo del contenido del archivo de entrada:
```
-p project1 -r us-central1 -s 2024-12-01 -e 2024-12-15 -l 100
-p project2 -r europe-west1 -s 2024-11-15 -l 50
```
Estos argumentos indican a la herramienta que analice los dos siguientes ámbitos:
- Hasta 100 lotes en el proyecto 1 de la región us-central1 creados entre el 1 y el 15 de diciembre del 2025.
- Hasta 50 lotes en el proyecto 2 de la región europe-west1 creados a partir del 15 de noviembre del 2025.

Script de cualificación

Usa este método si tienes la ruta directa de Cloud Storage a un registro de eventos de Spark específico que quieras analizar. Para usar este método, debes descargar y ejecutar un script de shell, run_qualification_tool.sh, en una máquina local o en una máquina virtual de Compute Engine configurada con acceso al archivo de registro de eventos en Cloud Storage.

Sigue estos pasos para ejecutar la secuencia de comandos en los archivos de eventos de cargas de trabajo por lotes de Serverless para Apache Spark.

1.Copia el archivo run_qualification_tool.sh en un directorio local que contenga los archivos de eventos de Spark que quieras analizar.

Ejecuta la secuencia de comandos de cualificación para analizar un archivo de eventos o un conjunto de archivos de eventos que se encuentren en el directorio de la secuencia de comandos.
```
./run_qualification_tool.sh -f EVENT_FILE_PATH/EVENT_FILE_NAME \
    -o CUSTOM_OUTPUT_DIRECTORY_PATH \
    -k SERVICE_ACCOUNT_KEY  \
    -x MEMORY_ALLOCATEDg  \
    -t PARALLEL_THREADS_TO_RUN
```
Marcas y valores:

-f (obligatorio): consulta Ubicaciones de los archivos de eventos de Spark para localizar los archivos de eventos de cargas de trabajo de Spark.
- EVENT_FILE_PATH (obligatorio a menos que se especifique EVENT_FILE_NAME): ruta del archivo de eventos que se va a analizar. Si no se proporciona, se supone que la ruta del archivo de eventos es el directorio actual.
- EVENT_FILE_NAME (obligatorio a menos que se especifique EVENT_FILE_PATH): nombre del archivo de eventos que se va a analizar. Si no se proporciona, se analizan los archivos de eventos encontrados de forma recursiva en EVENT_FILE_PATH.
-o(Opcional): Si no se proporciona, la herramienta crea o usa un directorio output en el directorio actual para colocar los archivos de salida.
- CUSTOM_OUTPUT_DIRECTORY_PATH: ruta del directorio de salida de los archivos de salida.
-k (opcional):
- SERVICE_ACCOUNT_KEY: La clave de la cuenta de servicio en formato JSON si es necesario para acceder a EVENT_FILE_PATH.
-x (opcional):
- MEMORY_ALLOCATED: memoria en gigabytes que se asignará a la herramienta. De forma predeterminada, la herramienta usa el 80% de la memoria libre disponible en el sistema y todos los núcleos de la máquina disponibles.
-t(opcional):
- PARALLEL_THREADS_TO_RUN: número de hilos paralelos que puede ejecutar la herramienta. De forma predeterminada, la herramienta ejecuta todos los núcleos.
Ejemplo de uso de comandos:
```
./run_qualification_tool.sh -f gs://dataproc-temp-us-east1-9779/spark-job-history \
    -o perfboost-output -k /keys/event-file-key -x 34g -t 5
```
En este ejemplo, la herramienta de cualificación recorre el directorio gs://dataproc-temp-us-east1-9779/spark-job-history y analiza los archivos de eventos de Spark que contiene este directorio y sus subdirectorios. El /keys/event-file-key tiene acceso al directorio. La herramienta usa 34 GB memory para la ejecución y ejecuta 5 subprocesos paralelos.

Ubicaciones de archivos de eventos de Spark

Sigue cualquiera de estos pasos para encontrar los archivos de eventos de Spark de las cargas de trabajo por lotes de Serverless para Apache Spark:

En Cloud Storage, busca el spark.eventLog.dir de la carga de trabajo y descárgalo.
1. Si no encuentras el spark.eventLog.dir, define el spark.eventLog.dir en una ubicación de Cloud Storage, vuelve a ejecutar la carga de trabajo y descarga el spark.eventLog.dir.
Si has configurado Spark History Server para el trabajo por lotes, haz lo siguiente:
1. Ve a Spark History Server y selecciona la carga de trabajo.
2. En la columna Registro de eventos, haga clic en Descargar.

Archivos de salida de la herramienta de cualificación

Una vez que se haya completado el trabajo de cualificación o el análisis de la secuencia de comandos, la herramienta de cualificación colocará los siguientes archivos de salida en un directorio perfboost-output del directorio actual:

AppsRecommendedForBoost.tsv: Lista de aplicaciones separadas por tabulaciones recomendadas para usar con la ejecución de consultas nativas.
UnsupportedOperators.tsv: Lista de aplicaciones separadas por tabulaciones que no se recomiendan para usar con la ejecución de consultas nativas.

Archivo de salida `AppsRecommendedForBoost.tsv`

En la siguiente tabla se muestra el contenido de un archivo de salida AppsRecommendedForBoost.tsv de ejemplo. Contiene una fila por cada aplicación analizada.

Archivo de salida AppsRecommendedForBoost.tsv de ejemplo:

applicationId	nombreaplicación	rddPercentage	unsupportedSqlPercentage	totalTaskTime	supportedTaskTime	supportedSqlPercentage	recommendedForBoost	expectedRuntimeReduction
app-2024081/batches/083f6196248043938-000	projects/example.com:dev/locations/us-central1 6b4d6cae140f883c0 11c8e	0,00%	0,00%	548924253	548924253	100%	TRUE	30,00%
app-2024081/batches/60381cab738021457-000	projects/example.com:dev/locations/us-central1 474113a1462b426bf b3aeb	0,00%	0,00%	514401703	514401703	100%	TRUE	30,00%

Descripciones de las columnas:

applicationId: la ApplicationID de la aplicación Spark. Úsalo para identificar la carga de trabajo por lotes correspondiente.
applicationName: nombre de la aplicación de Spark.
rddPercentage: porcentaje de operaciones de RDD en la aplicación. La ejecución de consultas nativas no admite operaciones de RDD.
unsupportedSqlPercentage: Porcentaje de operaciones de SQL no admitidas por la ejecución de consultas nativas.
totalTaskTime: tiempo acumulado de todas las tareas ejecutadas durante la ejecución de la aplicación.
supportedTaskTime: tiempo total de las tareas admitido por la ejecución de consultas nativas.

Las siguientes columnas proporcionan información importante para ayudarte a determinar si la ejecución de consultas nativas puede beneficiar a tu carga de trabajo por lotes:

supportedSqlPercentage: porcentaje de operaciones SQL admitidas por la ejecución de consultas nativas. Cuanto mayor sea el porcentaje, mayor será la reducción del tiempo de ejecución que se puede conseguir ejecutando la aplicación con la ejecución de consultas nativas.
recommendedForBoost: Si TRUE, se recomienda ejecutar la aplicación con Native Query Execution. Si recommendedForBoost es FALSE, no uses la ejecución de consultas nativas en la carga de trabajo por lotes.
expectedRuntimeReduction: porcentaje de reducción previsto en el tiempo de ejecución de la aplicación al ejecutarla con la ejecución de consultas nativas.

`UnsupportedOperators.tsv` archivo de salida.

El archivo de salida UnsupportedOperators.tsv contiene una lista de operadores utilizados en aplicaciones de carga de trabajo que no son compatibles con la ejecución de consultas nativas. Cada fila del archivo de salida muestra un operador no admitido.

Descripciones de las columnas:

unsupportedOperator: El nombre del operador que no admite la ejecución de consultas nativas.
cumulativeCpuMs: número de milisegundos de CPU consumidos durante la ejecución del operador. Este valor refleja la importancia relativa del operador en la aplicación.
count: número de veces que se usa el operador en la aplicación.

Usar la ejecución de consultas nativas

Puedes usar la ejecución de consultas nativas con tu aplicación configurando las propiedades de ejecución de consultas nativas cuando crees la carga de trabajo por lotes, la sesión interactiva o la plantilla de sesión que ejecuta tu aplicación.

Usar la ejecución de consultas nativas con cargas de trabajo por lotes

Puedes usar la Google Cloud consola, la CLI de Google Cloud o la API de Dataproc para habilitar la ejecución de consultas nativas en una carga de trabajo por lotes.

Consola

Usa la Google Cloud consola para habilitar la ejecución de consultas nativas en una carga de trabajo por lotes.

En la Google Cloud consola:
1. Ve a Lotes de Dataproc.
2. Haz clic en Crear para abrir la página Crear lote.
Selecciona y rellena los siguientes campos para configurar el lote de ejecución de consultas nativas:
- Contenedor:
  - Versión de entorno de ejecución: selecciona 1.2, 2.2 o un número de versión major.minor superior. Consulta las versiones del entorno de ejecución de Serverless para Apache Spark compatibles.
- Configuración de los niveles de controlador y ejecutor:
  - Selecciona Premium en todos los niveles (Nivel de computación del controlador y Nivel de computación de ejecución).
- Propiedades: introduzca pares de Key (nombre de la propiedad) y Value para especificar las propiedades de ejecución de consultas nativas:
  
  Clave Valor
  
  spark.dataproc.runtimeEngine nativo
Rellena, selecciona o confirma otros ajustes de cargas de trabajo en lote. Consulta Enviar una carga de trabajo por lotes de Spark.
Haz clic en Enviar para ejecutar la carga de trabajo por lotes de Spark.

Clave	Valor
`spark.dataproc.runtimeEngine`	nativo

gcloud

Define las siguientes marcas de comando de la CLI de gcloud gcloud dataproc batches submit spark para configurar una carga de trabajo por lotes para la ejecución de consultas nativas:

gcloud dataproc batches submit spark \
    --project=PROJECT_ID \
    --region=REGION \
    --jars=file:///usr/lib/spark/examples/jars/spark-examples.jar \
    --class=org.apache.spark.examples.SparkPi \
    --properties=spark.dataproc.runtimeEngine=native,spark.dataproc.driver.compute.tier=premium,spark.dataproc.executor.compute.tier=premium \
    OTHER_FLAGS_AS_NEEDED

Notas:

PROJECT_ID: tu ID de proyecto Google Cloud . Los IDs de proyecto se indican en la sección Información del proyecto del panel de control de la consola Google Cloud .
REGION: una región de Compute Engine disponible para ejecutar la carga de trabajo.
OTHER_FLAGS_AS_NEEDED: consulta Enviar una carga de trabajo por lotes de Spark.

API

Define los siguientes campos de la API de Dataproc para configurar una carga de trabajo por lotes para la ejecución de consultas nativas:

RuntimeConfig.properties: define las siguientes propiedades de ejecución de consultas nativas:
```
"spark.dataproc.runtimeEngine":"native"
"spark.dataproc.driver.compute.tier":"premium"
"spark.dataproc.executor.compute".tier:"premium"
```
Notas:
- Consulta Enviar una carga de trabajo por lotes de Spark para definir otros campos de la API de cargas de trabajo por lotes.

Cuándo usar la ejecución de consultas nativas

Utilice la ejecución de consultas nativas en los siguientes casos:

APIs de DataFrame de Spark, APIs de Dataset de Spark y consultas de Spark SQL que leen datos de archivos Parquet y ORC. El formato del archivo de salida no afecta al rendimiento de la ejecución de consultas nativas.
Cargas de trabajo recomendadas por la herramienta de cualificación de ejecución de consultas nativas.

Cuándo no usar la ejecución de consultas nativas

Entradas de los siguientes tipos de datos:

Byte: ORC y Parquet
Marca de tiempo: ORC
Estructura, matriz y mapa: Parquet

Limitaciones

Habilitar la ejecución de consultas nativas en los siguientes casos puede provocar excepciones, incompatibilidades con Spark o que la carga de trabajo vuelva al motor de Spark predeterminado.

Alternativas

La ejecución de consultas nativas en la siguiente ejecución puede provocar que la carga de trabajo vuelva al motor de ejecución de Spark, lo que puede provocar regresiones o errores.

ANSI: si el modo ANSI está habilitado, la ejecución vuelve a Spark.
Modo que distingue entre mayúsculas y minúsculas: la ejecución de consultas nativas solo admite el modo predeterminado de Spark, que no distingue entre mayúsculas y minúsculas. Si el modo de distinción entre mayúsculas y minúsculas está habilitado, se pueden producir resultados incorrectos.
Análisis de tablas con particiones: la ejecución de consultas nativas solo admite el análisis de tablas con particiones cuando la ruta contiene la información de la partición. De lo contrario, la carga de trabajo vuelve al motor de ejecución de Spark.

Comportamiento incompatible

Si se usa la ejecución de consultas nativas en los siguientes casos, se pueden producir comportamientos incompatibles o resultados incorrectos:

Funciones JSON: la ejecución de consultas nativas admite cadenas entre comillas dobles, no entre comillas simples. Se producen resultados incorrectos con comillas simples. Si se usa "*" en la ruta con la función get_json_object, se devuelve NULL.
Configuración de lectura de Parquet:
- La ejecución de consultas nativas trata spark.files.ignoreCorruptFiles como si tuviera el valor predeterminado false, aunque se haya definido como true.
- Ejecución de consultas nativas ignora spark.sql.parquet.datetimeRebaseModeInRead, y devuelve solo el contenido del archivo Parquet. No se tienen en cuenta las diferencias entre el calendario híbrido antiguo (juliano gregoriano) y el calendario gregoriano proléptico. Los resultados de Spark pueden variar.
NaN: no se admite. Por ejemplo, se pueden producir resultados inesperados al usar NaN en una comparación numérica.
Lectura columnar de Spark: se puede producir un error grave porque el vector columnar de Spark no es compatible con la ejecución de consultas nativas.
Desbordamiento: si las particiones aleatorias se definen con un número elevado, la función de desbordamiento en disco puede activar un OutOfMemoryException. Si esto ocurre, reducir el número de particiones puede eliminar esta excepción.