Spark

Apache Spark est un moteur open-source de traitement distribué, conçu pour traiter de grands volumes de données rapidement et efficacement. Il se distingue par sa capacité à effectuer des calculs en mémoire (in-memory computing), ce qui le rend bien plus rapide que les solutions traditionnelles comme Hadoop MapReduce.

• Polyvalence : Spark permet de traiter des données en batch (lots), en streaming (temps réel), de faire de l’analytique SQL et du machine learning.
• Écosystème riche : Spark propose des modules pour SQL (Spark SQL), le streaming (Structured Streaming), le machine learning (MLlib) et le traitement de graphes (GraphX).
• Langages supportés : Scala (langage natif), Python, Java, R.

Grâce à son architecture distribuée, Spark est utilisé par de nombreuses entreprises pour l’analyse de données massives, la détection de fraudes, la recommandation de produits, l’analyse de logs, etc.

Spark s’intègre facilement avec de nombreux systèmes et formats de données, ce qui en fait un outil central dans les architectures Big Data modernes.

• Connecteurs NoSQL & bases distribuées :
  • MongoDB : Lecture/écriture directe via le connecteur officiel Spark-MongoDB (idéal pour analyses sur des collections massives).
  • Cassandra : Connecteur Spark-Cassandra pour traiter des données distribuées à grande échelle.
  • Elasticsearch : Connecteur Spark-Elastic pour indexer ou analyser des documents en temps réel.
• Streaming & ingestion temps réel :
  • Kafka : Structured Streaming permet de consommer/produire des flux Kafka pour des pipelines temps réel (logs, IoT, clickstream...)
• Formats de fichiers :
  • Lecture/écriture de fichiers Parquet, CSV, JSON, ORC, etc., sur HDFS, S3, ou le système local.

Conseil pratique : Pour des pipelines robustes, privilégier les formats colonne (Parquet/ORC) et utiliser les connecteurs natifs pour la performance et la compatibilité.

Exemple d’usage : Un pipeline Spark lit des données brutes sur HDFS (Parquet), les enrichit via une jointure avec MongoDB, puis écrit les résultats dans Elasticsearch pour visualisation en temps réel.

Spark est utilisé dans de nombreux contextes Big Data, grâce à sa rapidité et sa flexibilité. Voici quelques scénarios concrets :

• Traitement de logs massifs :
  • Collecte et analyse de logs applicatifs ou systèmes pour détecter des erreurs, tendances ou tentatives d’intrusion.
  • Exemple : Un cluster Spark analyse en continu les logs d’accès web pour générer des rapports de trafic ou alerter en cas de pics d’erreurs.
• Analyse de clickstream :
  • Analyse des parcours utilisateurs sur un site web ou une application mobile pour optimiser l’expérience ou personnaliser les recommandations.
  • Exemple : Spark Streaming traite les événements de navigation en temps réel pour ajuster les recommandations produits sur un site e-commerce.
• Machine learning distribué (MLlib) :
  • Entraînement de modèles de classification, clustering ou régression sur des jeux de données massifs, directement dans le cluster Spark.
  • Exemple : Utiliser MLlib pour détecter la fraude bancaire à partir de millions de transactions.
• Batch vs streaming :
  • Le mode batch traite de grands volumes de données historiques (ex : reporting mensuel).
  • Le mode streaming permet de réagir en temps réel aux nouveaux événements (ex : détection d’anomalies instantanée).
  • Exemple : Calculer des statistiques globales chaque nuit (batch) et détecter les fraudes à la volée pendant la journée (streaming).

Grâce à sa polyvalence, Spark s’adapte à tous les besoins : analyse exploratoire, production de dashboards, automatisation de processus data, IA, etc.

Exemple : WordCount avec PySpark

Ce programme compte le nombre d’occurrences de chaque mot dans un fichier texte distribué sur plusieurs nœuds du cluster.

from pyspark import SparkContext
sc = SparkContext()

# Charger le fichier texte
txt = sc.textFile("/data/mon_fichier.txt")
# Découper chaque ligne en mots
mots = txt.flatMap(lambda ligne: ligne.split())
# Associer chaque mot à 1
paires = mots.map(lambda mot: (mot, 1))
# Additionner les occurrences
compte = paires.reduceByKey(lambda a, b: a + b)
# Afficher le résultat
print(compte.collect())
sc.stop()

