Prendre RDV
Lexique · DevOps / Cloud / Data

Apache Spark : définition, architecture et exemple PySpark

Le moteur de calcul distribué open source qui traite de gros volumes de données en mémoire : origine, architecture, DataFrames, Spark SQL, streaming, exemple PySpark et comparaison avec MapReduce.

Par Équipe Blent· Mis à jour le · 14 min de lecture· Niveau intermédiaire

Apache Spark en bref

Type
Moteur de calcul distribué
Origine
AMPLab, université de Berkeley (2009)
Créateur
Matei Zaharia
Gouvernance
Apache Software Foundation
Licence
Apache 2.0
Langages
Scala, avec API Python, Java, SQL et R
Modules
Spark SQL, Structured Streaming, MLlib, GraphX

Définition : Apache Spark

Apache Spark est un moteur open source de calcul distribué, conçu pour traiter de grands volumes de données sur un cluster de machines. Il répartit un traitement en tâches parallèles et conserve autant que possible les données intermédiaires en mémoire, ce qui le rend bien plus rapide que MapReduce pour les enchaînements de transformations. Spark expose une API unifiée en Python, Scala, Java, SQL et R, et couvre le traitement par lots, le streaming, l'analyse SQL et le machine learning. Né à l'université de Berkeley, il est devenu un projet de la fondation Apache et le socle de nombreuses plateformes data, dont Databricks.

En une phrase : Spark découpe un traitement de données en tâches exécutées en parallèle sur un cluster, en gardant les données en mémoire entre deux étapes.

Dans cette définition

Qu'est-ce qu'Apache Spark ?

Apache Spark est un moteur de calcul : il ne stocke pas les données, il les lit depuis un système de fichiers ou une base, les transforme en parallèle sur plusieurs machines, puis écrit le résultat. Il remplace avant tout MapReduce, le modèle de calcul de l'écosystème Hadoop, dont il reprend l'idée du calcul distribué tout en évitant d'écrire sur disque entre chaque étape.

Le projet naît en 2009 à l'AMPLab de l'université de Berkeley, autour de Matei Zaharia, et passe en open source en 2010. L'article fondateur sur les RDD paraît en 2012. Spark rejoint la fondation Apache en 2013 et devient un projet de premier niveau en 2014, année de sa version 1.0. Les créateurs de Spark fondent ensuite Databricks, qui en fait le cœur de sa plateforme. La version 4 du projet, publiée en 2025, a notamment renforcé la compatibilité ANSI du SQL et l'intégration de Spark Connect.

Spark s'est imposé comme le moteur de référence du data engineering. Notre article Apache Spark : tout savoir sur le framework Big Data détaille ses composants, et Spark Streaming : Bien démarrer son module de flux.

À retenir : Spark est un moteur de calcul, pas une base de données. Il lit et écrit ailleurs, et ne travaille réellement que lorsqu'une action lui demande un résultat.

Comment fonctionne Apache Spark ?

Spark sépare la description du traitement de son exécution : le code construit un plan, et le cluster ne travaille que lorsqu'un résultat est demandé.

  1. Démarrer l'application

    Le programme principal, appelé driver, crée une SparkSession et demande des ressources à un gestionnaire de cluster : Kubernetes, YARN ou le mode autonome de Spark.

  2. Lire les données

    Spark charge les fichiers (Parquet, CSV, JSON) ou les tables en les découpant en partitions, chacune pouvant être traitée indépendamment par un executor.

  3. Décrire les transformations

    Filtres, jointures et agrégations construisent un plan logique. Ces transformations sont paresseuses : rien ne s'exécute tant qu'aucun résultat n'est demandé.

  4. Optimiser le plan

    Lors d'une action (écriture, count, show), l'optimiseur Catalyst réécrit le plan puis Spark le découpe en jobs, stages et tâches, avec des échanges de données (shuffles) entre stages.

  5. Exécuter en parallèle

    Les tâches sont distribuées aux executors, qui traitent chacun leurs partitions, gardent les données en mémoire si possible et renvoient le résultat ou l'écrivent sur disque.

  6. Reprendre après une panne

    Spark conserve le lignage des transformations : si un executor tombe, les partitions perdues sont recalculées à partir de leurs sources, sans repartir de zéro.

L'architecture et les modules de Spark

Une application Spark repose sur un driver, qui orchestre le traitement, et des executors, qui exécutent les tâches sur les machines du cluster. Un gestionnaire de cluster (Kubernetes, YARN ou le mode autonome) leur alloue les ressources.

