Département Mathématiques et Informatique

Rapport du
Stage d’Initiation
Filière :
« Ingénierie Informatique : Big Data et Cloud Computing »

II-BDCC

Développement d'un Pipeline ETL

pour l'Analyse des Demandes de Prêt :
Mise en Oeuvre, Automatisation et
Visualisation des Données

Réalisé par: Encadré par:

 Zakaria Ouakrim  Mme. FANDI Kawtar
 Mr. OUHMOUCH Hicham

Année Universitaire: 2024-2025

1
 Dédicace

Je dédie ce travail

À MES CHERS PARENTS

Pour votre amour inconditionnel, vos encouragements constants et vos prières bienveillantes. Que
ce travail soit le reflet de vos sacrifices et de vos espérances pour moi. Recevez-le comme un
humble témoignage de ma profonde gratitude, de mon respect et de l'amour immense que je vous
porte.

À MA GRANDE FAMILLE
Je vous exprime ma sincère gratitude pour votre soutien indéfectible, votre amour et votre
encouragement constant. Vous avez été une source de réconfort et de motivation tout au long de
mon parcours.

À L'ÉQUIPE DE M2T
Je suis profondément reconnaissant envers la société « M2T » et toute son équipe pour leur soutien
et leur bienveillance. Votre professionnalisme et votre générosité ont été une grande source
d'inspiration pour moi.

À MES AMIS CHERS

Merci pour votre amitié sincère, votre présence constante et les moments précieux que nous avons
partagés. Que Dieu vous accorde santé, bonheur et prospérité.

2
Remerciement

Je tiens à exprimer ma profonde gratitude à Monsieur Hicham et Madame Kawtar, mes

encadrants, pour leur soutien inestimable, leurs conseils éclairés et leur accompagnement
tout au long de ce projet. Votre expertise, votre disponibilité et votre encouragement
constant ont été essentiels à la réussite de ce travail. Merci pour votre confiance et votre
engagement, qui ont non seulement enrichi mon apprentissage, mais aussi renforcé ma
passion pour ce domaine.

Je souhaite également remercier toute l’équipe de M2T pour l’opportunité exceptionnelle

qui m’a été offerte de travailler au sein de votre entreprise. Votre accueil chaleureux, votre
esprit d'équipe et votre professionnalisme ont créé un environnement de travail inspirant et
motivant. Cette expérience a été une occasion unique de développer mes compétences et
d'apprendre dans un cadre stimulant et bienveillant.

Merci à chacun de vous pour votre soutien et votre collaboration, qui ont grandement
contribué au succès de ce projet.

3
 Table des matières
Dédicace ............................................................................................................................................... 2
Remerciement ...................................................................................................................................... 3
Introduction générale ........................................................................................................................ 7
Chapitre 1: Le contexte générale du projet ................................................................................... 8
1. Introduction ............................................................................................................................ 8
2. Présentation de l'Organisation Hôte .......................................................................................... 8
2.1 M2T ............................................................................................................................... 8
2.2 L’organigramme de l’entreprise .............................................................................. 10
3. Description du projet .......................................................................................................... 10
3.1 Étude de L’existant ................................................................................................... 10
3.2 Problématique ........................................................................................................... 11
3.3 Solution proposée ..................................................................................................... 11
4. Conclusion ........................................................................................................................... 11
Chapitre 2: Analyse et Conception du Système ........................................................................ 12
1. Introduction .......................................................................................................................... 12
2. Les besoins fonctionnels et non fonctionnels ......................................................................... 12
2.1 Besoins fonctionnels ................................................................................................ 12
2.2 Besoins non fonctionnels ........................................................................................ 12
3. Concepts Clés : ETL et Data Lake ........................................................................................... 13
3.1 ETL.............................................................................................................................. 13
3.2 Data lake .................................................................................................................... 13
4. Modélisation du Système: Diagrammes UML et MCD.......................................................... 14
4.1 Diagramme de séquence ................................................................................................ 14
4.2 Modélisation des Données: Diagramme MCD .................................................................... 14
5. Technologies Utilisées et Justification ..................................................................................... 15
5.1 Apache Hadoop ........................................................................................................ 15
5.2 Hive ............................................................................................................................. 16
5.3 Airflow ......................................................................................................................... 16
5.4 Python .......................................................................................................................... 17
5.5 Pandas .......................................................................................................................... 18
5.6 Docker .......................................................................................................................... 18
5.7 Git/GitHub .................................................................................................................. 19
5.8 Matplotlib ..................................................................................................................... 19
5.9 Visual Studio Code....................................................................................................... 19
6. Conclusion ............................................................................................................................. 20
Chaptire 3: Réalisation ....................................................................................................................... 21
1. Introduction .................................................................................................................................... 21
2. Architecture du projet..................................................................................................................... 21
3. Mise en Oeuvre et Développement du Système ............................................................................ 22
3.1 Configuration de l’environnement de développement ................................................. 22
3.2 Mise en Place d'un Environnement de Test avec HDFS et Hive ...................... 23
3.2 Automatisation des Workflows avec Apache Airflow ................................................. 25
3.3 Partie du code de l’extraction....................................................................................... 26
3.4 Processus de Transformation (Transform) ................................................................... 27
3.5 Processus de Chargement (Load) ................................................................................. 28
3.6 Génération des Rapports CSV ..................................................................................... 29
4. Visualisation des Données avec Matplotlib ................................................................................... 29
4.1 Tableau de bord d’échéance détaillé ............................................................................ 30
4.2 Tableau de Bord Détails des Clients............................................................................ 33

4
5. Conclusion ..................................................................................................................................... 36
Conclusion ......................................................................................................................................... 37

5
 Liste des Figures
