Université Cheikh Anta Diop
Ecole Supérieure Polytechnique
Département Génie Informatique
Année Universitaire 2022-2023
Module: Big Data
TP2: Apache Spark
Travail réalisé par le binôme : Seynabou Diop et Maty Seck MBOUP
DIC3-Informatique
Table des matières
Présentation ......................................................................................................... 3
Installation ........................................................................................................... 3
Test de Spark avec Spark-Shell............................................................................... 4
L'API de Spark ....................................................................................................... 5
Exemple ........................................................................................................... 6
Spark Batch en Java .............................................................................................. 7
Préparation de l'environnement et Code ............................................................. 7
Test du code en local ........................................................................................ 8
Lancement du code sur le cluster ..................................................................... 10
Spark Streaming ................................................................................................. 13
Environnement et Code ................................................................................... 13
Test du code en Local ...................................................................................... 14
Lancement du code sur le cluster ..................................................................... 15
Présentation
Spark [[Link] est un système de traitement rapide et parallèle. Il fournit des
APIs de haut niveau en Java, Scala, Python et R, et un moteur optimisé qui supporte l'exécution
des graphes. Il supporte également un ensemble d'outils de haut niveau tels que Spark SQL.
Spark peut s'exécuter sur plusieurs plateformes : Hadoop, Mesos, en standalone ou sur le
cloud. Il peut également accéder diverses sources de données, comme HDFS, Cassandra,
HBase et S3.
Dans ce TP, nous allons exécuter Spark sur Hadoop YARN. YARN s'occupera ainsi de la
gestion des ressources pour le déclenchement et l'exécution des Jobs Spark.
Installation
Nous avons procédé à l'installation de Spark sur le cluster Hadoop utilisé dans le TP1.
Maintenant nous allons lancer nos machines grâce aux commandes suivantes puis allons entrer
dans le contenaire master. Nous lancerons ensuite les démons yarn et hdfs :
Vérifions que tous les démons sont lancés en tapant : jps
La même opération sur les nœuds esclaves a donné :
Test de Spark avec Spark-Shell
Dans le but de tester l'exécution de Spark, commençons par créer un fichier [Link] dans notre
nœud master, contenant le texte suivant :
Chargeons-le ensuite dans HDFS :
Spark-shell : Vérifions si spark-shell est bien installé en tapant la commande spark-shell:
Testons Spark avec un code scala simple comme suit (à exécuter ligne par ligne) :
Pour afficher le résultat, sortons de spark-shell en cliquant sur Ctrl-C. Nous téléchargeons
ensuite le répertoire [Link] créé dans HDFS comme suit :
L'API de Spark
A un haut niveau d'abstraction, chaque application Spark consiste en un programme driver qui
exécute la fonction main de l'utilisateur et lance plusieurs opérations parallèles sur le cluster.
L'abstraction principale fournie par Spark est un RDD (Resilient Distributed Dataset), qui
représente une collection d'éléments partitionnés à travers les noeuds du cluster, et sur
lesquelles on peut opérer en parallèle.
Exemple
L'exemple que nous allons présenter ici par étapes permet de relever les mots les plus
fréquents dans un fichier. Pour cela, le code suivant est utilisé :
Etape 1 : Créons un RDD à partir d'un fichier texte de Hadoop
Etape 2 : Convertissons les lignes en minuscule
Etape 3 : Séparons les lignes en mots
Etape 4 : Produisons les tuples (mot, 1)
Etape 5 : Comptons tous les mots
Etape 6 : Inverser les tuples (action de sélection des n premiers
Spark Batch en Java
Préparation de l'environnement et Code
Nous allons dans cette partie créer un projet Spark Batch en Java (un simple WordCount), le
charger sur le cluster et lancer le job.
1. Créons un projet Maven avec IntelliJ IDEA, en utilisant la config suivante :
2. Rajoutons dans le fichier pom les dépendances nécessaires, et indiquer la version du
compilateur Java:
3. Sous le répertoire java, créons un package que vous appellerez [Link].tp21, et dedans, une
classe appelée WordCountTask :
C’est fait voir l’illustration dans la figure de la réponse suivante.
4. Écrivons le code suivant dans WordCountTask (N'oubliez pas de rajouter les imports
nécessaires !) :
Test du code en local
1. Insérons un fichier texte [Link] dans le répertoire src/main/resources.
2. Créons une nouvelle configuration de type "Application" (Run->Edit
Configurations) que nous appelons WordCountTask, et définissons les arguments suivants
(fichier de départ et répertoire d'arrivée) comme Program arguments :
3. Cliquons sur OK, et lancer la configuration. Si tout se passe bien, un répertoire out sera créé
sous resources, qui contient deux fichiers : part-00000, part-
00001.
Lancement du code sur le cluster
Pour exécuter le code sur le cluster, nous avons modifié comme indiqué dans l’énoncé les lignes
en jaune.
Lançons ensuite une configuration de type Maven. Un fichier intitulé [Link] est créé
sous le répertoire target :
Nous allons maintenant copier ce fichier dans docker. Pour cela, naviguons vers le répertoire
du projet avec votre terminal (ou plus simplement utiliser le terminal dans IntelliJ), et tapons
la commande suivante :
Revenons à votre contenaire master, et lançons un job Spark en utilisant ce fichier jar généré,
avec la commande spark-submit, un script utilisé pour lancer des applications spark sur un
cluster.
Tout se passe bien, nous trouverons dans le répertoire output, deux fichiers part-00000 et part-
00001, qui ressemblent à ce qui suit :
Nous allons maintenant tester le comportement de spark-submit si on l'exécuteen mode cluster
sur YARN. Pour cela, exécuter le code suivant :
Tout se passe bien, nous obtenons un répertoire output2 dans HDFS avec les fichiers usuels.
Spark Streaming
Environnement et Code
Nous allons commencer par tester le streaming en local, comme d'habitude.
Pour cela :
1. Commençons par créer un nouveau projet Maven, avec le fichier pom suivant :
2. Créons une classe [Link] avec le code suivant:
Ce code permet de calculer le nombre de mots dans un stream de données toutes les secondes.
Test du code en Local
Le Stream ici sera diffusé par une petite commande utilitaire qui se trouve dans la majorité des
systèmes Unix-like.
Exécutons notre classe Stream. On voit sur notre console des lignes en continu :
l'application est en écoute sur localhost:9999.
Ouvrons un terminal, et tapons la commande suivante pour créer le stream:
o nc -lk 9999
A chaque fois qu’on écrit quelque chose sur le terminal, l'application l'intercepte, et
l'affichage sur l'écran de la console change, comme suit :
Ensuite, pour voir le résultat final du comptage, arrêter l'exécution en cliquant sur le
carré rouge, puis observons la console, nous voyons un affichage qui ressemble à ceci :
Lancement du code sur le cluster
Lançons un mvn package install pour créer le fichier jar.
Copions le fichier jar sur le contenaire hadoop :
Lançons la commande suivante puis observons le résultat :
Comme le résultat obtenu quand on lançait en local, à chaque fois qu’on écrit quelque chose
sur le terminal, l'application l'intercepte, et l'affichage sur l'écran de la console change, comme
suit :
Fin du tp