Utilizzo di Lightning Engine

Lightning Engine è la nuova generazione di prestazioni di Apache Spark, che introduce miglioramenti esclusivi progettati per offrire miglioramenti sostanziali in termini di prestazioni, efficienza dei costi e stabilità operativa.

Vantaggi

I vantaggi di Lightning Engine includono:

  • Operazioni sui dati accelerate: ottieni significativi miglioramenti delle prestazioni e risparmi sui costi grazie alle ottimizzazioni dell'interazione con spazio di archiviazione sul cloud, tra cui la gestione dei metadati, i workload di scrittura e l'I/O vettoriale.

  • Esecuzione intelligente delle query: sfrutta i miglioramenti avanzati dell'ottimizzatore che riducono dinamicamente i dati scansionati, ottimizzano l'elaborazione dei dati e generano piani di esecuzione più efficienti per query più veloci ed economiche.

  • Workload di AI e ML semplificati: riduci i tempi di avvio dei cluster per i workload basati su GPU e semplifica il deployment in ambienti sicuri con immagini AI e ML native.

Sebbene Lightning Engine offra notevoli miglioramenti delle prestazioni, l'impatto specifico varia a seconda del workload. È più adatto per le attività a elevato utilizzo di risorse di calcolo che sfruttano le API Spark Dataframe, le API Spark Dataset e le query Spark SQL, anziché le operazioni con I/O limitato.

Confronto con il motore standard

Lightning Engine è un'alternativa al motore standard utilizzato per eseguire i job Spark su un cluster Managed Service for Apache Spark. La tabella seguente confronta le proprietà di attivazione, l'applicabilità dei workload e i vantaggi principali di Lightning Engine rispetto al motore standard.

Funzionalità Motore standard Lightning Engine
Proprietà di attivazione --engine=default o non impostare il flag --engine=lightning
Ideale per Job di uso generale, sviluppo e test Workload su scala aziendale che richiedono un'accelerazione significativa
Vantaggi principali Prestazioni di riferimento Interazione ottimizzata con spazio di archiviazione sul cloud, esecuzione intelligente delle query

Requisiti

I seguenti requisiti si applicano alla funzionalità Lightning Engine:

  • Versione dell'immagine: Lightning Engine deve essere utilizzato con Managed Service for Apache Spark versione dell'immagine 2.3.3 o successive.
  • Job supportati: sono supportati Spark, PySpark, SparkSQL e SparkR. Il motore standard verrà eseguito su altri tipi di job inviati a un cluster Lightning Engine.

Esecuzione nativa delle query

L'esecuzione nativa delle query (NQE) è un componente facoltativo di Lightning Engine che fornisce un livello di accelerazione più approfondito per job specifici. È un motore nativo basato su Apache Gluten e Velox, ottimizzato per l'hardware Google, che migliora le prestazioni eseguendo parti di una query Spark al di fuori della JVM.

NQE è consigliato per:
Attività a elevato utilizzo di risorse di calcolo (anziché operazioni con I/O limitato) che sfruttano le API Spark Dataframe, le API Spark Dataset e le query Spark SQL che leggono i dati da file Parquet e ORC. Il formato del file di output non influisce sulle prestazioni.
NQE non è consigliato per:
Job che si basano fortemente su set di dati distribuiti resilienti (RDD), funzioni definite dall'utente (UDF) o sulla maggior parte delle librerie di machine learning (ML) di Spark.

Requisiti

I seguenti requisiti si applicano alla funzionalità di esecuzione nativa delle query:

  • Motore di esecuzione: NQE è disponibile solo sui cluster in cui è abilitato il motore Lightning durante la creazione del cluster.

  • Sistema operativo: sono supportate solo le immagini Debian-12. I job con NQE abilitato che utilizzano qualsiasi altro sistema operativo non riusciranno.

  • Job supportati: sono supportati Spark, PySpark, SparkSQL e SparkR. Il motore standard verrà eseguito (senza NQE) su altri tipi di job inviati a un cluster Lightning Engine.

  • Tipi di macchine: sono supportate solo le famiglie di macchine che utilizzano processori Intel o AMD. I job con NQE abilitato che utilizzano processori ARM non riusciranno (ma possono trarre vantaggio da Lightning Engine senza NQE).

  • Nessuna GPU e acceleratori: i job con NQE abilitato inviati agli acceleratori GPU non riusciranno (ma possono trarre vantaggio da Lightning Engine senza NQE).

  • Tipi di dati: gli input dei seguenti tipi di dati non sono supportati:

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

Prezzi

Per informazioni sui prezzi, consulta Prezzi di Managed Service for Apache Spark su Compute Engine.

Creare un cluster Lightning Engine

Questa sezione mostra come creare un cluster Managed Service for Apache Spark che abilita Lightning Engine sui job Spark inviati al cluster.

