GPUs mit Dataproc Serverless verwenden

Sie können Ihren Dataproc Serverless-Batcharbeitslasten GPU-Beschleuniger hinzufügen, um folgende Vorteile zu erzielen:

• Beschleunigung der Verarbeitung von großen Arbeitslasten für die Datenanalyse

• Mit GPU-Bibliotheken für maschinelles Lernen das Modelltraining mit großen Datasets beschleunigen

• Erweiterte Datenanalysen wie Video- oder Natural Language Processing durchführen.

Bei allen unterstützten Dataproc Serverless Spark-Laufzeiten wird jedem Arbeitslastknoten die Spark RAPIDS-Bibliothek hinzugefügt. Die Version 1.1 der serverlosen Dataproc-Spark-Laufzeit enthält außerdem die XGBoost-Bibliothek für Arbeitslastknoten. Diese Bibliotheken bieten leistungsstarke Tools für die Datentransformation und das maschinelle Lernen, die Sie in Ihren GPU-beschleunigten Arbeitslasten verwenden können.

Vorteile von GPUs

Die Verwendung von GPUs mit Ihren serverlosen Dataproc-Spark-Arbeitslasten bietet folgende Vorteile:

• Leistungssteigerung: Die GPU-Beschleunigung kann die Leistung von Spark-Arbeitslasten erheblich steigern, insbesondere bei rechenintensiven Aufgaben wie maschinellem Lernen und Deep Learning, Graphenverarbeitung und komplexer Analyse.

• Schnelleres Modelltraining: Wenn Sie GPUs anhängen, kann sich die Zeit für das Trainieren von Modellen bei Aufgaben für maschinelles Lernen drastisch verkürzen. So können Data Scientists und Entwickler schnell iterieren und experimentieren.

• Skalierung:Kunden können Knoten weitere GPUs oder leistungsstärkere GPUs hinzufügen, um immer komplexer werdende Verarbeitungsanforderungen zu erfüllen.

• Kosteneffizienz: GPUs erfordern zwar eine anfängliche Investition, aber aufgrund kürzerer Verarbeitungszeiten und einer effizienteren Ressourcennutzung können Sie im Laufe der Zeit Kosten sparen.

• Erweiterte Datenanalyse:Mit der GPU-Beschleunigung können Sie erweiterte Analysen wie Bild- und Videoanalyse sowie Natural Language Processing auf großen Datenmengen durchführen.

• Verbesserte Produkte:Eine schnellere Verarbeitung ermöglicht eine schnellere Entscheidungsfindung und reaktionsfähigere Anwendungen.

Einschränkungen und Überlegungen

• Sie können NVIDIA A100- oder NVIDIA L4-GPUs an serverlose Dataproc-Batcharbeitslasten anhängen. A100- und L4-Beschleuniger unterliegen der regionalen Verfügbarkeit von Compute Engine-GPUs.

• Die XGBoost-Bibliothek wird nur für GPU-beschleunigte Arbeitslasten in Dataproc Serverless bereitgestellt, wenn die Spark-Laufzeitversion 1.x verwendet wird.

• Für serverlose, GPU-beschleunigte Dataproc-Batches mit XGBoost werden erhöhte Compute Engine-Kontingente verwendet. Wenn Sie beispielsweise eine serverlose Batch-Arbeitslast ausführen möchten, die eine NVIDIA L4-GPU verwendet, müssen Sie das Kontingent für NVIDIA_L4_GPUs zuweisen.

• Jobs mit aktiviertem Accelerator sind nicht mit der Organisationsrichtlinie constraints/compute.requireShieldedVm kompatibel. Wenn Ihre Organisation diese Richtlinie erzwingt, können Jobs, die mit dem Accelerator ausgeführt werden, nicht ausgeführt werden.

• Sie müssen den Standardzeichensatz auf UTF-8 festlegen, wenn Sie die RAPIDS-GPU-Beschleunigung mit unterstützten Dataproc Serverless-Laufzeiten vor Version 2.2 verwenden. Weitere Informationen finden Sie unter Serverlose Batch-Arbeitslast mit GPU-Beschleunigern erstellen.

Preise

Informationen zu den Preisen für Beschleuniger finden Sie unter Dataproc Serverless-Preise.

Hinweise

Führen Sie die folgenden Schritte aus, bevor Sie eine serverlose Batch-Arbeitslast mit angehängten GPU-Beschleunigern erstellen:

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.

Serverlose Batch-Arbeitslast mit GPU-Beschleunigern erstellen

Reichen Sie eine Dataproc Serverless-Batcharbeitslast ein, für die NVIDIA L4-GPUs zum Ausführen einer parallelisierten PySpark-Aufgabe verwendet werden. Führen Sie die folgenden Schritte mit der gcloud CLI aus:

1. Klicken Sie auf Maximieren und erstellen Sie dann mit einem Text- oder Code-Editor den aufgeführten PySpark-Code in einer test-py-spark-gpu.py-Datei auf Ihrem lokalen Computer.

   Maximieren Minimieren

   #!/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. Verwenden Sie die gcloud CLI auf Ihrem lokalen Computer, um den serverlosen Dataproc Serverless-Batchjob mit fünf Workern einzureichen, wobei jeder Worker mit L4-GPUs beschleunigt wird:

   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
   

Hinweise:

• PROJECT_ID: Ihre Google Cloud-Projekt-ID.
• REGION: Eine verfügbare Compute Engine-Region zum Ausführen der Arbeitslast.
• BUCKET_NAME: Der Name Ihres Cloud Storage-Buckets Spark lädt Arbeitslastabhängigkeiten in einen /dependencies-Ordner in diesem Bucket hoch, bevor die Batcharbeitslast ausgeführt wird.
• --version::Bei allen unterstützten serverlosen Dataproc-Laufzeiten wird jedem Knoten einer GPU-beschleunigten Arbeitslast die RAPIDS-Bibliothek hinzugefügt. Nur bei der Laufzeitversion 1.1 wird jedem Knoten einer GPU-beschleunigten Arbeitslast die XGBoost-Bibliothek hinzugefügt.

• --properties (siehe Spark-Attribute für die Ressourcenzuweisung) :

  • spark.dataproc.driverEnv.LANG=C.UTF-8 und spark.executorEnv.LANG=C.UTF-8 (erforderlich bei Runtime-Versionen vor 2.2): Mit diesen Eigenschaften wird der Standardzeichensatz auf C.UTF-8 festgelegt.

  • spark.dataproc.executor.compute.tier=premium (erforderlich): GPU-beschleunigte Arbeitslasten werden mit Premium-Daten-Compute-Units (DCUs) abgerechnet. Preise für Dataproc Serverless-Beschleuniger

  • spark.dataproc.executor.disk.tier=premium (erforderlich): Knoten mit A100-40-, A100-80- oder L4-Beschleunigern müssen die Premium-Speicherebene verwenden.

  • spark.dataproc.executor.resource.accelerator.type=l4 (erforderlich): Es muss nur ein GPU-Typ angegeben werden. Im Beispieljob wird die L4-GPU ausgewählt. Die folgenden Beschleunigertypen können mit den folgenden Argumentnamen angegeben werden:

    GPU-Typ	Name des Arguments
    A100 40GB	a100-40
    A100 80GB	a100-80

  • spark.executor.instances=5 (erforderlich): Es müssen mindestens zwei sein. Legen Sie in diesem Beispiel „5“ fest.

  • spark.executor.cores (optional): Mit dieser Eigenschaft können Sie die Anzahl der Kern-vCPUs angeben. Gültige Werte für L4-GPUs sind 4 (Standard) oder 8, 12, 16, 24, 48 oder 96. Der einzige gültige und Standardwert für A100-GPUs ist 12. Konfigurationen mit L4-GPUs und 24-, 48- oder 96-Kernen haben an jedem Executor 2-, 4- oder 8-GPUs. Bei allen anderen Konfigurationen ist eine 1 GPU angeschlossen.

  • spark.dataproc.executor.disk.size (erforderlich): L4-GPUs haben eine feste Festplattengröße von 375 GB, mit Ausnahme von Konfigurationen mit 24, 48 oder 96 Kernen, die jeweils 750, 1,500 oder 3,000 GB haben. Wenn Sie diese Eigenschaft beim Einreichen einer L4-beschleunigten Arbeitslast auf einen anderen Wert festlegen, tritt ein Fehler auf. Wenn Sie eine A100 40- oder A100 80-GPU auswählen, sind die zulässigen Größen 375 g, 750 g, 1.500 g, 3.000 g, 6.000 g und 9.000 g.

  • spark.executor.memory (optional) und spark.executor.memoryOverhead (optional): Sie können eine dieser Eigenschaften festlegen, aber nicht beide. Der verfügbare Arbeitsspeicher, der nicht von der festgelegten Property belegt wird, wird auf die Property angewendet, die nicht festgelegt ist. Standardmäßig ist spark.executor.memoryOverhead für PySpark-Batcharbeitslasten auf 40% des verfügbaren Arbeitsspeichers und für andere Arbeitslasten auf 10% festgelegt (siehe Spark-Ressourcenzuweisungseigenschaften).

    In der folgenden Tabelle sehen Sie die maximale Arbeitsspeichermenge, die für verschiedene A100- und L4-GPU-Konfigurationen festgelegt werden kann. Der Mindestwert für beide Eigenschaften beträgt 1024 MB.

    	A100 (40 GB)	A100 (80 GB)	L4 (4 Kerne)	L4 (8 Kerne)	L4 (12 Kerne)	L4 (16 Kerne)	L4 (24 Kerne)	L4 (48 Kerne)	L4 (96 Kerne)
    Maximaler Arbeitsspeicher (MB)	78040	165080	13384	26768	40152	53536	113072	160608	321216

  • Spark RAPIDS-Properties (optional): Standardmäßig legt Dataproc Serverless die folgenden Spark RAPIDS-Property-Werte fest:

    • spark.plugins=com.nvidia.spark.SQLPlugin
    • spark.executor.resource.gpu.amount=1
    • spark.task.resource.gpu.amount=1/$spark_executor_cores
    • spark.shuffle.manager=''. Diese Eigenschaft ist standardmäßig nicht festgelegt. NVIDIA empfiehlt jedoch, den RAPIDS-Zufallsmix-Manager zu aktivieren, wenn GPUs verwendet werden, um die Leistung zu verbessern. Legen Sie dazu spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager fest, wenn Sie eine Arbeitslast einreichen.

    Informationen zum Festlegen von Spark RAPIDS-Eigenschaften finden Sie unter RAPIDS Accelerator for Apache Spark Configuration (RAPIDS Accelerator für Apache Spark konfigurieren). Informationen zum Festlegen erweiterter Spark-Eigenschaften finden Sie unter RAPIDS Accelerator for Apache Spark Advanced Configuration (Erweiterte Konfiguration des RAPIDS Accelerators für Apache Spark).