La distribution des données

La tolérance aux pannes

Le traitement en parallèle

Utilisation de matériel standard

Flexibilité évolutivité et sociabilité

Les domaines d’application
Les Framework de big-data
Algorithme de MapReduce
Exemple 2
 Conclusion

• En un temps restreint, Hadoop a su s'imposer dans le secteur

des technologies de l’informatique en facilitant le processus
de traitement , intégration et analyse des données massives.
• Dans ce contexte, Hadoop a une panoplie d’applications dans
divers domaines tel que la détection des fraudes bancaires, le
suivi de flux de données des clics des utilisateurs ainsi que le
suivi de géolocalisation et les données des machines et
capteurs.
• Aujourd’hui, avec de plus en plus de données à capturer et à
analyser, Hadoop, doté de ses compétences, continue à
répondre à cette évolution des données et aux besoins de ses
utilisateurs.
 Le cours de cette semaine présente le système
de programmation Spark, un autre mécanisme
pour écrire des programmes de type
MapReduce sur HDFS, nettement plus
performant et plus polyvalent que YARN.

YARN : qu’est-ce que c’est ?

Pierre Nerzic
69 /
 YARN est l’un des principaux composants de Apache Hadoop. Il
permet de gérer les ressources du système et de planifier les
tâches. Découvrez sa définition, son utilité, ses fonctionnalités et
ses différents composants.

Les initiales YARN désignent le terme

Yet Another Resource Negotiator
, un nom donné avec humour par les développeurs.

Cette technologie est devenue un sous-projet de Apache Hadoop

en 2012, et a été ajoutée comme une fonctionnalité clé de
Hadoop avec la mise à jour 2.0 déployée en 2013.

Pierre Nerzic
70 /
 Présentation de Spark

Spark est une API de programmation parallèle sur des données.

L’objet principal de Spark est le RDD : Resilient Distributed Dataset.
C’est un dispositif pour traiter une collection de données par des
algorithmes parallèles robustes.
Un RDD ne contient pas vraiment de données, mais seulement un
traitement.

Ce traitement n’est effectué que lorsque cela apparaît

nécessaire. On appelle cela l’évaluation paresseuse.
D’autre part, Spark fait en sorte que le traitement soit distribué sur
le cluster, donc calculé rapidement, et n’échoue pas même si des
machines tombent en panne.
Pierre Nerzic
71 /
 Avantages de Spark

Spark permet d’écrire des traitements complexes composés de plusieurs

phases map-reduce. On peut le faire également avec YARN, mais les
données issues de chaque phase doivent être stockées sur HDFS, pour
être réutilisées immédiatement après dans la phase suivante.
Cela prend beaucoup de temps et d’espace.
Les jobs YARN sont assez longs à lancer et exécuter. Il y a des
temps de latence considérables.
Au contraire, Spark utilise beaucoup mieux la mémoire centrale des
machines du cluster et gère lui-même l’enchaînement des tâches.
Les traitements peuvent être écrits dans plusieurs langages : Scala, Java
et Python.
On utilisera ce dernier pour sa simplicité pédagogique et le fait que vous
l’apprenez dans d’autres cours.
Pierre Nerzic
72 /
 Premier exemple Spark

Soit un fichier de données de type CSV provenant de

http://opendata.paris.fr décrivant des arbres remarquables à
Paris. Chaque ligne décrit un arbre : position GPS, arrondissement,
genre, espèce, famille, année de plantation, hauteur, circonférence,
etc. Le séparateur est ' ; ' .
La première ligne contient les titres.
On souhaite afficher l’année de plantation (champ n°6) de l’arbre
le plus grand (champ n°7).
Avec des commandes
cat arbres.csv | cutUnix,
- d ' ;ce' -f6,7
traitement s’écrirait
| egrep :
-v 'HAUTEUR|;$'
|\ sort - t ' ; ' -k2 -n -r | head -n 1

Par contre, j’aurais apprécié que cut permette de changer l’ordre des champs,
ça aurait facilité le classement.
Pierre Nerzic
73 /
 Principe du traitement

