Se usó la API de Cloud Translation para traducir esta página.

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 for 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 usan 1.2.26+, 2.2.26+ o una versión del entorno de ejecución de Spark posterior que se ejecute en el nivel de precios premium de Serverless para Apache Spark. El precio del nivel Premium es más alto que el del nivel Estándar, pero no hay cargos adicionales por la ejecución de consultas nativas. Para obtener información sobre los precios, consulta 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 para tu carga de trabajo por lotes o sesión interactiva.

Configuración obligatoria de la propiedad

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

Propiedades opcionales de asignación de recursos

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 establecer y configurar el nivel y el tamaño del disco premium para los procesos del controlador y del ejecutor de Spark.

Los niveles de discos Premium usan la función de Shuffle basada en columnas en lugar de filas para proporcionar un mejor rendimiento. Para obtener una mejor capacidad de procesamiento de E/S de Shuffle, usa los niveles de disco premium del controlador y del ejecutor con un tamaño de disco lo suficientemente grande como para admitir archivos de Shuffle.

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 cualquiera de las siguientes maneras:

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

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

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

Ejemplos:

Configuración de 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	6 g	1 g
14 g	12 g	2 g
28 g	24 g	4G
56 g	48 g	8 g

Ejecuta la herramienta de calificación

Para identificar las cargas de trabajo por lotes que pueden lograr tiempos de ejecución más rápidos con la ejecución de consultas nativas (NQE), puedes usar la herramienta de calificación. La herramienta analiza los registros de eventos de Spark para estimar los posibles ahorros en el tiempo de ejecución y, además, identifica las operaciones que no son compatibles con el motor de NQE.

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

Trabajo de calificación (recomendado): Este es el método principal y recomendado. Es un trabajo de PySpark que descubre y analiza automáticamente las cargas de trabajo por lotes recientes en uno o más Google Cloud proyectos y regiones. Usa este método cuando desees realizar un análisis amplio sin necesidad de ubicar manualmente archivos de registro de eventos individuales. Este enfoque es ideal para la evaluación a gran escala de la idoneidad de la NQE.
Secuencia de comandos de calificación (alternativa): Este es un método alternativo para casos de uso avanzados o específicos. Es un secuencia de comandos de shell que analiza un solo archivo de registro de eventos de Spark o todos los registros de eventos dentro de un directorio específico de Cloud Storage. Usa este método si tienes la ruta de acceso de Cloud Storage a los registros de eventos que deseas analizar.

Trabajo de calificación

El trabajo de calificación simplifica el análisis a gran escala, ya que analiza de forma programática las cargas de trabajo por lotes de Serverless for Apache Spark y envía un trabajo de análisis distribuido. La herramienta evalúa los trabajos en toda tu organización, lo que elimina la necesidad de buscar y especificar manualmente las rutas de acceso a los registros de eventos.

Asigna roles de IAM

Para que el trabajo de calificación acceda a los metadatos de la carga de trabajo por lotes y lea 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 IAM otorgados en todos los proyectos que se analizarán:

Envía el trabajo de calificación

Envía el trabajo de calificación con la herramienta de gcloud CLI. El trabajo incluye una secuencia de comandos de PySpark y un archivo JAR que se alojan en un bucket público de Cloud Storage.

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

Como una carga de trabajo por lotes de Serverless para Apache Spark Esta es una ejecución de trabajo simple y autónoma.
Como un trabajo 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 del trabajo

Argumento	Descripción	¿Es obligatorio?	Valor predeterminado
`--project-ids`	Es un solo ID de proyecto o una lista separada por comas de IDs de proyectos de Google Cloud para analizar las cargas de trabajo por lotes.	No	Es el proyecto en el que se ejecuta el trabajo de calificación.
`--regions`	Es una sola región o una lista de regiones separadas por comas para analizar dentro de los proyectos especificados.	No	Todas las regiones dentro de los proyectos especificados.
`--start-time`	Es la 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 aplica ningún filtro de fecha de inicio.
`--end-time`	Es la fecha de finalización para filtrar lotes. Solo se analizarán los lotes creados en esta fecha o antes de ella (formato: AAAA-MM-DD).	No	No se aplica ningún filtro de fecha de finalización.
`--limit`	Es la cantidad máxima de lotes que se pueden analizar por región. Primero se analizan los lotes más recientes.	No	Se analizan todos los lotes que coinciden con los demás criterios de filtro.
`--output-gcs-path`	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 masivo. Si se proporciona, este argumento anula todos los demás argumentos que definen el alcance (`--project-ids`, `--regions`, `--start-time`, `--end-time`, `--limit`).	No	Ninguno

Ejemplos de trabajos de calificación

Un trabajo por lotes de Serverless para Apache Spark para realizar análisis simples y ad hoc. Los argumentos del trabajo se enumeran 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

