Utiliser Lightning Engine

Lightning Engine est la nouvelle génération de performances Apache Spark. Il introduit des améliorations exclusives conçues pour améliorer considérablement les performances, la rentabilité et la stabilité opérationnelle.

Avantages

Voici quelques avantages de Lightning Engine :

  • Opérations sur les données accélérées : obtenez des gains de performances et des économies de coûts importants grâce à des optimisations de l'interaction avec le stockage cloud, y compris la gestion des métadonnées, les charges de travail d'écriture et les E/S vectorisées.

  • Exécution intelligente des requêtes : profitez des améliorations avancées de l'optimiseur qui réduisent dynamiquement les données analysées, optimisent le traitement des données et génèrent des plans d'exécution plus efficaces pour des requêtes plus rapides et plus économiques.

  • Charges de travail d'IA et de ML simplifiées : réduisez les temps de démarrage des clusters pour les charges de travail basées sur GPU et simplifiez le déploiement dans des environnements sécurisés à l'aide d'images optimisées pour l'IA.

Bien que le moteur Lightning offre des gains de performances considérables, l'impact spécifique varie en fonction de la charge de travail. Il est particulièrement adapté aux tâches gourmandes en calcul qui exploitent les API Spark DataFrame, Spark Dataset et les requêtes Spark SQL, plutôt qu'aux opérations liées aux E/S.

Comparaison avec le moteur standard

Lightning Engine est une alternative au moteur standard utilisé pour exécuter des jobs Spark sur un cluster Managed Service pour Apache Spark. Le tableau suivant compare le moteur Lightning aux propriétés d'activation du moteur standard, à l'applicabilité de la charge de travail et aux principaux avantages.

Fonctionnalité Moteur standard Lightning Engine
Option de la CLI --engine=default ou désactiver le signalement --engine=lightning
Recommandé pour Tâches à usage général, développement et tests Charges de travail à l'échelle de l'entreprise nécessitant une accélération importante
Principaux avantages Performances de référence Interaction optimisée avec le stockage cloud, exécution intelligente des requêtes

Conditions requises

Les exigences suivantes s'appliquent à la fonctionnalité Lightning Engine :

  • Version de l'image : Lightning Engine doit être utilisé avec la version 2.3.3 ou ultérieure de l'image Managed Service pour Apache Spark, ainsi qu'avec les versions mineures 2.3 de l'image. Lightning Engine n'est pas compatible avec la version 3.0 de l'image Managed Service pour Apache Spark.
  • Tâches compatibles : Spark, PySpark, SparkSQL et SparkR sont compatibles. Le moteur standard s'exécute sur d'autres types de jobs envoyés à un cluster Lightning Engine.

Exécution native des requêtes

L'exécution native des requêtes est un composant optionnel de Lightning Engine qui fournit un niveau d'accélération plus élevé pour des jobs spécifiques. Il s'agit d'un moteur natif basé sur Apache Gluten et Velox, optimisé pour le matériel Google, qui améliore les performances en exécutant des parties d'une requête Spark en dehors de la JVM.

Le NQE est recommandé pour :
 Tâches gourmandes en calcul qui exploitent les API Spark DataFrame et Spark Dataset, ainsi que les requêtes Spark SQL qui lisent les données des fichiers et tables Parquet, ORC, Apache Iceberg et Delta Lake. Le format du fichier de sortie n'a aucune incidence sur ses performances.
La NQE n'est pas recommandée pour :
 Jobs qui reposent fortement sur les ensembles de données distribués résilients (RDD), les fonctions définies par l'utilisateur (UDF), la plupart des bibliothèques Spark Machine Learning (ML) et les opérations liées aux E/S avec des délais dus à l'accès au stockage.

Exécution native des requêtes sur ARM

Managed Service pour Apache Spark est compatible avec l'exécution de requêtes natives dans Lightning Engine sur l'architecture ARM, spécifiquement optimisée pour les processeurs Google Axion sur les VM ARM C4A (voir Types de machines ARM compatibles avec Managed Service pour Apache Spark) à l'aide de l'image 2.3-ubuntu22-arm. Les instances Google Axion C4A sont des VM basées sur ARM, conçues sur des cœurs ARM Neoverse V2, qui offrent des améliorations significatives du rapport prix/performances.

L'exécution de NQE sur des instances Google Axion ARM combine le rapport prix/performances au niveau matériel et la bande passante mémoire élevée par cœur avec l'accélération des requêtes vectorisées natives au niveau logiciel, ce qui réduit considérablement les temps d'exécution des requêtes et le coût total de possession (TCO).

