Pool con accelerazione della GPU di Apache Spark in Azure Synapse Analytics (deprecato)

Articolo
07/25/2024

Apache Spark è un framework di elaborazione parallela che supporta l'elaborazione in memoria per migliorare le prestazioni di applicazioni analitiche di Big Data. Apache Spark in Azure Synapse Analytics è una delle implementazioni Microsoft di Apache Spark nel cloud.

Azure Synapse offre ora la possibilità di creare pool abilitati per la GPU di Azure Synapse per eseguire carichi di lavoro Spark usando le librerie RAPIDS sottostanti che sfruttano la potenza di elaborazione parallela elevata delle GPU per accelerare l'elaborazione. L'acceleratore RAPIDS per Apache Spark consente di eseguire le applicazioni Spark esistenti senza alcuna modifica del codice abilitando semplicemente un'impostazione di configurazione, preconfigurata per un pool abilitato per la GPU. È possibile scegliere di attivare/disattivare l'accelerazione GPU basata su RAPIDS per il carico di lavoro o parti del carico di lavoro impostando questa configurazione:

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

Nota

L'anteprima per i pool abilitati per la GPU di Azure Synapse è ora stata deprecata.

Attenzione

Notifica relativa alla deprecazione e disabilitazione per le GPU nel runtime di Azure Synapse per Apache Spark 3.1 e 3.2

L'anteprima con accelerazione della GPU è ora deprecata nel runtime di Apache Spark 3.2 (deprecato). Per i runtime deprecati non sono disponibili correzioni di bug e funzionalità. Questo runtime e l'anteprima con accelerazione della GPU corrispondente in Spark 3.2 sono stati ritirati e disabilitati a partire dall'8 luglio 2024.
L'anteprima accelerata della GPU è ora deprecata nel runtime di Azure Synapse 3.1 (deprecato). Il runtime di Azure Synapse per Apache Spark 3.1 ha raggiunto la fine del supporto lo scorso 26 gennaio 2023. Il supporto ufficiale è stato sospeso il 26 gennaio 2024 e a partire da tale data non sono stati più risolti i problemi relativi ai ticket di supporto né fornite correzioni ai bug o aggiornamenti della sicurezza.

Acceleratore RAPIDS per Apache Spark

L'acceleratore Spark RAPIDS è un plug-in che funziona eseguendo l'override del piano fisico di un processo Spark da operazioni GPU supportate ed eseguendo tali operazioni sulle GPU, accelerando così l'elaborazione. Questa libreria è attualmente disponibile in anteprima e non supporta tutte le operazioni Spark (di seguito è riportato un elenco di operatori attualmente supportati; altro supporto viene aggiunto tramite nuovi release).

Opzioni di configurazione del cluster

Il plug-in RAPIDS Accelerator supporta solo un mapping uno-a-uno tra GPU ed executor. Ciò significa che un processo Spark deve richiedere risorse executor e driver che possono essere ospitate dalle risorse del pool (in base al numero di core GPU e CPU disponibili). Per soddisfare questa condizione e garantire un utilizzo ottimale di tutte le risorse del pool, è necessaria la configurazione seguente di driver ed executor per un'applicazione Spark in esecuzione in pool abilitati per la GPU:

Dimensioni del pool	Opzioni relative alle dimensioni del driver	Core driver	Memoria driver (GB)	Executor cores	Memoria dell'executor (GB)	Numero di executor
GPU-Large	Driver di piccole dimensioni	4	30	12	60	Numero di nodi nel pool
GPU-Large	Driver medio	7	30	9	60	Numero di nodi nel pool
GPU-XLarge	Driver medio	8	40	14	80	4 * Numero di nodi nel pool
GPU-XLarge	Driver di grandi dimensioni	12	40	13	80	4 * Numero di nodi nel pool

Tutti i carichi di lavoro che non soddisfano una delle configurazioni precedenti non verranno accettati. Questa operazione viene eseguita per assicurarsi che i processi Spark vengano eseguiti con la configurazione più efficiente usando tutte le risorse disponibili nel pool.

L'utente può impostare la configurazione precedente tramite il carico di lavoro. Per i notebook, l'utente può usare il comando magic %%configure per impostare una delle configurazioni precedenti, come illustrato di seguito. Ad esempio, usando un pool di grandi dimensioni con tre nodi:

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

Eseguire un processo Spark di esempio tramite notebook in un pool con accelerazione GPU di Azure Synapse

È consigliabile acquisire familiarità con i concetti di base relativi all'uso di un notebook in Azure Synapse Analytics prima di procedere con questa sezione. Verranno ora illustrati i passaggi per eseguire un'applicazione Spark che usa l'accelerazione GPU. È possibile scrivere un'applicazione Spark in tutti i quattro linguaggi supportati in Synapse, PySpark (Python), Spark (Scala), SparkSQL e .NET per Spark (C#).

Creare un pool abilitato per la GPU.
Creare un notebook e collegarlo al pool abilitato per la GPU creato nel primo passaggio.
Impostare le configurazioni come illustrato nella sezione precedente.
Creare un DataFrame di esempio copiando il codice seguente nella prima cella del 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);

A questo punto è possibile eseguire un'aggregazione ottenendo lo stipendio massimo per ID reparto e visualizzare il risultato:

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();

È possibile visualizzare le operazioni nella query eseguite sulle GPU esaminando il piano SQL tramite il Server cronologia Spark:

Come ottimizzare l'applicazione per le GPU

La maggior parte dei processi Spark è in grado di visualizzare prestazioni migliorate tramite l'ottimizzazione delle impostazioni di configurazione dalle impostazioni predefinite e lo stesso vale per i processi che sfruttano il plug-in acceleratore RAPIDS per Apache Spark.

Quote e vincoli di risorse nei pool abilitati per la GPU di Azure Synapse

Livello di area di lavoro

Ogni area di lavoro di Azure Synapse dispone di una quota predefinita di 50 vCore GPU. Per aumentare la quota di core GPU, inviare una richiesta di supporto tramite il portale di Azure.

Passaggi successivi

Azure Synapse Analytics

Condividi tramite