Utiliser les GPU

Vous pouvez associer des accélérateurs de GPU à vos charges de travail par lot Managed Service pour Apache Spark pour obtenir les résultats suivants :

  • Accélérer le traitement des charges de travail d'analyse de données à grande échelle.

  • Accélérer l'entraînement de modèles sur de grands ensembles de données à l'aide de bibliothèques de machine learning GPU.

  • Effectuer des analyses de données avancées, telles que le traitement vidéo ou le traitement du langage naturel.

Tous les environnements d'exécution Spark Managed Service pour Apache Spark compatibles ajoutent la bibliothèque Spark RAPIDS à chaque nœud de charge de travail. La version 1.1 de l'environnement d'exécution Spark Managed Service pour Apache Spark ajoute également la bibliothèque XGBoost aux nœuds de charge de travail. Ces bibliothèques fournissent de puissants outils de transformation des données et de machine learning que vous pouvez utiliser dans vos charges de travail accélérées par GPU.

Avantages des GPU

Voici quelques-uns des avantages de l'utilisation de GPU avec vos charges de travail Spark Managed Service pour Apache Spark :

  • Amélioration des performances : l'accélération GPU peut améliorer considérablement les performances des charges de travail Spark, en particulier pour les tâches nécessitant beaucoup de calcul, telles que le machine learning et le deep learning, le traitement de graphes et l'analyse complexe.

  • Entraînement de modèles plus rapide : pour les tâches de machine learning, l'association de GPU peut réduire considérablement le temps nécessaire à l'entraînement des modèles, ce qui permet aux data scientists et aux ingénieurs d'itérer et d'expérimenter rapidement.

  • Scalabilité : les clients peuvent ajouter des nœuds GPU ou des GPU plus puissants aux nœuds pour gérer des besoins de traitement de plus en plus complexes.

  • Rentabilité : bien que les GPU nécessitent un investissement initial, vous pouvez réaliser des économies au fil du temps grâce à des temps de traitement réduits et à une utilisation plus efficace des ressources.

  • Analyse de données améliorée : l'accélération GPU vous permet d'effectuer des analyses avancées, telles que l'analyse d'images et de vidéos, et le traitement du langage naturel sur de grands ensembles de données.

  • Produits améliorés : un traitement plus rapide permet une prise de décision plus rapide et des applications plus réactives.

Limites et points à noter

Tarifs

Les accélérateurs de GPU sont disponibles avec le niveau de tarification Premium. Pour en savoir plus sur les tarifs des accélérateurs, consultez Tarifs de Managed Service pour Apache Spark.

Avant de commencer

