Usa Lightning Engine

Lightning Engine es un entorno de ejecución de alto rendimiento para Apache Spark en Managed Service para Apache Spark que acelera las cargas de trabajo con uso intensivo de procesamiento y reduce los costos de tiempo de ejecución sin necesidad de realizar cambios en tu código de Spark. Está diseñado para ingenieros de datos y profesionales de análisis que ejecutan cargas de trabajo de cómputo intensivo que usan APIs de DataFrame de Spark, APIs de Dataset de Spark o consultas en SQL de Spark.

Si tus cargas de trabajo están vinculadas principalmente a la E/S o dependen en gran medida de los conjuntos de datos resilientes y distribuidos (RDD), el motor estándar podría ser más adecuado.

Beneficios

Entre los beneficios de Lightning Engine, se incluyen los siguientes:

• Operaciones de datos aceleradas: Obtén mejoras significativas en el rendimiento y ahorros de costos a través de optimizaciones en la interacción con Cloud Storage, lo que incluye el manejo de metadatos, las cargas de trabajo de escritura y la E/S vectorizada.

• Ejecución inteligente de consultas: Aprovecha las mejoras avanzadas del optimizador que reducen de forma dinámica los datos analizados, optimizan el procesamiento de datos y generan planes de ejecución más eficientes para realizar consultas más rápidas y rentables.

• Cargas de trabajo de IA y AA optimizadas: Reduce los tiempos de inicio de los clústeres para las cargas de trabajo basadas en GPU y simplifica la implementación en entornos seguros con imágenes optimizadas para IA.

Si bien Lightning Engine ofrece mejoras de rendimiento sustanciales, el impacto específico varía según la carga de trabajo.

Comparación con el motor estándar

Lightning Engine es una alternativa al motor estándar que se usa para ejecutar trabajos de Spark en un clúster de Managed Service para Apache Spark. En la siguiente tabla, se compara Lightning Engine con las propiedades de activación, la aplicabilidad de la carga de trabajo y los beneficios clave del motor estándar.

Función	Motor estándar	Lightning Engine
Marca de la CLI	--engine=default o anular la configuración de la marca	--engine=lightning
Ideal para	Trabajos de uso general, desarrollo y pruebas	Cargas de trabajo a escala empresarial que requieren una aceleración significativa
Beneficios clave	Rendimiento de modelo de referencia	Interacción optimizada con Cloud Storage y ejecución inteligente de consultas

Requisitos de Lightning Engine

Se aplican los siguientes requisitos a la función Lightning Engine:

• Versión de imagen: Lightning Engine se debe usar con la versión de imagen 2.3.3 de Managed Service para Apache Spark y las versiones de imagen secundarias 2.3 posteriores, o bien con la versión de imagen 3.0.2 y las versiones de imagen secundarias 3.0 posteriores (imágenes debian13 y ubuntu24).
• Trabajos compatibles: Se admiten Spark, PySpark, SparkSQL y SparkR. El motor estándar se ejecuta en otros tipos de trabajos enviados a un clúster de Lightning Engine.

Ejecución de consultas nativas

La ejecución de consultas nativas (NQE) es un componente opcional de Lightning Engine que proporciona un nivel más profundo de aceleración para trabajos específicos. Es un motor nativo basado en Apache Gluten y Velox, optimizado para el hardware de Google, que aumenta el rendimiento ejecutando partes de una consulta de Spark fuera de la JVM.

Se recomienda usar NQE para lo siguiente:

Tareas de procesamiento intensivo que aprovechan las APIs de DataFrame de Spark, las APIs de Dataset de Spark y las consultas en SQL de Spark que leen datos de archivos y tablas de Parquet, ORC, Apache Iceberg y Delta Lake. El formato del archivo de salida no afecta su rendimiento.

No se recomienda usar NQE en los siguientes casos:

Trabajos que dependen en gran medida de conjuntos de datos distribuidos resilientes (RDD), funciones definidas por el usuario (UDF), la mayoría de las bibliotecas de aprendizaje automático (AA) de Spark y operaciones vinculadas a E/S con retrasos debido al acceso al almacenamiento.

Ejecución de consultas nativas en ARM

Managed Service para Apache Spark admite la ejecución de consultas nativas dentro de Lightning Engine en la arquitectura de ARM, optimizada específicamente para los procesadores Google Axion en las VMs de ARM C4A (consulta los tipos de máquinas de ARM admitidos en Managed Service para Apache Spark) con la imagen 2.3-ubuntu22-arm. Las instancias C4A de Google Axion son VMs basadas en ARM compiladas en núcleos ARM Neoverse V2 que ofrecen mejoras significativas en la relación precio-rendimiento.

