Big Data

Lotfi NAJDI
Année Universitaire 2022 / 2023
Finance et Ingénierie Décisionnelle
ENSA Agadir
Spark
Hadoop MapReduce

• les ensembles de données sont lus à partir du disque

• Après chaque opération map ou reduce, le résultat est écrit à nouveau sur disque.

• L'écriture sur disque fournit la tolérance aux pannes, par contre les I/O sur disque
sont couteux (latence importante )

• Difficile à composer et à imbriquer de multiples opérations

Pourquoi Spark ?

• Hadoop MapReduce a permis de simplifier considérablement l'analyse des

données sur les gros clusters

• Spark représente une alternative à Hadoop MapReduce pour le calcul

distribué qui vise à résoudre les problèmes relatifs à la performance.

• les exigences ne cessent de croître:

• Analyses et algorithmes avancés (à passages multiples ) comme le cas du

machine learning et du traitement des graphes
• Support des requêtes ad-hoc interactives
• le traitement de flux de données en quasi temps réel (stream processing)
Spark

Spark is a fast, in-memory data processing engine suitable for use in a wide range of
circumstances.

Apache Spark is a unified analytics engine for large-scale data processing. Apache
Spark
Spark
 Spark écrit les données en RAM et non pas sur disque

 Apache Spark exécute les applications de manière très rapide en mémoire (par rapport à
Hadoop) .

 Réduction du nombre de cycles de lecture/écriture sur le disque et stockage des données

intermédiaires en mémoire (amélioration de la latence et du taux de transfert )

Apache Spark
Spark?
• Spark SQL : Requêtes sur les données structurées
relationnelles

• Spark Streaming : le traitement de flux de données

en quasi temps réel à l’aide des micro-batches.

• MLib pour le Machine Learning.

• GraphX pour représenter sous la forme de graphes

des données reliées comme les connexions des
utilisateurs de réseaux sociaux.

Apache Spark
Cluster Spark

Spark 3.0.2 Documentation (apache.org)

 Cluster Spark

• Driver program: Le processus qui exécute la méthode main (le point de départ du programme).

• Spark Driver permet de créer un object SparkContext.

• La création du SparkContext constitue la première étape à faire car elle permet à une application Spark
d'établir une connexion avec l'environnement d’exécution de Spark et d’accéder au cluster Spark
(ressources de traitement) à l'aide du cluster manager.

• SparkContext représente le noyau d'une application Spark.

• SparkContext agit en tant que maître de l'application Spark.

• SparkConf permet de spécifier les paramètres de configuration avant la création du SparkContext (master
URL , application name ..etc)
Cluster Spark

• A l'aide du cluster manager, une application Spark est lancée sur un ensemble de

machines.

• Spark peut fonctionner en se connectant à des cluster managers de types différents :

• Standalone Cluster Manager (cluster managers autonome intégré par défaut dans Spark).

• Autres cluster managers comme Hadoop Yarn, Apache Mesos, etc.

Cluster Spark

• Une application Spark est une combinaison de Driver et de ses propres executors.

• Worker node: Tout nœud qui peut exécuter du code d'application dans le cluster

• Executor: Processus lancé ,pour une application sur un worker node, qui exécute des tâches et

conserve des données en mémoire ou sur disque pendant leur exécution. Chaque application

dispose de ses propres exécuteurs.

• Task : Une unité de travail qui sera attribuée à un seul Executor.

• Job : Un calcul parallèle composé de plusieurs tâches qui sont lancées en réponse à une action

Spark (par exemple, save, collect).

 Cluster Spark

Spark applications run as independent sets of processes on a cluster, coordinated by the

SparkContext object in your main program (called the driver program).

Specifically, to run on a cluster, the SparkContext can connect to several types of cluster
managers (either Spark’s own standalone cluster manager, Mesos or YARN), which allocate
resources across applications.

Once connected, Spark acquires executors on nodes in the cluster, which are processes that run
computations and store data for your application.

Next, it sends your application code to the executors.

Finally, SparkContext sends tasks to the executors to run.

Spark 3.0.2 Documentation (apache.org)

Application Spark

L’ Application (programme ) accède à Spark à travers l’objet appelé SparkContext qui

représente connexion à un cluster.

• Un programme Spark est constitué d’ une séquence d'opérations

invoquées à travers un SparkContext.

• Ces opérations manipulent un type spécial de structure de données, appelé

Resilient Distributed Dataset (RDD).

RDD
Les objets de données sont stockés dans ce que l'on appelle des ensembles de données distribués
résilients (RDD : resilient distributed datasets) répartis sur le cluster de données permettant la
récupération complète de données. Wikipédia

• RDD est la structure de données de base de Apache Spark

• Un RDD est une collection de données calculée à partir d'une source et conservée en mémoire vive.

• La manipulation des RDDs permet de mettre en œuvre des tâches de bas niveau. En pratique nous
allons utiliser d’autres API permettant une abstraction de plus haut niveau comme la DataFrame
API.

• Sont dits Résilient car les RDD sont immuables (immutable ) c.-à-d. ne peuvent pas être modifiés