Les briques de calcul

  • RDD : la structure d'origine, une collection distribuée et immuable. Elle reste disponible, mais on lui préfère aujourd'hui les DataFrames.
  • DataFrame et Dataset : des tables distribuées à colonnes typées, que l'optimiseur Catalyst sait réécrire et accélérer.
  • Spark SQL : l'exécution de requêtes SQL sur des DataFrames, des fichiers ou des tables de catalogue.

Les modules spécialisés

ModuleRôle
Spark SQLRequêtes SQL et API DataFrame, avec l'optimiseur Catalyst
Structured StreamingTraitement de flux en micro-lots, avec la même API que le batch
MLlibAlgorithmes de machine learning distribués et pipelines
GraphXCalculs sur des graphes, surtout en Scala
Spark ConnectClient léger qui pilote un cluster Spark distant

Ces modules partagent le même moteur : une équipe peut donc enchaîner lecture de fichiers, transformation SQL et entraînement d'un modèle dans une seule application.

Exemple : calculer des ventes par catégorie avec PySpark

Cet exemple lit des ventes au format Parquet, calcule le chiffre d'affaires par catégorie et écrit le résultat.

python
from pyspark.sql import SparkSession
from pyspark.sql import functions as F

# Créer la session Spark (point d'entrée de l'application)
spark = SparkSession.builder.appName("ventes-par-categorie").getOrCreate()

# Lecture paresseuse : aucune donnée n'est encore chargée
ventes = spark.read.parquet("s3a://entrepot/ventes/")

# Transformations : filtre, agrégation, tri
resultat = (
    ventes
    .filter(F.col("statut") == "valide")
    .groupBy("categorie")
    .agg(
        F.sum("montant").alias("chiffre_affaires"),
        F.count("*").alias("nb_commandes"),
    )
    .orderBy(F.col("chiffre_affaires").desc())
)

# Voir le plan d'exécution choisi par Catalyst
resultat.explain()

# L'écriture est une action : c'est elle qui déclenche le calcul
resultat.write.mode("overwrite").parquet("s3a://entrepot/ca-par-categorie/")

Les lignes de lecture, de filtre et d'agrégation ne font que construire un plan. Le calcul démarre à l'écriture : Spark répartit les partitions entre les executors, effectue un shuffle pour regrouper les lignes par catégorie, puis écrit les fichiers. La méthode explain() affiche le plan physique, utile pour repérer un shuffle superflu.

bash
# Soumettre l'application à un cluster Kubernetes
spark-submit \
  --master k8s://https://cluster.example.com:6443 \
  --deploy-mode cluster \
  --conf spark.executor.instances=4 \
  --conf spark.executor.memory=4g \
  ventes_par_categorie.py

En production, ces jobs sont rarement lancés à la main : ils sont planifiés par un orchestrateur comme Apache Airflow et exécutés sur Kubernetes ou une plateforme managée.

Les principaux cas d'usage d'Apache Spark

Spark intervient dès que les données dépassent la capacité d'une seule machine ou que les transformations deviennent coûteuses.

  • ETL à grande échelle

    Nettoyer, joindre et transformer des téraoctets de données avant de les charger dans un entrepôt ou un lac.

  • Analyse SQL

    Interroger de gros volumes de fichiers ou de tables avec Spark SQL, sans déplacer les données.

  • Streaming de données

    Traiter des flux issus de Kafka ou de fichiers avec Structured Streaming, en micro-lots.

  • Machine learning distribué

    Entraîner des modèles sur de grands jeux de données avec MLlib et préparer les features à l'échelle.

  • Data lakehouse

    Lire et écrire des tables Delta Lake, Iceberg ou Hudi, avec transactions et historique.

  • Préparation de données pour l'IA

    Dédoublonner, filtrer et tokeniser des corpus massifs destinés à l'entraînement de modèles.

Quels sont les avantages d'Apache Spark ?

Spark combine performance, polyvalence et écosystème, ce qui explique sa place dans la plupart des plateformes data.

  • Traitement en mémoire, nettement plus rapide que MapReduce pour les traitements itératifs et enchaînés.
  • API unifiée pour le batch, le SQL, le streaming et le machine learning, dans un même moteur.
  • Support de Python, Scala, Java, SQL et R, avec les DataFrames comme interface commune.
  • Optimiseur Catalyst et exécution Tungsten qui améliorent les performances sans effort du développeur.
  • Tolérance aux pannes grâce au lignage des transformations.
  • Écosystème très large : connecteurs, formats de fichiers, offres managées et communauté active.

Quelles sont les limites d'Apache Spark ?