Figure 1 : Chiffres clés M2T .................................................................................................... 9
Figure 2 : Exemple d'opérateurs M2T .................................................................................... 9
Figure 3 : Organigramme de l’entreprise ............................................................................. 10
Figure 4 : Processus ETL ....................................................................................................... 13
Figure 5 : Diagramme de Séquence UML du Processus ETL Automatisé avec Apache
Airflow................................................................................................................................ 14
Figure 6 : Modèle Conceptuel de Données (MCD) ................................................................... 15
Figure 7 : Logo de Apache Hadoop ........................................................................................... 16
Figure 8 : Logo de Hive ............................................................................................................ 16
Figure 9 : Logo de Airflow ........................................................................................................ 17
Figure 10 : Logo de Python........................................................................................................ 18
Figure 11 : Logo de Pandas ........................................................................................................ 18
Figure 12 : Logo de Docker ....................................................................................................... 19
Figure 13 : Logo de Git et GitHub ............................................................................................. 19
Figure 14 : Logo de Matplolib ................................................................................................... 19
Figure 15 : Logo de Vs code ...................................................................................................... 20
Figure 16 : Architecture du projet .............................................................................................. 22
Figure 17 : Version Docker utilisé ............................................................................................. 22
Figure 18 : Mes images Docker ................................................................................................. 23
Figure 19 : Conteneurs Docker Configurés ............................................................................... 23
Figure 20 : La base de données et les tables sur Hive................................................................ 24
Figure 21 : la table output_table_etl .......................................................................................... 24
Figure 22 : Copié les données vers namenode conteneur .......................................................... 25
Figure 23 : Création d'un fichier HDFS et transfert des données .............................................. 25
Figure 24 : Airflow DAG ........................................................................................................... 25
Figure 25 : La représentation graphe du DAG ........................................................................... 25
Figure 26 : Les tâches de notre DAG ......................................................................................... 26
Figure 27 : Partie du Code de l'Extraction ................................................................................. 27
Figure 28 : Partie du Code du Transformation ........................................................................... 28
Figure 29 : Partie du code de chargement .................................................................................. 28
Figure 30 : Capture d'écran du DAG Apache Airflow ............................................................... 29
Figure 31 : les quatre tâches exécutées avec succès .................................................................. 29
Figure 32 : Résultat de 'head -n 2' affichant les deux premières lignes du fichier CSV. ........... 29
Figure 33 : Logo du Tkinter ....................................................................................................... 30
Figure 34 : Tableau de bord Vue détaillée des échéances .......................................................... 30
Figure 35 : Nombre total d'échéances par client ........................................................................ 31
Figure 36 : Nombre total d'échéances par espace de service .................................................... 31
Figure 37 : Répartition des demandes de prêt par produit ........................................................ 32
Figure 38 : Raisons de rejet des demandes de prêt et nombre associé....................................... 33
Figure 39 : Relation entre code_es et le statut des demandes de prêt. ....................................... 33
Figure 40 : Tableau de bord Détails des Clients ........................................................................ 34
Figure 41 : Répartition des statuts des demandes de prêt par genre (1 = homme, 2 = femme) . 34
Figure 42 : Répartition des statuts des demandes de prêt par âge des clients ............................ 35
Figure 43 : Raisons de rejet des demandes de prêt par genre .................................................... 35
Figure 44 : Raisons de rejet des demandes de prêt par âge des clients ...................................... 36
Figure 45 : Répartition géographique des clients par ville ........................................................ 36

6
Introduction générale

L'analyse des données est devenue une composante essentielle pour les entreprises
modernes dans leur recherche d'optimisation des processus et de prise de décision. À l’aide
des technologies de traitement et de visualisation des données, il est devenue impératif
pour les organisations de maximiser l'exploitation de ces outils pour maintenir leur
compétitivité. Notre projet présenté ici s'inscrit dans cette dynamique, avec pour objectif
principal d'identifier et de visualiser les données dans les demandes de prêt à partir de
données stockées dans un data lake Hadoop.

Ce projet a consisté à développer un pipeline de données utilisant le processus ETL (Extract,

Transform, Load) pour extraire des données de diverses tables résidant dans le système
Hadoop via HDFS. Après le traitement, les données ont été chargées dans une table Hive,
puis utilisées pour générer un rapport CSV et des visualisations graphiques, tout en étant
toujours sauvegardées. Ce projet répond à un besoin essentiel de l'entreprise : fournir une
analyse précise et des visualisations claires pour éclairer leur décision stratégique.
Le but de ce rapport est de faire une présentation exhaustive de tous les aspects que j’ai pu
apprendre et appliquer. Ce livrable se compose de trois sections :

La Section 1 propose une introduction au projet, offrant un aperçu complet du contexte

général. Elle présente l'organisation hôte et fournit une description des objectifs du projet
et des problèmes qu'il vise à résoudre.

Dans la Section 2, cette section sera focalisé pour découvrir les différentes technologies
utilisées dans le projet ETL, en explorant les aspects théoriques et techniques sous-jacents.

Enfin, la Section 3 présente les résultats du projet. Elle détaille le processus d'ETL, depuis
l'extraction des données jusqu'à leur chargement dans la table final sur Hive, ainsi que la
création des visualisations à l'aide de Matplotlib. Le rapport se conclut par une discussion
sur les enseignements tirés et les perspectives d'amélioration pour de futures itérations du
projet.

7
Chapitre 1: Le contexte générale du projet

1. Introduction
Ce chapitre présente le contexte général dans lequel s'inscrit le projet. Tout d'abord,
il présente la société hôte M2T, filiale du groupe Banque Centrale Populaire.
La seconde partie mettra en avant les principales caractéristiques de ce projet, incluant la
problématique abordée, les objectifs visés, la solution technologique proposée, ainsi que la
méthodologie adoptée au cours de ce travail. Ce chapitre pose les bases pour les sections
suivantes, où chaque aspect sera exploré en profondeur.

2. Présentation de l'Organisation Hôte