Voyons comment faire la même chose avec Spark. Une fois que le
fichier arbres.csv est placé sur HDFS, il faut :
1. séparer les champs de ce fichier.
2. extraire le 7e et 6e champs dans cet ordre – ce sont la hauteur
de l’arbre et son année de plantation. On en fait une paire (clé,
valeur). La clé est la hauteur de l’arbre, la valeur est son année
de plantation.
3. éliminer la clé correspondant à la ligne de titre du fichier et les
clés vides (hauteur inconnue).
4. convertir les clés en float
5. classer les paires selon la clé dans l’ordre décroissant.
6. afficher la première des paires. C’est le résultat voulu.

Pierre Nerzic
74 /
Lancement

Spark offre plusieurs manières de lancer le programme,

dont : Lancement en local :
spark-submit ageMaxH.py
Lancement sur un cluster de Spark Workers :
spark-submit --master spark://master:7077
ageMaxH.py
L’option --master spark://master:7077 indique de faire
appel au cluster de machines sur lesquelles tournent des
Spark Workers. Ce sont des processus clients chargés de faire
les calculs distribués pour Spark.
Spark permet aussi de lancer l’exécution sur YARN :
spark-submit --master yarn-cluster ageMaxH.py
Ce sont les esclaves YARN qui exécutent le programme Spark.
Pierre Nerzic 75 / 45
Éléments de l’API Spark

Pierre Nerzic 76 / 45
Principes

Spark est facile à apprendre car il repose sur des principes

peu nombreux et simples.
Données :
• RDD : ils représentent des données distribuées modifiées
par une transformation, par exemple un map ou un
filter.
• Variables partagées entre des traitements et distribuées
sur le cluster de machines.
Méthodes :
• Transformations : ce sont des fonctions (au sens
mathématique) du type : RDD ←
transformation(RDD). Elles créent un nouveau RDD à
partir d’un existant.
• Actions : ce sont des fonctions qui permettent
d’extraire des informations
Pierre Nerzic
des RDD, par exemple les 77 / 45
 RDD

Un RDD est une collection de données abstraite, résultant de la

transformation d’un autre RDD ou d’une création à partir de données
existantes. Un RDD est distribué, c’est à dire réparti sur plusieurs
machines afin de paralléliser les traitements.
On peut créer un RDD de deux manières :
Paralléliser une collection:Si votre programme
contient des données itérables (tableau,
liste. . . ), elles peuvent devenir un RDD.

donnees = [ ' v e a u ' , ' v a c h e ' , 'cochon ', 'couvée '] RDD
= sc.parallelize(donnees)

On le nomme « collection parallélisée

». Pierre Nerzic 78 / 45
RDD (suite)

Jeux de données externes

Spark peut utiliser de nombreuses sources de données Hadoop :
HDFS, HBase. . . et il connait de nombreux types de fichiers :
texte et les formats Hadoop tels que SequenceFile.
Voici comment lire un simple fichier texte ou CSV :

RDD = sc.textFile("hdfs:/share/data.txt")

Comme avec MapReduce, chaque ligne du fichier constitue

un enregistrement.
Les transformations appliquées sur le RDD traiteront
chaque ligne séparément. Les lignes du fichier sont
distribuées sur différentes machines pour un traitementPierre Nerzic
parallèle.
79 / 45
 Lire et écrire des SequenceFile
Certains traitements Spark font appel à la notion de paires (clé,valeur). C’est l
cas de l’exemple initial. Les clés permettent par exemple de classer des valeurs
dans un certain ordre.
Pour stocker efficacement ce genre de RDD, on emploie un
SequenceFile.
Lecture d’un SequenceFile dans un RDD
Cette fonction lit les paires du fichier et crée un RDD :

RDD = sc.sequenceFile("hdfs:/share/data1.seq")

Écriture d’un RDD dans un SequenceFile

Cette méthode enregistre les paires (clé, valeur) du RDD :