• Les RDD sont tolérants aux pannes.

Création des RDDs

• Parallélisation d'une collection existante dans le driver program (liste par

exemple)

• Chargement à partir d'un ensemble de données dans un système de

stockage externe : HDFS, Hive , txt ..etc.

• SparkContext offre de nombreuses fonctions permettant de charger des

données provenant de sources externes
RDD

• Spark divise chaque RDD en plusieurs partitions.

• Les partitions sont distribuées sur les nœuds du cluster.

• Spark parallélise les opérations invoquées sur chaque RDD.

• Un programme Spark est une séquence d'opérations parallèles invoquées sur

les RDD.
Manipulation des RDD

Spark propose deux types d'opérations distinctes :

• Les transformations sont des opérations qui reçoivent un ou plusieurs RDD et en

renvoient un nouveau RDD.

• Les actions sont des opérations qui renvoient un résultat final au driver ou bien

enregistrent le résultat dans un système de stockage.

Transformations
Narrow Transformation: chaque partition d'entrée contribuera à une seule partition de sortie.

(map ,flatMap,filter, sample)

What are Transformations? - Databricks

Transformations
les partitions d'entrée contribuent à de nombreuses partitions de sortie.(sortByKey ,
reduceByKey, groupByKey ,join..etc)

What are Transformations? - Databricks

Actions

Les actions sont des opérations qui renvoient un résultat final au driver ou bien
enregistrent le résultat dans un système de stockage.
• collect
• take
• reduce
• forEach

• count
• save
Actions

• Les actions sont des instructions qui sont traitées par Spark au moment de

leur exécution.

• Elles consistent à exécuter toutes les transformations précédentes afin

d'obtenir le résultat souhaité.

• Une action consiste à exécuter une ou plusieurs tâches par les workers de

manière parallèle, dans la mesure du possible.

Lazy evaluation

Spark utilise l’évaluation paresseuse (lazy evaluation) afin d’évaluer les

transformations

• Les transformations ne sont pas immédiatement exécutées lors de leurs

invocations.

• Les transformations ne sont exécutées que lorsque Spark reçoit une action.

Lazy evaluation permet de réduire le nombre de passages nécessaires pour

charger et transformer les données et de produire un plan d’exécution physique

efficace.
Spark: DataFrame

• Dans Spark, un DataFrame est une collection de données distribuée organisée en

colonnes nominatives.

• Conçu pour faciliter le traitement de grands ensembles de données

• DataFrame permet aux développeurs de structurer une collection de données

distribuées, permettant une abstraction de plus haut niveau ;

• Semblable à une table dans une base de données relationnelle ou bien à un data frame
en R/Python, mais avec de plus riches optimisations
Spark: DataFrame

• Les RDD constituent le modèle de données de base le plus utilisé par Spark

• API de bas niveau (low-level) qui propose deux types de méthodes : les

transformations et les actions.

• Sans schéma (schema-less) , c-à-d aucun schéma, lors du traitement ou de l'accès

aux attributs des données par nom ou par colonne.

• En plus de l'API RDD, Spark offre une interface pour travailler sur des données

structurées comme les tables des bases de données relationnelles : DataFrame

Transformations et Actions pour DataFrame

Transformations :
• select()
• filter() orderBy(), sort()
• distinct(), dropDuplicates()
• join ()
• groupBy ()
Actions
• Count()
• show()
• collect()
• take()
• write
RDD vs DataFrame
• RDD :

• Low level abstraction

• Transformation et des actions de bas niveau et un contrôle sur votre ensemble de

données (unstructured data)

• Absence d’exigence de schéma et format en colonne, lors du traitement ou de

l'accès aux attributs des données.

• Dataframe

• High-level abstractions

• Traitement exigeant des expressions de haut niveau (filtres, agrégation, requêtes

SQL..etc)

• Avantages en termes d'optimisation et de performance pour les données structurées

et semi-structurées.
RDD
Dataframe
Dataframe
Apache Spark

• Apache Spark est un moteur de traitement des données à grande échelle :

• Le calcul distribué (cluster computing)

• Interface SQL

• Machine Learning

• Permet de surmonter de nombreuses limitations de Hadoop

• Spark offre un écosystème très riche de services permettant de travailler sur les Big data

grâce à des API de haut niveau en accessibles via plusieurs langages de programmation

comme Java, Scala, Python et R.

• Spark DataFrame constitue l’abstraction la plus pratique pour la manipulation des données
Streaming Data
 Spark Streaming

• Stream processing is defined as the continuous processing of endless streams of data

• Spark Streaming is an extension of the core Spark API that enables scalable, high-

throughput, fault-tolerant stream processing of live data streams.

Spark Streaming

• Les données peuvent être consommées à partir de nombreuses sources comme Kafka,
Flume, Kinesis ou les sockets TCP

• Les données peuvent être traitées par tous les algorithmes Spark (ML , graph)

• Enfin, les données traitées peuvent être exportées vers des systèmes de fichiers, des
bases de données et des tableaux de bord en temps réel.
Spark Streaming

