Utiliser Lightning Engine

Lightning Engine est la nouvelle génération de performances Apache Spark. Il introduit des améliorations exclusives conçues pour offrir des gains considérables en termes de performances, de rentabilité et de stabilité opérationnelle.

Avantages

Les avantages de Lightning Engine sont les suivants :

• Opérations sur les données accélérées : obtenez des gains de performances et des économies de coûts significatifs 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 : tirez parti 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 rentables.

• 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 avec des images d'IA et de ML natives.

Bien que Lightning Engine offre des gains de performances considérables, l'impact spécifique varie en fonction de la charge de travail. Il est plus adapté aux tâches gourmandes en calcul qui exploitent les API Spark Dataframe, les API 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 tâches Spark sur un cluster Managed Service pour Apache Spark. Le tableau suivant compare les propriétés d'activation, l'applicabilité des charges de travail et les principaux avantages de Lightning Engine et du moteur standard.

Fonctionnalité	Moteur standard	Lightning Engine
Propriété d'activation	--engine=default ou désactiver l'indicateur	--engine=lightning
Idéal 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 significative
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 d'image 2.3.3 ou ultérieure de Managed Service pour Apache Spark.
• Tâches compatibles : Spark, PySpark, SparkSQL et SparkR sont compatibles. Le moteur standard s'exécute sur les autres types de tâches envoyées à un cluster Lightning Engine.

Exécution native des requêtes

L'exécution native des requêtes (NQE, Native Query Execution) est un composant facultatif de Lightning Engine qui offre un niveau d'accélération plus élevé pour des tâches 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.

La NQE est recommandée pour :

Les tâches gourmandes en calcul (plutôt que les opérations liées aux E/S) qui exploitent les API Spark Dataframe, les API Spark Dataset et les requêtes Spark SQL qui lisent des données à partir de fichiers Parquet et ORC. Le format du fichier de sortie n'a pas d'incidence sur ses performances.

La NQE n'est pas recommandée pour :

Les tâches qui reposent fortement sur les ensembles de données distribués résilients (RDD, Resilient Distributed Datasets), les fonctions définies par l'utilisateur (UDF, User-Defined Functions) ou la plupart des bibliothèques Spark Machine Learning (ML).

Conditions requises

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

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

• Système d'exploitation : seules les images Debian-12 sont compatibles. Les tâches compatibles avec la NQE qui utilisent un autre système d'exploitation échoueront.

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

• Types de machines : seules les familles de machines utilisant des processeurs Intel ou AMD sont compatibles. Les tâches compatibles avec la NQE qui utilisent des processeurs ARM échoueront (mais peuvent bénéficier de Lightning Engine sans NQE).

• Aucun GPU ni accélérateur : les tâches compatibles avec la NQE envoyées sur des accélérateurs GPU échoueront (mais peuvent bénéficier de Lightning Engine sans NQE).

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

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

Tarifs

Pour obtenir des informations sur les tarifs, consultez Tarifs de Managed Service pour Apache Spark sur Compute Engine.

Créer un cluster Lightning Engine

Cette section explique comment créer un cluster Managed Service pour Apache Spark qui active Lightning Engine sur les tâches Spark envoyées au cluster.

Vous pouvez également activer l'exécution native des requêtes (NQE) sur le cluster lorsque vous créez le cluster, ou vous pouvez activer la NQE ultérieurement pour des tâches Spark spécifiques envoyées au cluster.

Avant de commencer

Connectez-vous à votre Google Cloud compte. 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.

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.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Installez la Google Cloud CLI.

Remarque : Si vous avez déjà installé la gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.

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.

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

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.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Installez la Google Cloud CLI.

Remarque : Si vous avez déjà installé la gcloud CLI, assurez-vous que vous disposez de la dernière version en exécutant gcloud components update.

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.

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

gcloud init

Rôles requis

Certains rôles IAM sont requis pour créer un cluster Managed Service pour Apache Spark et envoyer des tâches au cluster. En fonction des règles d'administration, ces rôles peuvent déjà avoir été attribués. Pour vérifier les attributions de rôles, consultez la section Devez-vous 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 pour Apache Spark, demandez à votre administrateur de vous accorder les rôles IAM suivants :

• Éditeur Managed Service pour Apache Spark (roles/dataproc.editor) sur le projet
• Utilisateur du compte de service (roles/iam.serviceAccountUser) sur le compte de service Compute Engine par défaut

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 pour Apache Spark, demandez à votre administrateur d'attribuer le rôle IAM Worker Managed Service pour Apache Spark (roles/dataproc.worker) au compte de service Compute Engine par défaut sur le projet.

Important : Vous devez attribuer ce rôle au compte de service Compute Engine par défaut, et non à votre compte utilisateur. Si vous ne l'accordez pas au bon compte principal, vous risquez de rencontrer des erreurs d'autorisation.

Créer le cluster