RDD.saveAsSequenceFile("hdfs:/share/
data2.seq") Pierre Nerzic 80 / 45
Actions

Avant de voir les transformations, voyons les actions. Ce sont des

méthodes qui s’appliquent à un RDD pour retourner une valeur
ou une collection.
liste = RDD.collect() retourne le RDD sous forme
d’une liste Python. Attention à la taille si c’est du
BigData. nombre = RDD.count() retourne le nombre
d’éléments premier = RDD.first() retourne le premier
élément premiers = RDD.take(n) retourne les n premiers
éléments. Note: il n’y a pas de méthode last pour
retourner le ou les derniers éléments.
resultat = RDD.reduce(fonction) applique une
fonction d’agrégation (associative) du type fn(a,b)→c

Pierre Nerzic
22 /
Transformations

Les RDD possèdent plusieurs méthodes qui ressemblent aux

fonctions map, filter, etc. de Python.
En Python ordinaire, map est une fonction dont le premier paramètre
est une lambda ou le nom d’une fonction, le second paramètre est la
collection à traiter :

liste = [1,2,3,4]
doubles = map(lambda n: n*2, liste)

En pySpark, map est une méthode de la classe RDD, son seul

paramètre est une lambda ou le nom d’une fonction :

liste = sc.parallelize([1,2,3,4])
doubles = liste.map(lambda n:
n*2)
Les deux retournent les résultats, liste ou
Pierre Nerzic 82 / 45
RDD.
Transformations de type map

Chacune de ces méthodes retourne un nouveau RDD à partir

de celui qui est concerné (appelé self en Python).
RDD.map(fonction) : chaque appel à la fonction
doit retourner une valeur qui est mise dans le RDD
sortant.
RDD = sc.parallelize([1,2,3,4])
print RDD.map(lambda n: n+1).collect()

RDD.filter(fonction) : la fonction retourne un booléen. Il

ne reste du RDD que les éléments pour lesquels la fonction
retourne True.
RDD = sc.parallelize([1,2,3,4])
print RDD.filter(lambda n: (n%2)==0).collect()
Pierre Nerzic 83 / 45
Transformations de type map (suite)

RDD.flatMap(fonction) : chaque appel à la fonction doit retourner

une liste (vide ou pas) et toutes ces listes sont concaténées dans le
RDD sortant.

RDD = sc.parallelize([0,1,2,3])
print RDD.flatMap(lambda n: [n*2, n*2+1]).collect()

La fonction lambda retourne une liste, le double et le double+1 du nombre

traité.
Appliquée à la collection par un simple map, on obtiendrait la liste
imbriquée : [[0, 1], [2, 3], [4, 5], [6, 7]].
Avec un flatMap, les résultats sont concaténés ensemble, donc on récupère :
[0, 1, 2, 3, 4, 5, 6, 7].

Pierre Nerzic 84 / 45
Transformations ensemblistes

Ces transformations regroupent deux RDD, self et celui passé en

paramètre.

RDD.distinct() : retourne un seul exemplaire de chaque élément.

RDD = sc.parallelize([1, 2, 3, 4, 6, 5, 4,
3]) print RDD.distinct().collect()

RDD1.union(RDD2) : contrairement à son nom, ça retourne la

concaténation et non pas l’union des deux RDD. Rajouter
distinct() pour faire une vraie union.
RDD1 =
sc.parallelize([1,2,3,4]) RDD2
= sc.parallelize([6,5,4,3])
print
Pierre Nerzic 85 / 45
RDD1.union(RDD2).collect()
Transformations ensemblistes (suite)
RDD1.intersection(RDD2) : retourne l’intersection des deux RDD.

RDD1 =
sc.parallelize([1,2,3,4]) RDD2
= sc.parallelize([6,5,4,3])
print
RDD1.intersection(RDD2).collect
()

Pierre Nerzic 86 / 45
Transformations sur des paires (clé, valeur)

Les transformations suivantes manipulent des RDD dont

les éléments sont des paires (clé, valeur) ((K,V) en
anglais)
RDD.groupByKey() : retourne un RDD dont les éléments
sont des paires (clé, liste des valeurs ayant cette clé dans le
RDD concerné).
RDD.sortByKey(ascending) : retourne un RDD dont les
clés sont triées. Mettre True ou False.
RDD.reduceByKey(fonction) : regroupe les valeurs ayant
RDD =la sc.parallelize([
même clé et leur applique la fonction (a,b)→c.
(1,"paul"),(2,"anne"),
(1,"emile"),(2,"marie"),(1,"victor") ])
print RDD.reduceByKey(lambda a,b: a+"-"+b).collect()

retourne [(1, "paul-emile-victor"),

Pierre Nerzic (2, "anne- 87 / 45
marie")]
Transformations de type jointure

Spark permet de calculer des jointures entre RDD1={(K1,V1). . .

} et RDD2={(K2,V2). . . } et partageant des clés K identiques.
RDD1.join(RDD2) : retourne toutes les paires (K, (V1,
V2)) lorsque V1 et V2 ont la même clé.
RDD1.leftOuterJoin(RDD2) : retourne les paires (K, (V1,
V2)) ou (K, (V1, None)) si (K,V2) manque dans RDD2
RDD1.rightOuterJoin(RDD2) : retourne les paires (K,
(V1, V2)) ou (K, (None, V2)) si (K,V1) manque dans
RDD1 RDD1.fullOuterJoin(RDD2) : retourne toutes les
paires (K, (V1, V2)), (K, (V1, None)) ou (K, (None, V2))
RDD1 = sc.parallelize([ (1,"tintin"),(2,"asterix"),
(3,"spirou")
RDD2 = sc.parallelize([ (1,1930),(2,1961),(1,1931),
(4,1974) ]) Pierre Nerzic 88 / 45
SparkSQL

Pierre Nerzic 89 / 45
Présentation

SparkSQL rajoute une couche simili-SQL au dessus des RDD

de Spark. Ça s’appuie sur deux concepts :

DataFrames Ce sont des tables SparkSQL : des données sous forme

de colonnes nommées. On peut les construire à partir
de fichiers JSON, de RDD ou de tables Hive.
RDDSchema C’est la définition de la structure d’un DataFrame.
C’est la liste des colonnes et de leurs types. Un
RDDSchema peut être défini à l’aide d’un fichier
JSON.

Il y a des liens entre DataFrame et RDD.

Les RDD ne sont que des données, des n-uplets bruts. Les
DataFrames sont accompagnées d’un schéma.
Pierre Nerzic 90 / 45
BigData - Semaine 4
SparkSQL

Début d’un programme

Un programme pySparkSQL doit commencer par ceci :

#!/usr/bin/python
from pyspark import SparkConf, SparkContext,
SQLContext from pyspark.sql.functions import *

nomappli = "essai1"
config =
SparkConf().setAppName(nomappli) sc =
SparkContext(conf=config)
sqlContext = SQLContext(sc)

sqlContext représente le contexte SparkSQL. C’est un objet qui

possède plusieurs méthodes dont celles qui créent des
DataFrames et celles qui permettent de lancer des requêtes SQL.
Pierre Nerzic 91 / 45
Créer un DataFrame

Il y a plusieurs manières de créer un DataFrame. Il faut à la

fois fournir le schéma (noms et types des colonnes) et les
données. L’une des méthodes simples consiste à utiliser un
fichier JSON.
Un fichier JSON est pratique car il contient à la fois les données
et le schéma, mais ça ne convient que pour de petites données.
Un fichier JSON contient la sérialisation d’une structure de
données JavaScript. Pour les données qui nous intéressent, c’est
simple.
Chaque n-uplet est englobé par {...} ; les champs sont écrits
"nom":"valeur". Voici un exemple de trois n-uplets :
{"nom":"Paul"}
{"nom":"Émile", "age":30}
Pierre Nerzic 92 / 45
BigData - Semaine 4
API SparkSQL

Méthodes de DataFrame

count() retourne le nombre de n-uplets du DataFrame

concerné.
distinct() retourne un nouveau DataFrame ne
contenant que les n-uplets distincts
limit(n) retourne un nouveau DataFrame ne contenant
que les n premiers n-uplets
join(autre, condition, type) fait une jointure entre
self et autre sur la condition. Le type de jointure est une
chaîne parmi "inner" (défaut), "outer",
"left_outer", "right_outer" et "semijoin"
collect() retourne le contenu de self sous forme d’une
liste de Row. On peut l’utiliser pour un affichage final :
print achats.filter(achats.idclient == 1).collect()
Pierre Nerzic 93 / 45