Es un trabajo por lotes de Serverless for Apache Spark para analizar hasta 50 de los lotes más recientes que se encuentran en sample_project en la región us-central1. Los resultados se escriben en el bucket de Cloud Storage. Los argumentos del trabajo se enumeran 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/

Es un trabajo de Dataproc en Compute Engine que se envía a un clúster de Dataproc para realizar análisis masivos en un flujo de trabajo de análisis a gran escala, repetible o automatizado. Los argumentos del trabajo se colocan en un objeto INPUT_FILE que se sube a un objeto BUCKET en Cloud Storage. Este método es ideal para analizar diferentes períodos o límites de lotes en diferentes 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 de 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 dirigen la herramienta para que analice los siguientes dos alcances:
- Hasta 100 lotes en project1 en la región us-central1 creados entre el 1 y el 15 de diciembre de 2025.
- Hasta 50 lotes en project2 en la región europe-west1 creados a partir del 15 de noviembre de 2025

Secuencia de comandos de calificación

Usa este método si tienes la ruta de acceso directa de Cloud Storage a un registro de eventos de Spark específico que deseas analizar. Este enfoque requiere que descargues y ejecutes una secuencia de comandos de shell, run_qualification_tool.sh, en una máquina local o en una VM 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 la carga de trabajo por lotes de Serverless para Apache Spark.

1.Copia run_qualification_tool.sh en un directorio local que contenga los archivos de eventos de Spark que se analizarán.

