Faculté polydisciplinaire de Taroudant

BIG DATA

Lab 4 : Ingestion des données

Bouchhar Maryam & Adardour Naima

28/12/2023
 Exercise 1: Data Ingestion using Apache Flume
Dans cet exercice, nous allons installer et configurer un agent Flume pour récupérer des
données en suivant un fichier log. Les données seront ensuite regroupées par lots et ingérées dans
HDFS (Hadoop Distributed File System).

Data ingestion
Quoi ?

L'ingestion de données désigne le processus de collecte de data à partir de différentes

sources et sa centralisation sur un site de destination dans lequel elles sont prêtes à être analysées
et utilisées.

Qui ?

Ce processus est essentiel pour les entreprises et les organisations qui souhaitent tirer des
enseignements et des informations utiles à partir de grandes quantités de données.

Les professionnels des données, les ingénieurs en données, les scientifiques des données et
les équipes informatiques sont généralement responsables de la mise en œuvre de la Data
Ingestion.
 Où ?

La Data Ingestion peut se produire à partir de diverses sources, y compris des bases de
données externes, des fichiers plats, des flux de capteurs, des API web, etc. Les données peuvent
être ingérées dans des entrepôts de données, des data lakes ou d'autres systèmes de stockage.

Comment ?

L'ingestion de données peut être effectuée de différentes manières :

L’ingestion en temps réel ou en flux (ingestion de données en streaming ou en flux) :

Cette solution permet de prendre des décisions en temps réel en s’appuyant sur des
données de dernière fraicheur. Elle est utile lorsque les données collectées sont extrêmement
urgentes.

Par exemple :

- Les systèmes de géolocalisation doivent transmettre l’information en temps-réel. Sans

solution real-time, ces systèmes n’ont guère d’intérêt.
- Les données acquises à partir d'un réseau électrique doivent être surveillées en
permanence pour garantir la disponibilité de l'électricité.

L’ingestion par lots ou batch :

Lorsqu’une entreprise n’a pas une réelle nécessité d’accéder à des informations en temps
réel, elle peut programmer leur envoi et leur centralisation à intervalles réguliers. Cette approche
est bénéfique pour les processus reproductibles.

Par exemple :

- Les organisations qui doivent générer des rapports et tableaux de bords à intervalles
réguliers (quotidien, hebdomadaire, etc.).

Les architectures Lambda et Kappa : (Combinaison des deux solutions précédentes)

L’architecture Lambda permet de sélectionner des types de données à recueillir par lots et
tout en mettant en place une centralisation et exportation en temps réel pour la data sensible au
facteur temps.
 L’architecture Kappa a le même objectif mais au lieu que le flux et les lots soient dissociés
en deux couches distinctes, celles-ci sont fusionnées dans un souci d’économie de la charge
opérationnel. Cependant, cette solution d’ingestion n’a qu’une fonction de traitement et n’intègre
pas la fonction de stockage.

Pourquoi ?
- Elle permet concrètement d’extraire des informations localisées dans des bases de
données diverses qui ne communiquent pas forcément entre elles.
- Les entreprises deviennent plus agiles et peuvent optimiser leur processus de
décision et ainsi booster leurs performances à plusieurs niveaux (commercial,
marketing, financier, organisationnel, managérial, etc.).

En d'autres termes, le processus d'ingestion de données aide une entreprise à mieux

comprendre les besoins et le comportement de son public et à rester compétitive

Apache Flume
Quoi ?
Un outil open-source développé en 2009 par cloudera, il facilite la collecte, l'agrégation et
le déplacement efficace de grands volumes de données (logs, événements, etc.) depuis diverses
sources vers un ou plusieurs systèmes de stockage centralisés, tels que Apache Hadoop HDFS.

Quand ?

Flume est souvent utilisé dans le contexte du traitement de données distribuées et de

l'ingestion de données en temps réel.
 Comment ?

Flume suit généralement une architecture de type agent, où chaque agent est responsable
de la collecte et du transfert de données. Les agents peuvent être configurés pour former des flux
de données.