Avant de créer une charge de travail par lot sans serveur avec des accélérateurs de GPU associés, procédez comme suit :

  1. 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.

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

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

    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 APIs

  5. Installez la Google Cloud CLI.

  6. 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.

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

    gcloud init

  8. 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

  9. Verify that billing is enabled for your Google Cloud project.

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

    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 APIs

  11. Installez la Google Cloud CLI.

  12. 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.

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

    gcloud init
  14. Dans la Google Cloud console, accédez à la page Buckets de Cloud Storage.

    Accéder à la page "Buckets"

  15. Cliquez sur Créer.
  16. Sur la page Créer un bucket, saisissez les informations concernant votre bucket. Pour passer à l'étape suivante, cliquez sur Continuer.
    1. Dans la section Premiers pas, procédez comme suit :
    2. Dans la section Choisir l'emplacement de stockage de vos données, procédez comme suit :
      1. Sélectionnez un type d'emplacement.
      2. Choisissez un emplacement où les données de votre bucket seront stockées de manière permanente dans le menu déroulant Type d'emplacement.
        • Si vous sélectionnez le type d'emplacement birégional, vous pouvez également choisir d'activer la réplication turbo à l'aide de la case à cocher correspondante.
      3. Pour configurer la réplication entre buckets, sélectionnez Ajouter une réplication entre buckets via le service de transfert de stockage , puis procédez comme suit :

        Configurer la réplication entre buckets

        1. Dans le menu Bucket, sélectionnez un bucket.

        2. Dans la section Paramètres de réplication , cliquez sur Configurer pour configurer les paramètres du job de réplication.

          Le volet Configurer la réplication entre buckets s'affiche.

          • Pour filtrer les objets à répliquer en fonction du préfixe de leur nom, saisissez le préfixe avec lequel vous souhaitez inclure ou exclure des objets, puis cliquez sur Ajouter un préfixe.
          • Pour définir une classe de stockage pour les objets répliqués, sélectionnez-en une dans le menu Classe de stockage. Si vous ignorez cette étape, les objets répliqués utiliseront la classe de stockage par défaut du bucket de destination.
          • Cliquez sur OK.
    3. Dans la section Choisir comment stocker vos données, procédez comme suit :
      1. Sélectionnez une classe de stockage par défaut pour le bucket ou bien classe automatique pour gérer automatiquement les classes de stockage des données de votre bucket.
      2. Pour activer l'espace de noms hiérarchique, dans la section Optimiser le stockage pour les charges de travail utilisant beaucoup de données, sélectionnez Activer l'espace de noms hiérarchique sur ce bucket.
    4. Dans la section Choisir comment contrôler l'accès aux objets, indiquez si votre bucket applique ou non la protection contre l'accès public, et sélectionnez une méthode de contrôle des accès pour les objets de votre bucket.
    5. Dans la section Choisir comment protéger les données d'objet, procédez comme suit :
      • Sous Protection des données , sélectionnez les options que vous voulez définir pour votre bucket.
        • Pour activer la suppression réversible, cochez la case Règle de suppression réversible (pour la récupération de données), puis spécifiez le nombre de jours pendant lesquels vous souhaitez conserver les objets après leur suppression.
        • Pour définir la gestion des versions d'objets, cochez la case Gestion des versions d'objets (pour le contrôle des versions), puis spécifiez le nombre maximal de versions par objet et le nombre de jours après lesquels les versions obsolètes expirent.
        • Pour activer la règle de conservation sur les objets et les buckets, cochez la case Conservation (pour la conformité), puis procédez comme suit :
      • Pour choisir comment vos données d'objet seront chiffrées, développez la section Chiffrement des données (), puis sélectionnez une méthode de chiffrement des données.
  17. Cliquez sur Créer.

Créer une charge de travail par lot sans serveur avec des accélérateurs de GPU

Envoyez une charge de travail par lot Managed Service pour Apache Spark qui utilise des GPU NVIDIA L4 pour exécuter une tâche PySpark parallélisée. Procédez comme suit à l'aide de la gcloud CLI :

  1. Cliquez sur Développer, puis créez et enregistrez le code PySpark listé dans un fichier test-py-spark-gpu.py sur votre ordinateur local à l'aide d'un éditeur de texte ou de code.

    #!/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. Utilisez la gcloud CLI sur votre ordinateur local pour envoyer la job par lot sans serveur Managed Service pour Apache Spark avec cinq nœuds de calcul, chacun accéléré par des 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