Ejecuta la secuencia de comandos de calificación para analizar un archivo de eventos o un conjunto de archivos de eventos incluidos 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 encontrar los archivos de eventos de la carga de trabajo de Spark.
- EVENT_FILE_PATH (obligatorio, a menos que se especifique EVENT_FILE_NAME): Es la ruta de acceso al archivo de eventos que se 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 analizará. Si no se proporciona, se analizan los archivos de eventos que se encuentran de forma recursiva en EVENT_FILE_PATH.
-o(opcional): Si no se proporciona, la herramienta crea o usa un directorio output existente en el directorio actual para colocar los archivos de salida.
- CUSTOM_OUTPUT_DIRECTORY_PATH: Es la ruta de acceso al directorio de salida de los archivos de salida.
-k (opcional):
- SERVICE_ACCOUNT_KEY: Es la clave de la cuenta de servicio en formato JSON si es necesario acceder a EVENT_FILE_PATH.
-x (opcional):
- MEMORY_ALLOCATED: Es la 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: Es la cantidad de subprocesos paralelos que ejecutará la herramienta. De forma predeterminada, la herramienta ejecuta todos los núcleos.
Ejemplo de uso del comando:
```
./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 calificación recorre el directorio gs://dataproc-temp-us-east1-9779/spark-job-history y analiza los archivos de eventos de Spark que se encuentran en este directorio y sus subdirectorios. El acceso al directorio se proporciona en /keys/event-file-key. La herramienta usa 34 GB memory para la ejecución y ejecuta 5 subprocesos paralelos.

Ubicaciones de los archivos de eventos de Spark

Realiza cualquiera de los siguientes pasos para encontrar los archivos de eventos de Spark para las cargas de trabajo por lotes de Serverless for Apache Spark:

En Cloud Storage, busca el archivo spark.eventLog.dir de la carga de trabajo y, luego, descárgalo.
1. Si no encuentras el archivo spark.eventLog.dir, configúralo en una ubicación de Cloud Storage, vuelve a ejecutar la carga de trabajo y descarga el archivo spark.eventLog.dir.spark.eventLog.dir
Si configuraste el servidor de historial de Spark para el trabajo por lotes, haz lo siguiente:
1. Ve al servidor de historial de Spark y, luego, selecciona la carga de trabajo.
2. Haz clic en Descargar en la columna Registro de eventos.

Archivos de salida de la herramienta de calificación

Una vez que se completa el trabajo de calificación o el análisis de la secuencia de comandos, la herramienta de calificación coloca los siguientes archivos de salida en un directorio perfboost-output en el directorio actual:

AppsRecommendedForBoost.tsv: Es una lista separada por tabulaciones de las aplicaciones recomendadas para usar con la ejecución de consultas nativas.
UnsupportedOperators.tsv: Es una lista separada por tabulaciones de las aplicaciones 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 para cada aplicación analizada.

Archivo de salida AppsRecommendedForBoost.tsv de muestra:

applicationId	applicationName	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.00%	TRUE	30.00%
app-2024081/batches/60381cab738021457-000	projects/example.com:dev/locations/us-central1 474113a1462b426bf b3aeb	0.00%	0.00%	514401703	514401703	100.00%	TRUE	30.00%

Descripciones de columnas:

applicationId: Es el ApplicationID de la aplicación de Spark. Se usa para identificar la carga de trabajo por lotes correspondiente.
applicationName: Es el nombre de la aplicación de Spark.
rddPercentage: Es el porcentaje de operaciones de RDD en la aplicación. La ejecución de consultas nativas no admite las operaciones de RDD.
unsupportedSqlPercentage: Porcentaje de operaciones en SQL que no admite la ejecución de consultas nativas.
totalTaskTime: Es el tiempo acumulado de todas las tareas ejecutadas durante la ejecución de la aplicación.
supportedTaskTime: Es el tiempo total de la tarea que admite 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 tu carga de trabajo por lotes:

supportedSqlPercentage: Es el porcentaje de operaciones de SQL que admite la ejecución de consultas nativas. Cuanto mayor sea el porcentaje, mayor será la reducción del tiempo de ejecución que se puede lograr ejecutando la aplicación con la ejecución de consultas nativas.
recommendedForBoost: Si es TRUE, se recomienda ejecutar la aplicación con la ejecución de consultas nativas. Si recommendedForBoost es FALSE, no uses la ejecución de consultas nativas en la carga de trabajo por lotes.
expectedRuntimeReduction: Es el porcentaje esperado de reducción en el tiempo de ejecución de la aplicación cuando la ejecutas con la ejecución de consultas nativas.

Archivo de salida `UnsupportedOperators.tsv`.

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

Descripciones de columnas:

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

Usa 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.

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

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

Console

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

En la consola de Google Cloud , haz lo siguiente:
1. Ir a Lotes de Dataproc
2. Haz clic en Crear para abrir la página Crear lote.
Selecciona y completa los siguientes campos para configurar el lote para la ejecución de consultas nativas:
- Contenedor:
  - Versión del entorno de ejecución: Selecciona 1.2, 2.2 o un número de versión major.minor superior. Consulta las versiones compatibles del entorno de ejecución de Serverless para Apache Spark.
- Configuración del nivel de ejecutor y controlador:
  - Selecciona Premium para todos los niveles (Nivel de procesamiento del controlador, Nivel de procesamiento del ejecutor).
- Propiedades: Ingresa 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/nativa/indígena/aborigen
Completa, selecciona o confirma otros parámetros de configuración de las cargas de trabajo por lotes. Consulta Envía 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/nativa/indígena/aborigen

gcloud

Establece las siguientes marcas de comando de gcloud dataproc batches submit spark de gcloud CLI 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: El ID de tu proyecto de Google Cloud . Los IDs del proyecto se enumeran en la sección Información del proyecto en el panel de la consola Google Cloud .
REGION: Es una región de Compute Engine disponible para ejecutar la carga de trabajo.
OTHER_FLAGS_AS_NEEDED: Consulta Envía una carga de trabajo por lotes de Spark.

API

Configura 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: Establece 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 Envía una carga de trabajo por lotes de Spark para configurar otros campos de la API de carga de trabajo por lotes.

Cuándo usar la ejecución de consultas nativas

Usa 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 el rendimiento de la ejecución de consultas nativas.
Son las cargas de trabajo que recomienda la herramienta de calificació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
Struct, Array y Map: Parquet

Limitaciones

Habilitar la ejecución de consultas nativas en las siguientes situaciones puede causar excepciones, incompatibilidades con Spark o que la carga de trabajo recurra al motor de Spark predeterminado.

Resguardos

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 genera una regresión o una falla.

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

Comportamiento incompatible

El uso de la ejecución de consultas nativas puede generar un comportamiento incompatible o resultados incorrectos en los siguientes casos:

Funciones JSON: La ejecución de consultas nativas admite cadenas entre comillas dobles, no comillas simples. Los resultados incorrectos se producen con comillas simples. Usar "*" en la ruta de acceso con la función get_json_object devuelve NULL.
Configuración de lectura de Parquet:
- La ejecución de consultas nativas trata spark.files.ignoreCorruptFiles como si estuviera configurado con el valor predeterminado false, incluso cuando se establece en true.
- La ejecución de consultas nativas ignora spark.sql.parquet.datetimeRebaseModeInRead y solo devuelve el contenido del archivo Parquet. No se consideran las diferencias entre el calendario híbrido heredado (juliano gregoriano) y el calendario gregoriano proléptico. Los resultados de Spark pueden variar.
NaN: No compatible. Por ejemplo, pueden producirse resultados inesperados cuando se usa NaN en una comparación numérica.
Lectura columnar de Spark: Se puede producir un error fatal, ya que el vector columnar de Spark es incompatible con la ejecución de consultas nativas.
Volcado: Cuando las particiones de la mezcla se establecen en una cantidad grande, la función de volcado en disco puede activar un OutOfMemoryException. Si esto ocurre, reducir la cantidad de particiones puede eliminar esta excepción.