Ejecutar NQE en instancias de Google Axion ARM combina la relación precio-rendimiento a nivel de hardware y el alto ancho de banda de memoria por núcleo con la aceleración de consultas vectorizadas nativas a nivel de software, lo que reduce significativamente los tiempos de ejecución de las consultas y el costo total de propiedad (TCO).

Estos son algunos de los beneficios clave de ARM:

• Aceleración de 2.5 a 4 veces más rápida que Spark de código abierto: Ofrece mejoras de rendimiento de 2.5 a 4 veces más rápidas en comparación con Apache Spark de código abierto en cargas de trabajo analíticas.
• Optimización de costos: Maximiza la ventaja de precio-rendimiento de las instancias de Google Axion C4A (que ofrecen una relación precio-rendimiento hasta un 65% mejor en comparación con las instancias x86 comparables).
• Paridad completa de operadores y formatos: Paridad completa con los operadores de NQE de x86, con aceleración nativa para los formatos de tabla de Cloud Storage Parquet, Apache Iceberg y Delta Lake.
• Cero cambios de código: Activación sin problemas en clústeres de ARM con marcas de configuración estándar sin modificar el código de la aplicación de Spark.

Requisitos de la ejecución de consultas nativas

Se aplican los siguientes requisitos a la función de ejecución de consultas nativas:

• Motor de ejecución: NQE solo está disponible en los clústeres habilitados con el motor Lightning durante la creación del clúster.

• Trabajos admitidos: Se admiten Spark, PySpark, Spark SQL y SparkR. El motor estándar se ejecutará (sin NQE) en otros tipos de trabajos enviados a un clúster de Lightning Engine.

• Sin GPU ni aceleradores: Los trabajos habilitados para NQE que se envíen en aceleradores de GPU fallarán (pero pueden beneficiarse de Lightning Engine sin NQE).

• Tipos de datos: No se admiten las entradas de los siguientes tipos de datos:

  • Byte: ORC y Parquet
  • Struct, Array, Map: Parquet

Requisitos de arquitectura y sistema operativo

Los requisitos de NQE varían según la arquitectura del procesador:

Arquitectura	Tipos de máquina admitidos	Sistema operativo y de imagen compatibles
x86	Familias de máquinas Intel y AMD	Debian-12 y Ubuntu-22 (versión de imagen 2.3.3 y versiones posteriores de 2.3); Debian-13 y Ubuntu-24 (versión de imagen 3.0.2 y versiones posteriores de 3.0)
ARM	Serie de máquinas C4A (VMs de Google Axion ARM)	Imagen de 2.3-ubuntu22-arm (versión 2.3.3 y versiones posteriores de 2.3)

Precios

Para obtener información sobre los precios, consulta Precios de Managed Service para Apache Spark.

Crea un clúster de Lightning Engine

En esta sección, se muestra cómo crear un clúster de Managed Service para Apache Spark que habilite Lightning Engine en los trabajos de Spark enviados al clúster.

También puedes habilitar la ejecución de consultas nativas (NQE) en el clúster cuando lo creas, o puedes habilitar la NQE más adelante para trabajos de Spark específicos enviados al clúster.

Antes de comenzar

Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

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

Verify that you have the permissions required to complete this guide.

Verify that billing is enabled for your Google Cloud project.

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

Install the Google Cloud CLI.

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

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

Verify that you have the permissions required to complete this guide.

Verify that billing is enabled for your Google Cloud project.

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

Install the Google Cloud CLI.

Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

To initialize the gcloud CLI, run the following command:

gcloud init

Roles obligatorios

Se requieren ciertos roles de Identity and Access Management (IAM) para crear un clúster de Managed Service para Apache Spark y enviar trabajos al clúster. Según las políticas de la organización, es posible que el propietario de un proyecto de la nube o el administrador de servicios ya te hayan otorgado estos roles a ti o a una cuenta de servicio. Para verificar el otorgamiento de roles, consulta ¿Necesitas otorgar roles?.

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

Roles de usuario

Para obtener los permisos que necesitas para crear un clúster de Managed Service para Apache Spark, 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

Rol de cuenta de servicio

Para asegurarte de que la cuenta de servicio predeterminada de Compute Engine tenga los permisos necesarios para crear un clúster de Managed Service para Apache Spark, 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.

