Utilizzo di GPU con Dataproc Serverless

Puoi collegare gli acceleratori GPU ai carichi di lavoro batch Dataproc Serverless per ottenere i seguenti risultati:

• Accelera l'elaborazione dei carichi di lavoro di analisi dei dati su larga scala.

• Accelera l'addestramento dei modelli su set di dati di grandi dimensioni utilizzando le librerie di machine learning delle GPU.

• Eseguire analisi avanzate dei dati, come l'elaborazione di video o del linguaggio naturale.

Tutti i runtime di Spark serverless Dataproc supportati aggiungono la libreria Spark RAPIDS a ciascun nodo dei carichi di lavoro. La versione 1.1 del runtime Spark serverless Dataproc aggiunge anche la libreria XGBoost ai nodi dei carichi di lavoro. Queste librerie forniscono potenti strumenti di trasformazione dei dati e machine learning che puoi utilizzare nei carichi di lavoro con accelerazione GPU.

Vantaggi della GPU

Ecco alcuni dei vantaggi dell'utilizzo di GPU con i carichi di lavoro Dataproc Serverless Spark:

• Miglioramento delle prestazioni: l'accelerazione della GPU può incrementare notevolmente le prestazioni dei carichi di lavoro Spark, in particolare per attività ad alta intensità di calcolo, come machine e deep learning, elaborazione di grafici e analisi complesse.

• Addestramento dei modelli più rapido: per le attività di machine learning, il collegamento delle GPU può ridurre drasticamente il tempo necessario per l'addestramento dei modelli, consentendo a data scientist e ingegneri di eseguire iterazioni e sperimentare rapidamente.

• Scalabilità: i clienti possono aggiungere ai nodi più nodi GPU o GPU più potenti, per gestire esigenze di elaborazione sempre più complesse.

• Efficienza dei costi: sebbene le GPU richiedano un investimento iniziale, puoi risparmiare nel tempo grazie alla riduzione dei tempi di elaborazione e all'utilizzo più efficiente delle risorse.

• Analisi dei dati avanzata: l'accelerazione GPU consente di eseguire analisi avanzate, come l'analisi di immagini e video ed l'elaborazione del linguaggio naturale, su set di dati di grandi dimensioni.

• Prodotti migliorati: un'elaborazione più rapida consente un processo decisionale più rapido e applicazioni più reattive.

Limitazioni e considerazioni

• Puoi collegare GPU NVIDIA A100 o NVIDIA L4 a carichi di lavoro batch Dataproc Serverless. Gli acceleratori A100 e L4 sono soggetti alla disponibilità regionale delle GPU di Compute Engine.

• La libreria XGBoost è fornita solo ai carichi di lavoro con accelerazione GPU Dataproc Serverless solo quando si utilizza Dataproc Serverless, versione 1.x del runtime Spark.

• I batch Dataproc Serverless con accelerazione GPU con XGBoost utilizzano quote di Compute Engine maggiori. Ad esempio, per eseguire un carico di lavoro batch serverless che utilizza una GPU NVIDIA L4, devi allocare la quota NVIDIA_L4_GPUS.

• I job abilitati per l'acceleratore non sono compatibili con il criterio dell'organizzazione constraints/compute.requireShieldedVm. Se la tua organizzazione applica questo criterio, i relativi job abilitati per l'acceleratore non verranno eseguiti correttamente.

• Devi impostare il set di caratteri predefinito su UTF-8 se utilizzi l'accelerazione GPU RAPIDS con runtime Dataproc serverless supportati precedenti alla versione 2.2. Per ulteriori informazioni, consulta Creazione di un carico di lavoro batch serverless con acceleratori GPU.

Prezzi

Consulta i prezzi di Dataproc Serverless per informazioni sui prezzi dell'acceleratore.

Prima di iniziare

Prima di creare un carico di lavoro batch serverless con acceleratori GPU collegati, segui questi passaggi:

1. Accedi al tuo account Google Cloud. 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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   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

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Abilita le API Dataproc, Compute Engine, and Cloud Storage.

   Abilita le API

5. Installa Google Cloud CLI.

6. Per initialize gcloud CLI, esegui questo comando:

   gcloud init

7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   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

8. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

9. Abilita le API Dataproc, Compute Engine, and Cloud Storage.

   Abilita le API