2.1 M2T
M2T, filiale du groupe Banque Centrale Populaire et établissement de paiement
agrée par Bank AL-Maghrib en 2018, M2T est aujourd’hui le leader et premier spécialiste
au Maroc dans les services d’encaissement de toutes factures sur des réseaux propres et
tiers, ainsi que la gestion déléguée, notamment pour le compte d’opérateurs & distributeurs
d’Eau, d’Électricité, Télécommunications, Transfert de fonds, Transports etc.
Depuis sa création en 2001, M2T a focalisé son activité sur deux principaux champs d’action
destinés aux entreprises & institutions : les Services et les Solutions de Paiement multicanal
sécurisés. Le savoir-faire de M2T trouve ses sources dans une organisation constituée de
directeurs et cadres ayant une longue expérience dans la gestion de transactions
électroniques et la gestion stratégique et opérationnelle de réseaux de distribution externes,
ainsi que d’ingénieurs expérimentés spécialisés dans les secteurs informatiques et de
télécommunications. Présents au Maroc, mais également au Sénégal, au Mali, au Niger et
en Côte d’Ivoire à travers sa filiale ATPS, et en France, à travers sa filiale ETPS, M2T compte
parmi ses clients des entités de renom, notamment des multinationales ainsi que diverses
entreprises privées et publiques.
M2T compte aujourd’hui plus de 250 collaborateurs, d’experts et de professionnels dont
l’objectif est de servir qualitativement chaque mois plus de 3 millions de clients, via des
solutions performantes et sécurisées à forte valeur ajoutée.
M2T gère un réseau de +4500 agences à travers le réseau Tasshilat, leader dans
l'encaissement de factures et Chaabi Cash, le spécialiste du transfert d'argent national et
international.
M2T met également à dispositions des entreprises 18 ans d'expérience et d'expertise en
leur proposant un catalogue complet de solution de paiement et de gestion de portefeuille :
Amanpay, GETI, E-pag, Pay Direct, ...

8
M2T aujourd’hui, effectue un million de transactions sécurisées par jour, soulignant
ainsi l’importance de cette entreprise mais également des données qu’elle en ressort
et qui doivent être gérées.

Figure 1: Chiffres clés M2T

M2T est un hub de paiement multicanal qui propose des paiements de factures pour
les opérateurs les plus importants au Maroc, qu’ils soient des entreprises privées ou des
entités publiques.

Voici une image traduisant quelques références :

Figure 2: Exemple d'opérateurs M2T

L’entreprise M2T se veut d’être un hub multi canal en proposant :

● Externalisation et digitalisation des procédures et de la relation client via des

canaux sécurisés à fort potentiel via une démarche optimale en termes de coûts et de délais.

9
 ● Le bénéficiaire économisera du temps et n’aura plus besoin à se déplacer les
locaux ou réseau de l’organisme pour ses opérations et peut aller vers un point de
proximité ou utiliser son wallet ou application bancaire.
● Sécurité des flux financiers, authentification de l’utilisateur et traçabilité assurés
par le canal d’accès.
● Réduire les coûts et délais des processus actuels et accroître la productivité.
● Traiter des volumes de plus en plus importants et une population de plus en plus
diversifiée.
● Plus de proximité et de disponibilité 7j/24 des services pour les usagers.
● Une couverture large et globale pour tous les usagers.
● Réduire les réclamations et améliorer la qualité du service rendu.

2.2 L’organigramme de l’entreprise

Figure 3: Organigramme de l’entreprise

Durant ma période de stage, j’ai été attribuée au département Systèmes
d’informations, qui lui, s’occupe de l’ensemble des solutions technologiques de l’entreprise.
En effet, constitué de deux plateaux, un plateau consacré à la Data et à l’ensemble des
solutions concernant les sciences de l’information, et un autre consacré à la Prod qui assure
le bon fonctionnement du système de paiement de factures de M2T.

3. Description du projet
3.1 Étude de L’existant
Avant la mise en place de la solution proposée, l'entreprise se trouvait confrontée à
un processus manuel et répétitif pour générer le rapport mensuel sur les demandes de prêt.
Chaque mois, les équipes devaient extraire les données brutes depuis le lac de données
Hadoop, effectuer manuellement les transformations nécessaires pour les rendre
exploitables, puis créer les visualisations à partir de ces données transformées. Ce
processus non automatisé était non seulement un consommateur de temps, mais
également sujet à des erreurs humaines, ce qui pouvait affecter la qualité des rapports
produits. De plus, l'absence d'une solution centralisée et automatisée impliquait que chaque
cycle de génération de rapport nécessitait une nouvelle création des visualisations,
augmentant ainsi la charge de travail des équipes et limitant l'efficacité opérationnelle de
l'entreprise.

10
3.2 Problématique
Comment automatiser et optimiser le processus d'extraction, de transformation et de
chargement (ETL) des données de demandes de prêt issues d'un lac de données Hadoop,
afin de garantir l'intégrité, la disponibilité et la visualisation des données pour une prise de
décision éclairée et une gestion efficace des risques ?
3.3 Solution proposée
Pour répondre à la problématique identifiée, une solution de pipeline de données
automatisé a été développée en utilisant un processus ETL (Extract, Transform, Load).
Cette solution permet d'automatiser l'extraction des données de demandes de prêt à partir
des différentes tables du data lake, tout en assurant leur transformation pour garantir la
cohérence et l'intégrité des informations. Une fois transformées, les données sont chargées
dans une table Hive centralisée, où elles sont immédiatement disponibles pour l'analyse.
En parallèle, une autre sauvegarde automatique est effectuée dans une autre table Hive,
garantissant qu'il y a toujours une copie des données en cas d'imprévu. Cette
automatisation permet de générer le rapport mensuel de manière automatique et cohérente,
tout en intégrant directement les visualisations nécessaires, réduisant ainsi
considérablement la charge de travail manuelle et les risques d'erreurs.

4. Conclusion
Ce chapitre a présenté le contexte du projet, en soulignant les défis auxquels
l'entreprise est confrontée dans la gestion manuelle et répétitive des données de demandes
de prêt. Le projet vise à automatiser le processus d'ETL (Extract, Transform, Load) pour
assurer l'intégrité et la disponibilité des données, tout en facilitant leur analyse grâce à des
visualisations et des rapports générés automatiquement. Les besoins fonctionnels et non
fonctionnels ont été définis pour orienter le développement de la solution. Les prochains
chapitres exploreront en détail la solution proposée, sa mise en œuvre et les résultats
obtenus.