Spark Streaming reçoit des flux de données d'entrée en temps réel et répartit les
données en lots, qui sont ensuite traités par le moteur Spark pour générer le flux final de
résultats par lots.
DStream

• Spark DStream (Discretized Stream) représente l'abstraction de base de Spark

Streaming.

• DStream est un flux continu de données.

• En interne, un DStream est représenté par une séquence de RDD.

• Toute opération sur un DStream s'applique à tous les RDD sous-jacents.

• Les DStreams peuvent être créés soit à partir de flux de données d'entrée provenant

de sources telles que Kafka , flume HDFS , soit en appliquant des opérations de haut

niveau sur d'autres DStreams.

Structured Streaming

Structured Streaming is a scalable and fault-tolerant stream processing engine

built on the Spark SQL engine. You can express your streaming computation the
same way you would express a batch computation on static data. The Spark SQL engine
will take care of running it incrementally and continuously and updating the final result
as streaming data continues to arrive.

You can use the Dataset/DataFrame API in Scala, Java, Python or R to express streaming
aggregations, event-time windows, stream-to-batch joins, etc. The computation is
executed on the same optimized Spark SQL engine.

Spark
Structured Streaming

the simplest way to perform stream

processing is not having to reason about
streaming at all

databriks
Unbounded Tables

data stream unbounded input table

new data in the

data stream
=
new rows appended
to a unbounded table
Structured Streaming

• L'idée principale du Structured Streaming consiste à considérer un data stream comme

une table virtuelle qui est enrichie en continu.

• Nouveau modèle de traitement des flux (stream processing) qui est très similaire à
un modèle de traitement par lots (batch processing ).

• Nous allons exprimer notre calcul de streaming sous la forme d'une requête (query)
standard de type batch sur cette table conceptuelle, comme s'il s'agissait d'une table
statique

• Spark va convertir automatiquement cette requête et l’exécuter comme une requête

incrémentielle sur la table d'entrée.
Nouveau modèle de stream processing
Une requête sur les Input génère un "Result Table". À chaque trigger intervalle (par exemple,
toutes les 1 seconde), de nouvelles lignes sont ajoutées à la table des Input, qui met
éventuellement à jour la table des résultats.
Trigger: every 1
sec t=2
t=1 t=3
Time

Input: data from source as an Input data data data

append-only table up to up to up to
t=1 t=2 t=3
Trigger: how frequently to check

Query
input for new data
Query: operations on input usual
map/filter/reduce, result up result up result up
aggregations, joins Result
to t = 1 to t = 2 to t = 3
Nouveau modèle de stream processing

Chaque fois que le "Result Table" est mis à jour, nous voudrions écrire les lignes de
résultats dans un collecteur externe.
t=1 t=2 t=3
Time

Input data up data up data up

to t = 1 to t = 2 to t = 3

Query
Result: final operated table Result result up result up result up
updated after every trigger to t = 1 to t = 2 to t = 3

Output: what part of result to write to

storage after every trigger Output
Nouveau modèle de stream processing

Append output: write only new rows that got added to result table since previous batch

t=1 t=2 t=3

Time

Input data up data up data up

to t = 1 to t = 2 to t = 3

Quer
y
Result result up result up result up
to t = 1 to t = 2 to t = 3

Output
[append mode] write new rows since last trigger to storage
Nouveau modèle de stream processing

Complete output: write full result table every time

t=1 t=2 t=3
Time

Input data up data up data up

to t = 1 to t = 2 to t = 3

Query
Result result up result up result up
to t = 1 to t = 2 to t = 3

Output
[complete mode]
write all rows in result table to storage
API - Dataset/DataFrame

Une seule API pour faire à la fois des traitements batch et streaming

static data = streaming data =

bounded table unbounded table
Batch Queries avec DataFrames

input = spark.read
.format("json") Lecture d’un fichier source json
.load("source-path")

result = input
.select("device", "signal") Query: projection , Filtre
.where("signal > 15")

result.write
.format("parquet") Ecriture dans un fichier parquet
.save("dest-path")
Streaming Queries avec DataFrames

input = spark.readStream Input : Lecture d'un flux JSON

.format("json")
Remplacer read avec readStream
.load("source-path")

result = input
.select("device", "signal") Query : projection , Filtre
.where("signal > 15")

result.writeStream Output : Ecriture des résultats dans un fichier Parquet

.format("parquet") Remplacer le save() avec start()
.start("dest-path")

Le code du traitement à réaliser (Query) n’a pas été modifié.

Exécution de Streaming Query

t =1 t =2 t =3
input = spark.readStream Streaming
.format("json") Source
.load("source-path")

result = input Project

device, signal
.select("device", "signal")

new files

new files
new files
process

process
process
.where("signal > 15")
Filter
result.writeStream signal >15
.format("parquet")
.start("dest-path") Streaming
Sink

DataFrames, Series of Incremental

Logical Plan
Datasets, SQL Execution Plans

Making-structured-streaming-ready-for-production