Voici les principaux avantages d'ARM :

  • Accélération de 2,5 à 4 fois par rapport à Spark Open Source : amélioration des performances de 2,5 à 4 fois par rapport à Apache Spark Open Source sur les charges de travail analytiques.
  • Optimisation des coûts : maximise l'avantage prix/performances des instances Google Axion C4A (qui offrent un rapport prix/performances jusqu'à 65% supérieur à celui des instances x86 comparables).
  • Parité complète des opérateurs et des formats : parité complète avec les opérateurs NQE x86, avec accélération native pour les formats de table Cloud Storage Parquet, Apache Iceberg et Delta Lake.
  • Aucune modification de code : activation fluide sur les clusters ARM à l'aide d'indicateurs de configuration standards sans modifier le code de votre application Spark.

Conditions requises

Les exigences suivantes s'appliquent à la fonctionnalité d'exécution de requêtes natives :

  • Moteur d'exécution : NQE n'est disponible que sur les clusters activés avec le moteur Lightning lors de la création du cluster.

  • Tâches compatibles : Spark, PySpark, SparkSQL et SparkR sont compatibles. Le moteur standard s'exécutera (sans NQE) sur d'autres types de tâches envoyées à un cluster Lightning Engine.

  • Aucun GPU ni accélérateur : les jobs compatibles avec NQE envoyés sur des accélérateurs GPU échoueront (mais pourront bénéficier de Lightning Engine sans NQE).

  • Types de données : les entrées des types de données suivants ne sont pas acceptées :

    • Octet : ORC et Parquet
    • Struct, Array, Map : Parquet

Exigences concernant l'architecture et le système d'exploitation

Les exigences NQE diffèrent selon l'architecture du processeur :