Spark n'est pas la réponse à tous les volumes ni à toutes les latences : son coût d'exploitation et de réglage doit être pesé.

  • Surdimensionné pour des données qui tiennent sur une machine : pandas, Polars ou DuckDB suffisent.
  • Latence de démarrage et d'ordonnancement peu adaptée aux traitements en quelques millisecondes.
  • Réglage délicat : partitions, shuffles, mémoire des executors et déséquilibres de données (skew).
  • Consommation de mémoire élevée, avec des erreurs de type out of memory fréquentes en cas de mauvais dimensionnement.
  • Streaming en micro-lots : la latence est plus élevée qu'avec un moteur à événements comme Flink.
  • Exploitation d'un cluster à prévoir, sauf recours à une offre managée.

Spark vs MapReduce : quelles différences ?

MapReduce et Spark répondent au même besoin, calculer en parallèle sur des données réparties, mais leurs choix techniques diffèrent nettement.

CritèreMapReduceApache Spark
Données intermédiairesÉcrites sur disque (HDFS)Gardées en mémoire quand c'est possible
PerformancesAdapté à un passage uniqueRapide pour les enchaînements et les itérations
APIMap et Reduce, verbeuseDataFrames, SQL, API riche en Python et Scala
Modes de traitementBatch uniquementBatch, SQL, streaming et machine learning
OptimisationManuelleAutomatique avec Catalyst
Usage actuelSurtout héritéStandard du data engineering

MapReduce reste pertinent pour comprendre le calcul distribué, mais Spark l'a remplacé dans presque tous les nouveaux projets. Le streaming est le principal point de comparaison avec Apache Flink : Flink traite les événements un par un avec une latence plus faible, quand Structured Streaming privilégie l'unification avec le batch.

Ce n'est pas un choix binaire. Beaucoup de plateformes combinent Kafka pour transporter les événements, Flink ou Spark pour les traiter, et Spark pour les traitements par lots et l'analyse SQL.

Bonnes pratiques pour exploiter Spark

Quelques réflexes évitent la plupart des problèmes de performance :

  • Choisir un format colonnaire : Parquet, avec un partitionnement adapté aux filtres les plus fréquents.
  • Limiter les shuffles : filtrer tôt, sélectionner uniquement les colonnes utiles et diffuser (broadcast) les petites tables lors des jointures.
  • Surveiller le skew : une clé très fréquente peut surcharger un seul executor. Spark 3 et ses versions suivantes atténuent le problème avec l'exécution adaptative des requêtes (AQE).
  • Dimensionner la mémoire : ajuster la mémoire et le nombre de cœurs des executors d'après la taille des partitions.
  • Préférer DataFrames et SQL aux RDD : l'optimiseur n'améliore que ce qu'il peut analyser.
  • Observer avec la Spark UI : elle montre les stages, les shuffles et les tâches les plus lentes.

Quand utiliser Apache Spark ?

Le choix de Spark dépend du volume de données, de la complexité des transformations et de l'infrastructure disponible.

Pertinent si

Spark se justifie

  • Les données se comptent en centaines de gigaoctets ou plus.
  • Les transformations combinent jointures, agrégations et enchaînements complexes.
  • Une même équipe veut du batch, du SQL et du streaming avec un seul outil.
  • Une plateforme managée comme Databricks ou un cluster Kubernetes est déjà disponible.
Moins adapté si

Une solution plus simple suffit

  • Les données tiennent en mémoire sur une machine.
  • Le besoin est une simple requête analytique : un entrepôt SQL suffit.
  • La latence attendue est de l'ordre de la milliseconde.
  • L'équipe n'a ni les compétences ni le temps pour régler un cluster.

Technologies et outils associés à Apache Spark

Spark s'intègre à des gestionnaires de cluster, des formats de fichiers, des sources de flux et des plateformes managées.

Les concepts à connaître autour d'Apache Spark

Ces notions expliquent le comportement de Spark et les choix de réglage qui en découlent.

Ressources pour approfondir Apache Spark

Trois articles du blog Blent pour passer de la définition à la pratique du streaming et des formats de données.

Questions fréquentes

Questions fréquentes

Spark est le moteur de calcul distribué, écrit en Scala et exécuté sur la JVM. PySpark est son interface Python : le code Python décrit les traitements, puis Spark les exécute sur le cluster. Les DataFrames y offrent des performances proches de celles de Scala.

Expertise

À propos de l'auteur

Équipe Blent

Les ingénieurs et mentors Blent conçoivent des plateformes data, industrialisent des pipelines et des modèles en production, et forment chaque année des centaines de professionnels au data engineering et à l'IA.

Sources et méthodologie

  • Documentation officielle Apache Spark (spark.apache.org)
  • Zaharia et al., Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing, NSDI 2012
  • Armbrust et al., Spark SQL: Relational Data Processing in Spark, SIGMOD 2015
  • Retours d'expérience des projets et formations Blent
Lexique

Explorer le lexique

Voir toutes les définitions