Méga Data II

MOUNTASSER IMADEDDINE
(imountasser@[Link])

Année Universitaire: 2023/2024

Informations de Base
 Objectifs:
Partie 1 : Etudier la plateforme Apache Spark
- Comprendre et Manipuler les RDDs
- Interagir avec les BDs (Spark SQL)
- Traiter les graphs avec Spark (GraphX)
- Traiter les données en temps réel (Saprk Streaming)
- Faire du Machine Learing sous Spark (Spark Mllib)
Partie 2 : Etudier les BDs NoSQL
- Etudier les différents formats de stockage
- BD orientée Colonnes (Hbase ou Cassandra)
- BD orientée Documents (MongoDB)
- BD orientée Graphe (Neo4j)
 Prérequis:
Fondamentaux des Big Data.
Base de Données.
 Mode d’évaluation:
Evaluation (Examen, Projets). 2
Plan du Cours
I. Introduction
1. Qu'est-ce que Spark ?
2. Avantages de l'utilisation de Spark
3. Domaines d’utilisation
4. Comment Interagir avec Spark

II. Architecture Applicative de Spark (Spark Ops)

1. Spark Unified Stack – Pile Spark
2. Composants Exécutifs de l’Architecture Spark
3. Gestion de Ressources dans un Cluster Spark
4. Configuration d’une Application Spark

III. Programmation avec Apache Spark

1. Resilient Distributed Dataset - RDD
2. RDD Manipulation (Transformations & Actions)
3. Chargement et Sauvegarde de Données
4. Programmation Avancée

3
Introduction Préliminaires

Framework permettant le stockage et le traitement distribué

d'ensembles de données extrêmement volumineux

• Open Source. • Vitesse de traitement lente.

• Haute Disponibilité (Data Availability). • Pas de traitement en temps réel.
• Evolutivité (Scalability). • Pas de traitement itératif.
• Tolérance aux pannes (Fault Tolerance). • Pas de traitement interactif.
• Fiabilité des données. • Difficulté d'utilisation.
• Utilisation du matériel de base.

4
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.
Limitation 1: Vitesse de traitement lente
À chaque étape du traitement:
• MapReduce lit et écrit les données intermédiaires sur le disque.
• Cette recherche sur le disque prend du temps et augmente la latence.
• Rend l'ensemble du processus très lent (90% du temps est consacré à
effectuer des opérations de lecture-écriture HDFS).
• Non adapté aux requêtes interactives et applications en temps réel et à
faible latence.
Solution:
Spark traite les données en mémoire, ce qui le rend 100 fois plus rapide
que Hadoop.
• Spark lit les données et les écrit dans la mémoire vive (RAM).
• Eviter la surcharge d’E/S et du réseau (Aucun temps n'est consacré au
déplacement des données/processus vers et depuis le disque).
• Rend le traitement plus rapide. 5
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.

Limitation 2: Pas de traitement en temps réel

• Hadoop n'est pas en mesure de traiter des données en temps réel.
• Hadoop ne prend en charge que le traitement par lots (batch
processing).
• Hadoop charge le fichier HDFS dans sa globalité.
• Hadoop ne traite pas les données diffusées en continu (Stream
processing).

