Aucune connaissance préalable n’est strictement obligatoire ; les prérequis détaillés sont précisés dans les ateliers.
Avancé
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Construire un petit pipeline de données et documenter ses choix.
Obligatoire ConsulterÉvaluer la compréhension de l'architecture et des outils.
Obligatoire ConsulterLivrer un pipeline reproductible avec ingestion, stockage et restitution.
Livrables :
Bienvenue dans ce cours complet sur le Big Data. Cette introduction vous fournira les bases nécessaires pour comprendre l'écosystème du Big Data et son importance croissante dans notre monde numérique.
Le Big Data fait référence à des ensembles de données si volumineux et complexes qu'ils nécessitent des outils et méthodes spécifiques pour être collectés, stockés, traités et analysés.
L'explosion du Big Data est principalement due à :
Le Big Data transforme de nombreux secteurs :
Le Big Data n'est pas qu'une question de volume, mais aussi de la capacité à extraire de la valeur des données pour prendre de meilleures décisions.
Le Big Data désigne des ensembles de données si volumineux et complexes qu'ils nécessitent des outils et méthodes spécifiques pour être traités et analysés. Ces données proviennent de sources variées et en croissance exponentielle, telles que les réseaux sociaux, les appareils IoT, les transactions en ligne, et bien d'autres.
Quantité massive de données générées chaque seconde, de l'ordre du téraoctet au zettaoctet.
Vitesse à laquelle les données sont générées, traitées et analysées en temps réel.
Diversité des types de données : structurées, semi-structurées et non structurées.
Qualité, fiabilité et exactitude des données collectées et analysées.
Potentiel des données à générer des informations utiles et exploitables pour l'entreprise.
Smartphones, tablettes, montres connectées générant des données de localisation, d'utilisation, etc.
Publications, likes, partages, commentaires, vidéos, et autres interactions sociales.
Historiques d'achat, parcours utilisateur, préférences, et comportements d'achat.
Capteurs, appareils intelligents, véhicules connectés générant des données en continu.
Le Big Data transforme la façon dont les organisations prennent des décisions et créent de la valeur :
L'histoire du Big Data est étroitement liée à l'évolution de l'informatique et des technologies de l'information. Ce voyage à travers le temps montre comment nous sommes passés des premiers systèmes de gestion de bases de données aux écosystèmes Big Data modernes.
1 Zettaoctet (ZB) = 1 milliard de Téraoctets
Le Big Data transforme de nombreux secteurs d'activité en permettant l'analyse de vastes volumes de données pour en extraire des informations précieuses. Voici quelques-uns des cas d'utilisation les plus marquants à travers différentes industries.
Les géants du commerce électronique comme Amazon utilisent le Big Data pour analyser des milliards de transactions et proposer des recommandations personnalisées en temps réel.
L'analyse du génome et des dossiers médicaux électroniques permet des diagnostics plus précis et des traitements sur mesure pour les patients.
Analyse rapide du génome pour identifier des prédispositions génétiques
Médicaments personnalisés en fonction du profil génétique
Détection précoce des épidémies et suivi des maladies
Augmentation des ventes grâce à la personnalisation et aux recommandations ciblées
Optimisation des chaînes d'approvisionnement et réduction des gaspillages
Développement de nouveaux produits et services basés sur les données
Meilleure gestion des risques et conformité réglementaire
Respect du RGPD et sécurisation des données sensibles
Nettoyage et préparation des données pour l'analyse
Pénurie de talents qualifiés en science des données
Complexité de l'intégration avec les systèmes existants
Cette section couvre les concepts fondamentaux du Big Data, les bonnes pratiques et les cas d'utilisation concrets pour une compréhension approfondie du domaine.
Les 3V (Volume, Vélocité, Variété) sont les piliers fondamentaux du Big Data, auxquels s'ajoutent d'autres caractéristiques importantes.
Le volume se rapporte à la quantité massive de données générées et collectées chaque jour.
Une entreprise de commerce électronique génère des millions de transactions quotidiennes, ce qui représente un volume massif de données à traiter et analyser pour des décisions commerciales éclairées.
La vitesse fait référence à la rapidité à laquelle les données sont générées, collectées et traitées.
Les systèmes de détection de fraude bancaire analysent les transactions en temps réel pour identifier les activités suspectes et protéger les utilisateurs.
Les bases de données NoSQL sont essentielles pour gérer des données non structurées ou semi-structurées à grande échelle.
Ce diagramme présente les quatre principaux types de bases de données NoSQL, leurs cas d'utilisation typiques et leurs avantages respectifs.
Une plateforme de médias sociaux gère des données variées : textes, images, vidéos, métadonnées, logs, etc., nécessitant des approches de traitement différentes.
La véracité concerne la qualité, l'exactitude et la fiabilité des données collectées.
Dans le domaine médical, la précision des données est cruciale pour des diagnostics fiables et des traitements appropriés.
La valeur représente l'utilité des données pour la prise de décision et la création d'avantages compétitifs.
L'analyse des données de navigation des utilisateurs permet d'améliorer l'expérience client et d'augmenter les taux de conversion sur les sites e-commerce.
La variabilité fait référence aux changements dans la structure, le format ou la signification des données dans le temps.
Les tendances saisonnières dans les données de vente ou les changements soudains dans le comportement des utilisateurs suite à un événement particulier.
La vérifiabilité assure que les données sont exactes, cohérentes et dignes de confiance.
Vérification de l'authenticité des avis clients pour prévenir les faux commentaires.
La visualisation transforme des données complexes en représentations graphiques faciles à interpréter.
Tableaux de bord interactifs pour suivre les indicateurs clés de performance (KPI) en temps réel.
Découvrez les différents systèmes de stockage et de gestion des données dans l'écosystème Big Data.
Entrepôt de données structurées optimisé pour l'analyse et la génération de rapports.
Référentiel qui stocke d'énormes quantités de données brutes dans leur format natif.
Les bases de données NoSQL sont essentielles pour gérer les données non structurées et semi-structurées :
Sous-ensemble d'un entrepôt de données, conçu pour un service ou une équipe spécifique.
Exemple : Un data mart dédié au service marketing pour analyser les campagnes publicitaires et le comportement des clients.
Explorez des concepts plus avancés essentiels pour maîtriser le Big Data.
Principe fondamental des systèmes distribués qui énonce qu'il est impossible pour un système de données distribué de fournir simultanément plus de deux des trois garanties suivantes :
Deux approches pour le traitement des données en temps réel et par lots :
Combine un flux rapide (speed layer) pour le temps réel et un traitement par lots (batch layer) pour des résultats précis.
Simplifie l'architecture en utilisant un seul flux de traitement pour le temps réel et les traitements par lots.
Découvrez les principaux outils utilisés dans l'écosystème Big Data.
Ce diagramme illustre l'architecture d'un cluster Hadoop typique :
Framework open-source pour le stockage et le traitement distribué de grands ensembles de données sur des clusters d'ordinateurs.
Moteur d'analyse unifié pour le traitement de données à grande échelle.
Plateforme de streaming d'événements distribuée pour la construction de pipelines de données en temps réel.
La maîtrise de ces concepts fondamentaux est essentielle pour concevoir des solutions Big Data efficaces et adaptées aux besoins spécifiques de chaque projet.
Cette section guide à travers le processus essentiel de planification et d'identification des besoins dans un projet Big Data, étape cruciale pour garantir le succès de toute initiative d'analyse de données.
Avant de plonger dans la technique, il est essentiel de bien comprendre le contexte métier et les objectifs du projet.
Identifier toutes les parties prenantes clés impliquées dans le projet.
Pour un projet d'analyse client, les parties prenantes pourraient inclure le marketing, les ventes, le service client et la direction.
Établir des objectifs SMART (Spécifiques, Mesurables, Atteignables, Réalistes, Temporels).
"Réduire le taux d'attrition des clients de 15% au cours des 6 prochains mois grâce à une meilleure analyse des comportements clients."
Définir les limites et les contraintes du projet pour en assurer la faisabilité.
Identifier les contraintes techniques, budgétaires et temporelles.
Un budget limité peut nécessiter l'utilisation de solutions open-source plutôt que des plateformes propriétaires coûteuses.
Anticiper les risques potentiels et élaborer des plans d'atténuation.
Risque de non-conformité au RGPD : prévoir une phase de nettoyage et d'anonymisation des données.
Méthodes et techniques pour recueillir efficacement les besoins des utilisateurs.
Conduire des entretiens structurés pour comprendre les besoins métier.
Organiser des sessions collaboratives avec les utilisateurs finaux.
Documenter de manière claire et précise les besoins identifiés.
Créer un document de référence qui servira de base au développement.
S'assurer que tous les besoins sont correctement compris et approuvés.
Organiser des revues formelles où chaque partie prenante peut valider ou demander des modifications.
Une planification minutieuse et une identification précise des besoins sont les fondations d'un projet Big Data réussi. Prendre le temps nécessaire à cette étape permet d'éviter des erreurs coûteuses plus tard dans le projet.
Cette section explore la structure organisationnelle typique d'un projet Big Data, en mettant en lumière les rôles clés, les responsabilités et les bonnes pratiques pour une collaboration efficace.
Comprendre comment les équipes Big Data sont généralement structurées pour maximiser l'efficacité.
Le noyau technique qui conçoit et implémente la solution Big Data.
Les professionnels qui transforment les données en informations exploitables.
Les responsables de la direction et de la conformité du projet.
Définition claire des responsabilités de chaque rôle dans un projet Big Data.
Responsable de la conception, de la construction et de la maintenance des pipelines de données.
Analyse des données complexes pour en extraire des informations exploitables.
Conçoit l'architecture globale de la solution de données.
Approches pour gérer efficacement un projet Big Data.
Méthodologie itérative et incrémentale adaptée aux projets complexes.
Pratiques visant à automatiser et améliorer le cycle de vie du développement.
Solutions pour faciliter la collaboration au sein des équipes Big Data.
Outils essentiels pour le versionnage et la collaboration sur le code.
Maintenir une documentation à jour est crucial pour la réussite du projet.
Une organisation efficace d'un projet Big Data repose sur une répartition claire des rôles, une communication fluide entre les équipes et l'adoption de méthodologies adaptées. La collaboration entre les différents profils techniques et métier est essentielle pour transformer la donnée en valeur ajoutée pour l'entreprise.
Un pipeline de données est un processus qui permet de déplacer et de transformer les données depuis leur source jusqu'à leur destination finale, en appliquant diverses opérations de traitement. Cette section détaille chaque étape clé d'un pipeline de données moderne.
Un pipeline de données typique comprend les étapes suivantes :
Comprendre les concepts fondamentaux et l'importance des pipelines dans l'écosystème Big Data.
Ce diagramme illustre le flux typique d'un pipeline de données :
Un pipeline de données est une séquence d'étapes qui permet de collecter, traiter et déplacer les données d'une source à une destination, en leur appliquant diverses transformations.
Les éléments essentiels qui constituent un pipeline de données moderne.
Structure typique et bonnes pratiques pour concevoir un pipeline efficace.
Approche structurée pour organiser les différents composants du pipeline.
Différentes approches pour structurer un pipeline de données.
Panorama des solutions logicielles utilisées pour implémenter des pipelines de données.
Solutions pour collecter et importer des données depuis diverses sources.
Frameworks pour transformer et analyser les données à grande échelle.
Outils pour planifier, surveiller et gérer les workflows de données.
Recommandations pour concevoir et maintenir des pipelines de données efficaces et fiables.
Assurer la robustesse du pipeline face aux pannes et erreurs.
Concevoir des pipelines capables de gérer une croissance des volumes de données.
Garantir l'exactitude, la complétude et la cohérence des données tout au long du pipeline.
Exemple concret de mise en œuvre d'un pipeline de données pour une application d'analyse de sentiment.
Une entreprise souhaite analyser en temps réel les avis clients sur ses produits à partir de différentes sources.
Architecture technique détaillée du pipeline.
Bénéfices obtenus grâce à cette implémentation.
Un pipeline de données bien conçu est essentiel pour transformer des données brutes en informations exploitables. En suivant les bonnes pratiques d'architecture et en choisissant les bons outils pour chaque étape, les organisations peuvent créer des systèmes évolutifs, fiables et performants qui répondent à leurs besoins spécifiques en matière d'analyse de données.
Un pipeline de données bien conçu est essentiel pour transformer des données brutes en informations exploitables. En suivant les bonnes pratiques d'architecture et en choisissant les bons outils pour chaque étape, les organisations peuvent créer des systèmes évolutifs, fiables et performants qui répondent à leurs besoins spécifiques en matière d'analyse de données.
Les participants peuvent ensuite explorer les différentes carrières et métiers liés au Big Data pour mieux comprendre les opportunités professionnelles.
Le cours sur le traitement des données est crucial, car il expose les participants aux technologies et aux méthodologies de traitement des données en Big Data.
Les notions statistiques sont importantes pour comprendre comment analyser les données en profondeur.
À ce stade, les participants peuvent découvrir les outils et les technologies couramment utilisés en Big Data.
Le Data Warehousing est un domaine essentiel en Big Data, et il est logique de l'aborder après avoir traité les bases.
Cette section fournit une compréhension des différentes unités de données utilisées en Big Data, ce qui peut être utile pour comprendre les échelles de données massives.
L'IA est un domaine en plein essor en relation avec le Big Data, et il est logique de l'aborder à ce stade.
Objectif : Réduire la taille des fichiers texte en utilisant l'algorithme de compression gzip.
Étapes :
Résultat : Les fichiers texte sont compressés en utilisant gzip, ce qui permet de réduire significativement leur taille tout en préservant leur intégrité. Par exemple, un fichier texte de 10 Mo peut être compressé à moins de 1 Mo avec gzip, offrant ainsi des économies importantes en termes d'espace de stockage.
Enfin, les participants peuvent apprendre comment utiliser le Big Data pour améliorer les produits et satisfaire les besoins des clients.
La stratégie client-data-produit en Big Data vise à optimiser les produits et les services en utilisant les données clients. Voici comment elle fonctionne, avec des exemples concrets de parties prenantes et d'outils associés :
Les données clients sont collectées à partir de diverses sources, notamment les transactions, les interactions en ligne et les réseaux sociaux.
Les données sont analysées pour identifier des tendances et des comportements.
Les clients sont regroupés en segments en fonction de leurs caractéristiques.
Les produits sont personnalisés en fonction des préférences des clients.
Les processus de fabrication et de distribution sont optimisés en fonction des données clients.
De nouveaux produits sont développés en fonction des besoins et des lacunes identifiés.
L'expérience client est améliorée grâce à une personnalisation accrue.
Les résultats sont mesurés en fonction de la satisfaction client, de la rétention et des ventes.
Une entreprise de commerce électronique utilise la stratégie client-data-produit en Big Data pour améliorer ses ventes en ligne. Les parties prenantes et les outils sont les suivants :
Partie Prenante : L'équipe marketing collecte des données sur le comportement des acheteurs en ligne à l'aide d'un CRM.
Partie Prenante : L'équipe d'analyse de données utilise Python et Apache Spark pour analyser les données et identifier les produits les plus populaires.
Partie Prenante : L'équipe de développement produit personnalise les pages de produits en fonction des préférences des clients.
Partie Prenante : L'équipe de logistique optimise les opérations d'expédition en fonction des données clients.
Partie Prenante : L'équipe de performance commerciale mesure la rétention et les ventes pour évaluer l'impact de la stratégie.
Cette stratégie a permis d'augmenter la satisfaction client, d'optimiser les processus et d'augmenter les ventes de manière significative.
Les bases de données NoSQL sont des solutions idéales pour stocker et gérer des volumes massifs de données, notamment dans le contexte du Big Data. Elles offrent des avantages clés tels que la flexibilité, la scalabilité, la haute disponibilité et la facilité de maintenance.
Les avantages clés des bases de données NoSQL pour le Big Data sont :
Les technologies de traitement distribué et de streaming sont essentielles pour traiter des volumes massifs de données en temps réel.
| Caractéristique | Traitement par lots | Traitement en temps réel |
|---|---|---|
| Latence | Élevée (minutes à heures) | Faible (millisecondes à secondes) |
| Volume de données | Grands volumes | Flux continu |
| Exemples d'outils | Hadoop MapReduce, Spark (batch) | Kafka Streams, Flink, Spark Streaming |
| Cas d'utilisation | Analyse historique, rapports | Alertes, monitoring, recommandations |
Les technologies de traitement distribué et de streaming permettent de traiter en temps réel des volumes massifs de données pour répondre aux besoins de l'entreprise. Elles sont capables de traiter des données structurees ou non structurees, en utilisant des algorithmes de traitement de données distribués, tel que MapReduce, pour traiter des données en parallèle sur de nombreux nœuds. De plus, ces technologies prennent en charge des fonctionnalités de streaming, tel que Apache Kafka, pour traiter des données en temps réel. Les technologies de traitement distribué et de streaming permettent l'analyse de données en temps réel, la mise en place de systèmes de recommandation, la gestion de flux de données en direct, la surveillance en temps réel, etc.
Hadoop est un framework open-source né chez Yahoo! en 2006, conçu pour stocker et traiter d’immenses volumes de données sur des grappes de serveurs standards. Il a révolutionné la gestion du Big Data en rendant possible l’analyse de pétaoctets de données à moindre coût.
Hadoop a posé les bases de la data moderne et reste utilisé pour l’archivage, le batch analytique et comme socle de clusters Big Data.
Exemple : Un fichier de 1 Go est découpé en 8 blocs de 128 Mo, chaque bloc est stocké sur 3 DataNodes différents. Si l’un tombe, le système continue de fonctionner sans perte.
Exemple : Pour compter les mots d’un corpus, chaque Map compte les mots dans un bloc, puis Reduce additionne les résultats de chaque Map.
Exemple : Une entreprise lance en parallèle un job MapReduce, une requête Hive et un pipeline Spark : YARN répartit les ressources pour optimiser l’utilisation du cluster.
1. Commandes HDFS de base
hdfs dfs -mkdir /data/mon_dossier : créer un dossier sur HDFShdfs dfs -put fichier.txt /data/mon_dossier/ : uploader un fichier local vers HDFShdfs dfs -ls /data/mon_dossier : lister les fichiers d’un dossierhdfs dfs -cat /data/mon_dossier/fichier.txt : afficher le contenu d’un fichierCes commandes permettent de manipuler HDFS en ligne de commande, comme un système de fichiers classique mais distribué.
2. Exemple WordCount en pseudo-code MapReduce
// MAP : pour chaque ligne du texte
pour chaque mot dans la ligne
émettre (mot, 1)
// REDUCE : pour chaque mot unique
somme = 0
pour chaque valeur associée au mot
somme += valeur
émettre (mot, somme)
Ce schéma est à la base de nombreux traitements distribués sur Hadoop.
3. Exemple WordCount Java (simplifié)
public static class Map extends Mapper<Object, Text, Text, IntWritable> {
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();
public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
StringTokenizer itr = new StringTokenizer(value.toString());
while (itr.hasMoreTokens()) {
word.set(itr.nextToken());
context.write(word, one);
}
}
}
public static class Reduce extends Reducer<Text, IntWritable, Text, IntWritable> {
public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable val : values) {
sum += val.get();
}
context.write(key, new IntWritable(sum));
}
}
Ce programme Java est typique des premiers jobs MapReduce sur Hadoop.
alice.txt (texte du livre « Alice au pays des merveilles ») depuis Project Gutenberg et place-le dans ton dossier local.
hdfs dfs -mkdir /data/alicehdfs dfs -put alice.txt /data/alice/hdfs dfs -ls /data/alice
hadoop jar /usr/lib/hadoop-mapreduce/hadoop-mapreduce-examples.jar wordcount /data/alice/alice.txt /data/alice/outputhdfs dfs -ls /data/alice/outputhdfs dfs -cat /data/alice/output/part-r-00000 | head -20Ce mini-lab permet de manipuler HDFS, de lancer un vrai job MapReduce, et de comprendre la logique du traitement distribué sur un cluster Hadoop.
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.
Exemple d’usage : Un job Spark lancé depuis un notebook Jupyter envoie le code au driver, qui le découpe en tâches distribuées sur plusieurs machines du cluster.
Exemple d’usage : Calculer le nombre de mots dans un gros corpus de texte distribué sur plusieurs serveurs.
Exemple d’usage : Charger un fichier CSV massif, filtrer les lignes selon des critères, agréger les résultats via une requête SQL.
Exemple d’usage : Détecter des anomalies dans des logs applicatifs en temps réel.
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.
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()
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()
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.
pip install pyspark ou conda install pyspark (pour Python) spark-shell ou spark-submit (pour Scala)
ventes.csv (exemple) :produit,quantite,prix
Stylo,10,1.5
Cahier,5,2
Stylo,7,1.5
Livre,3,10
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("MiniLabVentes").getOrCreate()
df = spark.read.option("header", True).csv("ventes.csv")
df.show()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()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()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()Bravo, tu viens de traiter et analyser des données massives comme un pro du Big Data !
Apache Kafka a été créé en 2010 par LinkedIn pour résoudre les problèmes de gestion des données en temps réel. Son développement a été initié par Jay Kreps, Neha Narkhede et Jun Rao. Le projet a été open-sourcé en 2011 et est devenu un projet de la Fondation Apache en 2012.
Kafka a été conçu pour répondre aux besoins spécifiques de LinkedIn en matière de traitement de données en temps réel, notamment pour la collecte de logs, les métriques, et les flux de données utilisateur.
Apache Kafka est une plateforme distribuée de diffusion de données en continu, capable de publier, stocker, traiter et souscrire à des flux d'enregistrement en temps réel. Elle est conçue pour gérer des flux de données provenant de plusieurs sources et les fournir à plusieurs utilisateurs simultanément.
Kafka est une solution Open Source de diffusion de données en continu, capable de publier, stocker, traiter et souscrire à des flux d'enregistrement en temps réel.
graph LR
P[Producteurs] -->|publient| T[Topics]
T --> B[(Brokers
partitions)]
B --> C[Consommateurs]
B --> C
Schéma : les producteurs publient dans des topics, les brokers les stockent dans leurs partitions, les consommateurs les lisent.
L'architecture de Kafka est composée de quatre composants principaux :
L'architecture de Kafka repose sur plusieurs composants clés :
graph TB
subgraph Producteurs
P1[App A]
P2[App B]
end
subgraph Cluster
B1[(Broker 1)]
B2[(Broker 2)]
B3[(Broker 3)]
end
subgraph Consommateurs
C1[Traitement 1]
C2[Traitement 2]
end
P1 --> B1
P2 --> B2
B1 --> C1
B2 --> C2
B3 --> C1
Vue d'ensemble : plusieurs producteurs alimentent un cluster de brokers, réparti vers les consommateurs.
Kafka est conçu comme une plateforme distribuée, composée de plusieurs composants interconnectés qui travaillent ensemble pour gérer les flux de données.
graph LR
P[Producteurs] -->|append| L[Partition leader]
L --> F1[Réplique 1]
L --> F2[Réplique 2]
Z[Zookeeper / KRaft] -.coordination.-> L
Composants : un topic est découpé en partitions, chaque partition est répliquée sur plusieurs brokers, un coordinateur (Zookeeper ou KRaft) maintient l'état du cluster.
L'architecture de Kafka est composée de plusieurs composants interconnectés :
graph LR
L[(Partition 0 - leader)] --> R1[(Réplique 1)]
L --> R2[(Réplique 2)]
R1 -.réplication.-> L
R2 -.réplication.-> L
Réplication : le leader reçoit les écritures et les réplique aux followers ; en cas de panne, un follower est élu leader.
La réplication est un mécanisme essentiel de Kafka qui assure la durabilité et la tolérance aux pannes. Chaque partition est répliquée sur plusieurs brokers, avec un broker leader et plusieurs brokers followers.
graph LR
T[(Topic - 3 partitions)] --> G1[Groupe A]
T --> G2[Groupe B]
G1 --> C1[Consommateur 1]
G1 --> C2[Consommateur 2]
G2 --> C3[Consommateur 3]
Groupes de consommateurs : chaque partition est assignée à un seul consommateur d'un groupe ; deux groupes différents relisent donc chacun la totalité du topic.
Les groupes de consommateurs permettent de répartir la charge de traitement entre plusieurs consommateurs. Chaque partition est assignée à un seul consommateur par groupe, garantissant ainsi une consommation exclusive des messages.
graph LR
TP[Topic commandes] --> P0[Partition 0]
TP --> P1[Partition 1]
TP --> P2[Partition 2]
P0 --> M0[Messages 0-99]
P1 --> M1[Messages 100-199]
P2 --> M2[Messages 200-299]
Topics et partitions : un topic est un découpage ordonné de partitions ; chaque partition est ordonnée mais il n'y a pas d'ordre global entre partitions.
Kafka utilise le modèle pub/sub, où les producteurs envoient des messages dans un topic et les consommateurs peuvent s'abonner à ce topic pour recevoir les messages. Cela permet une communication asynchrone et découplée entre les applications.
Voici un exemple d'utilisation simple :
// Producteur
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
Producer<String, String> producer = new KafkaProducer<>(props);
String logMessage = "[ERROR] " + new Date() + " - Une erreur s'est produite";
ProducerRecord<String, String> record = new ProducerRecord<>("logs-topic", "server-1", logMessage);
producer.send(record);
// Consommateur
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "my-group");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
consumer.subscribe(Collections.singletonList("logs-topic"));
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
for (ConsumerRecord<String, String> record : records) {
System.out.println(record.value());
}
consumer.commitSync();
}
Kafka offre une haute durabilité grâce à la réplication des partitions sur plusieurs brokers. Tu peux configurer le nombre de réplicas pour chaque topic. Un des réplicas est désigné comme le leader (pour les opérations de lecture et d'écriture), et les autres sont des followers qui répliquent les données du leader. Les messages sont stockés sur disque et peuvent être archivés pour garantir la persistance des données, même en cas de redémarrage des brokers.
replication.factor : Nombre de réplicas par partitionmin.insync.replicas : Nombre minimum de réplicas qui doivent confirmer l'écriturelog.retention.hours : Durée de rétention des messages// Création d'un topic avec réplication
kafka-topics.sh --create --topic my-topic --partitions 3 --replication-factor 3 --bootstrap-server localhost:9092Kafka est conçu pour être tolérant aux pannes. En cas d'arrêt d'un broker, les partitions qu'il héberge (et qui sont leaders) sont reprises par l'un des brokers contenant une réplique à jour (un follower devient le nouveau leader). Les consommateurs et producteurs continuent à interagir avec les partitions restantes sans interruption significative.
Kafka scale horizontalement en ajoutant simplement de nouveaux brokers au cluster. De plus, la division des topics en partitions permet de distribuer la charge de travail entre plusieurs brokers et consommateurs au sein d'un même groupe, atteignant ainsi un haut débit de traitement. Le nombre de partitions peut être ajusté (avec précaution) pour répondre à l'évolution de la demande.
// Métriques importantes à surveiller
- broker:messages-in-per-sec
- broker:bytes-in-per-sec
- broker:bytes-out-per-sec
- consumer:lagKafka est conçu pour offrir des temps de réponse très courts (faible latence), ce qui en fait un outil idéal pour les applications réactives et les processus en temps quasi-réel.
// Configuration pour la latence
Properties props = new Properties();
props.put("linger.ms", "1");
props.put("batch.size", "16384");
props.put("compression.type", "gzip");Kafka est agnostique au format des données. Cependant, pour une interopérabilité et une évolution des schémas efficaces, l'utilisation de formats de sérialisation structurés comme Avro, Protocol Buffers ou JSON Schema est fortement recommandée. Kafka utilise des Serializers pour convertir les objets en flux d'octets avant l'envoi et des Deserializers pour effectuer l'opération inverse à la réception.
// Avro
public class User {
private String name;
private int age;
// getters et setters
}
// Configuration
Properties props = new Properties();
props.put("key.serializer", "io.confluent.kafka.serializers.KafkaAvroSerializer");
props.put("value.serializer", "io.confluent.kafka.serializers.KafkaAvroSerializer");
Kafka offre différentes garanties de livraison configurables :
// Configuration pour exactly-once
Properties props = new Properties();
props.put("enable.idempotence", "true");
props.put("transactional.id", "my-transaction-id");
Dans une application web, les logs sont générés par le serveur et doivent être stockés et analysés en temps réel. Kafka peut être utilisé pour :
Dans une plateforme de e-commerce, les événements tels que les clics, les ajouts au panier et les commandes sont générés. Kafka peut être utilisé pour :
// Configuration du producteur
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
try (Producer<String, String> producer = new KafkaProducer<>(props)) {
ProducerRecord<String, String> record = new ProducerRecord<>("my-topic", "log-id-1", "message-1");
producer.send(record);
System.out.println("Message envoyé !");
} catch (Exception e) {
e.printStackTrace();
}
// Configuration du consommateur
Properties consumerProps = new Properties();
consumerProps.put("bootstrap.servers", "localhost:9092");
consumerProps.put("group.id", "my-group");
consumerProps.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
consumerProps.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
consumerProps.put("auto.offset.reset", "latest"); // ou "earliest" pour lire depuis le début
try (KafkaConsumer<String, String> consumer = new KafkaConsumer<>(consumerProps)) {
consumer.subscribe(Collections.singletonList("my-topic"));
while (true) {
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
for (ConsumerRecord<String, String> record : records) {
System.out.printf("Offset = %d, Key = %s, Value = %s%n",
record.offset(), record.key(), record.value());
}
}
}# Télécharger la dernière version stable
wget https://downloads.apache.org/kafka/3.4.0/kafka_2.13-3.4.0.tgz
# Décompresser
mkdir kafka && tar -xzf kafka_2.13-3.4.0.tgz -C kafka --strip-components 1
# Démarrer Zookeeper (pour les versions < 3.0)
bin/zookeeper-server-start.sh config/zookeeper.properties
# Démarrer Kafka
bin/kafka-server-start.sh config/server.propertiesLes fichiers de configuration principaux sont :
server.properties : Configuration du brokerzookeeper.properties : Configuration de ZookeeperExemple complet de configuration
broker.id : Identifiant unique du brokerlog.dirs : Répertoire de stockage des donnéesnum.partitions : Nombre de partitions par défautreplica.fetch.max.bytes : Taille maximale des requêtes de réplication# Créer un topic
bin/kafka-topics.sh --create --topic my-topic --partitions 3 --replication-factor 1 --bootstrap-server localhost:9092
# Lister les topics
bin/kafka-topics.sh --list --bootstrap-server localhost:9092
# Voir les détails d'un topic
bin/kafka-topics.sh --describe --topic my-topic --bootstrap-server localhost:9092
# Produire des messages
bin/kafka-console-producer.sh --broker-list localhost:9092 --topic my-topic
# Consommer des messages
bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my-topic --group my-group --from-beginningKafka expose des métriques JMX qui peuvent être surveillées avec des outils comme Prometheus et Grafana.
# Ajouter un nouveau broker
bin/kafka-server-start.sh config/server.properties# Créer un fichier de configuration
bin/kafka-reassign-partitions.sh --zookeeper localhost:2181 --generate --topics-to-move-json-file topics-to-move.json --broker-list "0,1,2" --broker-list "0,1,2,3"
# Appliquer le rebalancement
bin/kafka-reassign-partitions.sh --zookeeper localhost:2181 --execute --reassignment-json-file reassign.jsonbin/kafka-reassign-partitions.sh --zookeeper localhost:2181 --verify --reassignment-json-file reassign.jsonTélécharger la dernière version stable depuis le site officiel Apache Kafka.
# Décompression de l'archive
$ tar -xzf kafka_2.13-3.4.0.tgz
$ cd kafka_2.13-3.4.0
# Démarrage de Zookeeper (pour les versions < 3.0)
$ bin/zookeeper-server-start.sh config/zookeeper.properties
# Démarrage de Kafka
$ bin/kafka-server-start.sh config/server.properties
Les fichiers de configuration principaux sont :
server.properties : Configuration du brokerzookeeper.properties : Configuration de Zookeeper
# Créer un topic
$ bin/kafka-topics.sh --create --topic my-topic --bootstrap-server localhost:9092 --partitions 3 --replication-factor 1
# Lister les topics
$ bin/kafka-topics.sh --list --bootstrap-server localhost:9092
# Voir les détails d'un topic
$ bin/kafka-topics.sh --describe --topic my-topic --bootstrap-server localhost:9092
# Produire des messages
$ bin/kafka-console-producer.sh --topic my-topic --bootstrap-server localhost:9092
# Consommer des messages
$ bin/kafka-console-consumer.sh --topic my-topic --bootstrap-server localhost:9092 --from-beginning
Kafka expose des métriques JMX qui peuvent être surveillées avec des outils comme Prometheus et Grafana.
kafka-topics.sh --create \
--topic my-topic \
--partitions 3 \
--replication-factor 1 \
--bootstrap-server localhost:9092
kafka-topics.sh --list --bootstrap-server localhost:9092
kafka-topics.sh --describe \
--topic my-topic \
--bootstrap-server localhost:9092
kafka-console-producer.sh \
--broker-list localhost:9092 \
--topic my-topicTapez vos messages et appuyez sur Entrée pour les envoyer.
kafka-console-consumer.sh \
--bootstrap-server localhost:9092 \
--topic my-topic \
--group my-group \
--from-beginning
L'option --from-beginning permet de lire les messages depuis le début du topic.
kafka-consumer-groups.sh \
--list \
--bootstrap-server localhost:9092Affiche la liste de tous les groupes de consommateurs.
kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group my-group \
--describeAffiche les décalages actuels pour chaque partition consommée par le groupe.
# Réinitialiser au début (earliest)
kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group my-group \
--reset-offsets \
--to-earliest \
--execute \
--topic my-topic
# Réinitialiser à la fin (latest)
kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group my-group \
--reset-offsets \
--to-latest \
--execute \
--topic my-topicAttention: Cette opération est irréversible. Utilisez --dry-run avant pour voir les changements sans les appliquer.
kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group my-group \
--describe \
--members \
--verboseAffiche des informations détaillées sur les membres du groupe et leur retard de consommation.
kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--delete \
--group my-groupSupprime le groupe et toutes ses métadonnées. Les données des topics ne sont pas supprimées.
# Activer JMX pour exposer les métriques
export KAFKA_JMX_OPTS="-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=9999 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false"
# Lancer le consommateur avec JMX
KAFKA_JMX_OPTS="$KAFKA_JMX_OPTS" kafka-console-consumer.sh \
--bootstrap-server localhost:9092 \
--topic my-topic \
--group my-groupConnectez-vous avec JConsole ou un outil similaire sur localhost:9999 pour voir les métriques.
kafka-consumer-groups.sh \
--bootstrap-server localhost:9092 \
--group my-group \
--describe \
| grep -v "LAG 0"Affiche uniquement les partitions avec un décalage (lag) supérieur à zéro.
Les outils de visualisation et de monitoring sont essentiels pour surveiller et optimiser les performances des systèmes Big Data.
Créer un tableau de bord de service avec CPU, mémoire, latence et taux d’erreur. Ajouter une variable d’environnement, une alerte et un lien vers le runbook.
Répondre à cinq questions sur les sources, les variables et les seuils, puis construire un mini-dashboard avec une alerte documentée.
Construire un tableau de bord de logs avec une visualisation temporelle, un filtre par service et un panneau de tops erreurs. Exporter le dashboard et documenter la requête KQL utilisée.
Répondre à cinq questions sur les data views, les filtres et les dashboards, puis reproduire une investigation à partir d’un export de logs.
Les langages et les APIs sont essentiels pour développer des applications Big Data.
L'écosystème Big Data est composé d'une multitude d'outils spécialisés conçus pour traiter, stocker et analyser des volumes massifs de données. Cette section présente les principales catégories d'outils et leurs cas d'utilisation spécifiques.
Solutions pour le stockage distribué et évolutif de grands volumes de données non structurées et semi-structurées.
Frameworks pour le traitement distribué de grands ensembles de données, en mode batch ou en temps réel.
Plateformes pour le traitement et l'analyse de flux de données en continu avec une faible latence.
Les bases de données NoSQL (Not Only SQL) sont devenues essentielles pour gérer efficacement les défis du Big Data. Contrairement aux bases de données relationnelles traditionnelles, elles offrent une grande flexibilité, une évolutivité horizontale et des modèles de données adaptés à des cas d'utilisation spécifiques.
Stockage de documents JSON/BSON flexibles
Ex: MongoDB, CouchDBOptimisé pour les requêtes sur de grandes tables
Ex: Cassandra, HBaseIdéal pour les données fortement connectées
Ex: Neo4j, ArangoDBHautes performances pour accès simples
Ex: Redis, DynamoDBBase de données orientée documents leader du marché, idéale pour des applications évolutives et des données complexes.
Base de données distribuée conçue pour gérer de grandes quantités de données sur plusieurs serveurs.
Base de données distribuée et évolutive inspirée de Google Bigtable, conçue pour Hadoop.
Le Cloud a révolutionné la manière dont les entreprises gèrent et analysent leurs données massives. Les plateformes cloud offrent des solutions évolutives, flexibles et économiques pour le Big Data, éliminant la nécessité d'infrastructures coûteuses et complexes.
Montez ou descendez en puissance selon vos besoins
Payez uniquement pour les ressources consommées
Infrastructures certifiées et conformes
Ressources hautes performances disponibles à la demande
La plateforme cloud la plus complète et la plus largement adoptée
Service géré pour le traitement de données à grande échelle avec Apache Spark, Hadoop, Hive et plus.
Entrepôt de données rapide, simple et économique pour analyser toutes vos données.
Service de requêtes interactif sans serveur qui simplifie l'analyse de données dans S3 avec SQL standard.
L'infrastructure qui alimente les services Google
Service géré pour exécuter Apache Spark, Hadoop et plus de 30 outils open source.
Entrepôt de données serverless, hautement évolutif et économique pour l'analytique.
Service serverless de traitement de flux et par lots basé sur Apache Beam.
La solution cloud hybride complète pour les entreprises
Service cloud entièrement géré et complet pour les charges de travail open source.
Service d'analytique illimité qui réunit l'entreposage de données et le Big Data.
Plateforme d'analytique basée sur Apache Spark, optimisée pour Azure.
Analyse des charges de travail existantes et des dépendances
Définition de l'architecture cible et du plan de migration
Transfert des données et des applications vers le cloud
Ajustement des performances et des coûts en continu
Dans l'univers du Big Data, les données sont partout : des résultats de matchs de football ⚽ aux messages passionnés des supporters sur les réseaux sociaux 📱. Ce projet vous plonge au cœur d'un cas pratique d'analyse de données à grande échelle.
Mettre en place un système de collecte de données à partir de sources variées (réseaux sociaux, API, etc.)
Utiliser Kafka pour le streaming de données et Spark pour le traitement distribué
Implémenter un modèle d'analyse de sentiments pour évaluer l'opinion des supporters
Créer des tableaux de bord interactifs avec Grafana pour suivre les tendances en temps réel
Mise en place des connecteurs pour récupérer les données des réseaux sociaux et autres sources pertinentes.
Configuration du système de messagerie pour le streaming des données en temps réel.
Développement des jobs Spark pour le traitement distribué des données.
Intégration d'un modèle d'analyse de sentiments pour évaluer les opinions des supporters.
Création de tableaux de bord interactifs pour suivre les tendances en temps réel.
Pour approfondir ou mettre en pratique, plusieurs ressources et jeux de données sont proposés.
La certification en Big Data valide vos compétences dans la conception, la mise en œuvre et la gestion de solutions Big Data. Elle atteste de votre maîtrise des concepts fondamentaux et des technologies clés du domaine.
Délivrée par AFIP Formation
La certification est valable 2 ans. Un programme de recertification est disponible pour maintenir vos compétences à jour.
Valorisez votre CV et démarquez-vous sur le marché de l'emploi
Accès à une communauté d'experts certifiés
Opportunités d'avancement et de meilleures rémunérations
Suivez l'ensemble des modules du cours et participez aux ateliers pratiques.
Réalisez les exercices et travaux pratiques proposés pour chaque module.
Concevez et implémentez un projet pratique qui démontre vos compétences.
Participez aux sessions de révision et testez-vous avec des examens blancs.
Publié le 09/05/2025 — mis à jour le 15/10/2026