• flatMap : transforme chaque ligne en une liste de mots
• map : associe chaque mot à la valeur 1
• reduceByKey : additionne les valeurs pour chaque mot

Ce type de traitement illustre la puissance de Spark pour manipuler de grands volumes de texte de façon distribuée et rapide.

Exemple équivalent en Scala :

import org.apache.spark.{SparkConf, SparkContext}
val conf = new SparkConf().setAppName("WordCount")
val sc = new SparkContext(conf)

// Charger le fichier texte
val txt = sc.textFile("/data/mon_fichier.txt")
// Découper chaque ligne en mots
val mots = txt.flatMap(ligne => ligne.split(" "))
// Associer chaque mot à 1
val paires = mots.map(mot => (mot, 1))
// Additionner les occurrences
val compte = paires.reduceByKey(_ + _)
// Afficher le résultat
compte.collect().foreach(println)
sc.stop()

• flatMap : idem, découpe chaque ligne en mots
• map : associe chaque mot à la valeur 1
• reduceByKey(_ + _) : somme les valeurs pour chaque mot

Ce script Scala est natif dans Spark et très utilisé pour les traitements distribués à grande échelle.

Objectif : Lire un fichier CSV de ventes, calculer le chiffre d'affaires total par produit, et afficher les résultats.

1. Prépare ton environnement
   pip install pyspark ou conda install pyspark (pour Python)
   spark-shell ou spark-submit (pour Scala)
2. Télécharge ou crée un fichier ventes.csv (exemple) :
   

   produit,quantite,prix
   Stylo,10,1.5
   Cahier,5,2
   Stylo,7,1.5
   Livre,3,10
   

3. Lis le fichier avec Spark :
   • Python :

     from pyspark.sql import SparkSession
     spark = SparkSession.builder.appName("MiniLabVentes").getOrCreate()
     df = spark.read.option("header", True).csv("ventes.csv")
     df.show()

   • Scala :

     import org.apache.spark.sql.SparkSession
     val spark = SparkSession.builder.appName("MiniLabVentes").getOrCreate()
     val df = spark.read.option("header", true).csv("ventes.csv")
     df.show()

4. Calcule le chiffre d'affaires par produit :
   • Python :

     from pyspark.sql.functions import col, sum as sum_
     df = df.withColumn("quantite", col("quantite").cast("int"))
     df = df.withColumn("prix", col("prix").cast("double"))
     df = df.withColumn("total", col("quantite") * col("prix"))
     result = df.groupBy("produit").agg(sum_("total").alias("chiffre_affaires"))
     result.show()

   • Scala :

     import org.apache.spark.sql.functions._
     val df2 = df.withColumn("quantite", col("quantite").cast("int"))
       .withColumn("prix", col("prix").cast("double"))
       .withColumn("total", col("quantite") * col("prix"))
     val result = df2.groupBy("produit").agg(sum("total").alias("chiffre_affaires"))
     result.show()

5. Va plus loin !
   Trie les résultats, exporte-les en CSV, ou fais un graphique avec matplotlib (Python) ou Zeppelin (Scala).

Bravo, tu viens de traiter et analyser des données massives comme un pro du Big Data !

1. Quel est le principal avantage de Spark par rapport à Hadoop MapReduce ?
   A. Plus de langages supportés
   B. Calcul en mémoire, rapidité
   C. Interface graphique
   
2. À quoi sert la méthode reduceByKey dans l’exemple WordCount ?
   A. Trier les mots
   B. Additionner les valeurs par clé
   C. Filtrer les doublons
   
3. Quels formats de fichiers sont couramment utilisés avec Spark ? (cochez tout ce qui s’applique)
   A. Parquet
   B. CSV
   C. DOCX
   D. JSON
   
4. Quelle différence entre un RDD et un DataFrame ?
   A. RDD = structuré, DataFrame = non structuré
   B. RDD = non structuré, DataFrame = structuré
   C. Aucun différence
   
5. Quel connecteur permet d’ingérer des flux temps réel dans Spark ?
   A. JDBC
   B. Kafka
   C. Parquet
   

Valider mes réponses