10. Installa Google Cloud CLI.

11. Per initialize gcloud CLI, esegui questo comando:

    gcloud init

12. Nella console Google Cloud, vai alla pagina Bucket di Cloud Storage.

    Vai alla pagina Bucket

13. Fai clic su Crea bucket.
14. Nella pagina Crea un bucket, inserisci le informazioni del bucket. Per andare al passaggio successivo, fai clic su Continua.
    • In Assegna un nome al bucket, inserisci un nome che soddisfi i requisiti di denominazione dei bucket.
    • Per Scegli dove archiviare i tuoi dati, segui questi passaggi:
      • Seleziona un'opzione Tipo di località.
      • Seleziona un'opzione Località.
    • In Scegli una classe di archiviazione predefinita per i dati, seleziona una classe di archiviazione.
    • Per Scegli come controllare l'accesso agli oggetti, seleziona un'opzione Controllo dell'accesso.
    • In Impostazioni avanzate (facoltative), specifica un metodo di crittografia, un criterio di conservazione o le etichette dei bucket.
15. Fai clic su Crea.

Crea un carico di lavoro batch serverless con acceleratori GPU

Invia un carico di lavoro batch Dataproc Serverless che utilizza GPU NVIDIA L4 per eseguire un'attività PySpark parallelizzata. Segui questi passaggi utilizzando gcloud CLI:

1. Fai clic su Espandimi, quindi crea e salva il codice PySpark elencato in un file test-py-spark-gpu.py sulla tua macchina locale utilizzando un editor di testo o di codice.

   Espandi Comprimi

   #!/usr/bin/env python
   
   """S8s Accelerators Example."""
   
   import subprocess
   from typing import Any
   from pyspark.sql import SparkSession
   from pyspark.sql.functions import col
   from pyspark.sql.types import IntegerType
   from pyspark.sql.types import StructField
   from pyspark.sql.types import StructType
   
   spark = SparkSession.builder.appName("joindemo").getOrCreate()
   
   def get_num_gpus(_: Any) -> int:
     """Returns the number of GPUs."""
     p_nvidia_smi = subprocess.Popen(
         ["nvidia-smi", "-L"], stdin=None, stdout=subprocess.PIPE
     )
     p_wc = subprocess.Popen(
         ["wc", "-l"],
         stdin=p_nvidia_smi.stdout,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         universal_newlines=True,
     )
     [out, _] = p_wc.communicate()
     return int(out)
   
   num_workers = 5
   result = (
       spark.sparkContext.range(0, num_workers, 1, num_workers)
       .map(get_num_gpus)
       .collect()
   )
   num_gpus = sum(result)
   print(f"Total accelerators: {num_gpus}")
   
   # Run the join example
   schema = StructType([StructField("value", IntegerType(), True)])
   df = (
       spark.sparkContext.parallelize(range(1, 10000001), 6)
       .map(lambda x: (x,))
       .toDF(schema)
   )
   df2 = (
       spark.sparkContext.parallelize(range(1, 10000001), 6)
       .map(lambda x: (x,))
       .toDF(schema)
   )
   joined_df = (
       df.select(col("value").alias("a"))
       .join(df2.select(col("value").alias("b")), col("a") == col("b"))
       .explain()
   )
   
   

2. Utilizza gcloud CLI sulla tua macchina locale per inviare il job batch serverless di Dataproc serverless con cinque worker, con ogni worker accelerato con GPU L4:

   gcloud dataproc batches submit pyspark test-py-spark-gpu.py \
       --project=PROJECT_ID \
       --region=REGION \
       --deps-bucket=BUCKET_NAME \
       --version=1.1 \
       --properties=spark.dataproc.executor.compute.tier=premium,spark.dataproc.executor.disk.tier=premium,spark.dataproc.executor.resource.accelerator.type=l4,spark.executor.instances=5,spark.dataproc.driverEnv.LANG=C.UTF-8,spark.executorEnv.LANG=C.UTF-8,spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager
   

Note