Crea el clúster

En los siguientes ejemplos, se muestra cómo crear un clúster de Lightning Engine con la consola de Google Cloud , Google Cloud CLI, la API de Dataproc, las bibliotecas cliente de Cloud para Python o Terraform. También puedes crear un clúster con el motor Lightning habilitado con las bibliotecas cliente de Cloud para Go, Java y Node.js.

Console

1. Abre la página Crear clúster.
2. Haz clic en Configuración adicional para expandir esa sección.
3. Edita Personalización y otros.
4. En el panel que se abre, confirma que la casilla de verificación Habilitar Lightning Engine esté seleccionada.
5. Opcional: Para habilitar el entorno de ejecución nativo de forma predeterminada para los trabajos de Spark, selecciona la casilla de verificación Habilitar la ejecución nativa.
6. Haz clic en Guardar.
7. Establece otros parámetros de configuración del clúster según sea necesario.
8. Haga clic en Crear clúster.

Crea un clúster de ARM:

Para crear un clúster de ARM con Google Axion y la ejecución de consultas nativas, haz lo siguiente:

1. En Configuración de trabajadores, selecciona la serie de máquinas C4A y elige el tipo de máquina ARM.
2. En Imagen, selecciona la imagen 2.3-ubuntu22-arm.
3. En Configuración adicional > Personalización y otros, confirma que estén seleccionadas las opciones Habilitar Lightning Engine y Habilitar ejecución nativa.
4. Haga clic en Crear clúster.

gcloud

1. Para crear un clúster con Lightning Engine habilitado, ejecuta el comando gcloud dataproc clusters create con la marca --engine=lightning. Para obtener más información, consulta Crea un clúster con gcloud CLI.

   gcloud dataproc clusters create CLUSTER_NAME \
       --region=REGION \
       --engine=lightning \
       --image-version=2.3
   

2. Opcional: Para habilitar el entorno de ejecución nativo de forma predeterminada para los trabajos de Spark, incluye la propiedad spark:spark.dataproc.lightningEngine.runtime=native.

   gcloud dataproc clusters create CLUSTER_NAME \
       --region=REGION \
       --engine=lightning \
       --image-version=2.3 \
       --properties='spark:spark.dataproc.lightningEngine.runtime=native'
   

3. Crea un clúster de ARM con NQE: Para crear un clúster de Managed Service para Apache Spark con nodos de ARM de Google Axion C4A y NQE habilitado, haz lo siguiente:

   gcloud dataproc clusters create CLUSTER_NAME \
       --region=REGION \
       --image-version=2.3-ubuntu22-arm \
       --master-machine-type=c4a-standard-16 \
       --worker-machine-type=c4a-standard-16 \
       --engine=lightning \
       --properties='spark:spark.dataproc.lightningEngine.runtime=native'
   

API

Para crear un clúster con el motor Lightning habilitado, envía una solicitud clusters.create. Para obtener más información, consulta Crea un clúster con la API de REST.

1. En el cuerpo de la solicitud, configura el campo engine como LIGHTNING.

   {
     "projectId": "PROJECT_ID",
     "clusterName": "CLUSTER_NAME",
     "config": {
       "engine": "LIGHTNING",
       "gceClusterConfig": {},
       "softwareConfig": {
         "imageVersion": "2.3"
       }
     }
   }
   

2. Opcional: Para habilitar el entorno de ejecución nativo de forma predeterminada en todos los trabajos, incluye la propiedad spark:spark.dataproc.lightningEngine.runtime.

   {
     "projectId": "PROJECT_ID",
     "clusterName": "CLUSTER_NAME",
     "config": {
       "engine": "LIGHTNING",
       "gceClusterConfig": {},
       "softwareConfig": {
         "imageVersion": "2.3",
         "properties": {
           "spark:spark.dataproc.lightningEngine.runtime": "native"
         }
       }
     }
   }
   

Python

1. Para crear un clúster con Lightning Engine habilitado, usa el método create_cluster y establece el campo engine en la configuración del clúster como LIGHTNING. Para obtener más información, consulta Crea un clúster con Python.

   from google.cloud import dataproc_v1
   
   def create_lightning_cluster(project_id, region, cluster_name):
       client_options = {"api_endpoint": f"{region}-dataproc.googleapis.com:443"}
       cluster_client = dataproc_v1.ClusterControllerClient(client_options=client_options)
   
       cluster = {
           "project_id": project_id,
           "cluster_name": cluster_name,
           "config": {
               "engine": "LIGHTNING",
               "software_config": {
                   "image_version": "2.3-debian12",
               },
           }
       }
   
       operation = cluster_client.create_cluster(
           project_id=project_id,
           region=region,
           cluster=cluster
       )
       result = operation.result()
       print(f"Cluster created successfully: {result.cluster_name}")
   