Puoi anche abilitare l'esecuzione nativa delle query (NQE) sul cluster quando crei il cluster oppure puoi abilitare NQE in un secondo momento per job Spark specifici inviati al cluster.

Prima di iniziare

  1. Accedi al tuo Google Cloud account. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

  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 Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  6. Installa Google Cloud CLI.

  7. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

  8. Per inizializzare gcloud CLI, esegui questo comando: 

    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 Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  13. Installa Google Cloud CLI.

  14. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

  15. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

Ruoli obbligatori

Per creare un cluster Managed Service for Apache Spark e inviare job al cluster sono necessari determinati ruoli IAM. A seconda delle policy dell'organizzazione, questi ruoli potrebbero essere già stati concessi. Per verificare le concessioni dei ruoli, consulta Devi concedere i ruoli?.

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Ruoli utente

Per ottenere le autorizzazioni necessarie per creare un cluster Managed Service for Apache Spark, chiedi all'amministratore di concederti i seguenti ruoli IAM:

Ruolo del service account

Per assicurarti che il account di servizio predefinito di Compute Engine disponga delle autorizzazioni necessarie per creare un cluster Managed Service for Apache Spark, chiedi all'amministratore di concedere il ruolo IAM Worker di Managed Service for Apache Spark (roles/dataproc.worker) al account di servizio predefinito di Compute Engine sul progetto.

Crea il cluster

Gli esempi seguenti mostrano come creare un cluster Lightning Engine utilizzando la Google Cloud console, Google Cloud CLI, l'API Dataproc, Python o Terraform. Puoi anche creare un cluster Managed Service for Apache Spark con Lightning Engine abilitato utilizzando le librerie client Go, Java e Node.js.

Console

  1. Nella Google Cloud console, vai a Crea un cluster Apache Spark su Compute Engine. Per saperne di più, consulta Creare un cluster con la Google Cloud console.

    Vai a Crea un cluster Apache Spark su Compute Engine

  2. In Definisci il cluster, seleziona la casella di controllo Abilita Lightning Engine per creare un cluster con Lightning Engine abilitato.

  3. (Facoltativo) Per abilitare il runtime di esecuzione nativa per impostazione predefinita per i job Spark, seleziona la casella di controllo Abilita esecuzione nativa.

  4. Configura le altre impostazioni del cluster in base alle esigenze.

  5. Fai clic su Crea.

Gcloud CLI

  1. Per creare un cluster con Lightning Engine abilitato, esegui il gcloud dataproc clusters create comando con il flag --engine=lightning. Per saperne di più, consulta Creare un cluster con gcloud CLI.

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

  2. (Facoltativo) Per abilitare il runtime di esecuzione nativa per impostazione predefinita per i job Spark, includi la proprietà 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

Per creare un cluster con Lightning Engine abilitato, invia una richiesta clusters.create. Per saperne di più, consulta Creare un cluster con l'API REST.

  1. Nel corpo della richiesta, imposta il engine campo su LIGHTNING.

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

  2. (Facoltativo) Per abilitare il runtime di esecuzione nativa per impostazione predefinita per tutti i job, includi la proprietà 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. Per creare un cluster con Lightning Engine abilitato, utilizza il metodo create_cluster e imposta il campo engine nella configurazione del cluster su LIGHTNING. Per saperne di più, consulta Creare un cluster 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. (Facoltativo) Per abilitare il runtime di esecuzione nativa per impostazione predefinita per i job Spark, includi la proprietà 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. Nella configurazione della risorsa google_dataproc_cluster, imposta l'argomento engine su LIGHTNING.
  2. Per maggiori dettagli e opzioni avanzate, consulta la documentazione ufficiale di Terraform per la google_dataproc_cluster risorsa.

Verificare il motore del cluster

Console

  1. Nella Google Cloud console, vai alla pagina Dettagli cluster.
  2. Verifica che il valore Lightning Engine sia elencato nel campo Motore.
  3. Se hai abilitato l'esecuzione nativa delle query, verifica che native sia elencato nel campo Esecuzione nativa.

gcloud

  1. Per verificare il motore e NQE (se abilitato), esegui il comando gcloud dataproc clusters describe:

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

  2. Controlla l'output per le proprietà engine e lightningEngine.runtime:

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

Inviare un job con Lightning Engine

Dopo aver creato un cluster Lightning Engine, quando invii un job Spark al cluster, Lightning Engine viene abilitato automaticamente per il job.

Abilitare l'esecuzione nativa delle query per un job

Se hai abilitato l'esecuzione nativa delle query (NQE) quando hai creato un cluster Lightning Engine, tutti i job Spark verranno eseguiti con NQE abilitato, a meno che tu non disabiliti NQE per un job specifico.

Se non hai abilitato NQE quando hai creato il cluster Lightning Engine, puoi abilitare NQE per un job specifico quando lo invii, come mostrato negli esempi seguenti.

gcloud