• PROJECT_ID: l'ID del tuo progetto Google Cloud.
• REGION: una regione di Compute Engine disponibile in cui eseguire il carico di lavoro.
• BUCKET_NAME: il nome del bucket Cloud Storage. Spark carica le dipendenze del carico di lavoro in una cartella /dependencies in questo bucket prima di eseguire il carico di lavoro batch.
• --version: tutti i runtime Serverless Dataproc supportati aggiungono la libreria RAPIDS a ciascun nodo di un carico di lavoro con accelerazione GPU. Attualmente, solo la versione del runtime 1.1 aggiunge la libreria XGBoost a ciascun nodo di un carico di lavoro con accelerazione GPU.

• --properties (consulta le proprietà di allocazione delle risorse Spark) :

  • spark.dataproc.driverEnv.LANG=C.UTF-8 e spark.executorEnv.LANG=C.UTF-8 (obbligatorie per le versioni di runtime precedenti al giorno 2.2): queste proprietà impostano il set di caratteri predefinito su C.UTF-8.

  • spark.dataproc.executor.compute.tier=premium (obbligatorio): i carichi di lavoro con accelerazione GPU vengono fatturati utilizzando unità di calcolo di dati (DCU) premium. Consulta i prezzi dell'Accelerator per Dataproc Serverless.

  • spark.dataproc.executor.disk.tier=premium (obbligatorio): i nodi con acceleratori A100-40, A100-80 o L4 devono utilizzare il livello disco Premium.

  • spark.dataproc.executor.resource.accelerator.type=l4 (obbligatorio): deve essere specificato un solo tipo di GPU. Il job di esempio seleziona la GPU L4. I seguenti tipi di acceleratore possono essere specificati con i seguenti nomi di argomenti:

    Tipo di GPU	Nome argomento
    A100 40GB	a100-40
    A100 80GB	a100-80

  • spark.executor.instances=5 (obbligatorio): almeno due. Impostalo su cinque per questo esempio.

  • spark.executor.cores (facoltativo): puoi impostare questa proprietà per specificare il numero di vCPU core. I valori validi per le GPU L4 sono 4, predefinito oppure 8, 12 o 16. L'unico valore valido e predefinito per le GPU A100 è 12.

  • spark.dataproc.executor.disk.size (facoltativo per le GPU A100-40 e A100-80): Dataproc Serverless imposta le dimensioni predefinite del disco SSD GPU su 375 GB. Puoi modificare le dimensioni quando utilizzi GPU A100 40 o A100 80 (consulta le proprietà di allocazione delle risorse di Spark). Le GPU L4 richiedono dimensioni di 375 GB. Se imposti questa proprietà su un valore diverso durante l'invio di un carico di lavoro con accelerazione L4, si verifica un errore.

  • spark.executor.memory (facoltativo) e spark.executor.memoryOverhead (facoltativo): puoi impostare una di queste proprietà, ma non entrambe. La quantità di memoria disponibile non utilizzata dalla proprietà impostata viene applicata alla proprietà non impostata. Per impostazione predefinita, spark.executor.memoryOverhead è impostato sul 40% della memoria disponibile per i carichi di lavoro batch di PySpark e sul 10% per altri carichi di lavoro (consulta le proprietà di allocazione delle risorse di Spark).

    La tabella seguente mostra la quantità massima di memoria che può essere impostata per le diverse configurazioni GPU A100 e L4. Il valore minimo per ciascuna proprietà è 1024 MB.

    	A100 (40 GB)	A100 (80 GB)	L4 (4 core)	L4 (8 core)	L4 (12 core)	L4 (16 core)
    Memoria totale massima (MB)	78040	165080	13384	26768	40152	53536

  • Proprietà Spark RAPIDS (facoltative): per impostazione predefinita, Dataproc Serverless imposta i seguenti valori delle proprietà Spark RAPIDS:

    • spark.plugins=com.nvidia.spark.SQLPlugin
    • spark.executor.resource.gpu.amount=1
    • spark.task.resource.gpu.amount=1/$spark_executor_cores
    • spark.shuffle.manager=". Per impostazione predefinita, questa proprietà non è impostata. Tuttavia, NVIDIA consiglia di attivare il gestore shuffle RAPIDS quando utilizzi le GPU per migliorare le prestazioni. Per farlo, imposta spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager quando invii un carico di lavoro.

    Consulta RAPIDS Accelerator for Apache Spark Configuration per impostare le proprietà Spark RAPIDS e RAPIDS Accelerator for Apache Spark Advanced Configuration per impostare le proprietà avanzate di Spark.