11
Chapitre 2: Analyse et Conception du Système
1. Introduction
Dans ce chapitre, nous analysons et concevons le pipeline de données automatisé
pour le processus ETL dans Hadoop. Nous examinons les besoins du projet, les choix
technologiques pour la gestion des données et la visualisation, et les décisions de
conception prises pour optimiser la performance et l'intégrité des données.

2. Les besoins fonctionnels et non fonctionnels

Pour concevoir un système efficace et robuste, il est essentiel de définir clairement
les besoins fonctionnels et non fonctionnels qui guideront le développement du pipeline de
données.

2.1 Besoins fonctionnels

• Automatisation du processus ETL pour les données de demandes de prêt.
• Extraction efficace des données à partir des différentes tables du lac de données
Hadoop.
• Transformation des données pour garantir leur cohérence et leur intégrité avant le
chargement.
• Chargement des données transformées dans une table Hive centralisée pour
analyse.
• Génération automatique de visualisations et du rapport mensuel basés sur les
données consolidées.
• Sauvegarde automatique des données dans une table Hive distincte comme
backup pour assurer la sécurité et la disponibilité des informations.

2.2 Besoins non fonctionnels

• Performance : Capacité à traiter de grands volumes de données dans un temps
réduit.
• Haute disponibilité et résilience : Minimisation des temps d'arrêt en cas de panne ou
d'incident.
• Portabilité : Utilisation de Docker pour garantir que le système peut être facilement
déployé et exécuté sur différents environnements sans nécessiter de modifications
majeures.
• Maintenabilité : Facilité de maintenance et d'évolution du système sans perturber
son fonctionnement.

12
3. Concepts Clés : ETL et Data Lake
Avant de plonger dans les détails d’analyse de notre projet, il est important de
comprendre deux concepts fondamentaux qui jouent un grand rôle dans la gestion et
l’analyse des données.

3.1 ETL
ETL (Extract, Transform and Load) est un processus automatisé qui prend les
données brutes, extrait l’information nécessaire à l’analyse, la transforme en un format qui
répond aux besoins opérationnels et la charger. ETL résume généralement les données afin
de réduire leur taille et d’améliorer leur performance pour des types d’analyse spécifiques.

Figure 4: Processus ETL

Un processus ETL passe par trois étapes : Extraction, Transformation et chargement

- Extraction (Extract): est la première étape du processus ETL, consistant à récupérer les
données brutes à partir de diverses sources de stockage, telles que les base de données
SQL et NoSQL, fichiers, ou des systèmes de stockage en cloud. L’objectif de cette étape
est de centraliser les données nécessaires pour une analyse future.
- Transformation (Transform) est la deuxième étape du processus ETL, où les données
extraites sont nettoyées, modifiées et structurées pour répondre aux besoins spécifiques
d'analyse. Cette étape peut inclure des opérations telles que le filtrage des données, la
normalisation, l'agrégation, le calcul de nouveaux indicateurs, ou la conversion des formats
de données.
- Chargement (Load) est la troisième et dernière étape du processus ETL, où les données
transformées sont transférées vers un système de stockage final, tel qu'une base de
données, un entrepôt de données, ou un data lake. L'objectif de cette étape est de rendre
les données prêtes et accessibles pour l'analyse, la visualisation, ou la prise de décision.
3.2 Data lake
Un Data Lake est un système de stockage qui permet de conserver de grandes
quantités de données brutes dans leur format d'origine, qu'elles soient structurées, semi-
structurées, ou non structurées. Contrairement aux entrepôts de données traditionnels, un
data lake peut stocker des données sans avoir besoin de les transformer offrant ainsi une
grande flexibilité pour l'analyse future.

13
4. Modélisation du Système: Diagrammes UML et MCD
Dans cette section, nous présentons les diagrammes UML et MCD pour modéliser la
structure du système et la gestion des données, offrant une vue d'ensemble claire de
l'architecture et des flux de données.

4.1 Diagramme de séquence

Le diagramme de séquence UML ci-dessous illustre le déroulement du processus ETL
automatisé géré par Apache Airflow, depuis la planification du workflow jusqu'au chargement
final des données transformées. Chaque étape est représentée par les interactions entre
les différents composants du système.

Figure 5: Diagramme de Séquence UML du Processus ETL Automatisé avec Apache

Airflow

4.2 Modélisation des Données: Diagramme MCD

Avant de présenter le Modèle Conceptuel de Données (MCD), il est important de souligner
son rôle clé dans notre projet ETL. Le MCD aide à organiser les données et à définir les
relations entre elles, assurant ainsi une gestion efficace et cohérente des informations tout
au long du processus d'extraction, de transformation et de chargement.

14
 Figure 6: Modèle Conceptuel de Données (MCD)

5. Technologies Utilisées et Justification

5.1 Apache Hadoop
Apache Hadoop est un framework logiciel dédié au stockage et au traitement de
larges volumes de données. C'est un projet open source soutenu par la fondation Apache
Software Foundation.
Le framework principal Hadoop comprend quatre modules qui fonctionnent ensemble pour
former l'écosystème Hadoop :
HDFS (Hadoop Distributed File System) : C'est le composant central d'Hadoop, un
système de fichiers distribué qui offre un accès rapide aux données d'application sans
nécessiter de schémas prédéfinis.

15
YARN (Yet Another Resource Negotiator) : Ce module gère les ressources de calcul dans
les clusters et les utilise pour planifier et allouer les applications des utilisateurs sur le
système Hadoop.
MapReduce : Un modèle de programmation qui facilite le traitement de grandes quantités
de données à l'aide d'algorithmes parallèles et distribués. Il permet de développer des
applications qui transforment de grand ensembles de données en des formats plus gérables.

Hadoop Common : Ce composant regroupe les utilitaires et bibliothèques utilisés et

partagés par les autres modules d'Hadoop.
Ces composants font d'Hadoop un framework puissant pour le traitement et l'analyse de
données distribuées à grande échelle. Il permet aux entreprises de stocker, traiter et
analyser de grandes quantités de données de manière efficace et économique.