Per abilitare l'esecuzione nativa delle query quando invii un job Spark, includi la proprietà spark.dataproc.lightningEngine.runtime=native:

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

API

Per abilitare l'esecuzione nativa delle query quando invii un job Spark, includi la proprietà spark.dataproc.lightningEngine.runtime nella richiesta:

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

Disabilitare l'esecuzione nativa delle query per un job

Se hai abilitato l'esecuzione nativa delle query (NQE) quando hai creato un cluster Lightning Engine, tutti i job Spark verranno eseguiti con NQE abilitato, a meno che tu non disabiliti NQE per un job specifico.

Puoi disabilitare NQE per un job Spark specifico quando lo invii, come mostrato negli esempi seguenti.

gcloud

Per disabilitare l'esecuzione nativa delle query quando invii un job Spark a un cluster Lightning Engine, includi la spark.dataproc.lightningEngine.runtime=default proprietà:

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

API

Per disabilitare l'esecuzione nativa delle query quando invii un job Spark, a un cluster Lightning Engine, includi la proprietà spark.dataproc.lightningEngine.runtime=default:

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

Verificare l'esecuzione nativa delle query per un job

Dopo aver inviato un job a un cluster Lightning Engine, puoi verificare che l'esecuzione nativa delle query sia abilitata per il job.

Console

  1. Nella Google Cloud console, vai alla pagina Dettagli job.
  2. Verifica che native sia elencato nel campo Esecuzione nativa.

gcloud

  1. Esegui il comando gcloud dataproc jobs describe:

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

  2. Controlla l'output per lightningEngine.runtime nella Proprietà sezione:

    lightningEngine.runtime: native

Parametri di configurazione

La tabella seguente riepiloga i principali parametri di configurazione per Lightning Engine e l'esecuzione nativa delle query.

Nome parametro Descrizione Motori applicabili Valore predefinito Valore predefinito (Lightning Engine) Override utente (a livello di job) Ambito
--engine Impostazione a livello di cluster per selezionare il motore durante la creazione del cluster. A livello di cluster default lightning No Cluster
spark:spark.dataproc.lightningEngine.runtime Impostazione a livello di cluster per selezionare il runtime del motore Lightning durante la creazione del cluster. Solo Lightning default default No Cluster
spark.dataproc.lightningEngine.runtime Abilita o disabilita l'esecuzione nativa delle query (NQE) all'interno di Lightning Engine. Solo Lightning default default Sì. Può essere impostato su native o default. Job

Limitazioni

L'abilitazione dell'esecuzione nativa delle query nei seguenti scenari può causare eccezioni, incompatibilità di Spark o il fallback del workload al motore Spark predefinito.

Fallback

L'esecuzione nativa delle query nei seguenti scenari può comportare un fallback del workload al motore di esecuzione Spark:

  • ANSI: se la modalità ANSI è abilitata, l'esecuzione torna a Spark.
  • Modalità sensibile alle maiuscole/minuscole: l'esecuzione nativa delle query supporta solo la modalità predefinita di Spark che non fa distinzione tra maiuscole e minuscole. Se la modalità sensibile alle maiuscole/minuscole è abilitata, possono verificarsi risultati errati.
  • Scansione di tabelle partizionate: l'esecuzione nativa delle query supporta la scansione di tabelle partizionate solo quando il percorso contiene le informazioni sulla partizione. In caso contrario, il workload torna al motore di esecuzione Spark.

Comportamento incompatibile

Quando utilizzi l'esecuzione nativa delle query nei seguenti casi, possono verificarsi comportamenti incompatibili o risultati errati:

  • Funzioni JSON: l'esecuzione nativa delle query supporta le stringhe racchiuse tra virgolette doppie, non singole. Con le virgolette singole si verificano risultati errati. L'utilizzo di * nel percorso con la funzione get_json_object restituisce NULL.
  • Configurazione di lettura di Parquet:
    • L'esecuzione nativa delle query considera spark.files.ignoreCorruptFiles impostato sul valore predefinito false, anche quando è impostato su true.
    • L'esecuzione nativa delle query ignora spark.sql.parquet.datetimeRebaseModeInRead e restituisce solo i contenuti del file Parquet. Le differenze tra il calendario ibrido legacy e il calendario gregoriano prolettico non vengono prese in considerazione. I risultati di Spark possono variare.
  • NaN: non supportato. Possono verificarsi risultati imprevisti, ad esempio quando utilizzi NaN in un confronto numerico.
  • Lettura colonnare di Spark: può verificarsi un errore irreversibile perché il vettore colonnare di Spark non è compatibile con l'esecuzione nativa delle query.
  • Spill: quando imposti un numero elevato di partizioni di shuffle, la funzionalità di spill su disco può attivare un'OutOfMemoryException. In questo caso, la riduzione del numero di partizioni può eliminare questa eccezione.

Passaggi successivi