Solution:
Spark prend en charge le traitement en temps réel.
• Spark traite les flux de données entrants en formant des micro-lots.
• Spark applique des traitements sur ces micro-lots.
• Rend le traitement plus rapide.
6
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.
Limitation 3: Pas de traitement itératif
• Le traitement itératif nécessite un flux de données cyclique.
• Les algorithmes itératifs appliquent des opérations de manière répétée sur les
données (la sortie d'une étape précédente sert d'entrée à l'étape suivante).
• Ils nécessitent un partage de données plus rapide entre des tâches parallèles.
• Le partage de données est lent dans Hadoop en raison de la réplication, de la
sérialisation et des E/S disque.

7
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.
Solution:
Spark prend en charge le traitement itératif.
• Chaque itération doit être programmée et exécutée séparément.
• Les résultats intermédiaires sont stockés dans une mémoire distribuée au
lieu d'un stockage stable (disque).
• Grâce à une collection d’éléments répartis sur un cluster de nœuds (RDDs).
• Spark bénéficie de la mise en cache des RDDs au fil des itérations.
• RDD prend en charge le traitement en mémoire.

8
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.
Limitation 4: Pas de traitement interactif
• Des requêtes ad-hoc sont exécutées sur le même sous-ensemble de données.
• Chaque requête effectuera des E/S disque sur le stockage stable.
• Domine le temps d'exécution de l'application.

9
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.

Solution:
• Différentes requêtes peuvent s’exécuter à plusieurs reprises sur le
même ensemble de données.
• Ces données particulières peuvent être conservées en mémoire pour
de meilleurs temps d'exécution.

10
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.
Limitation 5: Pas facile à utiliser « Programmation »
• Hadoop n'a aucun type d'abstraction.
• Les développeurs doivent coder manuellement chaque opération.
• Augmente le nombre de lignes à coder et le rend difficile à utiliser.
• Hadoop est entièrement écrit en Java (Maitrise de l’API Hadoop).

Solution:
• Spark est facile à programmer en fournissant des APIs de haut niveau
(plus de 80 opérateurs de traitement de données).
• Réduire le nombre de lignes de code pour obtenir le même résultat.
• Ces opérateurs (APIs) sont disponibles dans plusieurs langages: Java,
Scala, Python et R.
• Spark est accessible à un public beaucoup plus large (communauté
scientifique, développeurs, data scientists et data analysts).
11
Introduction Préliminaires
Exemple:
Programme Word Count démontrant la concision et la simplicité de Spark.

12
Introduction Préliminaires

Apache Spark a été créé comme une alternative à l'utilisation de

MapReduce traditionnel sur Hadoop.

Limitation 5: Pas facile à utiliser « Débogage »

• Hadoop ne fournit pas de mode interactif.
• Rend également le débogage difficile si le programme échoue.

Solution:
• Spark possède un mode interactif.
• Le Shell Spark [REPL] offre une console interactive qui peut être
utilisée pour l'expérimentation et le test d'idées.
• Pas besoin de compilation et de déploiement, pour découvrir que
quelque chose ne fonctionne pas.
• Facilite le débogage.

13
Introduction Préliminaires

Apache Hadoop fournit un moteur de traitement MapReduce à deux étapes

basé sur le disque

Apache Spark est un moteur de traitement polyvalent à plusieurs étapes

basé sur la mémoire

14
Introduction Avantages

Spark est un moteur général (Platforme) de traitement de données

distribué, polyvalent, résilient, évolutif, fiable et très performant:
► Permet de créer des routines complexes de traitement de données en
plusieurs étapes.
► Fournit une API de haut niveau (Abstraction de programmation).
► Fournit un cadre tolérant aux pannes permettant de se concentrer sur la
logique plutôt que sur les problèmes d'infrastructure ou
d'environnement.
► Multiplateforme (S'appuie sur la JVM et son moteur d'exécution).
► Met en œuvre des structures en mémoire distribuées (RDDs).
► Réutilise ces structures pour assurer les opérations itératives et les
requêtes interactives.
15
Introduction Avantages

Spark est conçu pour la vitesse, la facilité d'utilisation et la flexibilité:

֎ Flexibilité (Polyvalence):
• Spark offre une seule pile de traitement de données unifiée.
• Cette pile aide à résoudre plusieurs scénarios (workloads) de
traitement de données:
- Traitement par lots (Batch Processing).
- Requêtes interactives.
- Traitement itératif requis par les algorithmes ML.
- Traitement en continu en temps réel (Stream Processing).
• Cette pile technologique aidera les entreprises à réduire
considérablement les coûts opérationnels et les ressources.
• Elles peuvent utiliser Spark pour la plupart de leurs besoins de
traitement de données.
16
Introduction Avantages

Spark est conçu pour la vitesse, la facilité d'utilisation et la flexibilité:

֎ Adaptabilité:
• Spark s'intègre facilement à l'écosystème du Big Data:
- Solutions de stockage distribués…
- Gestionnaires de cluster…
- Différents formats de stockage…
• Raison pour laquelle l'adoption de Spark a augmenté à un rythme
très rapide (Plus de 500 organisations utilisent Spark en production).

֎ Open Source « Large Communauté »:

• Télécharger le code source pour l’examiner, et comprendre
comment une certaine fonctionnalité a été implémentée.
• Contribuer à développer ou étendre ses fonctionnalités.

17
Introduction Avantages

Spark englobe de nombreux concepts dans un seul environnement de

développement et d'exécution unifié.

► ML qui est si riche en outils et en fonctionnalités en Python (ex.

SciKit-learn) peut désormais être utilisée par les développeurs
Scala (via Spark Mllib).
► Les DataFrames de R sont disponibles dans les API Scala, Java,
Python et R (via SparkSQL).
► Les calculs à nœud unique dans les algorithmes de ML sont migrés
vers leurs versions distribuées (via Spark Mllib).

Spark utilise toujours le même environnement qu’il s’agisse d’une

prédiction, requêtes de données structurées ou ad-hoc, traitement
batch ou en streaming distribué.
18
Introduction Domaines d’utilisation

Spark prend en charge un large éventail d'applications:

 Opérations d'extraction-transformation-chargement (ETL).
 Analyse prédictive et apprentissage automatique (ML).
 Opérations d'accès aux données (Requêtes SQL et visualisations).
 Exploration et traitement du texte.
 Traitement des événements en temps réel (event processing).
 Applications basées sur les graphes.
 Reconnaissance des formes.
 Systèmes de recommandation (RS)

Spark est mieux adapté au traitement analytique en ligne (OLAP).

19
Introduction Limitations
Mais, certaines scénarios ne sont pas appropriés pour Spark…
 Spark n'est pas nécessaire si on ne dispose pas d'une grande quantité de
données, en raison de :
• Son architecture distribuée, car Spark apporte nécessairement une
surcharge (overhead) au temps de traitement.
• Il doit passer du temps à configurer les travaux et les tâches.
• Une simple BDR peut être utilisée pour traiter les données plus rapidement
qu'un système distribué que Spark.
 Spark n'a pas été conçu pour les applications de traitement des transactions
en ligne (OLTP):
• N'est pas adapté aux transactions rapides, nombreuses et atomiques.
• Apportant des mises à jour asynchrones des données partagées.
 Exigences matérielles coûteuses: Les coûts associés proviennent du besoin
d'une grande quantité de RAM intégrée aux machines.
 Optimisation manuelle est requise: Les avantages et la puissance de Spark
doivent être optimisés par le développeur. 20
Introduction Aperçu Général

Apache Spark is an open-source parallel distributed

general-purpose cluster-computing framework, with
in-memory Big Data processing engine and
programming interfaces (APIs) for the programming
languages: Scala, Python, Java, and R…

21
Introduction Comment Utiliser Spark
Les programmes Spark peuvent être:
• Exécutés de manière interactive.
• Soumis sous forme de travaux par lots (Batch Jobs), y compris des
travaux en mini-lots et en micro-lots.
 Utilisation Interactive:
• Les shells interactifs sont principalement utilisés pour la découverte et le
développement.
• Des shells de programmation interactifs sont disponibles en Python
(PySpark), R (sparkr) et Scala (spark-shell).

22
Introduction Comment Utiliser Spark
Les programmes Spark peuvent être:
• Exécutés de manière interactive.
• Soumis sous forme de travaux par lots (Batch Jobs), y compris des
travaux en mini-lots et en micro-lots.
 Utilisation non Interactive:
• Les applications peuvent être soumises à l'aide de la commande spark-
submit.
• Cette commande a plus de contrôle sur l'exécution du programme.
• Les tâches de production sont généralement exécutées à l'aide de cette
commande.

23
Introduction Types Entrée/Sortie

Hadoop est la plate-forme la plus couramment utilisée avec Spark, à la

fois comme source de données et comme planificateur de ressources:
• Spark a une prise en charge intégrée pour la lecture et l'écriture de
fichiers vers et depuis HDFS.
• Prenant en charge de nombreux formats de fichiers et codecs de
compression Hadoop.
• Spark fournit une prise en charge native pour exécuter des
applications sur YARN, (i.e. Spark Jobs peuvent coexister et être gérées
avec d'autres Jobs sur un cluster Hadoop).
Spark peut être utilisé avec une multitude d'autres systèmes source et
cible, notamment :
• Systèmes de fichiers locaux ou réseau.
• Stockage d'objets (Amazon S3,…).
• SGBDR.
• BD NoSQL (Apache Cassandra, HBase et autres).
• Systèmes de messagerie (ex. Kafka).
24
Plan du Cours
I. Introduction
1. Qu'est-ce que Spark ?
2. Avantages de l'utilisation de Spark
3. Domaines d’utilisation
4. Comment Interagir avec Spark

II. Architecture Applicative de Spark (Spark Ops)

1. Spark Unified Stack – Pile Spark
2. Composants Exécutifs de l’Architecture Spark
3. Gestion de Ressources dans un Cluster Spark
4. Configuration d’une Application Spark

III. Programmation avec Apache Spark

1. Resilient Distributed Dataset - RDD
2. RDD Manipulation (Transformations & Actions)
3. Chargement et Sauvegarde de Données
4. Programmation Avancée

25
Spark Unified Stack – Pile Spark

26
Architecture Pile Spark

Spark fournit un moteur de traitement de données unifié connu sous le

nom de Pile Spark « Spark Unified Stack ».

Ce moteur unifié apporte des avantages importants dans le contexte de

création d'applications Big Data évolutives et intelligentes:
 Les applications sont plus simples à développer et à déployer car elles
utilisent un ensemble unifié d'API et s'exécutent sur un seul moteur.
 Possibilité de combiner différents types de traitement de données (Batch,
streaming, etc.) sur les mêmes données, dans une seule application Spark,
sans écrire les données intermédiaires sur un système de stockage.

Exemple:
Exécuter des requêtes interactives sur les résultats des prédictions
d'apprentissage automatique (ML) des flux de données (Streams) en temps réel.

27
Architecture Pile Spark

Spark fournit un moteur de traitement de données unifié connu sous le

nom de Pile Spark « Spark Unified Stack ».

Chaque composant est

conçu pour une charge
spécifique de traitement
de données

Cette pile repose sur

Ces composants font de Spark une plateforme fédératrice riche en

fonctionnalités (réalisation de nombreuses tâches qui devaient auparavant être
accomplies avec plusieurs frameworks différents).
28
Architecture Spark Core

Spark Core est le noyau du moteur de traitement de données distribué

Spark. Il offre:
• Fonctionnalités nécessaires pour gérer et exécuter des applications
distribuées (ex. planification, coordination et tolérance aux pannes).
• Abstraction de programmation puissante et générique pour le
traitement des données, i.e. données distribués résilients (RDD).

Fournit une plateforme d'exécution

généralisée pour toutes les applications
Spark.

Toute améliorations ou optimisation effectuée dans Spark Core sera

automatiquement disponible pour les autres composants.

29
Architecture Spark Core

Spark Core est le noyau du moteur de traitement de données distribué

Spark.

֎ Infrastructure Informatique Distribuée:

• Offre les composants responsable de la distribution, de la coordination et
de la planification des tâches sur les machines du cluster.
• Offre les composants pour la gestion de la mémoire et l’interaction avec
les systèmes de stockage (Traitement parallèle).
• Assure la gestion des échecs de tâches (récupération des pannes).
• Assure le déplacement (échange) efficace des données entre les machines,
i.e. le brassage des données « data shuffling ».

30
Architecture Spark Core

Spark Core est le noyau du moteur de traitement de données distribué

Spark.
֎ Abstraction de programmation « RDD »:
• Héberge l'API qui définit les ensembles de données résilients et
distribués (RDD) qui constituent la principale abstraction de
programmation de Spark.
• Fournit de nombreuses API pour créer et manipuler ces RDDs.
• Permet d'effectuer un traitement de données sans se soucier de
l'emplacement des données sur le cluster.
• Les API RDD sont exposées dans plusieurs langages de programmation
(Scala, Java, R et Python).

N.B Chaque développeur Spark devrait avoir une certaine connaissance du

RDD, en particulier ses API et ses principaux concepts.
31
Architecture Spark SQL

Spark SQL est conçu pour le traitement de données structurées à

grande échelle:
• Apporte un nouveau niveau de flexibilité, de facilité d'utilisation et de
performances.
• Permet aux utilisateurs d’exécuter des requêtes SQL (au-dessus de Spark)
pour effectuer le traitement des données.
• Offre une abstraction de haut niveau exposée via les API DataFrames.
• Capable de lire et d'écrire des données dans divers formats structurés et
systèmes de stockage, ex. fichiers JSON et CSV, BDR, Hive, et d'autres.
• Objectif est d'écrire moins de code, de lire moins de données et de
laisser l'optimiseur faire la majorité du travail.

32
Architecture Spark Streaming

Spark Streaming est conçu pour traiter des données de streaming en

temps réel à partir de diverses sources de données d'une manière à
haut débit et tolérante aux pannes:

• Les données peuvent être ingérées à partir de plusieurs sources de

diffusion de données, ex. Kafka, Flume, Twitter, HDFS et d'autres.
• Les données entrantes (flux incrémentiels) sont divisées en petits lots
(mini-batch), chacun est traité comme un RDD et répliqué sur le cluster
pour être traité.
• Offre la capacité de combiner des requêtes par lots et interactives avec le
traitement en continu grâce à la pile Spark unifiée.

Exemple: Flux de données incluent:

• Fichiers journaux générés par les serveurs Web.
• Files d'attente de messages contenant des mises à jour d'état
publiées par les utilisateurs d'un service Web.
33
Architecture Spark MLlib

Spark MLlib fournit des abstractions pour gérer et simplifier de

nombreuses tâches de création de modèles d'apprentissage
automatique (ML):

• Fournit plus de 50 algorithmes d'apprentissage automatique courants.

• Fournit des abstractions: la caractérisation, le pipeline (construction,
évaluation et réglage du modèle), et la persistance des modèles pour
assurer la migration du modèle du développement à la production.
• Basées sur des DataFrames pour profiter de la convivialité et des
optimisations fournies par le moteur Spark SQL (à partir de Spark 2.0).

Une bibliothèque de ML évolutive (cluster de machines) qui offre à la fois

efficacité et algorithme de haute qualité (malgré leurs nature itérative).

34
Architecture Spark GraphX

Spark Graphx permet de manipuler et d’effectuer des calculs parallèles

aux graphes:

• Fournir une abstraction pour créer un graphe orienté avec des propriétés
attachées à chaque sommet et arête.
• Comprend une collection d'algorithmes de traitement de graphes
courants, ex. classements de pages, composants connectés, chemins les
plus courts, etc.

N.B Une structure de données graphique est souvent utilisée pour représenter
des réseaux réels d'entités interconnectées (ex. réseaux sociaux, réseaux de
pages Web connectées sur Internet, etc.).

35
 Composants
Exécutifs de
l’Architecture Spark

36
omposants Exécutifs Spark Cluster

Spark est essentiellement un système distribué conçu pour traiter

efficacement et rapidement un grand volume de données.

Déployé sur un ensemble de machines, appelé Spark Cluster.

• Le cluster peut être d’une petite taille de quelques machines ou

comportant des milliers de machines.

Cet ensemble de machines doivent être géré efficacement et

intelligemment.

Spark s'appuient sur un gestionnaire des ressources.

• Les deux principaux composants d'un gestionnaire des ressources sont

le gestionnaire de cluster et les travailleurs (Workers).

37
omposants Exécutifs Spark Cluster
Le gestionnaire de cluster sait:
• Où se trouvent les nœuds de calcul (Workers)…
• Quantité de mémoire dont ils disposent…
• Nombre de cœurs de processeur (CPU) dont chacun dispose.

Chaque Worker:
• Offre des ressources (mémoire, CPU,…) au gestionnaire de
cluster.
• Effectue le travail assigné.

38
omposants ExécutifsSpark Application
Une application Spark se compose de deux parties:
1. La logique de traitement des données (programme) exprimée à
l'aide des API Spark. Elle peut être:
• Simple (Quelques lignes de code pour effectuer des opérations
de traitement de données).
• Complexe (Modèle de ML nécessitant de nombreuses itérations
et peut s'exécuter pendant plusieurs heures).

2. Le Spark Driver:
• Coordinateur central d'une application Spark.
• Interagit avec un Cluster Manager pour déterminer sur quelles
Workers la logique de traitement de données sera exécutée.

39
omposants Exécutifs Spark Driver
Le Spark Driver permet de:
• Demander au gestionnaire de cluster de lancer un processus
appelé exécuteur Spark (Executor), sur chacune de ces
machines (Workers).
• Gérer et distribuer les tâches Spark (Tasks) sur chaque
exécuteur au nom de l'application.
• Coordonner avec chaque exécuteur pour collecter les résultats
calculés et les fusionner (ex. si le programme invoque un
affichage de résultats).

40
omposants Exécutifs Spark Driver

Lorsque le Driver est exécuté, il remplit deux fonctions:

1. Conversion de la logique de traitement en tâches
• Conversion d'un programme en unités d'exécution physique (i.e. Tâches).
• Prend toutes les opérations codées et crée implicitement un graphe
acyclique dirigé (DAG).
• Il convertit le DAG en un plan d'exécution physique.
• Le plan d'exécution contient un ensemble d'étapes (stages).
• Chaque étape se compose de plusieurs tâches qui seront regroupées et
préparées pour être envoyées au cluster.
• Les étapes dépendent les unes des autres.

Flux de données et
leurs dépendances

41
omposants Exécutifs Spark Driver
Exemple: Analyse d’un fichier Log

Création d’un plan d'exécution

physique pour calculer les RDD
nécessaires à l'exécution.

Exécution

Le programme définie implicitement

un (DAG) d'objets RDD.

42
omposants Exécutifs Spark Driver

Lorsque le Driver est exécuté, il remplit deux fonctions:

2. Planification et orchestration de l'exécution des tâches sur les
exécuteurs
• Coordonner la planification et le déroulement des tâches individuelles
sur les exécuteurs.

• Garder une trace des ressources disponibles pour exécuter les tâches.
− Lorsque les exécuteurs sont démarrés, Ils s'enregistrent auprès du Driver.
− Le Driver dispose à tout moment d'une vue complète de l’état des
exécuteurs de l'application.

• Planification des tâches pour qu'elles s'exécutent "près" des données

(Data Locality):
− Lorsque cela est possible, le Driver examine l'ensemble actuel d'exécuteurs.
− Il tente de planifier chaque tâche à un emplacement approprié, en fonction
du placement des données.

43
omposants Exécutifs Spark Driver

Lorsque le Driver est exécuté, il remplit deux fonctions:

2. Planification et orchestration de l'exécution des tâches sur les
exécuteurs
• Coordonner l'emplacement et le mouvement des données entre les
étapes de traitement.

• Le Driver suit également l'emplacement des données cachées et

l'utilise pour planifier les futures tâches qui accèdent à ces données.
− Les tâches qui s'exécutent peuvent mettre des données en cache.

• Le Driver est également chargé de renvoyer les résultats d'une

application.

• Le Driver expose les informations sur l'application Spark en cours

d'exécution via une interface Web (port 4040).

44
omposants Exécutifs Spark Driver

45
omposants ExécutifsExecutors

Executors sont des processus hôtes (worker processes), lancés par

l’Application Master, responsables d’exécuter la logique de traitement
des données sous forme de tâches.
• Les exécuteurs sont dédiés à une application Spark spécifique.
• La durée de vie d'un exécuteur correspond à la durée d'une application
Spark, qui peut s'exécuter pendant quelques minutes ou quelques jours.
• Les exécuteurs réservent des ressources CPU et de mémoire sur les
nœuds esclaves (workers).
• Un worker a un nombre fini ou fixe d'exécuteurs qui peuvent être alloués
à tout moment.
• Les exécuteurs ne connaissent que les tâches qui leur sont attribuées.
• Chaque exécuteur Spark est un processus JVM.

46
omposants ExécutifsExecutors
Les exécuteurs ont deux rôles:
֎ Ils exécutent les tâches (des centaines ou des milliers) qui composent un
programme et renvoient les résultats au Driver.
• Les tâches sont la plus petite unité de travail planifiable dans un
programme Spark.
• Chaque tâche est exécutée sur un cœur de processeur (CPU core)
distinct.
• C'est ainsi que Spark peut accélérer le traitement d'une grande
quantité de données en les traitant en parallèle.

֎ Ils sont responsable de mettre en cache une partie des données en

mémoire et/ou sur disque lorsque cela est demandé par la logique de
l'application.
• Via un service appelé Block Manager qui réside dans chaque
exécuteur.
47
omposants ExécutifsExecutors
Au moment du lancement d'une application Spark, on peut configurer:
- Le nombre d'exécuteurs approprié dont une application a besoin.
- La quantité de mémoire et le nombre de cœurs CPU que chaque
exécuteur doit avoir (propriété: [Link]).
- Ce paramètre a un impact sur la quantité de données que Spark peut
mettre en cache, et la possibilité d’effectuer des opérations
gourmandes en mémoire (ex. regroupement, agrégations et jointures).

Cette configuration nécessite une certaine compréhension de (Question

de performance et d’optimisation):

- La quantité de données qui sera traitée…

- La complexité de la logique de traitement des données…
- La durée souhaitée pendant laquelle une application Spark doit
compléter la logique de traitement.
48
omposants ExécutifsMaster / Slaves

Spark utilise une architecture maître-esclave, où le Driver est le

maître et les exécuteurs sont les esclaves.
• Chacun de ces composants s'exécute en tant que processus
indépendant sur un cluster Spark.
• Une application Spark se compose d'un seul Driver et d'un ou
plusieurs exécuteurs Spark.
• Le Driver est le composant utilisé par les clients pour soumettre des
applications dans Spark.
Planifie et coordonne les tâches requises
pour exécuter une application Spark

Les tâches s'exécutent dans des exécuteurs,

qui sont hébergés sur des workers

49
omposants ExécutifsSpark Master

Le Spark Master est le processus qui demande des ressources dans le

cluster et les met à la disposition du Driver.

• Le Master négocie des ressources ou des conteneurs avec des nœuds

de travail (workers).
• Le Master suit aussi leur état et surveille leur progression.

N.B. Le Master n'est pas impliqué dans l'exécution de l'application et la

coordination de ses tâches et ses étapes.

Le processus Spark Master sert une interface utilisateur Web sur le port
8080 sur l'hôte maître (Master Node).

50
omposants ExécutifsCluster Manager

Le gestionnaire de cluster est un composant enfichable (pluggable)

dans Spark.
• Il est chargé de surveiller les nœuds de travail (workers).
• Il est responsable de réserver des ressources sur ces nœuds à la
demande du maître (Spark Master).
• Le Master met à son tour ces ressources du cluster à la disposition du
Driver sous la forme d'exécuteurs.

Remarques:
• Le Master et le Cluster Manager sont des processus centraux distincts
qui surveillent, réservent et allouent les ressources de cluster
distribuées sur lesquelles s'exécutent les exécuteurs.
• Le processus Master peut exécuter également les fonctions du
gestionnaire de cluster (mode Standalone).

51
omposants ExécutifsCluster Manager

N.B. Il est important de faire la distinction entre les composants

d'exécution d'application Spark et les emplacements et les types de
nœuds sur lesquels ils s'exécutent.
• Ces composants s'exécutent à différents endroits en utilisant
différents modes de déploiement.
• Il ne faut pas penser à ces composants en termes de nœud
physique.

Spark peut s'exécuter sur différents gestionnaires de cluster:

• Standalone, son gestionnaire de cluster autonome intégré.
• YARN.
• Mesos.
• Kubernetes.
• Cloud (Amazon EC2)
52
omposants ExécutifsCluster Manager

Spark peut s'exécuter sur une variété de gestionnaires de cluster pour

accéder aux machines d'un cluster :

1. Si on souhaite uniquement exécuter Spark seul sur un ensemble de

machines, le mode autonome intégré (Standalone) est le moyen le plus
simple de le déployer.
2. Si vous avez un cluster que vous souhaitez partager avec d'autres
applications distribuées (ex. travaux Spark et des travaux MapReduce),
Spark peut s'exécuter sur deux gestionnaires de cluster populaires:
Hadoop YARN et Apache Mesos.
3. Spark est également livré avec des scripts intégrés qui lancent un cluster
autonome et divers services de support, pour le déploiement sur Amazon
EC2.

53
 Gestion de
Ressources dans un
Cluster Spark

54
Cluster Manager Standalone Manager

Les gestionnaires de Cluster prennent en charge deux modes de

déploiement (i.e. selon l'endroit où le Driver de l’application s'exécute):
► Mode Client (Par défaut):
• Le Driver s'exécute dans la JVM de la machine sur laquelle on exécute
spark-submit.
• Il est possible de voir directement la sortie du Driver ou lui envoyer une
entrée (ex. un shell interactif).
• Nécessite que la machine assure une connectivité rapide avec les
workers et reste disponible pour la durée de l’application.
► Mode Cluster:
• le Driver est lancé dans le cluster en tant que processus sur l'un des
nœuds de travail.
• spark-submit est "fire-and-forget".
• Il est possible de fermer l’ordinateur pendant que l'application est en
cours d'exécution.
55
Cluster Manager Standalone Manager

Le gestionnaire autonome intégré à Spark offre un moyen simple et

rapide pour exécuter des applications sur un cluster.
• Le Cluster se compose d'un Master et de plusieurs Workers, chacun avec
une quantité configurée (à la soumission) de mémoire et de cœurs de
processeur (core CPU).
• Le processus Master agit en tant que gestionnaire de cluster.
• Le Master accepte les applications à exécuter et planifie les ressources
de travail (CPU core) entre elles.
• Spark alloue des ressources en fonction du CPU cores.
• Offre une interface utilisateur Web pour afficher les statistiques de
cluster et de tâches.
• Propose également une sortie de journal détaillée pour chaque tâche.

56
Cluster Manager Standalone Manager
 Mode Cluster s'exécutant sur deux nœuds:

1. Un processus client soumet une

application au Master.

2. Le Master demande à l'un de ses

nœuds de lancer un Driver.

3. Le Nœud génère une JVM du Driver.

4. Le Master demande aux deux nœuds

de lancer des exécuteurs pour
l'application.

5. Les workers génèrent des JVM

d'exécuteurs.

6. Le Driver et les exécuteurs

communiquent indépendamment des
processus du cluster.

57
Cluster Manager Standalone Manager
 Mode Cluster s'exécutant sur deux nœuds:
Remarques:
 Chaque exécuteur dispose d'un certain
nombre de threads (cœurs CPU) qui lui sont
alloués.
 Ce sont les emplacements de tâches
permettant d'exécuter plusieurs tâches en
parallèle.
 Dans un cluster autonome, pour chaque
application, il ne peut y avoir qu'un seul
exécuteur par worker.
 Si on a besoin de plus d'exécuteurs par
machine, il faut démarrer plusieurs
processus worker.
 Une seule application est affichée en cours
d'exécution dans ce cluster.
 S'il y en a plus, chacune aurait son propre
ensemble d'exécuteurs et son driver séparé.

58
Cluster Manager YARN Manager

YARN (Yet Another Resource Negotiator) est la nouvelle génération du

moteur d'exécution MapReduce de Hadoop.

L'architecture YARN de base est similaire à l'architecture de cluster

autonome de Spark. Les principaux composants sont:
• Gestionnaire de ressources (Resource Manager) similaire au processus
Spark Master pour chaque cluster:
− Gère les ressources parmi toutes les applications du système.
− Dispose d'un planificateur et d'un gestionnaire d'applications.
− Le planificateur alloue des ressources aux différentes applications en
cours d'exécution.
− Le planificateur effectue la surveillance et le suivi de l'état de
l'application.
− Le gestionnaire d'applications gère les applications sur tous les
nœuds.

59
Cluster Manager YARN Manager

YARN (Yet Another Resource Negotiator) est la nouvelle génération du

moteur d'exécution MapReduce de Hadoop.

L'architecture YARN de base est similaire à l'architecture de cluster

autonome de Spark. Les principaux composants sont:
• Gestionnaire de ressources (Resource Manager) similaire au processus
Spark Master pour chaque cluster.
• Gestionnaire de nœuds (Node Manager) similaire aux processus Spark
Worker pour chaque nœud du cluster.
− Contient un Application Master (par application) et un conteneur.
− Gère la surveillance des conteneurs et l'utilisation des ressources
(CPU, mémoire, disque et réseau) et le signale au RM.
− Un conteneur est un lieu où se déroule une unité de travail (Chaque
tâche s'exécute dans un conteneur).
− L'Application Master négocie les ressources auprès du Resource
Manager et surveille l’exécution des tâches.
60
Cluster Manager YARN Manager

YARN (Yet Another Resource Negotiator) est la nouvelle génération du

moteur d'exécution MapReduce de Hadoop.

L'architecture YARN de base est similaire à l'architecture de cluster

autonome de Spark. Les principaux composants sont:
• Gestionnaire de ressources (Resource Manager) similaire au processus
Spark Master pour chaque cluster.
• Gestionnaire de nœuds (Node Manager) similaire aux processus Spark
Worker pour chaque nœud du cluster.

YARN est le moteur d'exécution le plus naturel pour de nombreux

utilisateurs Spark potentiels et existants (des installations Hadoop ont
déjà YARN configuré avec HDFS).

N.B. L'exécution d'applications Spark sur YARN ne diffère pas beaucoup

de leur exécution sur d'autres gestionnaires de cluster.
61
Cluster Manager YARN Manager

Spark fournit une prise en charge native pour exécuter des applications
sur YARN, i.e. les charges de travail Spark peuvent coexister et être
gérées avec d'autres charges de travail sur un cluster Hadoop.

Les applications sur YARN s'exécutent dans des conteneurs (processus

JVM auxquels les ressources CPU et mémoire sont accordées).
• Le Spark Driver agit en tant que maître d'application YARN.
• Il est responsable de la demande de ressources d'application auprès
du gestionnaire de ressources.
• Il s'exécute dans son propre conteneur.

Les gestionnaires de nœuds (Node Manager) suivent les ressources

utilisées par les conteneurs et rendent compte au gestionnaire de
ressources (Resource Manager).
62
Cluster Manager YARN Manager
2 RM demande d'abord à un NM de
1 démarrer/allouer un conteneur pour le NMs démarrent les
Le client soumet une Spark Application Master AM 6 exécuteurs au nom du AM
application au Resource
Manager (RM)

• Déploiement en mode
Cluster
• Les clients peuvent interroger
le statut de l'application à • Le processus client
tout moment. reste actif et attend
que l'application se
termine.

• Tuer le processus
3 client n'arrêtera pas
l'application.
Le NM lance le conteneur
pour AM (Spark Driver)

5
AM demande au RM d'allouer 4 AM demande aux NM de 7 Le Spark Driver communique avec
plus de ressources (conteneurs) démarrer les conteneurs les exécuteurs indépendamment 63
à l'application d'exécuteurs des composants YARN
Cluster Manager YARN Manager
Remarques:

► Plusieurs applications peuvent s'exécuter dans un seul cluster YARN.

• Dans ce cas, chaque application a son propre maître d'application AM
(Contrairement au mode autonome).

► Le nombre de conteneurs dépend du type de l'application.

• Étant donné que Spark nécessite un Driver et des exécuteurs, il aura
toujours un conteneur pour le AM (Spark Driver) et un ou plusieurs
conteneurs pour ses exécuteurs.

► Les Nodes Manager de YARN peuvent lancer plusieurs conteneurs

(exécuteurs) par application.
• Contrairement aux Spark Workers (mode Standalone).

64
Cluster Manager YARN Manager
Le client (exécuté en dehors 2 RM demande d'abord à un NM de
du cluster) soumet une démarrer un conteneur pour le maître NMs démarrent les
application au Resource d'application Spark AM 6 exécuteurs au nom du AM
Manager (RM) 1
• Le AM gère l'allocation
des ressources et la com-
munication avec le RM

• Le Driver communique
directement avec les
exécuteurs de Spark

• La communication entre
Spark s'exécutant sur le Driver et le AM est
YARN en mode de désormais nécessaire
déploiement client
• La communication est
réparties entre le AM
et le Driver.

• Tuer le processus client

arrêtera l'application.

NM lance le 3
conteneur pour AM 4 5 7
Le Spark Driver communique avec les
AM demande au RM d'allouer plus de AM demande aux NM de exécuteurs Spark indépendamment 65
ressources (conteneurs) à l'application démarrer les conteneurs des composants YARN
d'exécuteurs
Cluster Manager Mesos Manager

Mesos fournit un noyau de systèmes distribués et fournit des

ressources de cluster de base aux applications.
• Au lieu que les applications demandent des ressources au cluster
(depuis le Master).
• Un cluster Mesos propose des ressources aux applications, qu'elles
peuvent accepter ou refuser.
• Capable de planifier l'espace disque, les ports réseau et même les
ressources personnalisées (pas seulement le CPU et la mémoire).
• Gère la charge de travail dans un environnement distribué par le partage
et l'isolation dynamiques des ressources.

Les frameworks s'exécutant sur Mesos se composent de:

• Planificateur: Accepte ou refuse les ressources offertes par le Mesos
Master et démarre les exécuteurs Mesos sur les esclaves.
• Exécuteur: Exécutent les tâches demandées par les planificateurs. 66
Cluster Manager Mesos Manager
1
Les Mesos Slaves offrent leurs 2 Le planificateur Mesos, exécuté dans un Driver
ressources au Master. s'enregistre auprès du Mesos Master.
Mesos Master offre à son tour les
3 ressources disponibles au planificateur
(cela se produit en continu : 1s).

Le planificateur accepte certaines

4 ressources et envoie une liste de ces
ressources, et une liste des tâches à
exécuter à l'aide des ressources, au
Mesos Master.

Le Master demande aux Slaves de

5 démarrer les tâches avec les
ressources requises.

Les Slaves lancent des exécuteurs

6 Mesos, qui lancent des exécuteurs
Spark dans des conteneurs de tâches.

Les exécuteurs Spark communique

7 librement avec le Driver, et exécutent
leurs tâches.
Spark s'exécutant sur un cluster Mesos
67
(2 nœuds, modes de déploiement: client, granularité: grossière)
Cluster Manager Mesos Manager
FINE-GRAINED Vs COARSE-GRAINED
► Coarse-grained mode (Grossier): Signifie que Spark démarre un
exécuteur Spark par Mesos slaves.
• Ces exécuteurs restent actifs pendant toute la durée de vie de
l'application Spark.
• Ils exécutent des tâches de la même manière que sur YARN et sur le
gestionnaire autonome.
► Fine-grained mode (Affiné): Un exécuteur Spark (et donc une tâche
Mesos), est démarré par tâche Spark.
• Plus de communication…
• Plus de sérialisation des données…
• Plus de configuration des processus d'exécuteur Spark.

Traitements sont susceptibles d'être plus lents en mode affiné qu’en mode
grossier.

68
Cluster Manager Mesos Manager

• Le mode affiné de Spark n'est

disponible que sur Mesos
(mode par Défaut).

• Offre un exécuteur Mesos

personnalisé , i.e. exécuteur Spark
Mesos (uniquement en ce mode).

• Permet d’utiliser les ressources du

cluster de manière plus flexible.

• Permet aux autres frameworks

s'exécutant sur le cluster d'utiliser
certaines des ressources dont
une application Spark n'a peut
être pas besoin actuellement.

• Il est principalement utilisé pour

les Batch ou Streaming Jobs qui
ont des tâches de longue durée.
Spark s'exécutant sur un cluster Mesos
(2 nœuds, modes de déploiement: client, granularité: Affinée) 69
Cluster Manager Mesos Manager
Remarques

► Mesos est similaire à YARN et le gestionnaire Standalone.

► La principale différence est que la planification est Backward

(rétrograde).
► Les applications ne demandent pas, mais acceptent les ressources
offertes par le CM.
► Parfois, Mesos est plus lent que YARN ou un cluster Standalone.

► Un passage en mode à granularité grossière est demandé en

définissant le paramètre [Link] sur true.
► En réalité, le projet Spark a été initialement lancé afin de démontrer
l'utilité de Mesos.

70
Cluster Manager Mode Local

Spark peut fonctionner dans une variété de modes ou environnements

différents.
► Mode Local:
• Mode non distribué, qui n'utilise qu'une seule machine (pseudo-distribué).
• Le Driver, le Master et l'exécuteur s'exécutent tous dans une seule JVM.
• Le parallélisme par défaut est le nombre de threads spécifié, i.e. l’exécuteur
peut générer plusieurs threads pour exécuter des tâches.
• Le nombre de threads détermine le nombre de tâches pouvant être
exécutées en parallèle.
• On peut spécifier plus de threads que de
cœurs de processeur disponibles.
• Multiplier le nombre de cœurs de
processeur par (2 ou 3), donne un bon
point de départ pour ce paramètre.
71
Cluster Manager Mode Local

Spark peut fonctionner dans une variété de modes ou environnements

différents.
► Mode Local:
• Ne nécessite aucune configuration préalable pour lancer les applications
Spark.
• Utile pour le développement, les tests unitaires et le débogage (pas d’accès
à un cluster complet ou essayer quelque chose rapidement).
• Limité lors de l’exécution des applications en production car il n'est pas
distribué et n'est pas évolutif.
• Les tâches ne sont pas réexécutées en cas d'échec (par défaut).
• L'interface utilisateur de l'application est disponible sur
[Link]
• Les interfaces utilisateur Master et Worker ne sont pas disponibles lors de
l'exécution en mode local.
72
Cluster Manager Choix entre CM
► Haute Disponibilité:
Spark Standalone:
• Prend en charge une récupération automatique du master avec ZooKeeper Quorum
(à l'aide du standby master).
• La récupération manuelle est aussi envisageable en utilisant un système de fichiers.
• Le cluster tolère l'échec du worker, même si la récupération du master est activée ou
non.
Apache YARN:
• Prend en charge une récupération automatique du master (via ActiveStandbyElector
intégré dans RM).
• Prend en charge la récupération manuelle (via un utilitaire de ligne de commande).
• Pas nécessaire d'exécuter un contrôleur de basculement ZooKeeper distinct.

Apache Mesos:
• Possède plusieurs Master offrant une tolérance aux pannes (un est le leader).
• Prend en charge une récupération automatique du master (via ZooKeeper).
• En cas de basculement, les tâches en cours d'exécution n'arrêtent pas leur exécution.
73
Cluster Manager Choix entre CM
► Sécurité:
Spark prend en charge l'authentification via un secret partagé avec tous les
gestionnaires de cluster.
Spark Standalone:
• Demande à l'utilisateur de configurer chacun des nœuds avec le secret partagé.
• Les données peuvent être cryptées à l'aide de SSL pour les protocoles de
communication.
• Le cryptage SASL est pris en charge pour les transferts en bloc de données.
• Controle l'accès aux apps dans l'interface Web via des listes de contrôle d'accès.
Apache YARN:
• Offre la sécurité pour l'authentification, l'autorisation de niveau de service,
l'authentification pour les consoles Web et la confidentialité des données.
• L'authentification Hadoop utilise Kerberos pour vérifier que chaque utilisateur et
service dispose d'une authentification.
Apache Mesos:
• Fournit une authentification pour toute entité interagissant avec le cluster.
• Utilise des listes de contrôle pour permettre l'accès aux services dans Mesos Access.
• SSL/TLS peut être activé pour crypter la communication. 74
Cluster Manager Choix entre CM
► Spark Standalone:
• Spécialement conçu pour les applications Spark.
• Moyen le plus simple pour exécuter une application Spark dans un environnement
en cluster.
• Ne prend pas en charge la communication avec un HDFS sécurisé (Authentification
Kerberos). Si ce type de sécurité est requis, YARN est recommandé.
• Permet un démarrage des tâches plus rapide que les tâches exécutées sur YARN.
► YARN Cluster:
• Disponibilité préalable d’un cluster YARN d'une taille importante, du savoir-faire
technique, des outils et des procédures nécessaires pour le gérer et le surveiller.
• Permet d'exécuter différents types d'applications et de mélanger facilement les
anciennes applications Hadoop et Spark.
• Fournit des méthodes pour isoler et hiérarchiser les applications parmi les
utilisateurs et les organisations (non disponible en mode Standalone).
• Pas besoin d'installer Spark sur chaque nœud du cluster.
75
Cluster Manager Choix entre CM
► Mesos Cluster:
• Noyau de systèmes distribués, évolutif et tolérant aux pannes écrit en C++.
• Prend en charge les applications C++ et Python (Contrairement à YARN).
• Permet de planifier d'autres types de ressources (Contrairement à YARN et
Standalone).
• Propose des options supplémentaires pour la planification des tâches que les
autres types de cluster n'ont pas (ex. mode à granularité fine).
• Sain pour le déploiement et la gestion d’applications dans des environnements
de cluster à grande échelle.
• Regroupe les ressources physiques existantes des machines/nœuds dans un
cluster (ressource virtuelle) (l'inverse de la virtualisation, i.e. ressource physique
se divise en plusieurs ressources virtuelles).

76
Configuration d’une
Application Spark

77
Application Spark Points d‘Entrée

Chaque application Spark a besoin d'un point d'entrée qui lui permet de:
• Communiquer avec les sources de données.
• Effectuer certaines opérations (ex. lecture et écriture de données).

► Spark 1.x:
Plusieurs points d'entrée ont été introduits:
• SparkContext.
• SQLContext. Il faut utiliser un contexte
• HiveContext. distinct pour chaque API
• StreamingContext.

► Spark 2.x:
• Un nouveau point d'entrée appelé SparkSession a été introduit.
• Combine essentiellement toutes les fonctionnalités disponibles dans les
contextes précités.
• Au lieu de générer des contextes séparés par l’utilisateur. 78
Application Spark SparkContext
Lors de la soumission d’une application Spark:
• spark-submit lance le Driver et appelle la méthode main() spécifiée par
l'utilisateur.
• Le Driver est le processus dans lequel le main() du programme s'exécute.
• Le Driver est responsable de la création du SparkContext.

SparkContext est l'instance d'application représentant la connexion au

Master (et Workers).
• Représente la connexion à un environnement d'exécution Spark.
• Utilisé pour accéder à l'environnement Spark sous-jacent et y effectuer des
opérations.
• Instancié au début d'une application Spark (y compris les shells interactifs).
• Utilisé pour l'intégralité du programme.
• Permet de créer des RDD, accéder aux services Spark et exécuter des tâches.
• SparkContext est un singleton et ne peut être créé qu'une seule fois dans
une application Spark.
79
Application Spark SparkSession

SparkSession est le point d'entrée commun pour une application Spark:

• Regroupe efficacement toutes les fonctionnalités disponibles dans les autres
contextes.
• Il s'agit d'un changement significatif dans le degré d'abstraction de l'API
Spark et de ses bibliothèques.
• Permet de résoudre le problème de nombreux utilisateurs partageant le
même SparkContext.
• SparkSession, peut être créée plusieurs fois au sein d’une application.
• Toutes les API accessibles dans ces contextes sont également disponibles
dans SparkSession.
• Généré par programme à l'aide du modèle de générateur SparkSession.
#Scala
val spark = [Link]()
.master("local[1]")
.appName("MyApp")
.config("config option", "config value")
80
.getOrCreate();
Application Spark Configuration

Spark est conçu pour que les paramètres par défaut « prêts à l'emploi »
fonctionnent dans de nombreux cas.

Il existe encore certaines configurations et options que les utilisateurs

pourraient vouloir modifier.
• Optimiser les performances d’une application.

Le réglage de Spark signifie simplement la modification de la

configuration d'exécution de l'application Spark.

Le principal mécanisme de configuration dans Spark est la classe

SparkConf.

N.B. Une instance SparkConf est requise lors de la création du

SparkContext.
81
Application Spark Configuration
Exemple: Créer une application à l'aide d'un SparkConf
#Python
# Construct a conf
conf = new SparkConf()
[Link]("[Link]", "My Spark App")
#Scala "local[4]")
[Link]("[Link]",
// Construct
[Link]("[Link]", a conf
"36000") # Override the default
port val conf = new SparkConf()
[Link]("[Link]",
# Create a SparkContext "My Spark App")
with this configuration
[Link]("[Link]", "local[4]")
sc = SparkContext(conf)
[Link]("[Link]", "36000") // Override the default
port
// Create a SparkContext with this configuration
val sc = new SparkContext(conf)
#Java
// Construct a conf
SparkConf conf = new SparkConf(); setAppName()
[Link]("[Link]", "My Spark App");
[Link]("[Link]", "local[4]"); setMaster()
[Link]("[Link]", "36000"); // Override the default
port
// Create a SparkContext with this configuration
JavaSparkContext sc = JavaSparkContext(conf);
82
Application Spark Configuration

Une instance SparkConf contient des paires clé/valeur d'options de

configuration que l'utilisateur peut modifier. Ensuite, cette instance et
fournie au constructeur SparkContext.
• Les valeurs SparkConf sont définies par programme dans le code de
l'application.
• Il est plus pratique de remplir les configurations de manière dynamique
pour une application donnée via l’outil spark-submit.
• Lorsqu'une application est lancée avec spark-submit, elle injecte des
valeurs de configuration dans l'environnement.

Exemple: Passer dynamiquement les options d’une configuration lors de l’exécution

$ bin/spark-submit \
--class [Link] \
--master local[4] \
--name "My Spark App" \
--conf [Link]=36000 \
[Link]
83
Application Spark Configuration

spark-submit prend également en charge le chargement des valeurs de

configuration à partir d'un fichier.
• Utile pour définir une configuration environnementale, qui peut être
partagée entre plusieurs utilisateurs.
Exemple: charger dynamiquement les options d’une configuration à partir d’un fichier
$ bin/spark-submit \
--class [Link] \
--properties-file [Link] \
[Link]

## Contents of [Link] ##
[Link] local[4]
[Link] "My Spark App"
[Link] 36000

84
Application Spark Configuration
Option Description
--master Indique le gestionnaire de cluster auquel se connecter.
--deploy-mode Il s'agisse de lancer le programme pilote localement (Local) ou sur l'une des
machines de travail à l'intérieur du cluster (Cluster).
--class La classe « principale/ main » de l’application si on exécute un programme
Java ou Scala.
--name Nom de l’application. Il sera affiché dans l’interface utilisateur Web de
Spark..
--jars Une liste de fichiers JAR à télécharger et à placer sur le chemin de classe de
l’application.
--files Une liste de fichiers à placer dans le répertoire de travail de l’application.
elle peut être utilisé pour les fichiers qu’on souhaite distribuer à chaque
nœud.
--executor-memory Quantité de mémoire à utiliser pour les exécuteurs, en octets. Par défaut
([Link]) (512m)
--driver-memory Quantité de mémoire à utiliser pour le processus du Driver, en octets.
[Link] Permet de limiter le nombre de cœurs utilisés par l'application pour chaque
(--executor-cores) exécuteur (Mode Yarn)
[Link] Permet de limiter le nombre total de cœurs sur tous les exécuteurs (Mode
(--total-executor-cores) Standalone & Mesos)

85
Application Spark Lancer un Programme
Spark fournit un script unique à utiliser pour soumettre un programme:
spark-submit.
• Peut se connecter à différents gestionnaires de cluster.
• Contrôler le nombre de ressources obtenues par l’application.
Les étapes qui se produisent lors de l’exécution d’une application Spark:
1. L'utilisateur soumet une application à l'aide de spark-submit.
2. Spark-submit lance le programme Driver et appelle la méthode main()
spécifiée par l'utilisateur.
3. Le Driver contacte le gestionnaire de cluster pour demander des ressources
pour lancer les exécuteurs.
4. Le gestionnaire de cluster lance les exécuteurs au nom du Driver.
5. Le processus du Driver s'exécute via l'application utilisateur. Sur la base des
actions et transformations RDD dans le programme, le Driver envoie le
travail aux exécuteurs sous forme de tâches.
6. Les tâches sont exécutées sur les processus exécuteurs pour calculer et
enregistrer les résultats.
7. Si la méthode main() se termine ou si elle appelle [Link](), elle
mettra fin aux exécuteurs et libérera les ressources du cluster. 86
Application Spark Déploiement

Lorsque spark-submit est appelé avec seulement le nom d'un script ou

d'un JAR, il exécute simplement le programme Spark fourni localement.
Si la soumission du programme se passe à un cluster Spark, il faut :
• Fournir des indicateurs supplémentaires avec l'adresse d'un cluster.
• Fournir une taille spécifique de chaque processus exécuteur à lancer.
Exemple:
$ bin/spark-submit --master spark://host:7077 --executor-memory 10g
my_script.py
L'indicateur --master spécifie une URL de cluster à laquelle se connecter.
$ bin/spark-submit
--master <master-url> \
--deploy-mode <deploy-mode> \
--conf <key<=<value> \
Le format général pour --driver-memory <value>g \
spark-submit est: --executor-memory <value>g \
--executor-cores <number of cores> \
--jars <comma separated
dependencies>
--class <main-class> \
87
<application-jar> \
Application Spark Déploiement

Option Description
spark://host:port Permet de se connecter à un cluster Spark Standalone sur le port
spécifié. Par défaut, les maîtres Spark utilisent le port 7077.
mesos://host:port Permet de se connecter à un maître de cluster Mesos sur le port
spécifié. Par défaut, les maîtres Mesos écoutent sur le port 5050.
yarn Permet de se connecter à un cluster YARN. Lors de l'exécution sur
YARN, vous devrez définir la variable d'environnement
HADOOP_CONF_DIR pour qu'elle pointe vers l'emplacement du
répertoire de configuration Hadoop, qui contient des informations
sur le cluster.
local Exécuté en mode local avec un seul cœur.
local[N] Exécuté en mode local avec N cœurs.
local[*] Exécuté en mode local et utilisé autant de cœurs que la machine
en possède.

88
Application Spark Déploiement
Exemple: Soumission d'une application Java en mode cluster autonome
# Submitting a Java application to Standalone cluster
mode
$ ./bin/spark-submit \
--master spark://hostname:7077 \
--deploy-mode cluster \
--class [Link] \
--name "Example Program" \
--jars [Link],[Link],[Link] \
--total-executor-cores 300 \
--executor-memory 10g \
[Link]
Exemple: Soumission d’une application Python en mode client YARN
$ export HADOP_CONF_DIR=/opt/hadoop/conf
$ ./bin/spark-submit \
--master yarn \
--py-files [Link],[Link],[Link] \
--deploy-mode client \
--name "Example Program" \
--queue exampleQueue \
--num-executors 40 \
--executor-memory 10g \
my_script.py 89
Références

► Learning Spark: Lightning-Fast Big Data Analysis (O’Reilly Media – 2015)

by Holden Karau, Andy Konwinski , Patrick Wendell , Matei Zaharia

► Beginning Apache Spark 2: With Resilient Distributed Datasets, Spark

SQL, Structured Streaming and Spark MLlib (Apress– 2016)
by Hien Luu

► Spark in Action (Manning Publications – 2017)

by Petar Zecevic and Marko Bonaci

► Spark in Action – Second Edition (Manning Publications – 2020)

by Jean-Georges Perrin

► Hands-on Guide to Apache Spark 3 Build Scalable Computing Engines

for Batch and Stream Data Processing (Apress– 2023)
by Alfonso Antolínez García
90
Plan du Cours
I. Introduction
1. Qu'est-ce que Spark ?
2. Avantages de l'utilisation de Spark
3. Domaines d’utilisation
4. Comment Interagir avec Spark

II. Architecture Applicative de Spark (Spark Ops)

1. Spark Unified Stack – Pile Spark
2. Composants Exécutifs de l’Architecture Spark
3. Gestion de Ressources dans un Cluster Spark
4. Configuration d’une Application Spark

III. Programmation avec Apache Spark

1. Resilient Distributed Dataset - RDD
2. RDD Manipulation (Transformations & Actions)
3. Chargement et Sauvegarde de Données
4. Programmation Avancée

91