Figure 7: Logo de Apache Hadoop

5.2 Hive
Apache Hive est un entrepôt de données open source conçu pour interroger et
analyser de grands ensembles de données stockés dans Hadoop. En tant que composant
clé de l'infrastructure Hadoop, Hive permet trois principales fonctions : la synthèse,
l'interrogation, et l'analyse des données. Il utilise HiveQL, un langage de requête qui
ressemble à SQL, pour faciliter les requêtes sur de vastes volumes de données.
Ce qui distingue Hive, c'est sa capacité à convertir automatiquement les requêtes HiveQL
en tâches MapReduce exécutées sur Hadoop, tout en supportant également des scripts
MapReduce personnalisés.

Figure 8: Logo de Hive

5.3 Airflow
Apache Airflow est une plate-forme open source qui permet de créer, planifier et
surveiller des workflows par la programmation. Elle est largement utilisée pour orchestrer et
gérer des pipelines de données complexes et le lancement de tâches. Airflow offre plusieurs
avantages, notamment sa flexibilité, car tout ce qui peut être fait avec du code Python peut
être intégré dans la plate-forme. De plus, Airflow est extensible grâce à de nombreux plugins

16
qui facilitent l'interaction avec divers systèmes externes, et permet également de développer
de nouveaux plugins pour répondre à des besoins spécifiques.
En écrivant des pipelines en code et en utilisant les plugins disponibles, Airflow offre une
plate-forme unifiée pour l'orchestration et le monitoring de divers systèmes dépendants.
Apache Airflow est utilisé pour l'orchestration des workflows ETL en raison de sa flexibilité
et de ses capacités de planification. Airflow permet de définir, planifier et surveiller les
workflows, garantissant ainsi l'automatisation et la gestion efficace des processus de
traitement de données.

Figure 9: Logo de Airflow

5.4 Python
Python est un des langages de programmation les plus connus. Ayant sa propre
forme (syntaxe), et ses propres significations (sémantique), il permet d’écrire les instructions
que l'ordinateur va tout simplement suivre. Il s’agit d’un langage interprété, c-à-d qu’il simule
un ordinateur qui comprend un langage de haut niveau. Au lieu de traduire le programme
source en un langage compréhensible par la machine, l’interpréteur exécute le code source
progressivement.
Python est un langage de programmation dont la syntaxe simple et facile à apprendre
favorise la lisibilité, réduisant ainsi les coûts de maintenance des programmes. Sa prise en
charge des modules et des packages encourage la modularité et la réutilisation du code.
De plus, l'interpréteur Python et sa grand bibliothèque sont disponibles gratuitement, sous
forme de source ou de binaire, pour toutes les principales plates-formes, et peuvent être
librement distribués.
Python a été choisi pour le processus ETL en raison de plusieurs avantages importants par
rapport à d'autres outils disponibles :
Flexibilité et Richesse des Bibliothèques : Python dispose d'une large gamme de
bibliothèques puissantes, telles que Pandas pour la manipulation de données et NumPy
pour les calculs numériques. Cette diversité facilite la gestion efficace de toutes les étapes
du processus ETL (extraction, transformation, chargement).
Facilité d'Intégration avec d'Autres Technologies : Python s'intègre aisément avec
d'autres outils utilisés dans ce projet, comme Apache Airflow pour l'orchestration des
workflows. Cette compatibilité simplifie la création de pipelines de données complexes tout
en exploitant des technologies complémentaires pour améliorer les performances et la
gestion des workflows.
Lisibilité et Simplicité du Code : La syntaxe claire et concise de Python permet de
développer et de maintenir facilement des scripts ETL. Contrairement à d'autres langages
ou outils spécialisés, Python rend le code plus lisible et compréhensible, ce qui est essentiel
pour la collaboration en équipe et la durabilité du projet.
Ces avantages font de Python un choix optimal pour les processus ETL dans ce projet,
offrant des solutions robustes, flexibles et faciles à maintenir pour l'extraction, la
transformation et le chargement des données.

17
 Figure 10: Logo de Python
5.5 Pandas
Pandas a été choisi pour le traitement des données dans ce projet en raison de ses
fonctionnalités puissantes et de sa simplicité d'utilisation. Bien que Apache Spark soit une
alternative courante pour les processus ETL, surtout lorsqu'il s'agit de traiter des volumes
massifs de données sur plusieurs nœuds, Pandas a été préféré dans ce contexte car le
projet fonctionne sur un seul nœud.
Pandas offre une performance optimale pour la manipulation de données sur un seul nœud
grâce à ses structures de données robustes et à ses nombreuses fonctions intégrées pour
le nettoyage, la transformation et l'analyse des données. De plus, Pandas permet de
facilement exporter des données transformées en fichiers CSV, facilitant ainsi la génération
de rapports automatiques
En optant pour Pandas, nous profitons de sa facilité et de sa capacité à gérer les données
en mémoire de manière efficace, tout en évitant la complexité et les coûts de configuration
liés à l'utilisation d'un cadre distribué tel qu'Apache Spark.

Figure 11: Logo de Pandas

5.6 Docker
Dans ce projet, Docker a été employé afin de garantir une mise en place cohérente
et portable des applications et services requis pour le pipeline ETL. Docker assure que les
scripts Python, ainsi que les configurations de Hadoop, Hive et Airflow, fonctionnent de
manière homogène sur divers environnements en encapsulant toutes les dépendances
dans des conteneurs. La mise en œuvre de cette méthode diminue les difficultés de
compatibilité, simplifie la gestion des versions et simplifie les tests et le débogage, ce qui
rend la maintenance du projet plus efficace et souple.

18
 Figure 12: Logo de Docker
5.7 Git/GitHub
Dans ce projet, j’ai employé Git et GitHub pour la gestion de version et la collaboration.
Git facilite la surveillance des modifications du code, ce qui facilite le contrôle des versions
et la gestion des branches. D'un autre côté, GitHub propose une plateforme centralisée pour
stocker le code, travailler en collaboration avec les autres membres de l'équipe et gérer les
contributions, garantissant ainsi une coordination efficace et une intégrité du code tout au
long du processus de développement.