Architecture Types de machines compatibles Système d'exploitation et image compatibles
x86 Familles de machines Intel et AMD Debian-12 et Ubuntu-22 (version 2.3.3 de l'image et versions ultérieures de 2.3)
ARM Série de machines C4A (VM ARM Google Axion) Image 2.3-ubuntu22-arm (version 2.3.3 et versions ultérieures 2.3)

Tarifs

Pour en savoir plus sur les tarifs, consultez la page Tarifs de Managed Service pour Apache Spark.

Créer un cluster Lightning Engine

Cette section vous explique comment créer un cluster Managed Service pour Apache Spark qui active Lightning Engine sur les jobs Spark envoyés au cluster.

Vous pouvez également activer l'exécution de requêtes natives (NQE) sur le cluster lorsque vous le créez, ou vous pouvez activer la NQE ultérieurement pour des jobs Spark spécifiques envoyés au cluster.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits sans frais pour exécuter, tester et déployer des charges de travail.

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

    Go to project selector

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

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

  5. Enable the Dataproc API.

    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

  6. Installez la Google Cloud CLI.

  7. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  8. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init

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

    Go to project selector

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

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

  12. Enable the Dataproc API.

    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

  13. Installez la Google Cloud CLI.

  14. Si vous utilisez un fournisseur d'identité (IdP) externe, vous devez d'abord vous connecter à la gcloud CLI avec votre identité fédérée.

  15. Pour initialiser la gcloud CLI, exécutez la commande suivante : 

    gcloud init

Rôles requis

Certains rôles Identity and Access Management (IAM) sont nécessaires pour créer un cluster Managed Service pour Apache Spark et envoyer des jobs au cluster. Selon les règles d'administration, il est possible qu'un propriétaire de projet Cloud ou un administrateur de service vous ait déjà attribué ces rôles à vous ou à un compte de service. Pour vérifier les attributions de rôles, consultez Dois-je attribuer des rôles ?.

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Rôles utilisateur

Pour obtenir les autorisations nécessaires pour créer un cluster Managed Service for Apache Spark, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Rôle du compte de service

Pour vous assurer que le compte de service Compute Engine par défaut dispose des autorisations nécessaires pour créer un cluster Managed Service for Apache Spark, demandez à votre administrateur d'accorder le rôle IAM Nœud de calcul Dataproc (roles/dataproc.worker) au compte de service Compute Engine par défaut sur le projet.

Créer le cluster

Les exemples suivants vous montrent comment créer un cluster Lightning Engine à l'aide de la console Google Cloud , de la Google Cloud CLI, de l'API Dataproc, des bibliothèques clientes Cloud pour Python ou de Terraform. Vous pouvez également créer un cluster avec le moteur Lightning activé à l'aide des bibliothèques clientes Cloud Go, Java et Node.js.

Console

  1. Ouvrez la page Créer un cluster.
  2. Cliquez sur Configuration supplémentaire pour développer cette section.
  3. Modifiez Personnalisation et autres.
  4. Dans le panneau qui s'ouvre, vérifiez que la case Activer Lightning Engine est cochée.
  5. Facultatif : Pour activer le runtime d'exécution native par défaut pour les jobs Spark, cochez la case Activer l'exécution native.
  6. Cliquez sur Enregistrer.
  7. Configurez les autres paramètres du cluster selon vos besoins.
  8. Cliquez sur Créer un cluster.

Créez un cluster ARM :

Pour créer un cluster ARM avec Google Axion et l'exécution de requêtes natives :

  1. Dans Configuration du nœud de calcul, sélectionnez la série de machines C4A, puis choisissez votre type de machine ARM.
  2. Dans Image, sélectionnez l'image 2.3-ubuntu22-arm.
  3. Dans Configuration supplémentaire > Personnalisation et autres, vérifiez que les options Activer le moteur Lightning et Activer l'exécution native sont sélectionnées.
  4. Cliquez sur Créer un cluster.

gcloud

  1. Pour créer un cluster avec le moteur Lightning activé, exécutez la commande gcloud dataproc clusters create avec l'option --engine=lightning. Pour en savoir plus, consultez Créer un cluster avec gcloud CLI.

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

  2. Facultatif : Pour activer le runtime d'exécution natif par défaut pour les jobs Spark, incluez la propriété 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. Créer un cluster ARM avec NQE : pour créer un cluster Managed Service pour Apache Spark avec des nœuds Google Axion C4A ARM et NQE activé :

    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

Pour créer un cluster avec le moteur Lightning activé, envoyez une requête clusters.create. Pour en savoir plus, consultez Créer un cluster avec l'API REST.

  1. Dans le corps de la requête, définissez le champ engine sur LIGHTNING.

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

  2. Facultatif : Pour activer le runtime d'exécution natif par défaut pour tous les jobs, incluez la propriété 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. Pour créer un cluster avec le moteur Lightning activé, utilisez la méthode create_cluster et définissez le champ engine dans la configuration du cluster sur LIGHTNING. Pour en savoir plus, consultez Créer un cluster avec 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. Facultatif : Pour activer le runtime d'exécution natif par défaut pour les jobs Spark, incluez la propriété 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. Dans la configuration de votre ressource google_dataproc_cluster, définissez l'argument engine sur LIGHTNING.
  2. Pour en savoir plus et découvrir les options avancées, consultez la documentation Terraform officielle sur la ressource google_dataproc_cluster.

Vérifier le moteur du cluster

Console

  1. Dans la console Google Cloud , accédez à la page Détails du cluster.
  2. Vérifiez que la valeur Lightning Engine figure dans le champ Moteur.
  3. Si vous avez activé l'exécution native des requêtes, vérifiez que native figure dans le champ Exécution native.

gcloud

  1. Pour vérifier le moteur et NQE (si activé), exécutez la commande gcloud dataproc clusters describe :

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

  2. Vérifiez les propriétés engine et lightningEngine.runtime dans le résultat :

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

Envoyer un job avec Lightning Engine

Si vous avez activé Lightning Engine lorsque vous avez créé un cluster, il est activé par défaut sur le job Spark lorsque vous l'envoyez au cluster.

Activer l'exécution native des requêtes pour un job

Si vous avez activé l'exécution native des requêtes (NQE) lorsque vous avez créé un cluster Lightning Engine, tous les jobs Spark s'exécutent avec la NQE activée, sauf si vous désactivez la NQE pour un job spécifique.

Si vous n'avez pas activé NQE lorsque vous avez créé le cluster Lightning Engine, vous pouvez l'activer pour un job lorsque vous l'envoyez, comme illustré dans les exemples suivants.

gcloud

Pour activer l'exécution native des requêtes lorsque vous envoyez un job Spark, incluez la propriété spark.dataproc.lightningEngine.runtime=native :

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

API

Pour activer l'exécution native des requêtes lorsque vous envoyez un job Spark, incluez la propriété spark.dataproc.lightningEngine.runtime dans votre requête :

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

Désactiver l'exécution native des requêtes pour un job

Si vous avez activé l'exécution native des requêtes (NQE) lorsque vous avez créé un cluster Lightning Engine, tous les jobs Spark s'exécuteront avec la NQE activée, sauf si vous la désactivez pour un job spécifique.

Vous pouvez désactiver NQE pour un job Spark spécifique lorsque vous l'envoyez, comme indiqué dans les exemples suivants.

gcloud

Pour désactiver l'exécution native des requêtes lorsque vous envoyez un job Spark à un cluster Lightning Engine, incluez la propriété spark.dataproc.lightningEngine.runtime=default :

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

API

Pour désactiver l'exécution native des requêtes lorsque vous envoyez un job Spark à un cluster Lightning Engine, incluez la propriété spark.dataproc.lightningEngine.runtime=default :

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

Vérifier l'exécution native des requêtes pour un job

Une fois que vous avez envoyé un job à un cluster Lightning Engine, vous pouvez vérifier que l'exécution native des requêtes est activée pour le job.

Console

  1. Dans la console Google Cloud , accédez à la page Jobs.
  2. Cliquez sur l'ID du job pour ouvrir la page Informations sur le job.
  3. Vérifiez que native est répertorié dans le champ Exécution native.

gcloud

  1. Exécutez la commande gcloud dataproc jobs describe :

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

  2. Vérifiez le résultat de lightningEngine.runtime dans la section Propriétés :

    lightningEngine.runtime: native

Paramètres de configuration

Le tableau suivant récapitule les principaux paramètres de configuration de Lightning Engine et de l'exécution de requêtes natives.

Nom du paramètre Description Moteur(s) concerné(s) Valeur par défaut Valeur par défaut (Lightning Engine) L'utilisateur peut le modifier (au niveau du job) Champ d'application
--engine Paramètre au niveau du cluster permettant de sélectionner le moteur lors de la création du cluster. À l'échelle du cluster default lightning Non Cluster
spark:spark.dataproc.lightningEngine.runtime Paramètre au niveau du cluster permettant de sélectionner le moteur d'exécution Lightning lors de la création du cluster. Éclair uniquement default default Non Cluster
spark.dataproc.lightningEngine.runtime Active ou désactive l'exécution native des requêtes (NQE) dans Lightning Engine. Éclair uniquement default default Oui. Elle peut être définie sur native ou default. Job

Limites

L'activation de l'exécution de requêtes natives dans les scénarios suivants peut entraîner des exceptions, des incompatibilités Spark ou le retour de la charge de travail au moteur Spark par défaut.

Actions de remplacement

L'exécution de requêtes natives dans les scénarios suivants peut entraîner un retour à la charge de travail vers le moteur d'exécution Spark :

  • ANSI : si le mode ANSI est activé, l'exécution revient à Spark.
  • Mode sensible à la casse : l'exécution de requêtes natives n'est compatible qu'avec le mode par défaut de Spark, qui n'est pas sensible à la casse. Si le mode sensible à la casse est activé, des résultats incorrects peuvent s'afficher.
  • Analyse de table partitionnée : l'exécution de requêtes natives n'est compatible avec l'analyse de table partitionnée que lorsque le chemin d'accès contient les informations de partition. Sinon, la charge de travail revient au moteur d'exécution Spark.

Comportement incompatible

Un comportement incompatible ou des résultats incorrects peuvent se produire lorsque vous utilisez l'exécution de requêtes natives dans les cas suivants :

  • Fonctions JSON : l'exécution de requêtes natives accepte les chaînes entourées de guillemets doubles, et non de guillemets simples. Des résultats incorrects s'affichent avec des guillemets simples. L'utilisation de * dans le chemin d'accès avec la fonction get_json_object renvoie NULL.
  • Configuration de lecture Parquet :
    • L'exécution de requêtes natives traite spark.files.ignoreCorruptFiles comme étant défini sur la valeur par défaut false, même lorsqu'il est défini sur true.
    • L'exécution de requêtes natives ignore spark.sql.parquet.datetimeRebaseModeInRead et ne renvoie que le contenu du fichier Parquet. Les différences entre l'ancien calendrier hybride et le calendrier grégorien proleptique ne sont pas prises en compte. Les résultats Spark peuvent varier.
  • NaN : non compatible. Des résultats inattendus peuvent se produire, par exemple, lorsque vous utilisez NaN dans une comparaison numérique.
  • Lecture en colonnes Spark : une erreur fatale peut se produire, car le vecteur en colonnes Spark est incompatible avec l'exécution de requêtes natives.
  • Débordement : lorsque vous définissez un grand nombre de partitions de shuffle, la fonctionnalité de débordement sur disque peut déclencher un OutOfMemoryException. Si cela se produit, vous pouvez éliminer cette exception en réduisant le nombre de partitions.

Étapes suivantes