Traitement distribué de données avec Apache Spark
Traitement distribué avec Spark est un cours de niveau avancé de 5 leçons (environ 1 h 40), avec 16 exercices et 15 questions de quiz. Prérequis : Analyse de données avec pandas et NumPy. Le cours demande un environnement de projet complet, prévu dans une phase ultérieure de la plateforme.
- Data engineering
- Avancé
- 5 leçons
- 1 h 40
- 16 exercices
- Environnement de projet complet (phase 2)
Le cours en bref
Ce cours vous apprend à passer de pandas au calcul distribué avec Apache Spark. Vous comprenez l'architecture driver et executors, manipulez des DataFrames PySpark, maîtrisez l'évaluation paresseuse, les partitions, le shuffle et les stratégies de jointure, écrivez des requêtes Spark SQL avec des fonctions de fenêtre, puis diagnostiquez et accélérez un job. Les exercices reproduisent en Python pur et en SQL les mécanismes internes du moteur.
Ce que tu sauras faire
- Lire des données avec un schéma explicite et transformer des DataFrames PySpark
- Expliquer l'évaluation paresseuse, les jobs, stages, tâches et le shuffle
- Contrôler les partitions et choisir une stratégie de jointure adaptée
- Écrire des requêtes Spark SQL avec agrégations et fonctions de fenêtre
- Écrire des tables partitionnées de façon idempotente
- Diagnostiquer un job lent et corriger déséquilibres, UDF et petits fichiers
Programme des 5 leçons
- Expliquer le rôle du driver, des executors et du gestionnaire de cluster
- Créer une SparkSession et lire un fichier avec un schéma explicite
- Sélectionner, filtrer et enrichir un DataFrame avec les fonctions de pyspark.sql.functions
Driver, executors et clusterSparkSessionDataFrame SparkSchéma et lecture de fichiersFonctions de colonnes
- 02
Transformations, actions et évaluation paresseuse
- Distinguer transformations et actions
- Expliquer l'évaluation paresseuse et le rôle de l'optimiseur
- Relier jobs, étapes (stages), tâches et shuffle
- Savoir quand mettre en cache un résultat intermédiaire
Évaluation paresseuseTransformations et actionsTransformations étroites et largesJobs, stages et tâchesMise en cache
- 03
Partitions, shuffle et jointures
- Contrôler le nombre de partitions avec repartition et coalesce
- Comprendre le partitionnement par hachage et l'agrégation en deux temps
- Choisir entre jointure par tri-fusion et jointure par diffusion (broadcast)
PartitionsPartitionnement par hachagerepartition et coalesceJointures distribuéesJointure par diffusion
- 04
Spark SQL et fonctions de fenêtre
- Interroger des DataFrames en SQL avec des vues temporaires
- Passer d'une écriture SQL à l'API DataFrame et inversement
- Calculer classements et cumuls avec les fonctions de fenêtre
- Enregistrer des tables partitionnées de façon idempotente
Spark SQLVues temporaires et tablesFonctions de fenêtreÉcriture partitionnée
- 05
Optimiser un job Spark
- Diagnostiquer un job lent avec l'interface Spark et explain()
- Appliquer les principaux leviers : formats en colonnes, élagage, diffusion, partitions
- Détecter et traiter le déséquilibre de données (skew)
- Remplacer les UDF Python par des fonctions natives ou vectorisées
Diagnostic d'un jobExécution adaptative (AQE)Déséquilibre et salageÉlagage et formats en colonnesUDF et pandas UDF
Projet final
Pipeline Spark d'analyse des ventes multi-magasins
À partir de données générées (plusieurs millions de ventes fictives, un référentiel de magasins et de produits, avec un magasin qui concentre une grande part des ventes), construisez un job PySpark qui lit les données brutes avec un schéma explicite, les nettoie, les enrichit, calcule des indicateurs quotidiens et des classements par région, puis écrit une table Parquet partitionnée par jour de façon idempotente. Mesurez et optimisez le job.
Livrables
- Le script PySpark (ou notebook) exécutable en mode local, avec les transformations factorisées en fonctions
- Les requêtes Spark SQL de classement et de cumul
- La table Parquet partitionnée par jour et la preuve qu'une relance d'un jour ne crée pas de doublon
- Un rapport d'optimisation : plans avant/après (explain), durée des stages, traitement du déséquilibre
Critères d'évaluation
- Les résultats sont exacts et vérifiés sur un échantillon
- Aucun collect ni UDF Python inutile ; les fonctions natives sont utilisées
- Les jointures utilisent la bonne stratégie et les clés sont contrôlées (unicité, orphelins)
- L'écriture est partitionnée, idempotente et sans multitude de petits fichiers
- Les optimisations sont justifiées par des mesures
Questions fréquentes
Quelle différence entre pandas et Spark ?
pandas travaille en mémoire sur une seule machine ; Spark répartit les données en partitions traitées en parallèle sur plusieurs machines, avec une évaluation paresseuse et un optimiseur. Pour des volumes modestes, pandas reste plus simple.
Faut-il un cluster pour suivre le cours ?
Non. Les exercices de code tournent en Python pur et en SQL dans le navigateur. Les tâches pratiques utilisent PySpark en mode local, qui offre la même API qu'un cluster.
Le cours utilise-t-il l'API RDD ?
Le cours s'appuie sur l'API DataFrame et Spark SQL, recommandées aujourd'hui. L'API RDD n'apparaît que pour illustrer le schéma map/reduce.
Quelles versions de Spark sont couvertes ?
Spark 3.5 et 4.x. Les notions présentées (évaluation paresseuse, shuffle, diffusion, AQE, fenêtres) sont communes à ces versions.
Ce cours, raconté pour ton métier
Dis ce que tu veux savoir faire : « Traitement distribué avec Spark » prend sa place dans ton parcours, avec des exemples de ton secteur. Les notions restent celles du cours.