Figure 13: Logo de Git et GitHub

5.8 Matplotlib
La création de visualisations des données transformées dans ce projet a été réalisée
en utilisant Matplotlib. La bibliothèque Python offre la possibilité de créer différents types de
graphiques, tels que des histogrammes, des courbes et des diagrammes en barres, ce qui
simplifie l'analyse et la présentation des résultats. En raison de sa souplesse et de ses
multiples possibilités de personnalisation, Matplotlib offre la possibilité de générer des
visualisations claires et informatives, qui sont indispensables pour saisir les insights des
données traitées.

Figure 14: Logo de Matplolib

5.9 Visual Studio Code
Visual Studio Code (VS Code) a été choisi comme éditeur de code pour ce projet en raison
de sa flexibilité et de ses nombreuses extensions. Il offre une interface intuitive et légère,
idéale pour le développement Python et la gestion des scripts ETL. Avec des fonctionnalités

19
comme l'auto-complétion, le débogage intégré, et la prise en charge de Git, VS Code
améliore l'efficacité du développement et facilite la collaboration entre les membres de
l'équipe.

Figure 15: Logo de Vs code

6. Conclusion
Dans ce chapitre, nous avons exploré les choix technologiques et les concepts clés
qui ont guidé la conception du système ETL. Le choix de technologies telles que Hadoop
pour le stockage distribué, Hive pour la gestion des données, Python et Pandas pour le
traitement et l'analyse, a été motivé par la nécessité d'une solution efficace, flexible et
scalable. Chaque technologie a été sélectionnée en fonction de ses capacités à répondre
aux besoins spécifiques du projet, garantissant ainsi une architecture robuste et optimisée
pour le traitement des données de demandes de prêt. Ce cadre technologique solide
prépare la voie pour la phase de réalisation, où ces outils seront intégrés pour atteindre les
objectifs du projet.

20
Chaptire 3: Réalisation
1. Introduction
Ce chapitre met l'accent sur la mise en œuvre concrète du projet, en détaillant la
mise en place du pipeline ETL utilisant les technologies choisies. Chaque étape du
développement sera examinée, allant de l'extraction des données à partir de Hive, à leur
transformation avec Python et Pandas, jusqu'au chargement final dans les tables Hive.
L'intégration des outils tels que Apache Airflow pour gérer les workflows et Docker pour
garantir un environnement de déploiement cohérent sera également abordée. Enfin, ce
chapitre abordera la conception des illustrations et des rapports, mettant en évidence
l'utilisation de chaque élément technologique pour atteindre les objectifs du projet.

2. Architecture du projet
L'architecture du projet est organisée autour d'un pipeline de données ETL (Extract,
Transform, Load) orchestré par Apache Airflow, visant à extraire, transformer, et charger les
données de manière efficace depuis un lac de données Hadoop.

Sources de Données:

Les données proviennent d'un lac de données Hadoop basé sur HDFS, comprenant
les tables que loan_request, clients, et payment_deadline. Ces tables contiennent les
informations nécessaires pour analyser les demandes de prêt, les détails des clients, et les
échéances de paiement.

Pipeline de Données (Processus ETL):

 Extraction (Extract): La première étape du processus ETL consiste à extraire les

données des tables Hadoop via Apache Hive. Hive permet d'accéder aux données
stockées dans HDFS et d'effectuer des requêtes pour récupérer les données
pertinentes des différentes tables.

 Transformation (Transform): Une fois les données extraites, elles sont

transformées à l'aide de Pandas, une bibliothèque Python. Cette étape comprend
le nettoyage des données, la fusion de tables, le remplissage des valeurs
manquantes, le réordonnancement des colonnes, et la création de nouvelles
colonnes. Pandas est choisi pour sa facilité d'utilisation et sa capacité à gérer les
données en mémoire, ce qui convient bien à un environnement à nœud unique.

 Chargement (Load): La dernière étape consiste à charger les données nettoyées

et transformées dans une table Hive, qui est stockée dans un fichier HDFS. En plus
de charger les données transformées dans une table principale, les données sont
également sauvegardées dans une autre table Hive pour des raisons de
sauvegarde, garantissant ainsi la persistance des données en cas d'incident.

21
Orchestration et Planification:

Apache Airflow est utilisé pour orchestrer et planifier les différentes étapes du pipeline
ETL. Airflow permet de définir des workflows qui automatisent l'extraction, la transformation,
et le chargement des données, tout en offrant des fonctionnalités de suivi et de gestion des
dépendances entre les tâches.

Figure 16: Architecture du projet

3. Mise en Oeuvre et Développement du Système

3.1 Configuration de l’environnement de développement
La première étape du projet a consisté à configurer l'environnement de
développement pour le pipeline ETL. J'ai installé Docker et utilisé des images Docker des
technologies nécessaires, telles que Hadoop, Hive, et Apache Airflow, pour créer des
conteneurs isolés. Cela a permis d'assurer que chaque composant du pipeline fonctionne
dans un environnement contrôlé, éliminant ainsi les problèmes de compatibilité et facilitant
le déploiement.

Figure 17: Version Docker utilisé

En installant ces images Docker, j'ai configuré rapidement les services nécessaires, incluant
Hadoop NameNode, Hadoop DataNode, PostgreSQL, Redis, Airflow Scheduler, Airflow
Worker, et Airflow Trigger. Cette configuration a permis d'éviter le processus de configuration
manuelle pour chaque technologie, simplifiant ainsi la mise en place initiale et permettant
de démarrer le développement et les tests dans un environnement cohérent et stable.

22
 Figure 18: Mes images Docker
L'image ci-dessous illustre les conteneurs Docker déployés pour chaque composant du
pipeline ETL, assurant un environnement isolé et reproductible pour le développement et
l'exécution des workflows.

Figure 19: Conteneurs Docker Configurés