Remarques :

  • PROJECT_ID : ID de votre Google Cloud projet.
  • REGION : région Compute Engine disponible pour exécuter la charge de travail.
  • BUCKET_NAME : nom de votre bucket Cloud Storage. Spark importe les dépendances de la charge de travail dans un dossier /dependencies de ce bucket avant d'exécuter la charge de travail par lot.
  • --version: : tous les environnements d'exécution Managed Service pour Apache Spark compatibles ajoutent la bibliothèque RAPIDS à chaque nœud d'une charge de travail accélérée par GPU. Seule la version 1.1 de l'environnement d'exécution ajoute la XGBoost XGBoost à chaque nœud d'une charge de travail accélérée par GPU.

  • --properties (voir Propriétés d'allocation des ressources Spark) :

    • spark.dataproc.driverEnv.LANG=C.UTF-8 et spark.executorEnv.LANG=C.UTF-8 (obligatoire avec les versions d'environnement d'exécution antérieures à 2.2) : ces propriétés définissent le jeu de caractères par défaut sur C.UTF-8.

    • spark.dataproc.executor.compute.tier=premium (obligatoire) : les charges de travail accélérées par GPU sont facturées à l'aide d'unités de calcul de données (DCU) Premium. Consultez Tarifs des accélérateurs Managed Service pour Apache Spark .

    • spark.dataproc.executor.disk.tier=premium (obligatoire) : les nœuds avec des accélérateurs A100-40, A100-80 ou L4 doivent utiliser le niveau de disque Premium.

    • spark.dataproc.executor.resource.accelerator.type=l4 (obligatoire) : un seul type de GPU doit être spécifié. L'exemple de tâche sélectionne le GPU L4. Les types d'accélérateurs suivants peuvent être spécifiés avec les noms d'arguments suivants :

      Type de GPU Nom de l'argument
      A100 40 Go a100-40
      A100 80 Go a100-80

    • spark.executor.instances=5 (obligatoire) : la valeur doit être au minimum "deux". Définissez la valeur sur "cinq" pour cet exemple.

    • spark.executor.cores (facultatif) : vous pouvez définir cette propriété pour spécifier le nombre de processeurs virtuels de cœur. Les valeurs valides pour les GPU L4 sont 4 (par défaut), 8, 12, 16, 24, 48 ou 96. La seule valeur valide et par défaut pour les GPU A100 est 12. Les configurations avec des GPU L4 et 24, 48 ou 96 cœurs comportent 2, 4 ou 8 GPU associés à chaque exécuteur. Toutes les autres configurations comportent 1 GPU associé.

    • spark.dataproc.executor.disk.size (obligatoire) : les GPU L4 ont une taille de disque fixe de 375 Go, à l'exception des configurations avec 24, 48 ou 96 cœurs, qui ont respectivement 750, 1,500 ou 3,000 Go. Si vous définissez cette propriété sur une valeur différente lorsque vous envoyez une charge de travail accélérée par L4, une erreur se produit. Si vous sélectionnez un GPU A100 40 ou A100 80, les tailles valides sont 375g, 750g, 1500g, 3000g, 6000g et 9000g.

    • spark.executor.memory (facultatif) et spark.executor.memoryOverhead (restreint) : vous pouvez définir la mémoire, mais pas memoryOverhead. La quantité de mémoire disponible non consommée par la propriété définie est appliquée à la propriété non définie. spark.executor.memoryOverhead est défini sur 40 % de la mémoire disponible pour les charges de travail par lot PySpark et sur 10 % pour les autres charges de travail (voir Propriétés d'allocation des ressources Spark).

      Le tableau suivant indique la quantité maximale de mémoire pouvant être définie pour différentes configurations de GPU A100 et L4. La valeur minimale pour l'une ou l'autre propriété est 1024 Mo.

      A100 (40 Go) A100 (80 Go) L4 (4 cœurs) L4 (8 cœurs) L4 (12 cœurs) L4 (16 cœurs) L4 (24 cœurs) L4 (48 cœurs) L4 (96 cœurs)
      Mémoire totale maximale (Mo) 78040 165080 13384 26768 40152 53536 113072 160608 321216

    • Propriétés Spark RAPIDS (facultatif) : par défaut, Managed Service pour Apache Spark définit les valeurs de propriété Spark RAPIDS suivantes :

      • spark.plugins=com.nvidia.spark.SQLPlugin
      • spark.executor.resource.gpu.amount=1
      • spark.task.resource.gpu.amount=1/$spark_executor_cores
      • spark.shuffle.manager=''. Par défaut, cette propriété n'est pas définie. NVIDIA recommande d'activer le gestionnaire de shuffle RAPIDS lorsque vous utilisez des GPU pour améliorer les performances. Pour ce faire, définissez spark.shuffle.manager=com.nvidia.spark.rapids.RapidsShuffleManager lorsque vous envoyez une charge de travail.
      • spark.rapids.sql.concurrentGpuTasks= minimum de (gpuMemoryinMB / 8, 4)
      • spark.rapids.shuffle.multiThreaded.writer.threads= minimum de (cœurs de processeur dans la VM / nombre de GPU par VM, 32)
      • spark.rapids.shuffle.multiThreaded.reader.threads= minimum de (cœurs de processeur dans la VM / nombre de GPU par VM, 32)

      Consultez Configuration de l'accélérateur RAPIDS pour Apache Spark afin de définir les propriétés Spark RAPIDS et Configuration avancée de l'accélérateur RAPIDS pour Apache Spark afin de définir les propriétés avancées de Spark.