Les exemples suivants montrent comment créer un cluster Lightning Engine à l'aide de la Google Cloud console, de Google Cloud CLI, de l'API Dataproc, de Python ou de Terraform. Vous pouvez également créer un cluster Managed Service pour Apache Spark avec Lightning Engine activé à l'aide de la bibliothèque cliente Go, Java et Node.js.

Console

1. Dans la Google Cloud console, accédez à Créer un cluster Apache Spark sur Compute Engine. Pour en savoir plus, consultez Créer un cluster avec la Google Cloud console.

   Accéder à Créer un cluster Apache Spark sur Compute Engine

2. Sous Définir votre cluster, cochez la case Activer Lightning Engine pour créer un cluster avec Lightning Engine activé.

3. Facultatif : pour activer l'environnement d'exécution natif par défaut pour les tâches Spark, cochez la case Activer l'exécution native.

4. Configurez les autres paramètres du cluster si nécessaire.

5. Cliquez sur Créer.

Gcloud CLI

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

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

2. Facultatif : pour activer l'environnement d'exécution natif par défaut pour les tâches 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'
   

API

Pour créer un cluster avec Lightning Engine 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 engine champ sur LIGHTNING.

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

2. Facultatif : pour activer l'environnement d'exécution natif par défaut pour toutes les tâches, incluez la propriété spark:spark.dataproc.lightningEngine.runtime.

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

Python

1. Pour créer un cluster avec Lightning Engine 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 l'environnement d'exécution natif par défaut pour les tâches 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 plus d'informations et d'options avancées, consultez la documentation Terraform officielle pour la google_dataproc_cluster ressource.

Vérifier le moteur du cluster

Console

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

gcloud

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

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

2. Vérifiez la sortie des propriétés engine et lightningEngine.runtime :

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

Envoyer une tâche avec Lightning Engine

Une fois que vous avez créé un cluster Lightning Engine, lorsque vous envoyez une tâche Spark au cluster, Lightning Engine est automatiquement activé sur la tâche.

Activer l'exécution native des requêtes pour une tâche

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

Si vous n'avez pas activé la NQE lorsque vous avez créé le cluster Lightning Engine, vous pouvez l'activer pour une tâche spécifique lorsque vous l'envoyez, comme illustré dans les exemples suivants.

gcloud

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

```none
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 une tâche Spark, incluez la propriété spark.dataproc.lightningEngine.runtime dans votre requête :

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

Désactiver l'exécution native des requêtes pour une tâche

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

Vous pouvez désactiver la NQE pour une tâche Spark spécifique lorsque vous l'envoyez, comme illustré dans les exemples suivants.

gcloud

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

```shell
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 une tâche Spark, à un cluster Lightning Engine, incluez la propriété spark.dataproc.lightningEngine.runtime=default :

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

Vérifier l'exécution native des requêtes pour une tâche

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

Console

1. Dans la Google Cloud console, accédez à la page Détails de la tâche.
2. 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 clusters describe JOB_ID --project=PROJECT_ID --region=REGION
   

2. Vérifiez la sortie 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 native des requêtes.

Nom du paramètre	Description	Moteur(s) applicable(s)	Valeur par défaut	Valeur par défaut (Lightning Engine)	L'utilisateur peut le modifier (au niveau de la tâche)	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 l'environnement d'exécution du moteur Lightning lors de la création du cluster.	Lightning uniquement	default	default	Non	Cluster
spark.dataproc.lightningEngine.runtime	Active ou désactive l'exécution native des requêtes (NQE) dans Lightning Engine.	Lightning uniquement	default	default	Oui. Peut être défini sur native ou default.	Job

Limites

L'activation de l'exécution native des requêtes dans les scénarios suivants peut entraîner des exceptions, des incompatibilités Spark ou un retour à l'environnement d'exécution Spark par défaut.

Retours

L'exécution native des requêtes dans les scénarios suivants peut entraîner un retour à l'environnement d'exécution Spark :

• ANSI : si le mode ANSI est activé, l'exécution revient à Spark.
• Mode sensible à la casse : l'exécution native des requêtes 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 se produire.
• Analyse de table partitionnée : l'exécution native des requêtes n'est compatible avec l'analyse de table partitionnée que lorsque le chemin contient les informations de partition. Sinon, la charge de travail revient à l'environnement d'exécution Spark.

Comportement incompatible

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

• Fonctions JSON : l'exécution native des requêtes est compatible avec les chaînes entourées de guillemets doubles, et non de guillemets simples. Des résultats incorrects se produisent avec des guillemets simples. L'utilisation de * dans le chemin avec la fonction get_json_object renvoie NULL.
• Configuration de lecture Parquet:
  • L'exécution native des requêtes 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 native des requêtes 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 être différents.
• 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 native des requêtes.
• Déversement : lorsque vous définissez un nombre élevé de partitions de brassage, la fonctionnalité de déversement sur disque peut déclencher une OutOfMemoryException. Dans ce cas, la réduction du nombre de partitions peut éliminer cette exception.

Étape suivante

• Accélérez les charges de travail et les sessions par lots Spark avec Lightning Engine.