Composants principaux d’agent :

Source : Représente l'origine des données à collecter. Les plus courants sont les suivantes :

Avro : cela permet de communiquer entre les différents agents de Flume Apache.

Spooling Directory Source : facilite la lecture des fichiers entrants.

Syslog (TCP ou UDP) : l’idée est de capter les événements d’un serveur syslog.

HTTP : il permet de traduire les requêtes POST et GET.

La source Taildir : elle permet de collecter des données à partir d’un répertoire et de les
diffuser vers les agents Flume.

La source Netcat : elle permet d’écouter un socket TCP/IP afin de recevoir des données
entrantes.

Channel : Stocke temporairement les données entre la source et la destination. Il existe

différents channels, à savoir :

Memory Channel : il permet de stocker les données en mémoire vive, facilitant ainsi une
plus grande vitesse de traitement, mais avec une capacité de stockage limitée.

File Channel : il permet de stocker les événements dans des fichiers sur disque, ce qui a
l’avantage de pouvoir stocker un volume important de données, mais avec parfois une lenteur de
traitement.

Kafka Channel : il permet de stocker des données dans un cluster Kafka, facilitant ainsi
une plus grande scalabilité et une haute disponibilité des logs collectés.

Sink : Représente la destination des données collectées. Les événements peuvent alors être
poussés vers HDFS, IRC, HBase, ElasticSearch, File (ou fichier local). Il est aussi possible
d’utiliser Avro pour faciliter la communication avec un autre agent.
 HDFS Sink : il permet d’écrire les données collectées dans le système de fichiers distribué
HDFS.

JDBC Sink : il permet d’écrire les données collectées dans une base de données
relationnelle via JDBC (Java Database Connectivity).

Kafka Sink : il permet d’écrire les logs récupérés dans un cluster Kafka.

Installation du Flume

La commande wget utilisée pour télécharger le fichier compressé "apache-flume-1.11.0-

bin.tar.gz" depuis le site web d'Apache.

Extraire (décompresser) le contenu du fichier "apache-flume-1.11.0-bin.tar.gz" :

Renommer le répertoire extrait en flume :

Déplacer le dossier "flume" vers "/usr/share" :

 Configuration de l’agent flume

Créer le fichier de configuration dans /usr/share/flume/conf.

Remplir le fichier de configuration en utilisant la commande vi :

Cette configuration Flume spécifie une source Flume qui utilise la commande tail pour
capturer en continu les nouveaux événements provenant du fichier /tmp/events. Ces événements
sont ensuite transmis à travers le canal de type mémoire pour mettre en mémoire tampon les
événements avant de les écrire dans le système de fichiers distribué HDFS. Les événements sont
écrits dans des fichiers avec un préfixe spécifique, et les fichiers sont arrondis toutes les 10
minutes.
Génération des messages log en utilisant des mots aléatoires
Installer le package wamerican :
 Afficher les dernières lignes du fichier "words" qui se trouve dans le répertoire
"/usr/share/dict/ ».

Les premières lignes trouvées dans le fichier words :

Création d’un script Python

Créez un script Python pour générer des événements aléatoires :

Ce script permet de générer de évènements avec un timestamp et une séquence de 9 mots

qui vient du fichier /usr/share/dict/words.
 Créez un répertoire dans HDFS pour ingérer les données de Flume :

Démarrage de l’agent flume

Le but de cette commande est de démarrer l'agent Flume avec le fichier de configuration
spécifié et la configuration Hadoop. L'agent Flume fait partie du système Apache Flume, qui est
utilisé pour collecter, agréger et déplacer efficacement de grandes quantités de données de
journal.

Il est important de noter que le comportement réel de l'agent Flume dépend de la

configuration spécifiée dans le fichier flume-conf.properties. Les propriétés de ce fichier
définissent les sources, les destinations (sinks) et les canaux pour l'agent Flume.
Exécuter le script Python gen_events.py :
 Cette commande exécute le script Python gen_events.py et ajoute la sortie de ce script à la