3.2 Mise en Place d'un Environnement de Test avec HDFS et Hive
En raison de la restriction d'accès aux données du lac de données de production aux
seuls employés internes, j'ai mis en place une solution alternative pour le développement et
les tests. J'ai créé un environnement HDFS local et utilisé des fichiers de test fournis au
format CSV. Pour simuler un lac de données, j'ai créé des tables externes dans Hive, reliant
ces tables aux fichiers CSV chargés dans HDFS. J'ai ensuite chargé les données depuis
HDFS dans les tables Hive, ce qui m'a permis de tester et de développer le pipeline ETL
dans un environnement contrôlé. Cette approche m'a offert la flexibilité nécessaire pour
manipuler les données et effectuer les transformations tout en garantissant que le processus
ETL fonctionnait correctement, même sans accès direct aux données de production.

23
 Figure 20: La base de données et les tables sur Hive
L'image suivante montre la table de sortie résultante du processus ETL après le chargement
des données transformées dans Hive.

Figure 21: la table output_table_etl

L'image suivante illustre le processus de copie des fichiers de données depuis la machine
locale vers le conteneur NameNode de Hadoop

24
 Figure 22: Copié les données vers namenode conteneur

L'image suivante montre la création d'un fichier dans HDFS et le transfert des données au
format CSV dans ce fichier.

Figure 23: Création d'un fichier HDFS et transfert des données

3.2 Automatisation des Workflows avec Apache Airflow

Dans Apache Airflow, j'ai créé un DAG pour automatiser le pipeline ETL avec quatre tâches
clés :

1- Extract: Extraction des données des fichiers CSV dans HDFS via des requêtes HiveQL.
2- Transform: Nettoyage et transformation des données avec Python et Pandas.
3- Load: Chargement des données transformées dans les tables Hive finales.
4- sendEmail: Envoi du rapport généré par e-mail aux parties prenantes.

Ce DAG permet une orchestration fluide et automatisée du processus ETL, garantissant

une gestion efficace des données et une distribution rapide des rapports.

Figure 24: Airflow DAG

Figure 25: La représentation graphe du DAG

25
 Figure 26: Les tâches de notre DAG
3.3 Partie du code de l’extraction
Pour la tâche d'extraction, j'ai utilisé PyHive pour me connecter au conteneur Hive
depuis le script Airflow. Cette connexion permet d'exécuter des requêtes HiveQL
directement à partir de Python. J'ai ainsi exécuté une requête SELECT pour récupérer
toutes les données nécessaires des tables externes Hive créées à partir des fichiers CSV
chargés dans HDFS. Ce processus d'extraction assure que les données brutes sont
correctement collectées et prêtes pour la transformation ultérieure.

26
 Figure 27: Partie du Code de l'Extraction
3.4 Processus de Transformation (Transform)
Dans la tâche de transformation, j'ai utilisé Python et la bibliothèque Pandas pour
nettoyer et préparer les données extraites. Les étapes de transformation comprenaient le
nettoyage des données pour supprimer les valeurs manquantes ou incorrectes, l'ajout de
nouvelles colonnes calculées, le renommage et la réorganisation des colonnes existantes,
ainsi que le réordonnancement des lignes en fonction de critères spécifiques. Ces
transformations ont permis d'organiser les données dans un format structuré et exploitable,
prêt pour le chargement final dans Hive.

27
 Figure 28: Partie du Code du Transformation
3.5 Processus de Chargement (Load)
Pour la tâche de chargement, j'ai utilisé les données transformées pour mettre à jour
les tables Hive. Les données nettoyées et réorganisées ont été écrasées dans une table
principale appelée output_table_etl. En parallèle, une copie de sécurité a été effectuée
dans une autre table, output_table_etl_backup, pour garantir la persistance des données.
Enfin, les données ont été exportées dans un fichier CSV pour générer le rapport final,
assurant ainsi la disponibilité des résultats pour une analyse et une diffusion ultérieures.

Figure 29: Partie du code de chargement

L'image ci-dessous montre le DAG d'Apache Airflow avec toutes les tâches
marquées comme réussies, confirmant que chaque étape du processus ETL a été exécutée
correctement.

28
 Figure 30: Capture d'écran du DAG Apache Airflow

Figure 31: les quatre tâches exécutées avec succès

3.6 Génération des Rapports CSV

Après le chargement des données transformées dans Hive, un script Python a été
utilisé pour générer automatiquement un rapports au format CSV à partir des données
consolidées. Ce fichier CSV contient toutes les informations pertinentes après les étapes
d'extraction, de transformation et de chargement, permettant une analyse facile et une
distribution rapide aux parties prenantes. Cette génération automatique de rapport facilite le
suivi des données et offre une vue d'ensemble claire pour la prise de décision.

Figure 32: Résultat de 'head -n 2' affichant les deux premières lignes du fichier CSV.
4. Visualisation des Données avec Matplotlib
Pour analyser visuellement les données transformées, j'ai utilisé Matplotlib, une bibliothèque
Python puissante pour la création de graphiques. Après le chargement et la consolidation
des données dans Hive, les données ont été exportées pour permettre la création de
visualisations facilitant la compréhension des tendances et des insights clés. Les
graphiques générés incluent des histogrammes, des courbes de tendances, et des
diagrammes en barres, offrant une représentation claire et informative des données
analysées. Contrairement aux autres étapes automatisées du pipeline ETL dans Airflow, la
génération de ces visualisations n'est pas déclenchée automatiquement; elle est initiée
manuellement par l'utilisateur selon les besoins.
Pour afficher ces visualisations et créer un tableau de bord interactif, j'ai utilisé Tkinter, une
bibliothèque Python pour les interfaces graphiques. Tkinter permet de concevoir une
interface utilisateur qui regroupe différentes visualisations Matplotlib, offrant ainsi une
plateforme unifiée pour explorer les données de manière interactive et approfondie.

29
 Figure 33: Logo du Tkinter
4.1 Tableau de bord d’échéance détaillé
Le tableau de bord affiché ci-dessus est conçu pour visualiser et analyser les
demandes de prêt. Il est constitué de plusieurs graphiques interactifs créés avec Matplotlib
et affichés à l'aide de Tkinter.

