Les pools Apache Spark avec accélération GPU dans Azure Synapse Analytics (déconseillé)

Article
07/22/2024

Apache Spark est un framework de traitement parallèle qui prend en charge le traitement en mémoire pour améliorer les performances des applications d’analytique du Big Data. Apache Spark dans Azure Synapse Analytics est l’une des implémentations par Microsoft d’Apache Spark dans le cloud.

Azure Synapse offre désormais la possibilité de créer des pools compatibles GPU Azure Synapse pour exécuter des charges de travail Spark en utilisant les bibliothèques RAPIDS sous-jacentes qui utilisent l’énorme puissance de traitement parallèle des GPU pour accélérer le traitement. L’accélérateur RAPIDS pour Apache Spark vous permet d’exécuter vos applications Spark existantes sans modification du code juste en activant un paramètre de configuration, qui est préconfiguré pour un pool compatible GPU. Vous pouvez choisir d’activer/de désactiver l’accélération GPU basée sur RAPIDS pour votre charge de travail ou des parties de votre charge de travail en définissant cette configuration :

spark.conf.set('spark.rapids.sql.enabled','true/false')

Remarque

La préversion pour les pools Azure Synapse avec GPU est désormais déconseillée.

Attention

Notification de dépréciation et de désactivation des GPU sur le Runtime Azure Synapse pour Apache Spark 3.1 et 3.2

La préversion accélérée par GPU est désormais déconseillée sur le runtime Apache Spark 3.2 (déconseillé). Les runtimes déconseillés ne vont pas bénéficier de corrections de bogues et de fonctionnalités. Ce runtime, ainsi que la préversion correspondante accélérée par le GPU sur Spark 3.2 ont été retirés et désactivés depuis le 8 juillet 2024.
La préversion accélérée par le GPU est désormais déconseillée sur runtime Azure Synapse 3.1 (déconseillé). Azure Synapse Runtime pour Apache Spark 3.1 a atteint sa fin de support le 26 janvier 2023, le support officiel étant interrompu à compter du 26 janvier 2024 et aucune autre réponse aux tickets de support, aux corrections de bogues ou aux mises à jour de sécurité au-delà de cette date.

Accélérateur RAPIDS pour Apache Spark

L’accélérateur RAPIDS Spark est un plug-in qui fonctionne en remplaçant le plan physique d’un travail Spark par des opérations GPU prises en charge et en exécutant ces opérations sur les GPU, accélérant ainsi le traitement. Cette bibliothèque est actuellement en préversion et ne prend pas en charge toutes les opérations Spark (voici une liste des opérateurs actuellement pris en charge, d’autres prises en charge sont progressivement ajoutées dans les nouvelles versions).

Options de configuration de cluster

Le plug-in de l’accélérateur RAPIDS prend uniquement en charge un mappage un-à-un entre les GPU et les exécuteurs. Cela signifie qu’un travail Spark doit demander des ressources de l’exécuteur et du pilote pouvant être prises en charge par les ressources du pool (en fonction du nombre de cœurs de CPU et de GPU disponibles). Pour répondre à cette condition et garantir une utilisation optimale de toutes les ressources du pool, nous avons besoin de la configuration suivante des pilotes et des exécuteurs pour une application Spark s’exécutant sur des pools compatibles GPU :

Taille du pool	Options de taille du pilote	Cœurs de pilote	Mémoire du pilote (Go)	Cœurs de l’exécuteur	Mémoire de l’exécuteur (Go)	Nombre d’exécuteurs
GPU-Large	Petit pilote	4	30	12	60	Nombre de nœuds dans le pool
GPU-Large	Pilote moyen	7	30	9	60	Nombre de nœuds dans le pool
GPU-XLarge	Pilote moyen	8	40	14	80	4 * Nombre de nœuds dans le pool
GPU-XLarge	Grand pilote	12	40	13	80	4 * Nombre de nœuds dans le pool

Toute charge de travail qui ne répond pas à l’une des configurations ci-dessus ne sera pas acceptée. Cela permet de s’assurer que les travaux Spark sont exécutés avec la configuration la plus efficace et la plus performante en utilisant toutes les ressources disponibles sur le pool.

L’utilisateur peut définir la configuration ci-dessus par le biais de sa charge de travail. Pour les notebooks, l’utilisateur peut utiliser la commande magic %%configure pour définir l’une des configurations ci-dessus, comme indiqué ci-après. Par exemple, en utilisant un grand pool avec trois nœuds :