fin du fichier /tmp/events. Le script Python lui-même (gen_events.py) serait responsable de
générer des événements ou des données.
 Lister les fichiers dans le répertoire "/flume/events" :

La commande hadoop fs -ls /flume/events affiche la liste des fichiers et sous-répertoires

présents dans le répertoire HDFS spécifié, qui est /flume/events.

Afficher le contenu du fichier events-.1703672333796

Ce fichier contient les enregistrements générés par le script gen_events.py.

 Autres scénarios d'utilisation d'Apache Flume :
Ingestion de journaux de serveur Web :

Configurer Flume pour ingérer des journaux à partir de serveurs Web. Cela peut inclure
des journaux d'accès, des journaux d'erreurs, ou tout autre journal pertinent généré par les
serveurs Web.

Collecte de données des médias sociaux :

Ingestion de données à partir de plates-formes de médias sociaux pour analyser les

tendances, les sentiments ou les interactions des utilisateurs. Flume peut être configuré pour
consommer des données à partir de diverses API de médias sociaux.

Ingestion de données IoT (Internet des objets) :

Utiliser Flume pour collecter et traiter des données à partir de dispositifs IoT. Il peut gérer
de grands volumes de données en continu générées par des ingescapteurs, des actionneurs et
d'autres dispositifs IoT.
 Exercise 2: Data Ingestion using Apache Sqoop
Exploration Apache Sqoop
Quoi ?

Sqoop est l’abréviation de « SQL to Hadoop », qui a pour objectif de permettre une
meilleure cohabitation des systèmes traditionnels de type SGBDs avec la plateforme Hadoop. On
peut utiliser Sqoop pour importer des données des SGBDR tels que MySQL, Oracle, SQL Server
ou Teradata au HDFS, transformer les données dans Hadoop via le MapReduce ou un autre
modèle de calcul, et les exporter en retour dans le SGBDR. Lorsque vous exportez les données
du SGBDR pour Hadoop, vous pouvez les stocker sur Hive, HBase ou directement sur le HDFS.

Qui ?

Apache Sqoop est utilisé par de nombreuses organisations, en particulier celles qui traitent
de grandes quantités de données et qui ont besoin de transférer ces données entre des bases de
données relationnelles et des systèmes de stockage distribués tels que Hadoop

Comment ?

Apache Sqoop utilise des commandes en ligne pour importer/exporter des données. Il se
connecte aux bases de données via JDBC, transfère les données en utilisant des map-reduce jobs,
et propose des options pour filtrer et transformer les données lors du transfert.

Pourquoi ?
 Apache Sqoop simplifie le transfert de données entre des bases de données SQL et
Hadoop, facilitant ainsi l'intégration des données stockées dans des bases de données
relationnelles avec les capacités de stockage et de traitement massif de données de Hadoop.

Installation Sqoop

Cette commande télécharge la distribution binaire Apache Sqoop 1.4.7 avec le support de
Hadoop 2.6.0.

Extraire le contenu d'une archive tar.gz

Déplacer le répertoire Sqoop vers /usr/local/sqoop

Ajouter les variables d'environnement nécessaires pour Sqoop dans le fichier ~/.bashrc.
Cela garantit que Sqoop est accessible depuis n'importe quel emplacement dans notre système.

Installation MySQL

Installer MySQL :
Démarrer le service MySQL :

Télécharger dataset crime_data_la.csv :

Télécharger dataset crime_data_area_name.csv

Créez une nouvelle base de données crime_la dans MySQL :

 Créez les tables crime_data_la et Area_lookup :

Cette commande permet à l'utilisateur root d'exécuter le client MySQL en activant la

possibilité de charger des données à partir de fichiers locaux.

Chargez les données dans la base de données crime_data_la :

Chargez les données dans la base de données crime_data_area_name :

 Cette commande permet de vérifier que les données sont bien chargées.

Après la sélection des données depuis la base de données crime_data_la , on a obtenu