Figure 34: Tableau de bord Vue détaillée des échéances

- Ce graphique montre le nombre total d'échéances pour chaque client, identifié par un ID
abrégé. Il aide à visualiser quels clients ont le plus d'échéances à gérer.

30
 Figure 35: Nombre total d'échéances par client
- Ce graphique en barres montre le nombre total d'échéances par espace de service.
Chaque barre représente un espace de service spécifique et le nombre total d'échéances
qui y sont associées.

Figure 36: Nombre total d'échéances par espace de service

- Ce diagramme circulaire montre la répartition des demandes de prêt par produit. Ici, 100 %
des demandes de prêt concernent le produit "TAYSSIR".

31
 Figure 37: Répartition des demandes de prêt par produit
- Ce graphique en barres illustre le nombre de demandes de prêt selon leur statut. Chaque
barre représente un statut différent et le nombre total de demandes de prêt associées à ce
statut.

Nombre de demandes de prêt par statut

- Raisons de rejet des demandes de prêt et nombre associé

32
 Figure 38: Raisons de rejet des demandes de prêt et nombre associé
- Ce graphique en barres groupées montre la relation entre le code_es (code de service) et
le statut des demandes de prêt. Chaque groupe de barres représente un code_es spécifique,
avec des barres individuelles indiquant les différents statuts des demandes.

Figure 39: Relation entre code_es et le statut des demandes de prêt.

4.2 Tableau de Bord Détails des Clients

Ce tableau de bord, intitulé "Détails des Clients", permet une analyse approfondie
des caractéristiques et des statistiques des clients concernant les demandes de prêt. À
l'aide de plusieurs graphiques, ce tableau de bord fournit une vue détaillée des données
relatives aux clients, telles que le genre, l'âge, la raison des demandes de prêt, et leur
répartition géographique.

33
 Figure 40: Tableau de bord Détails des Clients
- Ce graphique en barres montre la répartition des statuts des demandes de prêt en fonction
du genre des clients. Le genre "1" représente les hommes, et le genre "2" représente les
femmes. Chaque barre indique le nombre de demandes pour chaque statut (CREATED,
CREATED_ON_LS, FUNDS_UNLOCKED, REJECTED).

Figure 41: Répartition des statuts des demandes de prêt par genre (1 = homme, 2 = femme)
- Ce graphique en barres montre la répartition des statuts des demandes de prêt selon l'âge
des clients. Les âges représentés sont 26, 28, et 34 ans, avec des barres indiquant le
nombre de demandes pour chaque statut (CREATED, CREATED_ON_LS,
FUNDS_UNLOCKED, REJECTED).

34
 Figure 42: Répartition des statuts des demandes de prêt par âge des clients
- Ce graphique en barres montre les raisons de rejet des demandes de prêt en fonction du
genre des clients. L'axe des abscisses indique les différentes raisons de rejet, tandis que
les barres représentent le nombre de rejets pour chaque raison, séparés par genre (1 =
homme, 2 = femme).

Figure 43: Raisons de rejet des demandes de prêt par genre

- Ce graphique en barres montre les raisons de rejet des demandes de prêt en fonction de
l'âge des clients. L'axe des abscisses représente les différentes raisons de rejet, et les
barres indiquent le nombre de rejets pour chaque âge (26, 28, 34 ans).

35
 Figure 44: Raisons de rejet des demandes de prêt par âge des clients
- Ce diagramme circulaire montre la répartition géographique des clients par ville. Chaque
segment représente une ville (Casablanca, Agadir) et la proportion de clients associés à
chaque ville.

Figure 45: Répartition géographique des clients par ville

5. Conclusion
Dans ce chapitre, nous avons détaillé la mise en œuvre du pipeline ETL, depuis la
configuration de l'environnement de développement jusqu'à la création de tableaux de bord
pour l'analyse des données. Nous avons utilisé des outils tels que Docker pour assurer un
environnement cohérent, PyHive pour l'extraction des données, Pandas pour la
transformation, et Hive pour le chargement des données transformées. L'automatisation des
workflows avec Apache Airflow a permis d'optimiser le processus ETL, tandis que la
visualisation des données avec Matplotlib, affichée via des tableaux de bord statiques, a
fourni des insights précieux sur les demandes de prêt et les caractéristiques des clients.
Cette réalisation a démontré l'efficacité et la flexibilité de notre solution ETL, prête à être
exploitée pour des analyses plus approfondies et des prises de décision stratégiques.

36
Conclusion
Ce projet de mise en place d'un pipeline ETL complet pour l'analyse des données de
demandes de prêt a été une expérience d'apprentissage enrichissante et formatrice. À
travers les différentes étapes, de la configuration de l'environnement de développement à
la visualisation des résultats, j'ai acquis une compréhension approfondie des outils et
technologies clés tels que Hadoop, Hive, Python, Pandas, Apache Airflow, et Docker. La
complexité du projet m'a permis d'explorer diverses méthodes pour extraire, transformer,
et charger les données de manière efficace et automatisée, tout en assurant la qualité et
la fiabilité des données.

La conception et l'implémentation du pipeline ont permis de relever les défis liés à la

gestion et à l'analyse de grandes quantités de données, démontrant l'importance de
l'automatisation et de la bonne orchestration des processus dans un environnement Big
Data. La création de tableaux de bord pour visualiser les données a offert des insights
clairs et exploitables, essentiels pour la prise de décisions informées et stratégiques. De
plus, l'utilisation d'outils de conteneurisation comme Docker a facilité la gestion des
environnements et le déploiement des services.

Ce projet m'a permis de développer mes compétences techniques en manipulation de

données, en scripting Python, et en orchestration de workflows, tout en renforçant ma
capacité à résoudre des problèmes complexes et à travailler avec des environnements de
données distribués. En conclusion, cette expérience a non seulement enrichi mes
connaissances techniques, mais m'a également préparé à relever de futurs défis dans le
domaine du Big Data et de l'analyse de données, tout en soulignant l'importance d'une
approche méthodique et structurée pour la gestion de projets de données.

37