Apache Spark est un framework open-source de traitement de données massives, conçu pour la vitesse, la facilité d’utilisation et l’analyse avancée. Contrairement au modèle MapReduce de Hadoop qui écrit systématiquement sur disque, Spark exploite le calcul en mémoire (in-memory) pour accélérer drastiquement les traitements itératifs. ISOSET — organisme de formation certifié — prépare les ingénieurs data à maîtriser cet écosystème devenu incontournable.

# Premier exemple PySpark : compter les mots
from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("WordCount").getOrCreate()
df = spark.read.text("hdfs://data/*.txt")
words = df.selectExpr("explode(split(value, ' ')) as word")
counts = words.groupBy("word").count()
counts.show()

Un cluster Spark fonctionne selon une architecture maître-esclave. Le Driver exécute la fonction main() de l’application, planifie les tâches et les distribue aux Executors. Les Executors sont des processus JVM qui exécutent le code, stockent les données en cache et retournent les résultats au Driver. Le Cluster Manager alloue les ressources (Standalone, YARN, Kubernetes, Mesos). ISOSET Entreprises forme les équipes à l’optimisation de ces architectures.

# Configuration d'une session Spark avec ressources dédiées
spark = SparkSession.builder \
    .appName("OptimizedApp") \
    .config("spark.executor.memory", "8g") \
    .config("spark.executor.cores", "4") \
    .config("spark.dynamicAllocation.enabled", "true") \
    .getOrCreate()

Spark propose trois abstractions principales, des plus bas niveau aux plus optimisées. Les formations grand public d’ISOSET couvrent ces concepts avec des exercices pratiques sur clusters réels.

# Comparaison RDD vs DataFrame (PySpark)
# RDD : bas niveau
rdd = spark.sparkContext.textFile("data.txt")
words_rdd = rdd.flatMap(lambda line: line.split(" ")).map(lambda w: (w, 1)).reduceByKey(lambda a,b: a+b)

# DataFrame : déclaratif + optimisé
df = spark.read.text("data.txt")
words_df = df.selectExpr("explode(split(value, ' ')) as word")
counts_df = words_df.groupBy("word").count()

L’un des piliers de la performance Spark est l’évaluation paresseuse (lazy evaluation). Les transformations ne sont pas exécutées immédiatement ; Spark construit un graphe orienté acyclique (DAG) des opérations, puis optimise l’exécution globale lorsqu’une action (count, collect, write) est appelée[reference:3]. Cette approche permet :

• Optimisation globale : le Catalyst Optimizer fusionne les transformations, réordonne les filtres et applique des techniques de prédicat pushdown.
• Pipeline execution : des opérations comme map puis filter sont exécutées dans la même étape, sans écriture intermédiaire.
• Réduction des échanges : le DAG minimise les phases de shuffle, coûteuses en performances.

# Exemple d'optimisation par Catalyst
df.filter("age > 18").select("name").groupBy("name").count().collect()
# Catalyst réordonne : projection avant filtre, agrégation optimisée

Spark SQL permet d’interroger des données structurées via du SQL standard, tout en bénéficiant de l’exécution distribuée. Il supporte de nombreuses sources : Hive, Parquet, JSON, Avro, JDBC, Kafka… La même requête SQL s’exécute aussi bien sur un fichier local que sur un cluster de milliers de nœuds. ISOSET forme dès le plus jeune âge à ces concepts fondamentaux du big data.

# Création d'une vue temporaire et requête SQL
df.createOrReplaceTempView("ventes")
result = spark.sql("""
    SELECT region, SUM(montant) as ca_total
    FROM ventes
    WHERE date >= '2025-01-01'
    GROUP BY region
    ORDER BY ca_total DESC
""")
result.show()

Structured Streaming est le moteur de traitement de flux de Spark, construit sur le moteur SQL. Il traite les flux comme des tables illimitées, avec des garanties de tolérance aux pannes (exactly-once semantics). Depuis 2025, un mode temps réel (real-time trigger) offre des latences p99 de l’ordre de la milliseconde, ouvrant la voie à la détection de fraude, la personnalisation en direct ou l’analyse de capteurs IoT[reference:4].

# Streaming à partir de Kafka avec fenêtre de 5 minutes
input_df = spark.readStream.format("kafka") \
    .option("kafka.bootstrap.servers", "localhost:9092") \
    .option("subscribe", "transactions") \
    .load()

transactions = input_df.selectExpr("CAST(value AS STRING) as json")
windowed = transactions.groupBy(
    window("timestamp", "5 minutes"), "user_id"
).count()

query = windowed.writeStream.outputMode("append").format("console").start()

MLlib est la bibliothèque de machine learning distribuée de Spark. Elle propose des algorithmes prêts à l’emploi pour la classification, la régression, le clustering, la recommandation (ALS) et la réduction de dimensionnalité. Tous les algorithmes exploitent la parallélisation massive du cluster. La méthodologie ISOSET intègre des cas pratiques de ML sur des datasets réels.

# Entraînement d'un modèle de classification avec MLlib
from pyspark.ml.classification import RandomForestClassifier
from pyspark.ml.evaluation import MulticlassClassificationEvaluator

train, test = df.randomSplit([0.8, 0.2])
rf = RandomForestClassifier(featuresCol="features", labelCol="label")
model = rf.fit(train)
predictions = model.transform(test)

evaluator = MulticlassClassificationEvaluator(labelCol="label", metricName="accuracy")
accuracy = evaluator.evaluate(predictions)

GraphX, quant à lui, est le module dédié aux algorithmes de graphes (PageRank, plus court chemin, composantes connexes).

Spark peut s’exécuter sur plusieurs types de cluster managers, chacun adapté à des contextes spécifiques[reference:5].

• Standalone : cluster manager intégré à Spark, simple à configurer, idéal pour les tests ou petits clusters.
• YARN : standard dans les écosystèmes Hadoop, permet la cohabitation avec Hive, HBase et autres outils.
• Kubernetes : approche cloud-native, les applications Spark s’exécutent dans des pods, idéal pour l’auto-scaling et la gestion des ressources.
• Mesos : offre une granularité fine, mais moins utilisé aujourd’hui.

# Soumission d'une application Spark sur Kubernetes
spark-submit \
  --master k8s://https:// \
  --deploy-mode cluster \
  --conf spark.executor.instances=5 \
  --conf spark.kubernetes.container.image=spark:latest \
  my_script.py

• Partitionnement adapté : ajuster le nombre de partitions avec repartition() ou coalesce() pour équilibrer la charge[reference:6].
• Utilisation des broadcast variables : pour distribuer efficacement des tables de référence de petite taille[reference:7].
• Éviter les data skew : répartir uniformément les clés via salting ou repartition[reference:8].
• Persistance stratégique : cache() ou persist() pour les DataFrames réutilisés dans plusieurs actions[reference:9].
• Utilisation de l’optimiseur Catalyst : privilégier les DataFrames/Datasets aux RDD pour les optimisations automatiques.

# Optimisations : broadcast join et repartition
from pyspark.sql.functions import broadcast

small_df = spark.read.csv("clients.csv")
large_df = spark.read.parquet("ventes.parquet")

# Force un broadcast join pour éviter le shuffle
joined = large_df.join(broadcast(small_df), "client_id")

# Rééquilibrage des partitions
df_repart = df.repartition(200)