%%configure -f
{
    "driverMemory": "30g",
    "driverCores": 4,
    "executorMemory": "60g",
    "executorCores": 12,
    "numExecutors": 3
}

Exécuter un exemple de travail Spark par le biais d’un notebook sur un pool Azure Synapse accéléré par GPU

Avant de passer à cette section, il serait judicieux de vous familiariser avec les concepts de base de l’utilisation d’un notebook dans Azure Synapse Analytics. Passons en revue les étapes permettant d’exécuter une application Spark utilisant l’accélération GPU. Vous pouvez écrire une application Spark dans les quatre langages pris en charge dans Synapse : PySpark (Python), Spark (Scala), SparkSQL et .NET pour Spark (C#).

Créez un pool avec GPU.
Créez un notebook et attachez-le au pool compatible GPU que vous avez créé à la première étape.
Définissez les configurations comme expliqué dans la section précédente.
Créez un exemple de dataframe en copiant le code ci-dessous dans la première cellule de votre notebook :

import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}
import org.apache.spark.sql.Row
import scala.collection.JavaConversions._

val schema = StructType( Array(
  StructField("emp_id", IntegerType),
  StructField("name", StringType),
  StructField("emp_dept_id", IntegerType),
  StructField("salary", IntegerType)
))

val emp = Seq(Row(1, "Smith", 10, 100000),
    Row(2, "Rose", 20, 97600),
    Row(3, "Williams", 20, 110000),
    Row(4, "Jones", 10, 80000),
    Row(5, "Brown", 40, 60000),
    Row(6, "Brown", 30, 78000)
  )

val empDF = spark.createDataFrame(emp, schema)

emp = [(1, "Smith", 10, 100000),
    (2, "Rose", 20, 97600),
    (3, "Williams", 20, 110000),
    (4, "Jones", 10, 80000),
    (5, "Brown", 40, 60000),
    (6, "Brown", 30, 78000)]

empColumns = ["emp_id", "name", "emp_dept_id", "salary"]

empDF = spark.createDataFrame(data=emp, schema=empColumns)

using Microsoft.Spark.Sql.Types;

var emp = new List<GenericRow>
{
    new GenericRow(new object[] { 1, "Smith", 10, 100000 }),
    new GenericRow(new object[] { 2, "Rose", 20, 97600 }),
    new GenericRow(new object[] { 3, "Williams", 20, 110000 }),
    new GenericRow(new object[] { 4, "Jones", 10, 80000 }),
    new GenericRow(new object[] { 5, "Brown", 40, 60000 }),
    new GenericRow(new object[] { 6, "Brown", 30, 78000 })
};

var schema = new StructType(new List<StructField>()
{
    new StructField("emp_id", new IntegerType()),
    new StructField("name", new StringType()),
    new StructField("emp_dept_id", new IntegerType()),
    new StructField("salary", new IntegerType())
});

DataFrame empDF = spark.CreateDataFrame(emp, schema);

Nous allons maintenant effectuer un agrégat en obtenant le salaire maximal par ID de département et afficher le résultat :

val resultDF = empDF.groupBy("emp_dept_id").max("salary")
resultDF.show()

resultDF = empDF.groupBy("emp_dept_id").max("salary")
resultDF.show()

DataFrame resultDF = empDF.GroupBy("emp_dept_id").Max("salary");
resultDF.Show();

Vous pouvez voir les opérations de votre requête qui se sont exécutées sur des GPU en regardant dans le plan SQL via le serveur d’historique de Spark :

Comment paramétrer votre application pour les GPU

La plupart des travaux Spark peuvent voir une amélioration des performances en définissant les paramètres de configuration sur d’autres valeurs que les valeurs par défaut. Idem pour les travaux tirant parti du plug-in de l’accélérateur RAPIDS pour Apache Spark.

Quotas et contraintes de ressource dans les pools compatibles GPU Azure Synapse

Niveau Espace de travail

Chaque espace de travail Azure Synapse est fourni avec un quota par défaut de 50 vCores de GPU. Pour augmenter votre quota de cœurs GPU, envoyez une demande de support via le Portail Azure.

Étapes suivantes

Azure Synapse Analytics

Partager via