Utilizzare le GPU con Dataproc Serverless

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

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

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

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

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

Vantaggi della GPU

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

• Miglioramento delle prestazioni: l'accelerazione GPU può migliorare notevolmente le prestazioni dei carichi di lavoro Spark, in particolare per le attività che richiedono calcoli intensi, come il machine e il deep learning, l'elaborazione di grafici e l'analisi complessa.

• Addestramento dei modelli più rapido: per le attività di machine learning, l'attacco di GPU può ridurre drasticamente il tempo necessario per addestrare i modelli, consentendo ai data scientist e agli ingegneri di eseguire rapidamente l'iterazione e la sperimentazione.

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

• Efficienza dei costi: anche se le GPU richiedono un investimento iniziale, puoi ottenere risparmi nel tempo grazie a tempi di elaborazione ridotti e a un utilizzo più efficiente delle risorse.

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

• Prodotti migliorati: l'elaborazione più rapida consente di prendere decisioni più rapidamente e di creare applicazioni più reattive.

Limitazioni e considerazioni

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

• La libreria XGBoost viene fornita ai carichi di lavoro accelerati GPU di Dataproc Serverless solo se utilizzi la versione 1.x del runtime Spark di Dataproc Serverless.

• I batch accelerati da GPU di Dataproc Serverless con XGBoost utilizzano quote Compute Engine aumentate. 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 all'acceleratore non sono compatibili con i criteri dell'organizzazione constraints/compute.requireShieldedVm. Se la tua organizzazione applica questo criterio, i job con acceleratore attivo non verranno eseguiti correttamente.

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

Prezzi

Consulta la pagina Prezzi di Dataproc Serverless per informazioni sui prezzi degli acceleratori.

Prima di iniziare

Prima di creare un carico di lavoro batch serverless con acceleratori GPU collegati, esegui i seguenti passaggi:

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Dataproc, Compute Engine, and Cloud Storage APIs.

   Enable the APIs

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   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. Make sure that billing is enabled for your Google Cloud project.

9. Enable the Dataproc, Compute Engine, and Cloud Storage APIs.

   Enable the APIs

10. Install the Google Cloud CLI.

11. To initialize the gcloud CLI, run the following command:

    gcloud init

12. In the Google Cloud console, go to the Cloud Storage Buckets page.

    Go to Buckets page

13. Click Create bucket.
14. On the Create a bucket page, enter your bucket information. To go to the next step, click Continue.
    • For Name your bucket, enter a name that meets the bucket naming requirements.
    • For Choose where to store your data, do the following:
      • Select a Location type option.
      • Select a Location option.
    • For Choose a default storage class for your data, select a storage class.
    • For Choose how to control access to objects, select an Access control option.
    • For Advanced settings (optional), specify an encryption method, a retention policy, or bucket labels.
15. Click Create.

Creare 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 Espandi, quindi crea e salva il codice PySpark elencato in un test-py-spark-gpu.py file sul tuo computer 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 Dataproc Serverless con cinque worker, ciascuno con GPU L4 per l'accelerazione:

   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: un'area geografica Compute Engine disponibile per 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 ogni nodo di un carico di lavoro accelerato da GPU. Solo la versione 1.1 del runtime aggiunge la libreria XGBoost a ogni nodo di un carico di lavoro accelerato da GPU.

• --properties (vedi Proprietà di allocazione delle risorse Spark) :

  • spark.dataproc.driverEnv.LANG=C.UTF-8 e spark.executorEnv.LANG=C.UTF-8 (obbligatorie con le versioni di runtime precedenti a 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 accelerati tramite GPU vengono fatturati utilizzando unità di calcolo dei dati (DCU) premium. Consulta i prezzi degli acceleratori di Dataproc Serverless.

  • spark.dataproc.executor.disk.tier=premium (obbligatorio): i nodi con acceleratori A100-40, A100-80 o L4 devono utilizzare il livello di 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 40 GB	a100-40
    A100 80 GB	a100-80

  • spark.executor.instances=5 (obbligatorio): devono essere presenti almeno due elementi. Imposta su cinque per questo esempio.

  • spark.executor.cores (facoltativo): puoi impostare questa proprietà per specificare il numero di core vCPU. I valori validi per le GPU L4 sono 4, l'impostazione predefinita, oppure 8, 12, 16, 24, 48 o 96. L'unico valore valido e predefinito per le GPU A100 è 12. Le configurazioni con GPU L4 e core 24, 48 o 96 hanno GPU 2, 4 o 8 collegate a ogni executor. Tutte le altre configurazioni hanno una GPU collegata.1

  • spark.dataproc.executor.disk.size (obbligatorio): le GPU L4 hanno una dimensione fissa del disco di 375 GB, ad eccezione delle configurazioni con 24, 48 o 96 core, che hanno rispettivamente 750, 1,500 o 3,000 GB. Se imposta questa proprietà su un valore diverso quando invii un carico di lavoro accelerato L4, si verifica un errore. Se selezioni una GPU A100 40 o A100 80, le dimensioni valide sono 375 g, 750 g, 1500 g, 3000 g, 6000 g e 9000 g.

  • 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 workload batch PySpark e sul 10% per gli altri workload (vedi Proprietà di allocazione delle risorse Spark).

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

    	A100 (40 GB)	A100 (80 GB)	L4 (4 core)	L4 (8 core)	L4 (12 core)	L4 (16 core)	L4 (24 core)	L4 (48 core)	L4 (96 core)
    Memoria totale massima (MB)	78040	165080	13384	26768	40152	53536	113072	160608	321216

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

    • 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 di ordinamento RAPIDS quando si utilizzano le GPU per migliorare le prestazioni. Per farlo, imposta spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager quando invii un carico di lavoro.

    Consulta Configurazione di RAPIDS Accelerator per Apache Spark per impostare le proprietà RAPIDS di Spark e Configurazione avanzata di RAPIDS Accelerator per Apache Spark per impostare le proprietà avanzate di Spark.