2. Opcional: Para habilitar el entorno de ejecución nativo de forma predeterminada para los trabajos de Spark, incluye la propiedad spark:spark.dataproc.lightningEngine.runtime.

   from google.cloud import dataproc_v1
   
   def create_lightning_native_cluster(project_id, region, cluster_name):
       client_options = {"api_endpoint": f"{region}-dataproc.googleapis.com:443"}
       cluster_client = dataproc_v1.ClusterControllerClient(client_options=client_options)
   
       cluster = {
           "project_id": project_id,
           "cluster_name": cluster_name,
           "config": {
               "engine": "LIGHTNING",
               "software_config": {
                   "image_version": "2.3-debian12",
                   "properties": {
                       "spark:spark.dataproc.lightningEngine.runtime": "native"
                   }
               }
           }
       }
   
       operation = cluster_client.create_cluster(
           project_id=project_id,
           region=region,
           cluster=cluster
       )
       result = operation.result()
       print(f"Cluster created successfully: {result.cluster_name}")
   

Terraform

1. En la configuración del recurso google_dataproc_cluster, establece el argumento engine en LIGHTNING.
2. Para obtener más detalles y opciones avanzadas, consulta la documentación oficial de Terraform para el recurso google_dataproc_cluster.

Verifica el motor del clúster

Console

1. En la consola de Google Cloud , ve a la página Detalles del clúster.
2. Verifica que el valor Lightning Engine aparezca en el campo Motor.
3. Si habilitaste la ejecución de consultas nativas, verifica que native aparezca en el campo Ejecución nativa.

gcloud

1. Para verificar el motor y la NQE (si está habilitada), ejecuta el comando gcloud dataproc clusters describe:

   gcloud dataproc clusters describe CLUSTER_NAME --project=PROJECT_ID --region=REGION
   

2. Verifica el resultado de las propiedades engine y lightningEngine.runtime:

   clusterName: lightning-engine-cluster
   engine: lightningEngine
   lightningEngine.runtime: native
   

Envía un trabajo con Lightning Engine

Si habilitaste Lightning Engine cuando creaste un clúster, cuando envías un trabajo de Spark al clúster, Lightning Engine se habilita de forma predeterminada en el trabajo.

Habilita la ejecución de consultas nativas para un trabajo

Si habilitaste la ejecución de consultas nativas (NQE) cuando creaste un clúster de Lightning Engine, todos los trabajos de Spark se ejecutan con la NQE habilitada, a menos que inhabilites la NQE en un trabajo específico.

Si no habilitaste la NQE cuando creaste el clúster de Lightning Engine, puedes habilitarla para un trabajo cuando lo envíes, como se muestra en los siguientes ejemplos.

gcloud

Para habilitar la ejecución de consultas nativas cuando envías un trabajo de Spark, incluye la propiedad spark.dataproc.lightningEngine.runtime=native:

gcloud dataproc jobs submit spark \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --properties=spark.dataproc.lightningEngine.runtime=native \
    -- ...

API

Para habilitar la ejecución de consultas nativas cuando envías un trabajo de Spark, incluye la propiedad spark.dataproc.lightningEngine.runtime en tu solicitud:

{
  "job":{
    "placement":{
      "clusterName": ...
    },
    "sparkJob":{
      "mainClass": ...,
      "properties":{
         "spark.dataproc.lightningEngine.runtime":"native"
      }
    }
  }
}

Inhabilita la ejecución de consultas nativas para un trabajo

Si habilitaste la ejecución de consultas nativas (NQE) cuando creaste un clúster de Lightning Engine, todos los trabajos de Spark se ejecutarán con la NQE habilitada, a menos que la inhabilites en un trabajo específico.

Puedes inhabilitar NQE para un trabajo de Spark específico cuando lo envías, como se muestra en los siguientes ejemplos.

gcloud

Para inhabilitar la ejecución de consultas nativas cuando envías un trabajo de Spark a un clúster de Lightning Engine, incluye la propiedad spark.dataproc.lightningEngine.runtime=default:

gcloud dataproc jobs submit spark \
    --cluster=CLUSTER_NAME \
    --region=REGION \
    --properties=spark.dataproc.lightningEngine.runtime=default \
    -- ...

API

Para inhabilitar la ejecución de consultas nativas cuando envías un trabajo de Spark a un clúster de Lightning Engine, incluye la propiedad spark.dataproc.lightningEngine.runtime=default:

{
  "job":{
    "placement":{
      "clusterName": ...
    },
    "sparkJob":{
      "mainClass": ...,
      "properties":{
         "spark.dataproc.lightningEngine.runtime":"default"
      }
    }
  }
}

Verifica la ejecución de consultas nativas para un trabajo

Después de enviar un trabajo a un clúster de Lightning Engine, puedes verificar que la ejecución de consultas nativas esté habilitada para el trabajo.

Console

1. En la consola de Google Cloud , ve a la página Trabajos.
2. Haz clic en el ID de tarea para abrir la página Detalles del trabajo.
3. Verifica que native aparezca en el campo Ejecución nativa.

gcloud

1. Ejecuta el comando gcloud dataproc jobs describe:

   gcloud dataproc jobs describe JOB_ID --project=PROJECT_ID --region=REGION
   

2. Verifica el resultado de lightningEngine.runtime en la sección Propiedades:

   lightningEngine.runtime: native
   

Parámetros de configuración

En la siguiente tabla, se resumen los parámetros de configuración principales para Lightning Engine y la ejecución de consultas nativas.

Nombre del parámetro	Descripción	Motores aplicables	Valor predeterminado	Valor predeterminado (Lightning Engine)	Anulable por el usuario (nivel de trabajo)	Alcance
--engine	Configuración a nivel del clúster para seleccionar el motor durante la creación del clúster.	En todo el clúster	default	lightning	No	Clúster
spark:spark.dataproc.lightningEngine.runtime	Es la configuración a nivel del clúster para seleccionar el entorno de ejecución del motor de Lightning durante la creación del clúster.	Solo Lightning	default	default	No	Clúster
spark.dataproc.lightningEngine.runtime	Habilita o inhabilita la ejecución de consultas nativas (NQE) en Lightning Engine.	Solo Lightning	default	default	Sí. Se puede configurar en native o default.	Trabajo

Limitaciones

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

Protocolos de contingencia

La ejecución de consultas nativas en las siguientes situaciones puede generar un resguardo de la carga de trabajo al motor de ejecución de Spark:

• ANSI: Si el modo ANSI está habilitado, la ejecución recurre a Spark.
• Modo que distingue mayúsculas de minúsculas: Native Query Execution solo admite el modo predeterminado de Spark que no distingue mayúsculas de minúsculas. Si se habilita el modo que distingue mayúsculas de minúsculas, pueden producirse resultados incorrectos.
• Análisis de tablas particionadas: Native Query Execution admite el análisis de tablas particionadas solo cuando la ruta contiene la información de la partición. De lo contrario, la carga de trabajo recurre al motor de ejecución de Spark.

Comportamiento incompatible

Se puede producir un comportamiento incompatible o resultados incorrectos cuando usas la ejecución de consultas nativas en los siguientes casos:

• Funciones JSON: La ejecución de consultas nativas admite cadenas rodeadas por comillas dobles, no comillas simples. Se producen resultados incorrectos con comillas simples. Si usas * en la ruta de acceso con la función get_json_object, se muestra NULL.
• Configuración de lectura de Parquet:
  • La ejecución de consultas nativas trata a spark.files.ignoreCorruptFiles como si estuviera configurado en 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 y el calendario gregoriano proléptico. Los resultados de Spark pueden variar.
• NaN: No se admite. Pueden producirse resultados inesperados, por ejemplo, cuando usas NaN en una comparación numérica.
• Lectura de columnas de Spark: Puede producirse un error fatal porque el vector de columnas de Spark no es compatible con la ejecución de consultas nativas.
• Desbordamiento: Cuando configuras las particiones de shuffle en un número grande, la función de desbordamiento en el disco puede activar un OutOfMemoryException. Si esto ocurre, reducir la cantidad de particiones puede eliminar esta excepción.

¿Qué sigue?

• Acelera las cargas de trabajo y las sesiones por lotes de Spark con Lightning Engine.
• Revisa los tipos de máquinas ARM compatibles con Managed Service para Apache Spark.
• Obtén información para ajustar los trabajos de Spark para obtener un rendimiento óptimo.