ces résultat :

Après la sélection des données depuis la base de données area_lookup, on a obtenu

ces résultats :
 Cette commande Sqoop importe des données spécifiques depuis la table "crime_data_la"
d'une base de données MySQL vers Hadoop. Les données importées sont filtrées en fonction de
la condition spécifiée dans la clause WHERE, et le résultat est stocké dans le répertoire cible
"/user/ubuntu/crime_la/export" sur Hadoop.

Exercise 3: Explore Datastreaming and Apache kafka.

Datastreaming
Quoi (What) :

Le streaming de données (Data Streaming) est un modèle de traitement des données en

temps réel où les informations sont traitées au fur et à mesure de leur création, plutôt que
stockées pour un traitement ultérieur.

Pourquoi (Why) :

Le streaming de données permet de traiter les données en temps réel, offrant une réactivité
immédiate aux événements et un traitement continu des informations.

Comment (How) :

Le streaming de données est implémenté en utilisant des plates-formes de streaming telles

qu’Apache Flink, Apache Storm, ou des bibliothèques comme Apache Spark Streaming.
 Où (Where) :

Le streaming de données peut être mis en œuvre dans divers contextes, tels que l'Internet
des objets (IoT), l'analyse en temps réel, la surveillance de l'activité utilisateur, etc.

Quand (When) :

Le streaming de données est utilisé lorsque les analyses en temps réel sont cruciales,
nécessitant des réponses immédiates aux événements ou des décisions basées sur des données en
constante évolution.

Apache kafka
Quoi (What) :

Apache Kafka est une plateforme de streaming de données open source. À l’origine, elle
fut développée en interne par LinkedIn en guise de queue de messagerie. Toutefois, cet outil
largement évolué et ses cas d’usage se sont multipliés.

Pourquoi (Why) :

Il faut savoir que Kafka est distribué. Cela signifie que ses capacités sont élastiques. Il
suffit d’ajouter des noeuds, c’est-à-dire des serveurs, à un cluster pour l’étendre.

Une autre particularité de Kafka est sa faible latence. Cela signifie qu’elle peut prendre en
charge le traitement de nombreuses données en temps réel.

Elle permet de mettre à l'échelle horizontalement pour gérer de grandes quantités de

données et garantir la tolérance aux pannes. Les performances élevées, la scalabilité et la
durabilité des données.

Comment (How) :

Kafka est composé de :

Broker Kafka : Un broker Kafka est un serveur individuel qui stocke les données et les sert
aux producteurs et aux consommateurs. Plusieurs brokers forment un cluster Kafka.
 Topic : Un topic est une catégorie ou un canal de flux de données. Les producteurs publient
des messages dans un topic, et les consommateurs s'abonnent à un ou plusieurs topics pour traiter
ces messages.

Producer : Un producteur Kafka est une entité qui publie des messages dans un topic. Les
producteurs sont responsables de la génération des données.

Consumer : Un consommateur Kafka est une entité qui s'abonne à un ou plusieurs topics
pour traiter les messages publiés. Les consommateurs peuvent être organisés en groupes de
consommateurs.

Consumer Group : Un groupe de consommateurs est un ensemble de consommateurs

partageant la charge de traitement des messages d'un ou plusieurs topics.

Partition : Les topics peuvent être divisés en partitions. Chaque partition est un ordre
séquentiel et linéaire de messages. Les partitions permettent une distribution parallèle des
données.

Zookeeper : Zookeeper est utilisé par Kafka pour la gestion de cluster, la coordination et la
gestion des tâches réparties.

Producer API : Une API pour la publication de messages dans les topics.

Consumer API : Une API pour la souscription et le traitement des messages à partir des
topics.

Kafka Connect : Kafka Connect est un framework pour connecter Kafka à d'autres
systèmes de stockage et de traitement de données.

Kafka Streams : Kafka Streams est une bibliothèque Java pour la création d'applications de
traitement de flux directement sur la plateforme Kafka.