Calcul Distribué avec Spark
ENSA Khouribga
Pr. SOUSSI Nassima
Bases de Données NoSQL & Calcul Distribué [Link]@[Link]
: Introduction :
Types de traitement des Big Data
Bases de Données NoSQL & Calcul Distribué 2
Types de traitement des Big Data
Big Data : Types de traitement
1. Batch Processing = Traitement par lot
Traitement de la totalité de données déjà stockée dans le système de
stockage. Ex : Hadoop, Spark
2. Stream Processing = Traitement par flux
Micro-batch Processing : après un certain temps ou l’atteinte
d’une certaine taille, le système lance le traitement.
Ex: Spark Streaming
Native Processing : on traite chaque enregistrement arrivée en
temps réel. Ex: Flink, Storm
Bases de Données NoSQL & Calcul Distribué 3
Types de traitement des Big Data
Big Data : Types de traitement
2. Stream Processing :
Système Temps Réel
On dit « Temps réel » par abus de langage, mais ne signifie pas que
le traitement va être réalisé immédiatement
Extrêmement strict en terme de temps durant lequel le système est
censé réalisé une tache.
Très utilisé par les systèmes de production.
Bases de Données NoSQL & Calcul Distribué 4
Types de traitement des Big Data
Big Data : Types de traitement
2. Stream Processing :
Problème : Perte de donnée; temps de traitement de données doit
être proportionnel au vitesse de flux de données.
Solution : on ajoute un système d’ingestion qui stocke les données
arrivées dans une ou plusieurs files d’attentes pour être consommer
petit à petit.
Ces files d’attentes sont catégorisé par taille ou par sujet.
Ex : Kafka
Bases de Données NoSQL & Calcul Distribué 5
SPARK
Bases de Données NoSQL & Calcul Distribué 6
Définitions et concepts de base
Bases de Données NoSQL & Calcul Distribué 7
Calculs Distribués : Spark
Spark : Généralité
‒ Spark est un Framework de traitement de données distribués in-memory
développé en langage Scala.
‒ Réalise des traitement par lot (Batch) et à la volée (Streaming)
‒ Il se combine très bien avec des clusters Hadoop (en HDFS).
‒ Permet d’intégrer tous les outils et technologies Big Data.
‒ Offre des API de haut niveau en Java, Scala, Python et R.
‒ Il écrit les données en RAM, et non sur disque : ce qui permet
d’augmenter les performances des applications analytiques du Big Data
en utilisant un principe abstrait de mémoire partagée dite RDD.
Bases de Données NoSQL & Calcul Distribué 8
Calculs Distribués : Spark
RDD : Resilient Distributed Datasets
Resilient :
Le terme résilient fait référence à la capacité du RDD à résister aux
pannes.
Il est résilient (ou auto-résilient plus précisément), car les RDD sont
capables de se reconstruire en cas de panne.
Si une partition du RDD est perdue, Spark peut recalculer cette
partition à partir de l'historique des transformations appliquées.
même en cas perte de données, le traitement peut continuer sans
avoir à redémarrer tout le processus, car les RDD sont capables
d’être récupérer automatiquement.
Bases de Données NoSQL & Calcul Distribué 9
Calculs Distribués : Spark
RDD : Resilient Distributed Datasets
Distributed :
Les RDD sont distribués à travers plusieurs nœuds d’un cluster.
Cela signifie que les données contenues dans le RDD sont réparties
en plusieurs (portions de données), chacune traitée indépendamment
sur différents nœuds.
Ce partage des données permet à Spark d'exécuter des calculs en
parallèle sur de vastes ensembles de données, ce qui accélère
considérablement le temps de traitement.
Bases de Données NoSQL & Calcul Distribué 10
Calculs Distribués : Spark
RDD : Resilient Distributed Datasets
Dataset :
Un RDD est une collection de données qui peut contenir
différents types d’objets (par exemple, des lignes d’un fichier,
des objets Scala/Python, etc.).
Chaque RDD représente un groupe de données que Spark peut
manipuler et transformer à travers des opérations parallèles.
Bases de Données NoSQL & Calcul Distribué 11
Calculs Distribués : Spark
RDD : Définition
Bases de Données NoSQL & Calcul Distribué 12
Calculs Distribués : Spark
RDD : Sources de création
Le RDD est simple à créer et peut être obtenu à partir de
multiples sources :
Une collection (List, Set)
Un fichier local ou distribué (HDFS)
Une base de données: BDR, NoSQL …
Un autre RDD auquel on aura appliqué une transformation
(un filtre, un mapping…).
Bases de Données NoSQL & Calcul Distribué 13
Calculs Distribués : Spark
RDD : Opérations
On distingue deux opérations de base qui peuvent être effectuées
sur les RDD :
1. Transformations : des opérations qui créent un nouveau
RDD à partir des instances de RDD existants.
2. Actions : des fonctions qui retourne des valeurs à la fin du
traitement.
Bases de Données NoSQL & Calcul Distribué 14
Calculs Distribués : Spark
RDD : Opérations
Bases de Données NoSQL & Calcul Distribué 15
Calculs Distribués : Spark
RDD : Opérations
1. Transformations : Exemple
Fonction Description
Map() Crée un nouveau RDD en appliquant la fonction à chaque élément du RDD
Filter() Crée un nouveau RDD contenant les données répondant aux conditions de filtre
Sample() Crée un nouveau RDD constitué d’un échantillon de données du RDD source.
Groupbykey() Effectue une opération GroupBy()
Reducebykey() Effectue une opération Reduce()
Union() Union de deux ou plusieurs RDD
Bases de Données NoSQL & Calcul Distribué 16
Calculs Distribués : Spark
RDD : Opérations
2. Actions : Exemple
Fonction Description
Count() Compte le nombre d’éléments présents dans le RDD
Reduce() Effectue une agrégation entre les éléments du RDD.
Save() Persiste les données du RDD sur le disque dur
Persist() “Persiste” les données du RDD en mémoire
Sum() Effectue une somme des éléments du RDD
Foreach() Permet d’effectuer des actions spécifiques pour chaque élément du RDD
Retourner toutes les lignes du Dataset comme un tableau. À utiliser seulement si
Collect()
le Dataset a un volume faible.
Bases de Données NoSQL & Calcul Distribué 17
Calculs Distribués : Spark
RDD : Caractéristiques
1. Lazy computations : les données ne sont pas chargées depuis la
source tant que cela n’est pas nécessaire.
les calculs exécutés sur les RDD sont « paresseux » => Spark exécute
les expressions uniquement lorsqu’elles sont nécessaires.
Techniquement, c’est lorsqu’une action est déclenchée sur le RDD
que celui-ci est exécuté.
Ceci évite les exécutions de code coûteuses et inutiles et améliore
grandement les performances de l’application.
Bases de Données NoSQL & Calcul Distribué 18
Calculs Distribués : Spark
RDD : Caractéristiques
2. Immutable et partitionné : les RDD sont immutables.
‒ Les RDD sont composés d'une collection d'enregistrements qui sont
partitionnés.
‒ La partition est l'unité de base du parallélisme dans un RDD, et
chaque partition est une division logique de données qui est immuable =>
elle est accessibles uniquement en lecture.
Cela signifie qu’on ne peut donc pas modifier un RDD mais on
peut créer de nouveaux RDD en effectuant des transformations sur les
RDD existants.
Bases de Données NoSQL & Calcul Distribué 19
Calculs Distribués : Spark
RDD : Caractéristiques
3. In-memory computation : les RDD sont exécutés en mémoire.
Hadoop fait plusieurs lectures/écritures disque alors que Spark en limite
beaucoup et stocke les données des étapes intermédiaires en mémoire.
Accès Rapide
Traitement
Hadoop
Traitement
In Memory
Bases de Données NoSQL & Calcul Distribué 20
Calculs Distribués : Spark
RDD : Caractéristiques
3. In-memory computation :
Cas 1 : RDD non persisté
Par défaut, les RDD ne sont pas stockés en mémoire une fois que leur
utilisation est terminée, sauf si vous avez explicitement demandé leur
mise en cache (via cache() ou persist()).
Bases de Données NoSQL & Calcul Distribué 21
Calculs Distribués : Spark
RDD : Caractéristiques
3. In-memory computation :
Cas 2 : RDD mis en cache ou persisté
˗ Si vous avez explicitement mis un RDD en cache ou en persistance, Spark
garde ce RDD en mémoire (ou sur disque) afin de réutiliser les données sans
les recalculer.
˗ Si, à un moment donné, la mémoire devient insuffisante pour conserver tous
les RDD mis en cache, Spark peut utiliser un algorithme de LRU (Least
Recently Used) pour évincer les RDD les moins utilisés de la mémoire,
tout en gardant la possibilité de les recalculer à partir du graphe de lignage
si nécessaire.
Bases de Données NoSQL & Calcul Distribué 22
Calculs Distribués : Spark
RDD : Caractéristiques
3. In-memory computation :
Suppression d’un RDD
˗ Si vous cachez un RDD et qu’il n’est plus nécessaire après un certain
point du programme, vous pouvez également utiliser la méthode
unpersist() pour le supprimer manuellement de la mémoire, évitant ainsi
toute surcharge inutile.
˗ Si vous n’utilisez plus un RDD et que vous ne l'avez pas mis en cache ou
en persistance, Spark le libère automatiquement après son utilisation.
Bases de Données NoSQL & Calcul Distribué 23
Calculs Distribués : Spark
RDD : Persistance
On persiste un RDD dans les cas suivants:
1. Un RDD très utilisé
2. Un RDD crucial
On distingue plusieurs types de persistance :
1. Mémoire uniquement : pratique si on réutilisera ce RDD
plusieurs fois
2. Mémoire et disque : augmente la résilience du système
3. Disque : sauvegarder un RDD en cas de panne
Bases de Données NoSQL & Calcul Distribué 24
Concepts
de
Lineage et DAG
Bases de Données NoSQL & Calcul Distribué 25
Calculs Distribués : Spark
Lineage : Définition
Le lineage est un plan logique qui représente la série de transformations
appliquées à un RDD pour produire un nouveau RDD.
Spark conserve une trace de toutes les opérations effectuées sur les données
à partir de leur source initiale jusqu'au résultat final.
Grâce au lineage, Spark peut éviter de stocker systématiquement les résultats
intermédiaires sur le disque, car en cas de panne, il est capable de recalculer
les partitions perdues en suivant l'historique des transformations.
Lignée = structure logique qui garde une trace des transformations.
Bases de Données NoSQL & Calcul Distribué 26
Calculs Distribués : Spark
Lineage : Rôle
Le lineage est principalement utilisé pour assurer la tolérance aux pannes.
Le lineage permet de reconstruire n'importe quel RDD à partir de son origine
en cas de perte de données ou de défaillance du nœud.
Si une partition de données est perdue (par exemple, en raison d'une panne
de nœud), Spark utilise le graphe de lineage pour recalculer uniquement les
partitions perdues à partir des données d'origine, sans avoir à redémarrer
tout le processus.
La lignée permet à Spark de ne pas avoir besoin de stocker les résultats
intermédiaires sur disque.
Bases de Données NoSQL & Calcul Distribué 27
Calculs Distribués : Spark
Lineage : Exemple
Remarque : Pour afficher le ligneage, utiliser : rdd_name.toDebugString()
Bases de Données NoSQL & Calcul Distribué 28
Calculs Distribués : Spark
Lineage : Remarques
La lignée est stockée dans le nœud driver comme une structure de
données logique car il est responsable de la planification des tâches et des
transformations.
Le driver gère l'enchaînement des transformations sans les exécuter
jusqu’à ce qu'une action soit appelée.
Les nœuds workers ne stockent pas la lignée. Ils exécutent simplement
les tâches physiques définies par le DAG et renvoient les résultats au
driver.
Bases de Données NoSQL & Calcul Distribué 29
Calculs Distribués : Spark
Lineage : Remarques
La lignée se crée lors de la définition des transformations dans le
programme Spark, avant l'exécution.
La lignée est temporaire car elle n’est nécessaire que pendant le cycle
de vie de l'application Spark.
Après la fin de l'application ou après avoir effectué une action finale,
la lignée est libérée de la mémoire et n’est plus nécessaire.
Bases de Données NoSQL & Calcul Distribué 30
Calculs Distribués : Spark
Lineage : Résumé
!!! Attention !!!
la lignée de RDD n’enregistre pas les données, mais le flux
d’opérations qui permettent d’obtenir les données.
La lignée est très importante, c’est la clé de la tolérance aux pannes
de Spark …
Ce qui traduit la rapidité du système.
Bases de Données NoSQL & Calcul Distribué 31
Calculs Distribués : Spark
DAG : Définition
Le DAG (Directed Acyclic Graph) est un plan physique sous la forme
d’un graphe qui montre l’ordre d’exécution des différentes étapes d’un
programme Spark.
Il est constitué de nœuds, qui représentent les opérations, et de liens entre
ces nœuds, qui montrent les dépendances entre les opérations.
Le DAG permet de diviser le travail en petites tâches indépendantes qui
peuvent être exécutées en parallèle sur différents nœuds du cluster
Le DAG est un plan d’exécution physique que Spark va distribuer
aux différents nœuds du cluster pour effectuer les calculs.
Bases de Données NoSQL & Calcul Distribué 32
Calculs Distribués : Spark
DAG : Fonctionnement
Lorsqu'une action est appelée, Spark crée le DAG (à partir du lignée) et le soumet
au DAG Scheduler, un composant de Spark qui divise le DAG en stages (unité
d'organisation du calcul).
Chaque stage correspond à une séquence de transformations qui peuvent être
exécutées ensemble sans nécessiter de redistribution des données entre les
différents nœuds du cluster.
Chaque stage est ensuite subdivisé en plusieurs tâches (tasks)
Une tâche dans Spark est une unité de travail qui exécute une transformation sur
une partition spécifique d'un RDD. Lorsqu'une transformation est appliquée à un
RDD, Spark crée une tâche pour chaque partition de ce RDD. Ces tâches sont
ensuite exécutées en parallèle sur différents nœuds du cluster.
Bases de Données NoSQL & Calcul Distribué 33
Calculs Distribués : Spark
DAG : Exemple
DAG est une série d'étapes logiques qui
définissent comment Spark doit transformer les
données d'entrée pour produire le résultat final.
Boite Bleu : Opération Spark
Point Noire : RDD crée
Point Vert : RDD mise en cache
dans une étape(stage)
Bases de Données NoSQL & Calcul Distribué 34
Calculs Distribués : Spark
But du DAG : Tolérance aux pannes
Etape 1 : Détection de la panne
Lorsqu’un nœud du cluster tombe en panne, certaines partitions de
données peuvent être perdues.
Etape 2 : Identification des partitions perdues
Spark analyse le DAG pour identifier les étapes (stages) et partitions
affectées par la panne.
Le DAG permet à Spark de déterminer précisément quelles parties du
traitement doivent être recalculées.
Bases de Données NoSQL & Calcul Distribué 35
Calculs Distribués : Spark
But du DAG : Tolérance aux pannes
Etape 3 : Recalcul des partitions manquantes
Une fois les partitions manquantes identifiées, Spark utilise la lignée pour
recalculer uniquement les partitions manquantes, en rejouant les
transformations depuis les données sources ou un checkpoint, selon la
situation.
Remarque : Si certaines étapes ou partitions sont déjà présentes en mémoire
ou sur disque, grâce à la persistance ou aux checkpoints, Spark ne les
recalculera pas. Le DAG permet d'optimiser en ne relançant que les étapes
pertinentes.
Bases de Données NoSQL & Calcul Distribué 36
Calculs Distribués : Spark
Lineage vs. DAG
Critère Lineage DAG
Suivi des transformations Graphe acyclique dirigé qui
appliquées aux RDD, permettant représente le flux de
Définition
de reconstruire les données dépendances entre différentes
perdues. opérations.
Garantir la tolérance aux pannes en Optimiser l'exécution des
retraçant les transformations pour tâches en fonction des
Objectif principal recomputer les données en cas dépendances entre les
d'échec. opérations sur les
RDD/DataFrames.
Bases de Données NoSQL & Calcul Distribué 37
Calculs Distribués : Spark
Lineage vs. DAG
Critère Lineage DAG
Permet de reconstruire les RDD Planifie les tâches
perdus sans avoir à réexécuter d'exécution en fonction des
Tolérance aux pannes tout le workflow. dépendances définies, mais
ne gère pas directement la
tolérance aux pannes.
Fournir un mécanisme pour Organiser et planifier
suivre l'historique des l'exécution des tâches dans
Rôle
opérations sur les RDD. Spark pour maximiser
l'efficacité.
Bases de Données NoSQL & Calcul Distribué 38
Architecture de l’eco-système
Spark
Bases de Données NoSQL & Calcul Distribué 39
Calculs Distribués : Spark
Spark : Architecture
Bases de Données NoSQL & Calcul Distribué 40
Calculs Distribués : Spark
Spark : Architecture
‒ Spark s’exécute en mode maître-esclave : un master et un ou
plusieurs workers.
‒ Lorsque vous lancez un traitement sur le framework Spark, vous passez
par le Driver qui est en quelque sorte le master:
Driver = lance et coordonne plusieurs tâches sur le cluster en
communiquant avec le Cluster Manager.
Cluster Manager = gère les ressources des workers.
Workers = processus indépendants qui exécutent les tâches de calcul
Bases de Données NoSQL & Calcul Distribué 41
Calculs Distribués : Spark
Spark : Architecture
SparkContext :
‒ C’est le point d’accès à toutes les fonctionnalités de Spark.
‒ Il est utilisé par le Driver pour se connecter au gestionnaire du
Cluster afin de communiquer et de soumettre des jobs Spark.
Grâce à SparkContext, le driver peut instancier d’autres contextes
tels que SQLContext, HiveContext et StreamingContext, etc.
‒ Il fournit des méthodes pour créer des RDD.
Bases de Données NoSQL & Calcul Distribué 42
Calculs Distribués : Spark
Spark : Ecosystème
Bases de Données NoSQL & Calcul Distribué 43
Calculs Distribués : Spark
Spark : Ecosystème
Spark Core : est le cœur de l'écosystème Apache Spark et constitue la base
sur laquelle sont construites toutes les autres bibliothèques de Spark. Voici ses
rôles principaux :
- Gestion du traitement distribué : Il est responsable de l'exécution parallèle
et de la gestion des tâches sur les différents nœuds d'un cluster.
- API de programmation pour des langages comme Scala, Java, Python et R.
- Gestion de la résilience (mécanisme de tolérance aux pannes).
- Gestion de la mémoire à travers des structures comme les RDD.
- Ordonnancement des tâches et d'autres aspects liés à l'exécution distribuée.
Bases de Données NoSQL & Calcul Distribué 44
Calculs Distribués : Spark
Spark : Ecosystème
Spark SQL : étend les capacités de Spark Core en permettant le traitement des
données structurées et semi-structurées. Voici ses rôles principaux :
- Exécution des requêtes SQL sur des données distribuées.
- Utilisation des concepts de DataFrames et DataSets pour faciliter le
traitement des données structurées.
- Optimisation automatique des requêtes par le moteur Catalyst afin
d’améliorer ses performances.
- Support de nombreuses sources de données tel que CSV, JSON, Parquet,
ORC, Hive, et bien d'autres.
Bases de Données NoSQL & Calcul Distribué 45
Calculs Distribués : Spark
Spark : Ecosystème
Spark Streaming : permet un traitement à la volée du flux de
données (Micro-batch processing)
MLib : bibliothèque qui implémente un ensemble
d’algorithmes de ML les plus connus et les plus utilisés.
GraphX : pour le traitement de données sous la forme des
graphes.
Bases de Données NoSQL & Calcul Distribué 46
Calculs Distribués : Spark
Spark : Ecosystème
La dernière couche est dédié à l’interaction avec le système de
fichier qui permet d’associer le job à la partie de stockage approprié.
Elle est dite gestionnaire de ressource ou ordonnanceur
Standalone Scheduler : ordonnanceur de Spark
YARN : pour établir la connexion avec l’HDFS
MESOS : pour les systèmes distribués
Bases de Données NoSQL & Calcul Distribué 47
Calculs Distribués : Spark
Spark : Avantages
‒ Performance de traitement élevé : 100 fois plus rapidement que
Hadoop MapReduce pour un traitement en batch avec 10 fois moins de
ressources physiques).
‒ Tolérance aux pannes efficace (Principe de lignée)
‒ Traitement à la volée (Spark Streaming)
‒ L’évaluation paresseuse (lazy Evaluations)
‒ Support de plusieurs langages
‒ Meilleure intégration avec Hadoop grâce au gestionnaire de
ressource YARN.
Bases de Données NoSQL & Calcul Distribué 48
Calculs Distribués : Spark
Spark : Limitations
‒ Pas de support de traitement en temps réel
‒ Pas de systèmes de gestion des fichiers
‒ Couteux en terme de RAM
‒ La biblio Mlib n’est pas très à jour par rapport aux avancés
technologiques du ML : Nombre d’algorithmes prédéfinis est
assez limité
Bases de Données NoSQL & Calcul Distribué 49
Calculs Distribués : Spark
Spark : Avantages
Remarque:
Spark n’a pas pour vocation de remplacer Hadoop,
mais de fournir une solution unifiée et compréhensible
pour gérer différents cas d’usage Big Data.
Bases de Données NoSQL & Calcul Distribué 50
