Rapport PFE AALITI Souhaila

UNIVERSITE ABDELMALEK ESSAADI
FACULTE DES SCIENCES ET TECHNIQUES DE TANGER
DEPARTEMENT GENIE INFORMATIQUE

---------------------------------------------------------
MEMOIRE DE PROJET DE FIN D’ÉTUDE

INGENIEUR D’ETAT
EN
LOGICIELS ET SYSTEMES INTELLIGENTS
Elaboration d’une solution de monitoring des tâches sous

Spring
REALISE PAR : AALITI SOUHAILA
Soutenu le : 16/07/2020
Membres du Jury :
Mr. AIT KBIR M’hamed Président
Mr. ZILI Hassan Encadrant FSTT
Mr. AZOUAGH Noureddine Encadrant Entreprise
Année Universitaire 2019/2020

« Les batailles de la vie ne sont pas gagnées par les
plus forts, ni par les plus rapides, mais par ceux qui
n'abandonnent jamais. »
FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 2

Dédicace
A Allah le Tout Miséricordieux

À ma très chère mère, en témoignage de ma profonde gratitude et de mon incontestable
reconnaissance, pour son soutien tout au long de mon cursus, toute la confiance qu’elle
m’accorde et tout l’amour dont elle m’entoure, ses prières et ses bénédictions m’ont été d’un
grand secours pour mener à bien mes études.
À mon très cher père, celui qui m’a toujours indiqué la bonne voie, en signe d’amour, de
gratitude pour tous les soutiens et les sacrifices dont il a fait preuve à mon égard,
Nul mot ne saurait exprimer à sa juste valeur le dévouement et le profond respect que je
porte envers vous. Que DIEU vous préserve et vous accorde, santé, bonheur et prospérité
À mon cher frère, mes chères sœurs, qui sont toujours là pour moi et à mes cote, disposés à
me tendre la main et à me soutenir dans tout ce que j’entreprendrai.
À mon cher neveu, et ma chère nièce, qui sont mon porte-bonheur, les rayons de soleil de
tous mes jours et la joie de ma vie,
À toute ma famille,
À mes amis, et à tous mes proches,
À tous ceux qui m’aiment, je dédie cet humble travail.
AALITI Souhaila

Remerciements
Mes remerciements s’adressent en premier lieu à Allah tout puissant qui m’a aidé et
m’a donné la force, le courage et la santé pour réaliser ce projet.
Je tiens à exprimer ma profonde gratitude et mes sincères remerciements à mon

encadrant au sein de département informatique de la FSTT Mr ZILI Hassan qui m’a
encadré, soutenu, accompagné durant cette période de stage de projet de fin d’études. Ses
conseils, ses remarques ainsi que les nombreux échanges que nous avons eus, ont été d’un
immense secours pour mener à bien ce travail.
Je tiens à adresser mes vifs remerciements à Mr AZOUAGH Noureddine pour son

accompagnement quotidien, ses remarques toujours affûtées et ses encouragements, ainsi
que pour le temps qu’il m’a consacré tout au long de cette période de stage
Mes sincères remerciements pour tous les collaborateurs de VirtuoCode pour leur
accueil, leurs aides et pour leurs conseils.
Mes remerciements vont également aux membres du jury qui ont bien voulu assister à la
présentation et évaluer ce travail.
Enfin, je tiens également à adresser mes affectueux remerciements à l’ensemble du corps
professoral et administratif de l’FST de Tanger, pour l’accomplissement et la contribution à
ma formation durant ces 3 ans.

Résumé
Ce rapport constitue le fruit d’un travail accompli dans le cadre du projet de fin d’études
qui m’a été confié durant mon stage au sein de l’entreprise "VirtuoCode".
L’objectif du stage était de participer activement à la conception et la mise en œuvre

d’une solution de monitoring qui consiste à mieux organiser l’ordonnancement des tâches.
Ce sujet peut être décomposé en 2 grands volets, qui, s’ils ne sont pas interdépendants, vont
néanmoins dans le même sens de la mission générale : développement des scenarios de
migration des données sous forme des traitements batchs, et la surveillance, automatisation et
orchestration de leurs exécutions.
La matière première dans ce projet est le contenu généré par les APIs de Google et
Facebook. J’en ai donc puisé dans ces interfaces de programmation applicative, pour obtenir
des données qui sont à jour.
Cette solution est destinée spécialement aux administrateurs du département Back-

office de l’entreprise ‘Mobilosoft’ afin de les aider à mener à terme leur projet de migration.
J’ai veillé à développer cette solution avec les technologies les plus récentes et
performantes, et ceci dans un cadre agile en adoptant l’approche SCRUM.
Ce projet est réalisé avec la partie des traitements Batch à base de Spring Batch, et
Spring Cloud Data Flow pour le monitoring des tâches.
Le présent document représente une synthèse complète de l’élaboration de mon travail,

en détaillant tous les processus mis en place pour que mon projet voie le jour.
Mots-clés: JAVA, J2EE, Spring Boot , Spring Batch, Spring Cloud Data Flow, Traitement
Batch, Monitoring, Facebook API, Google My Business API.

Abstract
This report is the result of the work accomplished within the context of the end of studies
project which was entrusted to me during my internship within the company "VirtuoCode".
The objective of the internship was to actively participate in the design and the
implementation of a monitoring solution which will provide a better tasks scheduling.
My subject can be broken down into two main parts, which, if not interdependent,
nevertheless go in the same direction of my general mission: developing batch processing for
data migration scenarios, and monitoring, automating and scheduling their execution.
This solution is intended mainly for "Mobilosoft" company, especially for Back-office
administrators, in order to help them complete their migration project.
I have made sure to develop this solution with the latest and most efficient technologies,
all within an agile framework, by adopting the SCRUM approach.
The raw material in this project is the content generated from Google APIs and
Facebook. So, I have drawn from both these application programming interfaces to obtain
updated and refresh data.
This project is carried out with a batch processing part based on Spring Batch, and
another task monitoring part that integrates Spring Cloud Data Flow
This document provides a comprehensive synthesis of the development of my work,

detailing all the processes I put in place to make my project a successful one.
Keywords: JAVA, J2EE, Spring Boot, Spring Batch, Spring Cloud Data Flow, Batch
processing, Monitoring, Facebook API, Google My Business API.

Liste des abréviations
Abréviation Désignation
ADN Acide Désoxyribo-Nucléique
API Application Programming Interface
BD Big Data
BI Business Intelligence
DSL Domain-Specific Language
EOA End-of-Availability (fin de disponibilité)
EOL End-Of-Life (fin de vie)
EOS End-Of-Support (fin de support)
GMB Google My Business
JAR Java Archive
JMX Java Management Extensions
JSON JavaScript Object Notation
N/A Non Attribué
PDF Portable Document Format
REST REpresentational State Transfer
SCDF Spring Cloud Data Flow
SQL Structured Query Language
UI User Interface (interface utilisateur)
UML Unified Modeling Language
URI Uniform Resource Identifier
URL Uniform Resource Locator (adresse web)
WAR Web application ARchive
XD eXtrem Data
XP eXtrem Programming

Liste des figures
Figure 1 : L’écosystème du groupe Virtuology International .............................................................. 17

Figure 2 : Fiche Google d'un magasin Carrefour ................................................................................ 20
Figure 3: Le processus Scrum ............................................................................................................ 29
Figure 4 : Fonctionnement de Scrum ................................................................................................. 30
Figure 5 : Aperçu d’Asana ................................................................................................................. 32
Figure 6: Aperçu de Skype ................................................................................................................. 34
Figure 7 : Aperçu de Google Meet ..................................................................................................... 34
Figure 8: Liste des activités du diagramme de Gantt .......................................................................... 37
Figure 9: La durée des activités du diagramme de Gantt ................................................................... 37
Figure 10: Processus du traitement Batch ......................................................................................... 42
Figure 11: Traitement Batch .............................................................................................................. 43
Figure 12: Ordonnancement des tâches ............................................................................................ 44
Figure 13: Architecture de Spring Cloud Data Flow ............................................................................ 46
Figure 14: Diagramme de cas d'utilisation - Lancement et visualisation d'une tâche .......................... 54
Figure 15: Diagramme de cas d'utilisation – export des locations ...................................................... 55
Figure 16: Diagramme de séquences de création d’un site ................................................................ 56
Figure 17: Diagramme de séquences du traitement batch du site ..................................................... 56
Figure 18: Diagramme de séquences d'import des locations depuis GMB.......................................... 58
Figure 19: Diagramme de séquences du traitement batch des locations............................................ 58
Figure 20: Diagramme de séquences d'import des GMB Reviews ...................................................... 59
Figure 21: Diagramme de séquences du traitement batch des GMB reviews ..................................... 60
Figure 22: Diagramme d’entité-association du module Batch ............................................................ 61
Figure 23: Cycle de développement du projet ................................................................................... 63
Figure 24: Architecture globale du projet .......................................................................................... 64
Figure 25: Processus global de Spring Batch ...................................................................................... 66
Figure 26: Logo de Intellij IDEA .......................................................................................................... 67
Figure 27: Logo Spring ....................................................................................................................... 68
Figure 28: Logo Docker ..................................................................................................................... 69
Figure 29: Logo Maven ...................................................................................................................... 69
Figure 30: Logo Spring boot .............................................................................................................. 70
Figure 31: Logo Spring Data .............................................................................................................. 70
Figure 32: Logo Hibernate ................................................................................................................. 71
Figure 33: Logo Spring Batch ............................................................................................................. 71
Figure 34: Logo Google My Business ................................................................................................. 72
Figure 35: Facebook Graph API ......................................................................................................... 72
Figure 36: Logo Google Cloud SQL ..................................................................................................... 72
Figure 37: Logo Modelio ................................................................................................................... 73
Figure 38: Logo GanttProject............................................................................................................. 73
Figure 39: Logo Git ............................................................................................................................ 74
Figure 40: Interface ‘ajouter une nouvelle application’ depuis SCDF .................................................. 79
Figure 41: Interface ‘lister toutes les applications’ depuis SCDF ......................................................... 79

Figure 42: Interface ‘liste des sites’ depuis myMobilosoft avant migration ........................................ 80
Figure 43: Interface ‘liste des clients’ depuis myMobilosoft avant migration ..................................... 80
Figure 44: Interface 'création d'une tâche' depuis SCDF' ................................................................... 81
Figure 45: Interface 'visualiser le graphe associé d'une tâche' depuis SCDF ....................................... 81
Figure 46: Interface ‘liste des tâches’ depuis SCDF ............................................................................ 82
Figure 47: Interface 'Exécution d'un tâche' depuis SCDF .................................................................... 82
Figure 48: Interface 'liste des tâches' après complétion de la création d'un site ................................ 83
Figure 49: Interface ‘liste des sites’ depuis myMobilosoft après migration ........................................ 83
Figure 50: Interface ‘liste des locations’ depuis myMobilosoft avant la migration.............................. 84
Figure 51: Interface ‘liste des reviews’ depuis myMobilosoft avant la migration................................ 84
Figure 52: Interface ‘liste des reportings’ depuis myMobilosoft avant la migration............................ 85
Figure 53: Interface 'liste des tâches' après complétion de la création d'un client ............................. 85
Figure 54: Interface ‘liste des clients’ depuis myMobilosoft après migration ..................................... 86
Figure 55: Interface 'liste des tâches' après complétion d’importation des locations ......................... 86
Figure 56: Interface ‘liste des locations’ depuis myMobilosoft après la migration .............................. 87
Figure 57: Interface 'liste des tâches' après complétion d'importation du Facebook reviews ............. 87
Figure 58: Interface ‘liste des reviews de Facebook’ depuis myMobilosoft après la migration ........... 88
Figure 59: Interface 'liste des tâches' après complétion d'importation du GMB reviews .................... 88
Figure 60: Interface 'Visualisation des logs' après complétion d'importation des GMB reviews ........ 89
Figure 61: Interface ‘liste des reviews de Google’ depuis myMobilosoft après la migration ............... 89
Figure 62: Interface 'liste des tâches' après complétion de la migration ........................................... 90
Figure 63: Interface ‘page des reportings’ depuis myMobilosoft après la migration .......................... 90
Figure 64: Interface 'liste des locations' après un filtre ...................................................................... 91
Figure 65: La première feuille 'des données' du fichier Excel exporté ................................................ 91
Figure 66: La deuxième feuille 'des critères' du fichier Excel exporté ................................................. 91

Liste des tableaux
Tableau 1: Tableau d’analyse des risques .......................................................................................... 28

Tableau 2: Backlog du produit ........................................................................................................... 36
Tableau 3: Tableau comparatif des cas d'utilisations de Spring Batch Admin et SCDF ........................ 48
Tableau 4: Tableau comparatif entre Spring XD et SCDF .................................................................... 49
Tableau 5: Signification des cas d'utilisation du diagramme lancement d'une tâche .......................... 53
Tableau 6: Signification des cas d'utilisation du diagramme export des locations .............................. 55

Table de matières
Elaboration d’une solution de monitoring des tâches sous Spring ......................................1

Dédicace.............................................................................................................................................3
Remerciements ..................................................................................................................................4
Résumé ..............................................................................................................................................5
Abstract..............................................................................................................................................6
Liste des abréviations.........................................................................................................................7
Liste des figures..................................................................................................................................8
Liste des tableaux.............................................................................................................................10
Table de matières.............................................................................................................................11
Introduction générale ......................................................................................................................14
Chapitre I : Contexte général du projet ............................................................................................17
Introduction .................................................................................................................................. 17
1.1. Présentation de l’organisme d’accueil................................................................................ 17
1.1.1. Présentation du groupe Virtuology International ....................................................... 17
1.1.2. Présentation de la société VirtuoCode ....................................................................... 19
1.2. Présentation et positionnement du projet ......................................................................... 19
1.2.1. Contexte du projet ..................................................................................................... 19
1.2.2. Problématique ........................................................................................................... 22
1.2.3. Solution proposée ...................................................................................................... 23
Conclusion .................................................................................................................................... 24
Chapitre II : Conduite et gestion du projet .......................................................................................26
Introduction .................................................................................................................................. 26
2.1. Contrainte du projet .......................................................................................................... 26
2.1.1. Contraintes générales ................................................................................................ 26
2.1.2. Contraintes techniques .............................................................................................. 26
2.2. Identification des risques ................................................................................................... 27
2.3. Conduite du projet ............................................................................................................ 28
2.3.1. Aperçu de la méthodologie SCRUM............................................................................ 28
2.3.2. Les rôles de la méthodologie SCRUM ......................................................................... 29
2.3.3. Fonctionnement de SCRUM ....................................................................................... 29

2.4. Communication entre les membres d’équipe..................................................................... 32
2.4.1. Outil Asana ................................................................................................................ 32
2.4.2. Outil Skype ................................................................................................................ 33
2.4.3. Google Meet .............................................................................................................. 34
2.5. Backlog du produit............................................................................................................. 35
2.6. Planification du projet ....................................................................................................... 36
Conclusion .................................................................................................................................... 38
Chapitre III : Etude préliminaire .......................................................................................................40
Introduction .................................................................................................................................. 40
3.1. Expression des besoins ...................................................................................................... 40
3.1.1. Les besoins fonctionnels du projet ............................................................................. 40
3.1.2. Les besoins opérationnels du projet ........................................................................... 41
3.2. Traitement Batch ............................................................................................................... 42
3.3. Ordonnancement des batchs / jobs ................................................................................... 43
3.3.1. Définition................................................................................................................... 43
3.3.2. Choix de la solution à exploiter .................................................................................. 44
Conclusion .................................................................................................................................... 49
Chapitre IV : Conception et modélisation .........................................................................................51
Introduction .................................................................................................................................. 51
4.1. Diagramme de cas d’utilisation .......................................................................................... 51
4.1.1. Diagramme de lancement et visualisation d’une tâche/batch depuis la solution de
monitoring ................................................................................................................................ 52
4.1.2. Diagramme de cas d'utilisation – L’export des locations depuis la plateforme
myMobilosoft............................................................................................................................ 54
4.2. Workflow des opérations................................................................................................... 55
4.2.1. Diagramme de création d’un site ............................................................................... 55
4.2.2. Diagramme d’importation des locations depuis GMB ................................................. 57
4.2.3. Diagramme d’importation des avis des clients depuis GMB ........................................ 59
4.3. Diagramme d’entité-association ........................................................................................ 60
Conclusion .................................................................................................................................... 61
Chapitre V : Etude technique............................................................................................................63
Introduction .................................................................................................................................. 63
5.1. Architecture globale du projet ........................................................................................... 63
5.2. Les choix technologiques et frameworks utilisés ................................................................ 67
5.2.1. Environnements de développement .......................................................................... 67

5.2.2. Frameworks et APIs ................................................................................................... 70
5.2.3. Bases de données ...................................................................................................... 72
5.2.4. Modélisation et gestion de projet .............................................................................. 73
5.2.5. Système de gestion de code ....................................................................................... 74
Conclusion .................................................................................................................................... 74
Chapitre VI : Réalisation et mise en œuvre ......................................................................................76
Introduction .................................................................................................................................. 76
Itération 0 : Préparation du lancement du projet .......................................................................... 76
Itération 1 : Développement des batchs ........................................................................................ 76
Itération 2 : Isolation du module batch et la génération du jar ...................................................... 77
Itération 3 : Initiation à l’outil de monitoring ................................................................................. 77
Itération 4 : Câblage entre l’application batch et la solution de monitoring ................................... 78
Itération 5 : intégration et build du projet ..................................................................................... 78
Conclusion .................................................................................................................................... 92
Conclusion générale et perspectives ................................................................................................95
Webographie ...................................................................................................................................96
Annexes ...........................................................................................................................................97
Annexe 1 : Normes de développement ......................................................................................... 97
Règles de nommage .................................................................................................................. 97
Fonctions .................................................................................................................................. 97
Commentaires........................................................................................................................... 97
Mise en forme ........................................................................................................................... 98
Résumé ............................................................................................................................................99

Introduction générale
La concurrence est de plus en plus forte entre les entreprises. L’explosion des nouvelles
technologies mais aussi l’automatisation des tâches ont rendu la course aux bénéfices encore
plus folle qu’elle ne l’était. Face à cet écosystème de plus en plus complexe, les entreprises
changent et ne cessent de changer afin de rester dans la course.
Dans un tel contexte, rester compétitif n’est pas une tâche aisée. Ce qui pousse les
entreprises à engager des processus de migration, qui est un passage délicat, pour mettre en
œuvre des nouvelles plateformes technologiques et apporter de la nouveauté allant bien au-delà
des fonctionnalités liées aux nouvelles versions.
Par ailleurs, il est essentiel que ces entreprises choisissent toute une gamme de méthodes
de traitement pour garantir cette migration et rester concurrentielles. On y retrouve le traitement
batch, qui, et malgré les changements induits par l'essor des technologies, demeure plus utile
que jamais. Il offre un large éventail de fonctionnalités et d’avantages, dont les entreprises
peuvent en retirer profit ; Cela inclut l’efficacité, simplicité, réduction des coûts etc, de sorte
que les développeurs restent concentrés que sur la partie métier du système.
Ce traitement est devenu une pratique courante, car il s’avère comme la solution idéale
pour des scénarios tels que la migration des données. Toutefois, au lieu d'améliorer les
performances et la compétitivité de l’entreprise, une migration incorrecte peut créer des
inexactitudes.
Rejoignant cet esprit, il s’avère indispensable d’intégrer un outil de monitoring qui

permet de surveiller l’enchaînement et le déroulement de ce passage pas à pas, automatiser et
planifier les tâches informatiques. Ceci optimise le temps de traitement, fiabilise leurs
exécutions, et réduit les erreurs etc.
Dans ce sens s’inscrit mon projet de fin d’étude qui porte sur l’élaboration d’une solution
de monitoring des tâches, suite au développement des scenarios de migration des données sous
forme des traitements batchs, au sein de l’entreprise VirtuoCode.
Ce rapport décrit donc la totalité de mon projet, en détaillant chaque phase

individuellement.
Dans un premier temps, on va définir le contexte général du projet, c’est-à-dire qu’on

va présenter l’organisme d’accueil ainsi que le cadre logique de mon PFE.

Dans le deuxième chapitre, on détaillera comment on a géré le projet, en soulignant les
risques et les contraintes susceptibles de ralentir mon travail, ainsi que la conduite et la
planification du projet.
Le troisième chapitre est une étude préliminaire, qui met l’accent sur les notions de base
de mon projet. Il définit et explique: les besoins fonctionnels et opérationnels du projet, le
traitement batch ou par lots, et l’ordonnancement des tâches. Pour ce dernier, on y retrouve la
solution choisie, et le pourquoi de ce choix.
Tout projet informatique doit être soumis à une phase d’analyse et modélisation avant
sa réalisation, et le chapitre quatre détaille cette étape pas à pas.
L’avant dernier chapitre, soit le cinquième, est une étude technique du projet, qui
explique le fonctionnement technique de mon travail, ainsi que les technologies et outils que
j’ai exploité.
Finalement, on clôture ce rapport avec la réalisation et la mise en œuvre du projet, qui

illustre les fonctionnalités de la solution élaborée.

Chapitre I
Contexte général du projet
Ce chapitre introduit le contexte général du projet. On présente

l’organisme d’accueil tout au long de la durée du stage, sa société
mère et ses valeurs.
Pour retrouver par la suite, le contexte du projet, la problématique,

et la solution proposée.

Chapitre I : Contexte général du projet
Introduction
Tout projet se situe dans un cadre et un contexte bien précis, et le but de cette partie est
de situer le lecteur dans le contexte général de mon stage. Et pour ce faire, on va commencer
tout d’abord par une présentation générale de l’organisme d’accueil. On abordera par la suite la
présentation du projet où on décrira la problématique à traiter et la solution proposée, alors que,
la fin de ce chapitre portera sur la planification et la conduite du projet, ainsi que le planning de
travail adopté.
1.1. Présentation de l’organisme d’accueil

1.1.1. Présentation du groupe Virtuology International
1.1.1.1. L’écosystème
Virtuology International est un groupe d’agences spécialisées dans les métiers du

Marketing Digital, fondé en 2012 par Cédric Donck. Ayant l’ambition de regrouper sous une
bannière commune des spécialistes actifs dans toutes les principales disciplines du marketing
digital, chaque société du groupe est indépendante et tend à être la meilleure dans sa sphère de
compétences.
Par définition modulaire et formée à la coopération, chaque société a dans son ADN une
facilité à collaborer avec des équipes externes. Le groupe met à disposition ses méthodologies
et ses outils pour rendre les projets harmonieux et efficaces lorsque plusieurs compétences
renforcent un même projet.
Figure 1 : L’écosystème du groupe Virtuology International

Ce groupe englobe environ Vingt-six Startups, toutes actives dans le digital marketing.
1.1.1.2. Les valeurs
Pour le groupe Virtuology International, développer un groupe d’entreprises n’est pas

une finalité en soi. La manière dont cette croissance s’opère est aussi importante que le résultat
financier qui en découle. Les valeurs vécues au quotidien en sont la clé.
Ces valeurs sont le ciment qui permet de construire, progresser et traverser les moments
difficiles sans dévier de la trajectoire. Elles permettent de construire un lien qui va au-delà de
la simple collaboration, elles permettent de donner un sens à la stratégie de l’entreprise et
permettent à chacun de se l’approprier.
a) Intégrité et transparence
L’intégrité est la base de la confiance. Le management et les collaborateurs doivent être

transparents dans les décisions qu’ils prennent et respecter le cadre juridique, éthique et moral
en toutes circonstances. Ce précepte ne doit connaitre aucune exception, ni pour les petites
décisions ni pour les grandes.
b) Excellence
L’excellence ne doit pas être vécue comme une contrainte mais plutôt comme une fierté
de donner le meilleur de nous-mêmes dans toutes nos actions. Elle s’exprime tant dans le savoir-
faire métier que dans le savoir-être personnel.
c) Solidarité
La solidarité crée un cadre de soutien mutuel et permet à chacun de s’appuyer sur les
autres afin d’être plus forts ensemble. La solidarité est la capacité d’aider ceux qui nous
entourent, mais également de demander de l’aide lorsque nous en avons besoin.
d) Respect
Le respect est une valeur cardinale qui connaît plusieurs facettes: que ce soit le respect
de la parole donnée en interne, à nos clients ou à nos partenaires, le respect dans les relations
humaines, ou encore le respect de notre environnement. Nous voulons en tout point être dignes
de la confiance qui nous est faite.

e) Joie
La joie est une condition indispensable à l’épanouissement professionnel. Pour créer un

cadre de travail inspirant, nous défendons des relations harmonieuses entre collaborateurs et
une décontraction dans le travail quotidien.
1.1.2. Présentation de la société VirtuoCode
VirtuoCode est une société de services et d'ingénierie en informatique, fondée en 2020

filiale de l’entreprise Virtuology international.
La société est experte dans le domaine des nouvelles technologies et de l'informatique.

Elle englobe plusieurs métiers (conseil, conception et réalisation d'outils, maintenance ou
encore formation) et a pour objectif principal d'accompagner ses clients dans la réalisation des
projets informatiques.
1.2. Présentation et positionnement du projet
Mon projet s’inscrit dans le cadre des projets réalisés pour la société Mobilosoft,
notamment le projet « myMobilosoft » afin d'élaborer une solution de supervision et
d’automatisation de l’exécution des scénarios de migration pour ses clients, de la version 2 vers
la version 3.
Avant d’entamer la partie contexte du projet, il faut tout d’abord en avoir un aperçu sur
Mobilosoft, qui est une société spécialisée dans le digital marketing. Elle offre des solutions
web-to-store qui est un pan du marketing digital dont l’objectif est de répondre à des nouveaux
modes de consommation en offrant aux entreprises des outils leur permettant d’utiliser Internet
pour générer du trafic en point de vente physique (restaurants, magasins, bureaux). Grâce à ses
produits, Mobilosoft aide ses clients à gérer leurs données afin qu'elles puissent proposer des
informations vérifiées dans les résultats de recherche.
1.2.1. Contexte du projet
Comme on l’a cité auparavant, Mobilosoft offre des solutions web-to-store. Ceci
consiste à proposer une liste de produits et services permettant à ses clients de générer du trafic
dans leurs magasins. Parmi ces produits, on se limite à présenter :

1.2.1.1. Location
Le premier produit est dédié à la gestion de la localisation des points de vente, ce produit
s’occupe de la création et de la gestion du contenu des pages locales optimisées pour la
recherche.
Ce produit consiste à gérer le contenu et les informations des magasins des clients sur
Google, Facebook et sur les sites internet des magasins.
Ci-dessous un exemple d’une fiche Google gérée par la plateforme Mobilosoft pour un
magasin Carrefour :
Figure 2 : Fiche Google d'un magasin Carrefour
Les principales informations gérées par la plateforme sont :
- L’adresse des points de vente.
- Les horaires d’ouverture et de fermetures.
- Les évènements à venir.
- Les informations générales : le nom du magasin, le numéro de téléphone, le lien du

site web du magasin…
- Les photos.

- Les services.
- Les champs supplémentaires (Extra fields).
La gestion du contenu des pages locales des magasins a deux finalités:
1- Informer les visiteurs des sites web des magasins.
2- Optimiser le référencement naturel des pages web des magasins sur les moteurs de
recherche web.
1.2.1.2. Campaign
Le deuxième produit est dédié pour la gestion de campagnes. Ce produit a pour objectif
de permettre aux entreprises organisées en réseau de distribution de pouvoir publier, sur
chacune de leur pages points de ventes, du contenu (promotionnel, événementiel,
inspirationnel). Ce contenu pouvant être lié à l’actualité nationale de la chaîne ou aux
événements de la vie locale des points de vente (braderies, fêtes de quartier, produits exclusifs,
etc.).
Ces contenus peuvent être diffusés sous la forme de « Posts » (publications) gratuites
sur les pages magasins (Store Locator, Google et Facebook) ou d’annonces publicitaires
payantes sur Google et Facebook. Ils prennent le format de publication d’images, de texte et/ou
de vidéos.
1.2.1.3. Inbox
Le troisième permet la gestion des avis clients. Ce produit permet aux clients de
récupérer les avis déposés par les consommateurs sur les pages points de ventes dans Google et
Facebook, de les présenter dans une interface web et d’y répondre en toute simplicité. Le
bénéfice de cette gestion est l’amélioration de la réputation des magasins en ligne. Une bonne
gestion des avis d’un magasin est en effet prise en compte par les moteurs de recherche web
pour le référencement des pages de ces magasins. Cette gestion aide aussi les magasins à
fidéliser la clientèle et ainsi à améliorer l’expérience de ses clients dans ces magasins par le
biais de rapports mis à disposition des magasins.

1.2.1.4. Customer
Le dernier produit est connu communément dans Mobilosoft sous le nom « Customer»
ou des projets des clients à la demande, ce produit englobe tous les services et les prestations
que Mobilosoft offre à ses clients et qui ne font pas partie des produits cités précédemment.
Ces prestations concernent principalement :
- Des adaptations particulières des trois premiers produits cités précédemment pour les
clients qui désirent sortir du standard des produits de Mobilosoft.
- Support et accompagnement des clients dans des projets de mise en place des stratégies
de marketing.
Parmi les canaux de diffusion des produits Mobilosoft, on trouve :
 Google: la gestion des fiches Google sur « Google My Business ».

 Facebook: à travers ce média les produits de Mobilosoft permettent de gérer le contenu
des pages Facebook des magasins.
 GPS: pour la géo-positionnement des points de vente.
 Store Locator: pour localiser géographiquement un point de vente physique.
1.2.2. Problématique
Une migration applicative correspond généralement à une importante montée de version

d’une solution informatique. Elle est fréquemment associée à la mise en œuvre d’une nouvelle
plateforme technologique.
Concrètement, la migration va chercher à apporter de la nouveauté allant bien au-delà

des fonctionnalités liées à la nouvelle version puisqu’il s’agit notamment d’étudier d’un point
de vue des processus l’apport et l’intérêt des changements à venir.
Si ce passage vers la nouvelle version est fait pour pallier à des problèmes de
maintenance ou de choix stratégiques dans l’entreprise, il est souvent vu comme un calvaire par
les équipes informatiques, surtout pour la migration des données.

C’est là que prend place notre problématique; en effet, le projet myMobilosoft est sur le
point de la migration vers une version qui répond bien aux attentes de ses nombreux clients.
Donc, il est nécessaire de mener à bien ce projet avec minutie et dans une logique
industrielle, pour transformer cette migration en une réussite opérationnelle. Et pour se faire, il
fallait mettre en œuvre de traitements batchs vu la masse de ses données.
Et toute mise en œuvre de traitements batchs amène des problématiques d’exploitation

classiques : planification des traitements, suivi des exécutions pour vérifier que les traitements
ne tombent pas en erreur ou durent trop longtemps, gestion des incidents (relance des
traitements en échec etc).
Donc, il est indispensable de pourvoir un outil de supervision, ou d’ordonnancement qui

permet de piloter l’ensemble de ces batchs avec de la répartition de charge, la reprise sur erreur
et l’assurance de la journalisation.
1.2.3. Solution proposée
La solution qu’on propose pour répondre à cette problématique traite les besoins qu’on
a préalablement identifiées et consiste à morceler le travail sur trois parties:
- La première étant le développement de l’ensemble des batchs qui va servir à

transférer les données des clients Mobilosoft vers la version 3. Cette migration peut
être faite, avec deux approches ; depuis l’ancienne version, ou bien depuis les APIs
des medias partenaires. Sauf qu’on a opté pour la deuxième démarche, puisqu’on
obtiendra des données qui sont fraîches et à jour.
- La deuxième réside dans l’isolation de ces batchs dans un module séparé dans
l’application, et la génération d’un jar prêt à être exécuté indépendamment de tout
environnement pour ce module.
- La troisième, - la plus importante- consiste à élaborer une solution de monitoring,

permettant de planifier et de surveiller l’exécution automatique de batchs/tâches et
surtout d’en assurer la journalisation ; avec comme perspective, la mise en place
d’un tableau de bord (Dashboard) reflétant les statuts et l’état d’exécution des tâches
planifiées.

Conclusion
Dans ce premier chapitre, on a présenté l’organisme d’accueil, VirtuoCode, et sa société

mère, Virtuology International. Puis, on a retrouvé une présentation de mon projet, qui inclut
le contexte général, la problématique à traiter et finalement la solution proposée.

Chapitre II
Conduite et gestion du projet
Ce chapitre présente les démarches qu’on a suivies pour gérer,

conduire et mener à bien mon projet. On commence par
l’identification des contraintes et des risques.
Ensuite, on fait le choix de la méthodologie agile, ainsi que les

outils de communications entre les membres de l’équipe.
Et on clôture ce chapitre par le backlog du produit et la planification

du projet.

Chapitre II : Conduite et gestion du projet
Introduction
La gestion de projet est une démarche visant à organiser de bout en bout le bon
déroulement d’un projet.
En pratique, le projet est tourné vers l'objectif final, il doit être adaptable à des
modifications fréquentes, mais maîtrisé et planifié. Donc toute modification doit rester
planifiée. Et notamment, le projet doit rester dynamique et équilibrer continuellement les
contraintes techniques, de coût et de délai.
C’est le but dans lequel résident ce présent chapitre, c’est-à-dire l’identification des
contraintes et des risques éventuels, la méthodologie agile à adopter pour palier à ces difficultés, la
présentation des outils de communication entre mon équipe, et finalement la définition d’un
planning pour mon projet suite au backlog du produit.
2.1. Contrainte du projet
Cette section recense les contraintes et les restrictions particulières qui limitent mon
projet où qui lui imposent des conditions, en particulier celles qui sont liées à la portée.
Les contraintes peuvent provenir de facteurs externes (sociaux, environnementaux,

politiques, économiques et technologiques) ou de facteurs internes (ressources, expertise,
exigences opérationnelles, installations, etc.…). Il faut donc analyser l'environnement du projet
afin de recenser les contraintes.
Deux catégories de contraintes ont été recensées :
2.1.1. Contraintes générales

- Respecter la date de livraison du projet.
- Respecter les exigences du client d’une façon stricte.
- S’intégrer dans l’application myMobilosoft et respecter la logique et l’architecture

modulaire qu’elle suive.
2.1.2. Contraintes techniques

- Offrir une solution optimale, maintenable pour des utilisateurs non-techniques.

- Respecter les normes de la qualité du code, selon l’architecture modulaire de la
plateforme.
- Elaborer un tableau de bord intuitif et simple à interpréter lors de l’affichage des

résultats.
2.2. Identification des risques
Les risques sont définis comme la possibilité qu’un projet ne s’exécute pas
conformément aux prévisions des dates, de coût ou d’expression des besoins, ces dérives étant
considérées comme difficilement acceptables ou bien carrément inacceptables.
Exercer la maitrise des risques dans mon projet m’a permis de mieux communiquer sur
les difficultés potentielles du projet et de partager ses responsabilités avec les autres décideurs
concernés.
Le tableau ci-dessous indique les éventuels risques qui ont été recensés et identifiés dans
mon projet, ainsi que les actions préventives mises en œuvre pour en assurer la maîtrise:
Risque Impact Probabilité Action préventive
Les compétences de Les travaux sont Moyen Formation sur les

l’équipe sont ralentis différentes
insuffisantes technologies pour la
montée en
compétence
Mauvaise estimation Les délais et les Sévère Détermination d’un

de planning du projet coûts sont dépassés planning
prévisionnel
Absence en maladie Les travaux sont Faible Fourniture d’un

ralentis potentiel extra pour
la récupération

Manque de suivi Les délais et les Sévère Les suivis
coûts sont dépassés hebdomadaires et les
stand-up quotidiens
Modification des Les délais et les Moyen Réunions fréquentes

besoins coûts sont dépassés avec le directeur des
projets
Manque/problèmes Bloque l’avancement Elevé Faire des

des machines. du projet sauvegardes
journalières.
Tableau 1: Tableau d’analyse des risques
2.3. Conduite du projet
La gestion de projet est l'ensemble des activités visant à organiser le bon déroulement
d’un projet et à en atteindre les objectifs. Elle consiste à appliquer les méthodes, techniques, et
outils de gestion spécifiques aux différentes étapes du projet, de l'évaluation de l'opportunité
jusqu'à l'achèvement du projet.
Pour mon cas, j'étais sollicitée pour prendre en charge deux contraintes majeures: livrer
un produit de qualité et livrer à temps. Compte tenu de ces contraintes, de mes objectifs et des
caractéristiques de ma mission, j’ai opté pour la méthodologie SCRUM avec des bonnes
pratiques de XP pour mener mon projet, le choix de cette démarche avait pour raison le
découpage du projet en plusieurs itérations. A chaque itération une partie du projet aura été
traitée et à la fin de l’itération devra être livré.
2.3.1. Aperçu de la méthodologie SCRUM
La méthode agile Scrum consiste à focaliser les efforts d'une équipe sur des
fonctionnalités définis. Ceci afin de livrer un logiciel partiellement fonctionnel et enrichie au
fur et à mesure.

Le point fort de cette méthode est que le client est impliqué dans toutes les phases du
développement pour que le produit soit en final ce qu'il espérait. Chaque fonctionnalité est
divisée en plusieurs tâches, tout en prenant soin de bien s'assurer que la même fonctionnalité
ne devra pas être modifié après suite à l'ajout d'une autre.
Le processus Scrum est décrit dans la figure suivante :
Figure 3: Le processus Scrum
2.3.2. Les rôles de la méthodologie SCRUM
Les trois rôles définit par Scrum sont :

- Product Owner : Il représente généralement le client, qui porte la vision du produit à
réaliser, dans notre cas c’est M. Georges-Alexandre Hanin.
- Scrum Master : Sa mission est de tout mettre en œuvre pour que l'équipe travaille dans
de bonnes conditions et se concentre sur l'objectif du projet, dans le cadre de notre projet
c’est M. Azouagh Noureddine
- L’équipe SCRUM : Une équipe regroupant tous les rôles traditionnels : développeur,
testeur, administrateur, etc. Cette équipe est responsable de développer le produit. Dans
le contexte de notre projet cela représente toute l’équipe de VirtuoCode.
2.3.3. Fonctionnement de SCRUM

L’utilisation des méthodes agiles est une solution efficace pour modifier les pratiques
de travail et apporter de la souplesse et de la réactivité dans les organisations. Scrum, l’une des
méthodes les plus populaires, s’adapte parfaitement à la gestion de projet.

Figure 4 : Fonctionnement de Scrum
Toutes les activités (Sprint, réunion de planning, revues, rétrospective et mêlée) décrites dans
la méthode Scrum sont effectuées lors des boites de temps.
 Le sprint : Le sprint est une période d'un mois au maximum, au bout de laquelle l'équipe
délivre un incrément du produit, potentiellement livrable. La durée du sprint reste constante
pendant toute la durée du développement. Un nouveau sprint démarre dès la fin du
précédent. Chaque sprint possède un but et on lui associe une liste d'éléments et de
fonctionnalités à réaliser.
1. Le but du sprint ne peut être modifié.
2. La composition de l'équipe reste constante.
3. La qualité n'est pas négociable.
4. La liste d'items est sujette à négociations entre le propriétaire du produit et
l'équipe de développement.
 Réunion quotidienne : Chaque journée de travail commence par une réunion de 15 minutes
maximum appelée Daily Scrum ou StandUp.

Dans ce type de réunion le Scrum Master pose 3 questions à chaque équipier, à tour de rôle:
1. Qu'est-ce que tu as fait hier ?
2. Qu'est-ce que tu vas faire aujourd’hui ?
3. Quelles difficultés as-tu rencontrées ?
Ce qui m’a permis de ne pas laisser traîner ni un gros souci, ni un point de blocage, mais
de le résoudre assez rapidement, car en répondant à ces questions, on identifie les
obstacles qui freinent notre avancement au projet. De plus, cela m’a permis d’avoir de
réels échanges entre les collaborateurs du projet.
 Réunion de planification d'itération : Toute l'équipe Scrum est présente à cette réunion,
qui ne doit pas durer plus de 8 heures pour un sprint d'un mois. Pour un sprint plus court, la
durée est réduite proportionnellement. À l'issue de cette réunion, l'équipe décide des
éléments du carnet du produit qu'elle décide de traiter pendant la prochaine itération et
comment elle s'organisera pour y parvenir.
 Revue de sprint : À la fin du sprint, l'équipe Scrum et les parties-prenantes invitées se

réunissent pour effectuer la revue de sprint, qui dure au maximum 4 heures appelée (Sprint
Review). L'objectif de la revue de sprint est de valider avec l'ensemble des parties prenantes
l'incrément de la solution qui a été produite pendant le sprint et connaître l'état du projet,
afin de décider des actions à mettre en œuvre pour sa poursuite.
On planifie la réunion de planification d’itération et la revue de sprint à la fin de chaque

sprint pour une durée de 2 heures.
 Rétrospective du sprint : La rétrospective du sprint est faite en interne à l'équipe Scrum

(équipe de réalisation, propriétaire du produit et Scrum Master). Elle dure 3 heures pour un
sprint d'un mois, et réduit selon la durée du sprint. Elle a pour but l'adaptation aux
changements qui surviennent au cours du projet et l'amélioration continue du processus de
réalisation. L'objectif est d’inspecter l'itération précédente, afin de déterminer quels sont les
éléments du processus de développement qui ont bien fonctionné et ceux qui sont à
améliorer. L'équipe de développement déduit un plan d'actions d'amélioration qu'elle mettra
en place lors de l'itération suivante.

2.4. Communication entre les membres d’équipe
Dans cette section on va évoquer l’un des piliers essentiels de la bonne conduite de
projet, qui est la communication. Cette dernière représente l'ensemble des interactions et des
échanges verbaux ou écrites avec les membres d’équipe afin de transmettre l’information, et
de s’assurer qu’on suit la bonne voie lors la réalisation du projet.
Parmi les outils qu’on a utilisés pour bien établir cette communication, on note:
2.4.1. Outil Asana
Asana est un gestionnaire de communication d'équipe. Le produit prend en charge de

nombreuses fonctionnalités, notamment les espaces de travail, des projets, des tâches, des
étiquettes, des notes, des commentaires et une boîte de réception qui organise les mises à jour
des informations en temps réel. Il est conçu pour permettre aux individus et aux équipes de
planifier et gérer leurs projets et les tâches sans email. Chaque équipe reçoit un espace de travail.
Les espaces de travail contiennent des projets, et les projets contiennent des tâches.
Figure 5 : Aperçu d’Asana
Parmi les fonctionnalités offertes par l’outil Asana, on peut citer :
 Gestion du travail, des tâches et des projets
 Projets : organiser le travail en projets partagés sous forme de listes ou de tableaux Kanban
pour toutes initiatives, réunions et programmes.
 Tâches : décomposer le travail en tâches faciles à gérer par les membres de l’équipe.

 Sous-tâches : diviser les tâches en plusieurs éléments plus petits ou indiquer les étapes
nécessaires pour les terminer.
 Responsables de tâches : attribuer chaque tâche pour en désigner la personne responsable.
 Sections et colonnes : regrouper les tâches en sections ou colonnes dans les projets en vue Liste
ou Tableau (respectivement) pour garder les tâches organisées.
 Échéances : les échéances permettent de veiller à ce que chaque tâche soit achevée à temps.
On peut afficher les tâches dans un calendrier Asana ou même dans un calendrier professionnel.
 Pièces jointes : ajouter des fichiers à tout type de tâche ou discussion depuis ordinateur,
Google Drive, OneDrive, Dropbox ou Box.
 Dépendances : les dépendances de tâches indiquent clairement quelles tâches sont prêtes à être
commencées et lesquelles sont en attente d’autres tâches.
 Communication
 Commentaires sur les tâches : commenter directement une tâche pour préciser le travail à
faire et mentionnez des collègues ou d’autres tâches et projets pour tout connecter.
 Révision : laisser des commentaires précis directement sur les images et fichiers PDF. Ils se
transforment en tâches pour un suivi efficace.
 Révision d’image : laisser des commentaires précis sur des images pour que les créatifs
comprennent exactement le travail à effectuer.
 Gestion d’équipe
 Équipes : créer des équipes pour organiser les projets, et les relier aux collègues les uns aux
autres grâce à un calendrier et des discussions partagés.
 Collaborateurs : ajouter des collègues en tant que collaborateurs pour qu’ils puissent suivre
l’avancement de la tâche et reçoivent des notifications en cas de mise à jour.
 Permissions : limiter l’accès aux projets, créer des équipes masquées pour les informations
sensibles ou rendre publics les équipes et projets auxquels toute l’organisation doit accéder.
2.4.2. Outil Skype

Skype est un moyen simple, rapide et populaire pour les équipes distantes de rester en
contact et de collaborer. Il permet de passer des appels audio ou vidéo via Internet, ainsi que le
partage d'écran. La messagerie instantanée, le transfert de fichiers et la visioconférence sont des
fonctionnalités que Skype offre pour tous les utilisateurs.

Ce qui est utile pour organiser des réunions, et de joindre tous les membres de l’équipe,
là où ils se trouvent dans le monde.
Figure 6: Aperçu de Skype
2.4.3. Google Meet

Google Meet est un service de vidéo-communication développé par Google. Il est l’une
des deux applications qui constituent la nouvelle version de Google Hangouts, Google Meet a
été un produit premium, mains maintenant il peut être utilisé gratuitement par des groupes, des
équipes, des entreprises, des organisations, des écoles et des établissements d’enseignement
supérieur. On a surtout utilisé cet outil pour les réunions quotidiennes (daily standup).
Figure 7 : Aperçu de Google Meet

2.5. Backlog du produit
Le backlog du produit est la liste des fonctionnalités attendues d’un produit.
En tant qu’un administrateur Back-office de Mobilosoft :
Je peux Afin de
Ajouter ou importer une application depuis Pouvoir l’exploiter par la suite dans la
maven ou un jar en local composition d’un flux de tâches
Créer une nouvelle tâche pour la création d’un Créer un nouveau site avec le compte
site GMB associé dans la plateforme
myMobilosoft
Créer une nouvelle tâche pour la création d’un Créer un nouveau client avec les
client paramètres renseignés et le site ajouté
Créer une nouvelle tâche pour l’import des Importer tous les locations depuis GMB
locations d’un site précis
Créer une nouvelle tâche pour l’import de GMB Importer tous les avis des clients depuis
reviews GMB d’un site
Créer une nouvelle tâche pour l’import de Importer tous les avis des clients depuis
Facebook reviews Facebook d’un site
Créer une nouvelle tâche pour l’import des Importer tous les reportings des locations
reportings d’un site précis
Avoir un fichier de journalisation qui décrit Consulter les logs ou les fichiers de
l’historique de l’exécution de la tâche journalisations attachés à ce processus
Avoir le statut de l’exécution de la tâche Monitorer l’état de l’exécution de la

tâche
Créer une tâche composée Orchestrer, surveiller et contrôler

l’exécution du flux (l’ensemble des sous-
tâches)

Ré-exécuter la même tâche en cas d’échéance Faire une reprise sur erreur
Savoir les différents infos sur chaque l’exécution Consulter la durée, les paramètres, les
de la tâche arguments, et le job appelé pour chaque
exécution
Consulter le flux défini d’une tâche précise Visualiser le graphe d’ordonnancement
Générer un fichier Excel depuis la plateforme Faciliter l’analyse derrière ces données.
myMobilosoft contenant tous les infos des
locations d’un site précis
Spécifier les critères à prendre en considération Filtrer l’ensemble des locations selon le
lors l’export du fichier Excel. besoin.
Tableau 2: Backlog du produit
2.6. Planification du projet
Avant de se lancer dans la réalisation du projet, il est nécessaire de prendre le temps de

découper celui-ci en tâches, afin de planifier leur exécution et le temps à allouer pour chacune
d’elles.
Et pour se faire, on a utilisé le diagramme de Gantt qui est l’un des moyens les plus
populaires et les plus utiles d’afficher les activités (tâches ou événements) en fonction du temps.
À gauche du tableau, on trouve une liste des activités et, à droite, une échelle de temps
appropriée. Chaque activité est représentée par une barre ; la position et la longueur de la barre
reflètent la date de début, la durée et la date de fin de l'activité. Ceci permet donc de voir en un
coup d'œil :
- Quelles sont les différentes activités.

- Quand chaque activité commence et se termine.
- Combien de temps chaque activité est prévue pour durer.
- Lorsque les activités se chevauchent avec d'autres activités et dans quelle mesure.
- La date de début et de fin de l'ensemble du projet.

Figure 8: Liste des activités du diagramme de Gantt
Figure 9: La durée des activités du diagramme de Gantt

Conclusion
Dans ce deuxième chapitre, on a présenté en détails la gestion de mon projet. Ceci s’est
déroulé comme suit : la spécification des contraintes, ainsi que les potentiels risques du projet.
Ensuite, on a vu la conduite du projet, qui explique la méthode agile qu’on a suivi. Après, on a
cité les différents outils de communication qu’on a utilisé. A la fin on a mis en place un carnet
de produit et un planning pour les objectifs à atteindre.

Chapitre III
Etude préliminaire
Dans ce présent chapitre, on décrit les besoins fonctionnels et non

fonctionnels du projet. Puis, on aborde la partie qui explique c’est
quoi un traitement batch.
Et à la fin, on définit l’ordonnancement des batchs et les outils qui

y existent ; pour décider par la suite la solution à concevoir.

Chapitre III : Etude préliminaire
Introduction
L’étude préliminaire d’un projet permet de détailler, de définir, et d’exprimer des
besoins à satisfaire en termes de fonctions à assurer et d’objectifs à atteindre. Cette phase
formalise donc la prise de décision concernant les technologies à utilisés et les solutions à
adopter. Ce chapitre présente dans un premier temps une description des divers éléments
constituant le cahier de charge à savoir : les besoins fonctionnels, les besoins opérationnels.
Ensuite, on retrouve un aperçu en quoi consiste un traitement batch, et finalement la
détermination de l’outil d’ordonnancement à exploiter pour administrer ces batchs.
3.1. Expression des besoins

3.1.1. Les besoins fonctionnels du projet
Étant donné que l’objectif ultime de mon projet PFE, est d’élaborer une solution de
monitoring qui mène à bien la migration des clients vers la nouvelle version de la plateforme
myMobilosoft, il demeure nécessaire de définir les points essentiels de mon travail :
Lors de l’étude de projet qu’on a fait dans les chapitres précédents on a pu identifier des
différents besoins qui spécifient la mission à laquelle on doit répondre.
L’objectif de cette étape est de décrire les fonctions principales, optionnelles et les contraintes
de la solution attendue. Les spécifications suivantes représentent les fonctionnalités générales
du projet :
Administrer, superviser, gérer et piloter :
- La création des sites.
- La création des clients.
- L’import des locations depuis GMB.
- L’import des reviews des locations depuis GMB.
- L’import des reviews des locations depuis Facebook.
- L’import des reportings des locations depuis Google.

Exporter les locations d’un site sous forme d’un fichier Excel depuis la plateforme
myMobilosoft.
3.1.2. Les besoins opérationnels du projet

Les besoins opérationnels de mon projet sont :
L’ergonomie des interfaces
Les interfaces doivent être faciles à utiliser. Ceci permettra à une personne lambda
n’ayant pas un background informatique de pouvoir exploiter notre solution aisément.
Aptitude à la maintenance
La conformité aux standards de développement : on a mis en place et suivi des normes

de développement concernant tout ce qui est règles de nommage, de bonnes pratiques, etc. Voir
annexe.
Scalabilité
Mon travail doit être extensible, c’est-à-dire qu’il maintient ses fonctionnalités et ses
performances en cas de changement, aussi bien qu’il pourra y avoir une possibilité d’ajouter ou
de modifier de nouvelles fonctionnalités à tout moment.
Cela veut dire de nouvelles tâches qui recourent à des nouveaux batchs / jobs éventuellement
développés.
Disponibilité
La solution doit être disponible et en marche, 24 heures sur 24, 7 jours par semaine.
Cela consiste donc à mettre en place des actions pour que notre système soit toujours disponible
en appliquant certains principes tels que la sauvegarde des données.
Ce qui est assuré par mon utilisation de Google Cloud SQL comme service de gestion de base
de données qui facilite la configuration, la maintenance, la gestion et l'administration de notre
base de données.

Intégrité
Dans le cadre de mon projet, garantir l’intégrité des données est un point crucial; c’est-
à-dire de déterminer si les données ne subissent aucune altération ou destruction volontaire ou
accidentelle lors leur migration.
Documentation
On a veillé à rédiger un rapport décrivant le fonctionnement général et en détails de la

solution optée avec les technologies et les démarches suivies.
Ceci accordera à une simple personne ayant des connaissances informatique de mieux
comprendre mon objectif.
3.2. Traitement Batch
Le batch que l’on traduit en français par traitement par lots (Batch processing en anglais)
renvoie à l’enchaînement automatique d'une série de commandes informatiques.
Le batch est couramment utilisé pour réaliser des traitements différés, pendant la nuit
par exemple, dont les ressources serveurs d’une entreprise sont souvent moins sollicitées. Elles
vont pouvoir être allouées pour exécuter des batchs.
Figure 10: Processus du traitement Batch
Les traitements par lots sont utilisés dans de nombreux domaines :
- Pour renommer de gros volumes de documents ou de dossiers.

- Pour extraire des informations issues de plusieurs systèmes.
- Pour planifier l’arrêt d’un parc d’ordinateurs.
- Pour supprimer des fichiers temporaires.
Dans la BI (Business Intelligence) ou le BD (Big Data), on peut également y recourir

pour réaliser des calculs sur des quantités massives de données. Techniquement, le batch mis
en question vient afficher décrivant l’enchaînement de commandes à mettre en œuvre.
Un outil d’ordonnancement se charge de les déclencher au moment voulu. Cet outil est
capable de prendre en compte des règles d’exécution pour enchainer le traitement comme un
véritable programme. Autrement dit, si la tâche à exécuter est conforme, alors on l’exécute,
sinon on passe à la commande suivante.
Tâche
Conforme
Oui Non
Exécuter Ignorer
Figure 11: Traitement Batch
En informatique les traitements par lots et leurs exécutions différées s’opposent aux
traitements transactionnels.
Un traitement transactionnel, lui, va rapatrier le programme et ses données dans la mémoire

vive de l’ordinateur ou du serveur dont l’optique d’exécuter le tout en quasi temps réel.
3.3. Ordonnancement des batchs / jobs

3.3.1. Définition
L'ordonnancement de tâches informatiques concerne exclusivement la manière de
lancer des traitements (batchs) sur un ou plusieurs composants de son système d'information au
moyen de progiciels spécifiques. Ces progiciels allient la théorie de l'ordonnancement avec des

techniques propres à l'informatique (queues de traitements, gestion de fichiers, équilibrage de
charge…).
Cela permet de définir des enchaînements entre les traitements. En d’autres termes, on
lance un traitement à la suite d'un autre traitement. La notion de traitement peut être assez
générale puisqu'il s'agit de toute commande exécutable sur une ou plusieurs machines
informatiques, et pour être plus spécifique un traitement dans notre cas signifie un batch ou
encore un job.
Figure 12: Ordonnancement des tâches
3.3.2. Choix de la solution à exploiter

Parmi les solutions proposées pour répondre à la problématique principale de mon
projet, le fait de pourvoir un outil de supervision, ou un ordonnanceur qui permet de piloter
l’ensemble des batchs avec de la répartition de charge, la reprise sur erreur et l’assurance de la
journalisation, on retrouve :
3.3.2.1. Visual TOM

Visual TOM est une solution Cloud et DevOps conforme, dédiée à l’automatisation des
tâches et à l'orchestration des processus. C’est l’outil suggéré par l’entreprise. Cependant, c’est
une solution payante et qui manque de documentation.

3.3.2.2. Spring XD
Spring XD est un système unifié, distribué et extensible pour l'ingestion de données,
l'analyse en temps réel, le traitement batch et l'exportation de données. Son objectif principal
est de simplifier le développement d’applications Big Data.
Parmi les cas d’utilisation de Spring XD, on note :
- Internet des objets: Activer l'analyse prédictive en temps réel sur de grandes
quantités de données, en favorisant les améliorations commerciales et opérationnelles
en temps réel.
- Traitement d'événements complexes: Permet de créer des processeurs

d'événements complexes pour répondre aux événements en temps réel.
- Orchestration du batch workflow: Dédiée pour les traitements par lots, tout en
offrant des modèles out-of-the-box pour surveiller l’exécution des jobs sans avoir à
écrire du code. Spring XD se charge de la gestion de l'infrastructure, les spécificités
de l'environnement et l'automatisation des batchs.
Or, ce projet est en statut EOL / EOS / EOA depuis juillet 2017. La version 1.3 GA de
Spring XD était la dernière version qui ne traite que des corrections de bugs. Néanmoins,
l’écosystème de Spring l’a reconstruit dans le projet Spring Cloud Data Flow en s’appuyant sur
les capacités de Spring Boot et Spring Cloud.
3.3.2.3. Spring Batch Admin

En se basant toujours sur les solutions d’ordonnancement offertes par Spring, on
mentionne Spring Batch Admin. Ce projet fournit une interface utilisateur (UI) Web
d’administration et supervision des traitements par lots implémentés avec Spring Batch.
En plus du frontal web, cette console offre une API JSON et expose des métriques via
JMX (Java Management Extensions) pour gérer le fonctionnement des applications Batchs en
cours d'exécution.
Cependant, ce projet n’est plus pris en charge depuis le 31 décembre 2017. Ses
fonctionnalités ont été principalement dupliquées et développées via Spring Cloud Data Flow,
qui est désormais son alternative, ou son remplaçant recommandé.

3.3.2.4. Spring Cloud Data Flow
Les deux outils précités ont tous été expirés mais remplacés par Spring Cloud Data
Flow : l’outil qui englobe les fonctionnalités de Spring Batch Admin ainsi que Spring XD pour
l’orchestration des batch.
Il est utilisé aussi pour déployer des applications Spring Boot (ou des images Docker) sous
forme de flux ou de tâches. En d’autres mots, SCDF est un micro-service de traitement des
données soit par lot ou en temps réel.
C’est un modèle de programmation et d’exploitation natif au cloud pour les

microservices de données composables.
Avec Spring Cloud Data Flow, les développeurs peuvent créer et orchestrer des
pipelines de données pour des cas d’utilisation courants tels que l’acquisition de données,
l’analyse en temps réel et l’importation/exportation de données. .
Il existe deux types de pipelines de données, les pipelines de données en continu et en mode
batch.
Dans le premier cas, une quantité illimitée de données est consommée ou produite via un
middleware de messagerie. Dans le second cas, la tâche de courte durée traite un ensemble fini
de données puis se termine.
Figure 13: Architecture de Spring Cloud Data Flow
Ci-avant l’architecture de SCDF :

- Le serveur SCDF utilise Spring Cloud Deloyer pour cibler plusieurs runtimes (un
environnement d’exécution) comme Cloud Foundry, Yarn, Local etc
- Il expose une API REST pour la composition et le déploiement des applications de

type tasks.
- Il est accessible via une interface utilisateur d’administration qui offre des vues
spécifiques pour les applications, les streams, les tasks etc.
- Le tableau de bord SCDF propose un éditeur graphique pour créer des pipelines de
données de manière interactive, ainsi qu’une vue intuitive pour la surveillance et la
supervision des applications déployées.
- Il est accessible aussi via un terminal en ligne de commande (SCDF Shell) ou via
Restfull URL pour les clients.
Pour usage de développement, on a opté pour un environnement d’exécution en local.
Après la présentation de ces divers outils d’orchestration, on va examiner quelques cas

d'utilisation pour comparer et contraster la différence entre Spring Admin et Spring Cloud Data
Flow.
Ci-dessous un tableau qui synthétise la différence entre les cas d'utilisation de Spring
Batch Admin, ainsi que ceux qui sont pour Spring Cloud Data Flow :
Spring Batch Admin Spring Cloud Data Flow
Packaging - Dans un seul fichier -Spring Boot JARs ou un conteneur Docker

WAR -les batch jobs sont packagés
indépendamment du serveur d'orchestration
(deux entités différentes), ce qui permet plus
de flexibilité
Modèle -Les batch jobs et -Chaque batch job est exécuté dans une JVM
d’exécution l'application Web indépendante appelée Tasks (Tâches)

s'exécutent dans la même
JVM.
-Tous jobs partagent la

même zone de mémoire.
-separate JVM that will

shut down once your job
is complete.
Options - Interface utilisateur Web - Interface utilisateur Web

d’interaction - REST API - REST API
- interactive shell
- drag and drop (glisser/déposer) UI
Tableau 3: Tableau comparatif des cas d'utilisations de Spring Batch Admin et SCDF
Ci-après, un tableau comparatif entre Spring XD et Spring Cloud Data Flow:
Spring XD Spring Cloud Data Flow
Terminologie
XD-Admin Server (implementations: local, cloud

foundry, apache yarn, kubernetes, et apache
mesos)
XD-Container N/A
Modules Applications
Admin UI Dashboard
Batch / Job Task
REST-API
/modules /apps

/runtime/modules /runtime/apps
/jobs/definitions /task/definitions
/jobs/deployments /task/deployments
Tableau 4: Tableau comparatif entre Spring XD et SCDF
En se basant sur l’étude et la comparaison de ces multiples solutions citées juste avant,
il devient évident que Spring Cloud Data Flow est la meilleure solution à mettre en œuvre pour
monitorer et superviser nos batchs, car de un, il est préférable d’en tirer profit des solutions
Spring puisque la plateforme myMobilosoft est une application Spring Boot, et de deux, on ne
peut pas s’appuyer sur des solutions qui ne sont ni prises en charge ni en mises à jour.
Conclusion
Dans ce troisième chapitre, on a déterminé les besoins fonctionnels et opérationnels de
mon projet. Puis, pour mieux appréhender mon sujet, on a vu qu'est-ce que c'est un traitement
batch, et quels sont les outils qui servent à l’ordonnancer. Finalement, on y a choisi la solution
à opter pour l’orchestration et l’administration de nos batchs.

Chapitre IV
Conception et modélisation
Ce chapitre est une synthèse globale de l’analyse et la modélisation

de mon projet. On y retrouve les diagrammes de cas d’utilisation, le
workflow des opérations et le diagramme d’entité-association.

Chapitre IV : Conception et modélisation
Introduction
Maintenant qu’on a une idée précise des besoins fonctionnels et opérationnels de mon
projet, il est crucial qu’on passe à l’étape de d’analyse et modélisation.
Le modèle d’un système informatique est clé, car il sert comme document d’échange
entre clients et développeurs, d’outil de conception, de référence pour le développement, ainsi
que pour la maintenance et l’évolution. Concevoir les échanges qui auront lieu au niveau de la
solution élaborée, le rôle des utilisateurs et le format des données au préalable permet de savoir
la direction à prendre au niveau du développement, et de prévenir des fautes d’organisation des
relations entre entités par la suite.
L’idée est donc de mettre en place des diagrammes (car plus explicatifs que des textes)
qui représentent les interactions des utilisateurs avec le projet, le workflow des opérations, et
les entités existantes et les liaisons entre elles.
L’UML, notamment, est la technique la plus populaire pour la modélisation des

processus. Ce langage offre une multitude de diagrammes unifiés, dont la lecture donne une
idée détaillée du fonctionnement d’une solution donnée.
4.1. Diagramme de cas d’utilisation

Les diagrammes de cas d'utilisation ont pour but de capturer l'aspect dynamique d'un
système, et de le décrire du point de vue utilisateur.
Ce type de diagrammes comporte deux types d’entités fondamentaux : les acteurs qui
agissent sur le système, et les cas d’utilisation. Chaque cas d’utilisation représente une
fonctionnalité déclenchée par un acteur externe du système. Il permet donc de mieux
comprendre les besoins utilisateurs. Vu que mon produit final vise les administrateurs Back-
office de Mobilosoft, on n’aura qu’un seul acteur.

4.1.1. Diagramme de lancement et visualisation d’une
tâche/batch depuis la solution de monitoring
Notre ordonnanceur des tâches permet à l’administrateur d’enregistrer une application
de type Task par laquelle il peut créer / composer une nouvelle tâche. Par la suite, il peut
déclencher l’exécution de la tâche en question (batch) selon les paramètres saisis, et l’ordre
choisi. Une fois lancé, l’admin supervise le déroulement de ce processus et suit pas à pas
l’enchainement des tâches, on y retrouve le statut de l’exécution et le fichier de log.
Cas d’utilisation Signification
Ajouter une nouvelle Pour ce faire, l’administrateur doit renseigner le nom de

application l’application, son type -pour notre cas c’est ‘Task’- et l’URI.
Créer une nouvelle L’admin utilise ce cas pour accorder une définition à une tâche à
tâche partir de(s) application(s) Tasks déjà enregistrées : tâche simple ou
tâche composée (flux de tâches ordonnancées séquentiellement).
Exécuter une tâche Le cas d’utilisation principal de la solution. L’admin l’exploite pour
lancer d’une manière automatique un batch précis. Le batch à
exécuter est renseigné via paramètre.
Reprendre une tâche L’admin utilise ce cas pour reprendre l’exécution d’une tâche tout
en gardant sa définition.
Arrêter une tâche L’admin utilise ce cas pour arrêter ou suspendre l’exécution d’une
tâche précise.
Créer un site Pour ce faire, l’admin doit passer le nom du site et le compte GMB
sous forme de paramètre.
Créer un client Pour ce faire, l’admin doit passer le nom du client, son id et le site
qu’il veut lui faire associer.

Importer les locations Pour cette tâche, l’admin doit indiquer le nom du site pour lequel il
depuis GMB veut importer les locations depuis Google. Pour ce faire il doit le
passer comme paramètre avant de lancer la tâche qui lui correspond.
Importer les avis des Pour cette tâche, l’admin doit indiquer le nom du site pour lequel il
clients depuis GMB veut importer les avis des clients depuis Google. Pour ce faire il doit
le passer comme paramètre avant de lancer la tâche qui lui
correspond.
Importer les avis des Pour cette tâche, l’admin doit indiquer le nom du site pour lequel il
clients depuis veut importer les avis des clients depuis Facebook. Pour ce faire il
Facebook doit le passer comme paramètre avant de lancer la tâche qui lui
correspond.
Importer les Pour cette tâche, l’admin doit indiquer le nom du site pour lequel il
reportings veut importer les reportings. Pour ce faire il doit le passer comme
paramètre avant de lancer la tâche qui lui correspond.
Consulter les fichiers L’administrateur utilise ce cas pour voir les logs de l’exécution
de journalisations d’une tâche. Il retrouve donc un journal traçant pas à pas le
déroulement du processus. Il retrouve aussi le statut de cette
exécution.
Tableau 5: Signification des cas d'utilisation du diagramme lancement d'une tâche

Figure 14: Diagramme de cas d'utilisation - Lancement et visualisation d'une tâche
4.1.2. Diagramme de cas d'utilisation – L’export des locations

depuis la plateforme myMobilosoft
Sur la plateforme myMobilosoft, on a ajouté une nouvelle fonctionnalité offerte
à l’administrateur pour s’assurer davantage que le scenario de migration est mené à bien,
et les données conservent leurs intégrités
On parle de l’export de tous les informations des tous les locations d’un site
dans un fichier Excel, selon les critères saisis.
Cas d’utilisation Signification
S’authentifier Pour ce faire, l’administrateur doit utiliser son compte Google pour se
connecter à la plateforme myMobilosft.
A noter que ce cas d’utilisation était déjà implémenté dans l’application
Filtrer les Tant que l’administrateur est sur la page affichant la liste des locations,
locations il peut les trier par statut, channel, mot clé, code zip, tag etc

Exporter tous les L’admin exploite ce cas d’utilisation pour générer un fichier Excel
locations contenant les différentes informations de toutes les locations (horaires
d’ouverture, adresse, catégorie, service, extra-fields etc).
Exporter les L’administrateur doit filtrer les locations pour lesquelles il veut générer
locations avec le fichier Excel. Ce fichier comprend deux feuilles, la première contient
filtre les données (infos des locations), et la deuxième est consacrée pour les
critères déjà mentionnés.
Tableau 6: Signification des cas d'utilisation du diagramme export des locations
Figure 15: Diagramme de cas d'utilisation – export des locations
4.2. Workflow des opérations

Au niveau de ce diagramme, qui se rapproche du diagramme de séquences de UML, on
reprend un cas d’utilisation et le dissèque pour voir le workflow de son opération entre les
différentes phases du système, et les interactions qui prennent place entre les dites-phases. Ceci
donnera lieu à des fonctions de la solution de monitoring par la suite.
4.2.1. Diagramme de création d’un site

Le diagramme de séquences ci-dessous décrit le scénario de création d’un nouveau site.
Ceci se déclenche par la demande de l’utilisateur d’exécuter une tâche dont son paramètres
‘jobname’ est 'site’, avec comme paramètres le compte GMB voulu, depuis la solution de
monitoring. Cette dernière transmet ces paramètres à l’application batch qui se charge de sa
création.

Figure 16: Diagramme de séquences de création d’un site
Figure 17: Diagramme de séquences du traitement batch du site
La création d’un nouveau client se fait d’une manière identique que celle de création du
site.

4.2.2. Diagramme d’importation des locations depuis GMB
La suite logique du scénario précédent, soit celle de « la création d’un site», est tout
naturellement de commencer l’import des locations, comme le décrit le diagramme suivant.
Ceci se déclenche par la demande de l’utilisateur d’exécuter une tâche dont le paramètre
‘jobname’ est égale à ‘locations’ depuis la solution de monitoring. Cette dernière requiert alors
d’une application de type task (l’application dans laquelle on a développé ces batchs et on l’a
empaqueté sous forme de jar) de lui lancer le traitement batch correspondant, tout en lui passant
le nom du site pour lequel cette importation va être faite comme paramètre.
Ce traitement est enrobé par un job, qui est une entité qui encapsule un processus de
traitement par lots complet. Ce job comporte une ou plusieurs Steps. Dans notre cas, on a défini
une seule Step pour chaque job.
A son tour Step comporte 3 éléments essentiels, sont ItemReader, ItemProcessor et

ItemWriter.
- ItemReader lit le nom du site et l’envoie à la base de données, qui lui envoie à son
tour le compte GMB qui y associé. Une fois récupéré l’ItemReader renseigne ce
compte à l’API de GMB, cette dernière renvoie à son tour les locations GMB
correspondantes.
- ItemProcessor traite les GMB locations, en les convertissant aux Mobilosoft

locations.
- Une fois le traitement est effectué, ItemWriter écrit ces enregistrements (Mobilosoft
locations) dans notre base de données.
Ceci résume le scénario « Importation des locations depuis GMB », déclenché par
l’administrateur depuis la solution de monitoring.

Figure 18: Diagramme de séquences d'import des locations depuis GMB
Figure 19: Diagramme de séquences du traitement batch des locations

4.2.3. Diagramme d’importation des avis des clients depuis GMB
Le dernier diagramme qu’on a établi pour la clarification du workflow en sein de la
solution de monitoring concerne de l’importation des avis des clients de chacune des locations
d’un site depuis GMB.
Comme le précédent, ce scénario est déclenché via l’exécution de l’utilisateur

précisément l’administrateur la tâche du ‘gmbreviews’. Il lance ce batch via la solution de
monitoring, ce qui signifie qu’il demande à l’application du batch d’exécuter le job
correspondant.
Cette application envoie alors itérativement le compte GMB de la location en question

à l’API de Google, lui demandant la liste des avis des clients sur ce point de vente.
Une fois récupérés, le job se charge de les convertir en Mobilosoft reviews et les stocker
dans la base de données.
Si tout se passe bien, l’admin peut parcourir le fichier de log correspondant à ce scénario
et le lire à son aise.
Figure 20: Diagramme de séquences d'import des GMB Reviews

Figure 21: Diagramme de séquences du traitement batch des GMB reviews
Le reste des scenarios suivent la même logique que celui-ci. Pour l’import des reviews
depuis Facebook, on utilise l’API de Facebook au lieu de celle de GMB.
Et de même pour l’import des reportings, on a eu recours à l’API de Google pour l’exportation
des rapports.
4.3. Diagramme d’entité-association
Un diagramme entité-association est un type d'organigramme illustrant la façon dont

des « entités » telles que des objets ou concepts sont liées les unes aux autres au sein d'un
système. Les diagrammes entité-association sont généralement utilisés pour concevoir ou
déboguer des bases de données relationnelles dans le domaine de l'ingénierie informatique, des
systèmes d'information d'entreprise, de l'éducation et de la recherche. Appelés Entity-
Relatioship Diagram ERD en anglais, ils utilisent une série de symboles prédéfinis tels que des
rectangles, losanges et ovales reliés par des lignes pour décrire les interconnexions entre les

entités, leurs relations et leurs attributs. Ils imitent une structure grammaticale, où les entités
sont des noms et les relations des verbes.
Figure 22: Diagramme d’entité-association du module Batch
Conclusion
Dans ce chapitre on a fait une description complète du comportement du système à
développer. En d’autres mots, on a réalisé une modélisation à travers les diagrammes de cas
d’utilisation et les diagrammes de séquences qui mettent en exergue le séquencement des
opérations et des relations éventuelles entre les services. Et finalement, on a représenté la
relation entre les déférentes entités de système via le diagramme d’entité-association.

Chapitre V
Etude technique
Ce chapitre est une sorte d’étude technique du projet. On y retrouve

son fonctionnement global, vu du contexte technique. Aussi, on y
liste toutes les technologies et les APIs employées, que ça soit du
côté batchs ou monitoring.

Chapitre V : Etude technique
Introduction
L’élaboration de cette solution s’est effectuée en se basant sur la technologie Java. Ce
choix est justifié par la maturité et la richesse de cette technologie et par la multitude
d’avantages qu’elle offre et qu’on a déjà précités.
Ce chapitre est consacré à la présentation de l’architecture technique du projet, Ceci

inclut la description des architectures logicielle, ainsi que la description des différentes
technologies et Frameworks utilisés lors de la partie mise en œuvre.
5.1. Architecture globale du projet
Figure 23: Cycle de développement du projet

Figure 24: Architecture globale du projet
Spring Cloud Data Flow permet à un utilisateur de créer un graphe orienté, où chaque
nœud du graphe est une application de type Task. Cela se fait en utilisant ‘Composed Task
DSL’ : l’éditeur graphique de type "Drag & Drop" qui permet la création des tâches composées.
Cet éditeur est accessible via une API REST du serveur Data Flow. Ce dernier cible
plusieurs environnements d’exécution (runtimes) comme Cloud Foundry, Kubernates ou Local.
o Mais c’est quoi Task Application?
C’est une application de courte durée "Short-lived" qui traite un ensemble fini de
données puis se termine. Il existe deux variantes d'applications de courte durée.
1- Spring Cloud Task qui permet la création des microservices de courte durée pour
l’application Spring Boot. Ce qui donne la possibilité d’exécuter n’importe quelle tâche
de manière dynamique, d’allouer des ressources à la demande et de récupérer les
résultats une fois la tâche terminée.
2- Application Batch dont la vocation est d'effectuer un traitement par lot sur une masse
de données de façon autonome et automatique. Elle a pour objectif de lire des données

provenant de diverses sources homogènes ou hétérogènes (fichiers, bases de données,
web, etc.), puis d'effectuer des traitements/transformations sur ces données lues afin d'en
stocker le résultat dans un ou plusieurs conteneurs de destination (fichiers, bases de
données, etc.) dans le but de les exploiter. Pour rendre cette application de type Task, il
faut juste ajouter l’annotation @EnableTask.
Après avoir défini une application Batch, il s’avère important de jeter un coup d’œil en
quoi consiste Spring Batch.
o Qu’est-ce que Spring Batch ?
Lors le développement des scénarios de migration, on a suivi l’architecture de Spring

Batch, qui permet de construire des programmes de traitement par lot –qui est défini comme le
traitement d'une quantité finie de données sans interaction ou interruption-.
C’est un framework qui fournit un ensemble de composants et de fonctionnalités

réutilisables et personnalisables permettant de donner au programme tous les éléments
nécessaires à la définition d'un cadre structuré pour implémenter les règles métier et améliorer
la performance à travers des techniques de partitionnement et d'optimisation.
La figure suivante schématise de façon macroscopique l’architecture de Spring Batch :

Figure 25: Processus global de Spring Batch
Cette vue générale et non détaillée du framework Spring Batch présente plusieurs
composants qui doivent être définis et configurés pour suivre le workflow dont le sens suit la
numérotation qui accompagne chacun d'eux sur ce schéma.
 Le JobLauncher : le composant chargé de lancer/démarrer le programme de

traitement par lot (batch). Dans le worflow Spring Batch, le JobLauncher est chargé
d'exécuter un Job (tâche).
 Le Job : le composant qui représente la tâche à qui on délègue la responsabilité du

besoin métier traité dans le programme. Il est chargé de lancer de façon séquentielle
une ou plusieurs Step.
 La Step : le composant qui enveloppe le cœur même du besoin métier à traiter. Il est
chargé de définir trois sous-composants structurés comme suit:
o Le Reader : le composant qui est chargé de lire les données d'entrées à traiter.
Elles peuvent provenir de diverses sources (bases de données, fichiers plats (csv,
xml, xls, etc.)).

o Le Processor : le composant responsable de la transformation des données lues.
C'est là que toutes les règles de gestion sont implémentées.
o Le Writer : ce composant sauvegarde les données transformées par

le processor dans un ou plusieurs conteneurs désirés (bases de données, fichiers
plats (csv, xml, xls, etc.), cloud).
 Le Repository : le composant chargé d'enregistrer les statistiques issues du

monitoring sur le JobLauncher, le Job et la (ou les) Step à chaque exécution.
 Les Job et Step Listeners : sont des composants facultatifs qui offrent un cadre pour
l'implémentation des services de monitoring personnalisés. Ils sont très utiles pour
journaliser (loguer) les états du Job/Step avant et après leur exécution.
5.2. Les choix technologiques et frameworks utilisés

De nos jours, le choix des technologies à utiliser dans un projet informatique influence
beaucoup sur la qualité et les performances du logiciel produit.
Une analyse profonde avant tout choix final d’une technologie est nécessaire car un
mauvais choix va dévaloriser mon travail. C’est la raison pour laquelle on a consacré plus de
temps et d’effort en travaillant là-dessus.
Apres l’étude des fonctionnalités des différentes technologies, j’ai opté pour une liste
des technologies les plus sophistiquées qu’on va développer dans le paragraphe ci-dessous
5.2.1. Environnements de développement

5.2.1.1. IntelliJ IDEA
Figure 26: Logo de Intellij IDEA
IntelliJ IDEA est un IDE Java intelligent qui fournit une combinaison robuste d’outils
de développement. Ses fonctionnalités clés incluent :
 Une assistance au codage intelligent

 Une navigation et une recherche intelligentes
 De nombreuses factorisations
 Une analyse des codes
 Une assistance au développement Web et d'entreprise
 Des tests unitaires, une couverture de code et la facilitation du travail en équipe.
Les fonctionnalités de IntelliJ IDEA sont continuellement étendues par les utilisateurs
et les tiers via des plugins. IntelliJ IDEA prend en charge Java EE, Spring / Hibernate et d’autres
piles technologiques.
5.2.1.2. Spring
Figure 27: Logo Spring
Spring est un Framework libre pour construire et définir l'infrastructure des applications
java, dont il facilite le développement et les tests. Le Framework Spring a tout d’abord été écrit
par Rod Johnson et réalisé sous la licence Apache 2.0 en 2003.
Spring est considéré comme un conteneur dit « léger » c’est-à-dire une infrastructure
similaire à un serveur d'applications J2EE. Il prend donc en charge la création d’objets et la
mise en relation d’objets par l’intermédiaire d’un fichier de configuration qui décrit les objets
à fabriquer et les relations de dépendances entre ces objets. Le gros avantage par rapport aux
serveurs d’application est qu’avec Spring, les classes n’ont pas besoin d’implémenter une
interface quelconque pour être prises en charge par le Framework (au contraire des serveurs
d'applications J2EE et des EJBs). C’est en ce sens que Spring est qualifié de conteneur «léger».
Spring s’appuie principalement sur l’intégration de trois concepts clés :
1. L’inversion de contrôle est assurée de deux façons différentes : la recherche et

l’injection de dépendances.
2. La programmation orienté aspect.
3. Une couche d’abstraction qui permet d’intégrer d’autres Framework et bibliothèques

avec une plus grande facilité.

5.2.1.3. Docker
Figure 28: Logo Docker
Docker est un logiciel libre permettant de lancer des applications dans des conteneurs
logiciels.
Docker est un outil qui peut empaqueter une application et ses dépendances dans un
conteneur isolé, qui pourra être exécuté sur n'importe quel serveur. Il ne s'agit pas
de virtualisation, mais de conteneurisation, une forme plus légère qui s'appuie sur certaines
parties de la machine hôte pour son fonctionnement. Cette approche permet d'accroître la
flexibilité et la portabilité d’exécution d'une application, laquelle va pouvoir tourner de façon
fiable et prévisible sur une grande variété de machines hôtes
5.2.1.4. Maven
Figure 29: Logo Maven
Maven, un mot yiddish signifiant accumulateur de connaissances, a été initialement

lancé comme une tentative de simplifier les processus de construction dans le projet Jakarta
Turbine. C’est un outil de construction de projets open source développé par la fondation
Apache. Il permet notamment :
▪ D’automatiser certaines tâches : compilation, tests unitaires et déploiement des

applications qui composent le projet
▪ De gérer des dépendances vis-à-vis des bibliothèques nécessaires au projet
▪ De générer des documentations concernant le projet.

5.2.2. Frameworks et APIs
5.2.2.1. Spring Boot
Figure 30: Logo Spring boot
Il est aujourd’hui difficile d’étudier une architecture de microservices en Java sans parler
de Spring Boot. Certes il existe d’autres Framework (Dropwizard, Spark Java) mais la souplesse
d’utilisation de Spring Boot et son intégration à l’écosystème Spring font de son utilisation une
évidence, ce qui justifie le fait que le choix de la société pour le développement de la plateforme
MyMobilosoft se soit porté sur Spring Boot, bien qu’il en existe des dizaines d’autres.
Spring Boot est considéré comme une enveloppe de Spring créé pour répondre aux
besoins de redéfinir la même configuration à plusieurs endroits du code donc c’est un
Framework conçu pour simplifier le démarrage et le développement de nouvelles applications
Spring.
Spring Boot offre également un ensemble de “starter projects” permettant d’intégrer

l’ensemble des librairies nécessaires à la construction par exemple d’un connecteur vers une
technologie donnée.
5.2.2.2. Spring Data
Figure 31: Logo Spring Data
Spring Data est un projet supplémentaire de Spring créé pour répondre aux besoins
d’écrire plus simplement l’accès aux données. Il s’interface avec plusieurs sources de données
parmi lesquelles JPA, REST, MongoDB et quelques autres.

5.2.2.3. Hibernate
Figure 32: Logo Hibernate
Hibernate une solution open source de type ORM qui facilite le développement de la
couche persistance de l’application.
Hibernate permet de masquer la logique relationnelle aux développeurs objets et/ou

d’interconnecter facilement des objets avec une base de données existante. Il répond au besoin
dans les langages objets ; les données étant le plus souvent stockées dans des bases de données.
Hibernate permet d’assurer la rapidité, l’évolutivité et la maintenabilité du

développement, comme étant un Framework de mapping Objet/Relationnel. Il possède une
architecture parfaitement adaptable à tout type de développements et le support de la majorité
des bases de données du marché.
5.2.2.4. Spring Batch
Figure 33: Logo Spring Batch
Spring Batch est un framework open source pour le traitement batch ou par lots . Il s'agit
d'une solution légère et complète conçue pour permettre le développement d'applications par
lots, que l'on trouve souvent dans les systèmes d'entreprise modernes. Spring Batch s'appuie sur
l'approche de développement basée sur POJO du Framework Spring .
Il fournit des fonctions réutilisables qui sont essentielles dans le traitement de grands
volumes de données, y compris la journalisation / traçage, la gestion des transactions, le ré-
lancement des jobs. Il fournit également des services et des fonctionnalités techniques avancés
pour l’automatisation des jobs.

5.2.2.5. Google My Business API
Figure 34: Logo Google My Business
C’est une interface de programmation d’applications pour automatiser plusieurs tâches

sur Google My Business. Cela permet de gérer plusieurs emplacements et d'utiliser des
fonctionnalités telles que les publications, les réponses aux avis, les photos à grande échelle etc.
A savoir que, Google My Business est un service de référencement destiné aux propriétaires
d'entreprise et exploité par Google. GMB a pour but de donner aux propriétaires d'entreprise
davantage de contrôle sur ce qui apparaît dans les résultats de recherche. Google permet aux
propriétaires d'entreprise de vérifier les données concernant leur établissement en créant une
nouvelle fiche ou en revendiquant une fiche existante
5.2.2.6. Facebook Developers API
Figure 35: Facebook Graph API
L’API Graph est l’interface principale par laquelle les applications peuvent lire et écrire
sur le graphe social de Facebook. Accéder aux pages, aux publications, aux groupes, aux
évènements et à d’autres sections
5.2.3. Bases de données

5.2.3.1. Google Cloud SQL pour PostgreSql
Figure 36: Logo Google Cloud SQL

La plateforme sur laquelle on travaille utilise Google Cloud SQL pour PostgreSQL
comme service de gestion de base de données relationnelle. Il facilite la configuration, la gestion
et l'administration des bases de données. Ce cas d'utilisation est un composant fondamental
d'une architecture de microservices reposant sur un service de stockage indépendant, ce qui
permet la décentralisation de la gestion des données et assure l'évolutivité indépendante de
chaque service.
5.2.4. Modélisation et gestion de projet

5.2.4.1. Modelio
Figure 37: Logo Modelio
C’est un logiciel de modélisation UML (Unified Modeling Language) open source qui
peut remplacer dans bien des situations des logiciels commerciaux et coûteux. Étant simple
d’utilisation, nécessitant peu de ressources système, supportant UML 2, ce logiciel constitue
une excellente option pour une familiarisation à la modélisation.
5.2.4.2. GanttProject
Figure 38: Logo GanttProject
GanttProject est un logiciel libre de gestion de projet écrit en Java, qui permet d'éditer
un diagramme de Gantt. Parmi les fonctionnalités principales de ce projet :
- Description de la structure de découpage du projet (en anglais "Work Breakdown

Structure"). C'est une décomposition hiérarchique, axée sur les tâches, du travail que
l’équipe de projet doit exécuter pour atteindre les objectifs du projet et produire les
livrables voulus.
- Liens multiples de précédences entre les tâches (prédécesseurs/successeurs).

- Visualisation du chemin critique.
5.2.5. Système de gestion de code

5.2.5.1. Git & Github
Figure 39: Logo Git
GitHub est une plateforme open source de gestion de versions et de collaboration

destinée aux développeurs de logiciels. Livrée en tant que logiciel à la demande (SaaS, Software
as a Service), la solution GitHub a été lancée en 2008. Elle repose sur Git, un système de gestion
de code open source a pour but d'accélérer le développement logiciel.
Git permet de stocker le code source d'un projet et de suivre l'historique complet de
toutes les modifications apportées à ce code. Grâce aux outils qu'elle fournit pour gérer les
conflits éventuels résultant des changements apportés par plusieurs développeurs, il est possible
de collaborer efficacement sur un même projet. GitHub facilite la programmation collaborative
en mettant une interface Web à disposition du référentiel de code de Git, ainsi que des outils
d'administration favorisant la collaboration.
GitHub fait penser à un site de réseau social sérieux sur lequel se retrouvent les
développeurs de logiciels. Ses membres peuvent suivre les activités et évaluer le travail de
chacun, recevoir des mises à jour pour des projets spécifiques et communiquer de manière
publique ou privée.
Conclusion
Ce chapitre avait comme finalité d’expliquer le côté technique du projet. On a
commencé donc par la schématisation du fonctionnement global, et ensuite de lister les
technologies qu’on a employées.

Chapitre VI
Réalisation et mise en œuvre
Dans ce dernier chapitre, on retrouve les différentes tâches qu’on a

intégrées pour la réalisation et la mise en œuvre de ce projet, en fonction
d’une approche itérative et incrémentale.

Chapitre VI : Réalisation et mise en œuvre
Introduction
Après avoir mené à terme la phase d’analyse et de conception, et les outils et les
Frameworks dans les chapitres précédents. On décrit dans ce présent chapitre les différentes
tâches qu’on a intégrées pour la réalisation et la mise en œuvre de ce projet, tout en suivant une
approche itérative et incrémentale.
Itération 0 : Préparation du lancement du projet

Avant de donner le coup d’envoi du projet, une étape primordiale, communément
appelée dans le monde Agile « itération 0 », doit avoir lieu. Elle est initiée par une réunion de
lancement lors de laquelle la stratégie de l’équipe pour mener le projet est élucidée. Tous les
problèmes organisationnels et techniques sont identifiés et leurs actions correctives sont
déterminées afin que le projet puisse démarrer dans les meilleures conditions possibles.
Le résultat du sprint 0 :
a. Fournie des documentations sur différents outils utilisée.
b. L’analyse des besoins. Après validation de compréhension du besoin, on imagine la

solution. C’est la partie analyse de la solution.
c. Phase de conception ; on apporte plus de détails à la solution et on cherche à clarifier

des aspects techniques, tels que l’installation des différentes parties logicielles à installer sur du
matériel.
Itération 1 : Développement des batchs

Cette itération est le point d’entrée de la solution de monitoring, et représente la
fondation. Pour cela, j’ai identifié les différents processus ou traitements à implémenter afin de
réaliser un scenario complet de migration d’un client Mobilosoft. Ceci consiste à créer six batchs,
qui suivent la logique et l’architecture Spring Batch. Cette dernière est constituée en 2 couches:
- La couche Batch Core.

- La couche Batch Infrastructure.
La couche "Batch Core" contient une API permettant de lancer et gérer un batch.
Les principales interfaces et classes que contient l'API sont: Job, JobLauncher et Step.
Schématiquement un batch correspond à un job qui va être lancé via un JobLauncher.
Un job est constitué d'une ou plusieurs Step. Une Step correspond à une étape dans un batch.
La couche "Batch Infrastructure" contient un API fournissant comme principales interfaces:

ItemReader, ItemProcessor et ItemWriter.
Les jobs que j’ai développés sont les suivants :
- Job pour la création d’un client
- Job pour la création d’un site
- Job pour l’import des locations depuis GMB
- Job pour l’import des reviews depuis GMB
- Job pour l’import des reviews depuis Facebook
- Job pour l’import des reportings
Itération 2 : Isolation du module batch et la génération du jar

Cette itération m’a pris beaucoup de temps du fait que la plateforme myMobilosoft suit
une architecture modulaire, qui sépare les différentes parties de l'application en des modules.
Le problème majeur que j’ai rencontré est la dépendance entre modules. Il y a des modules qui
dépendent d'autres modules. Ce qui ajoute un niveau de difficulté supplémentaire au niveau de
l'implémentation de notre propre module, étant donné qu'il fallait vérifier que les dépendances
sont ajoutées avant de pouvoir lancer le module. Cela implique également que le module
principal doit être lancé avant le module qui en dépend.
Apres l’ajout des fichiers et des classes de configurations qui pallient au problème
précité, on a pu générer un jar pour notre module de batch.
Itération 3 : Initiation à l’outil de monitoring

La solution de monitoring choisie est Spring Cloud Data Flow. Ses principaux
composants sont : applications, le Data Flow Server et le runtime cible.

- L’application : l’application batch déjà développée et empaquetée dans un jar.
- Data Flow Server : c’est un jar qu’il faut le télécharger.
- Runtime : pour usage de développement, on a opté pour un environnement

d’exécution en local.
Itération 4 : Câblage entre l’application batch et la solution de monitoring

Cette itération n’étant pas facile, mais surtout très chronophage, du fait que j’ai procédé
par plusieurs démarches afin de choisir la solution la plus optimale pour tracer cette liaison. Il
s’agit de configurer la source de données de SCDF.
Cette solution démarre une instance H2 en mémoire. Donc si la tâche à exécuter depuis
SCDF utilise une base de données autre que H2, on aura des erreurs montrant que cette dernière
cherche ces données depuis sa source de données (H2) mais elle ne les trouve pas.
C’est pour cela, on a procédé par l’introduction de deux sources de données ; une pour
la logique métier, et l’autre dédiée aux batchs. Toutefois, l’utilisation de Google Cloud Platform
dans l’application myMobilosoft interfère ma configuration. Par conséquent, on a opté de
définir une source de données commune. Il s’agit de la base de données Postgres utilisée par
l’application.
Cette démarche, m’a permis de centraliser les données de SCDF et de l’application batch
dans une seule source.
Enfin, on a pu lancer le serveur SCDF dans un conteneur docker qui contient notre
environnement préconfiguré et les dépendances nécessaires, pour appeler par la suite le jar de
l’application batch déjà développé.
Itération 5 : intégration et build du projet

Après l’achèvement des itérations précédentes, il temps d’intégrer l’application batch
dans la solution de monitoring. C’est-à-dire de enregistrer cette application dans SCDF, pour
l’exploiter dans les tâches qu’il faut créer.
Les interfaces graphiques ci-dessous illustrent le résultat de cette itération.

Depuis la plateforme de monitoring, l’utilisateur peut ajouter une nouvelle application,
tout en renseignant le nom, le type et l’URI de l’application. Ce dernier représente Maven
artifact, une image Docker, http, ou l’URL d’un fichier. Dans la figure ci-dessous, l’utilisateur
importe l’application de batch déjà développée.
Figure 40: Interface ‘ajouter une nouvelle application’ depuis SCDF
L’utilisateur peut consulter et voir la listes des applications enregistrées, avec comme
suggestion d’afficher leurs détailles :
Figure 41: Interface ‘lister toutes les applications’ depuis SCDF

Avant de commencer la composition et l’exécution du flux de migration depuis l’outil
de monitoring, on va s’assurer d’abord que le client et le site n’existent pas dans la plateforme
myMobilosoft :
La figure ci-dessous montre que le client "client-fstt" n’existe pas dans la plateforme :
Figure 42: Interface ‘liste des sites’ depuis myMobilosoft avant migration
La figure ci-dessous montre que le client "site-fstt" n’existe pas dans la plateforme :
Figure 43: Interface ‘liste des clients’ depuis myMobilosoft avant migration

Sélectionnez ‘Create Task’ pour afficher l’éditeur graphique « Drag & Drop » qui
facilite la création d’un Task (tâche), c.-à-d. la création d’une nouvelle définition Task comme
le montre la figure suivante:
L’utilisateur peut glisser et déposez chaque application sur le canevas. Pour les relier il utilise
les flèches. A noter que la définition DSL de la tâche équivalente s’ajoute dans le panneau du
texte en haut.
Figure 44: Interface 'création d'une tâche' depuis SCDF'
La figure suivante illustre l’ordre d’exécution de chaque sous tâche. Les tâches
nommées site, client et locations sont exécutées l’une après l’autre, mais gmbreviews, fbreviews
et reportings se déclenchent parallèlement qu’après complétion de la tâche locations :
Figure 45: Interface 'visualiser le graphe associé d'une tâche' depuis SCDF

Une fois créé, l’utilisateur peut consulter la liste des tâches et les sous tâches y
composées. Comme il peut exécuter une tâche précise :
Figure 46: Interface ‘liste des tâches’ depuis SCDF
Quand l’utilisateur clique sur le bouton ‘run’ pour lancer l’exécution d’une tâche, une
interface s’affiche pour lui permettre de saisir les arguments et les paramètres y liés. Il peut
ignorer cette étape et cliquer directement sur ‘Launch the task’:
Figure 47: Interface 'Exécution d'un tâche' depuis SCDF

L’utilisateur peut continuer toujours à suivre et superviser le déroulement d’exécution
des tâches. Dans la figure ci-dessous la création d’un nouveau site est faite avec succès :
Figure 48: Interface 'liste des tâches' après complétion de la création d'un site
L’utilisateur peut s’assurer de la création du site depuis la plateforme myMobilosoft :
Figure 49: Interface ‘liste des sites’ depuis myMobilosoft après migration

Un site est une centralisation de plusieurs points de ventes (locations). L’utilisateur peut
accéder à la liste des locations du site créé avant de commencer l’importation des locations (pas
de locations ajoutées) :
Figure 50: Interface ‘liste des locations’ depuis myMobilosoft avant la migration
La figure suivante présente la liste des avis des clients du site créé avant la migration :
Figure 51: Interface ‘liste des reviews’ depuis myMobilosoft avant la migration

La figure suivante présente la page des reportings du site créé avant la migration :
Figure 52: Interface ‘liste des reportings’ depuis myMobilosoft avant la migration
Apres complétion de la tâche qui concerne la création du client depuis SCDF :
Figure 53: Interface 'liste des tâches' après complétion de la création d'un client

L’utilisateur peut consulter une autre fois la liste des clients depuis la plateforme
myMobilosoft, pour s’assurer que le nouveau client existe :
Figure 54: Interface ‘liste des clients’ depuis myMobilosoft après migration
L’utilisateur peut continuer toujours à superviser l’exécution des tâches, il peut

remarquer que l’importation des locations est terminée avec succès :
Figure 55: Interface 'liste des tâches' après complétion d’importation des locations

En consultant la plateforme, l’utilisateur peut lister l’ensemble des nouvelles locations
qui ont été ajoutées :
Figure 56: Interface ‘liste des locations’ depuis myMobilosoft après la migration
Dès que les locations sont bien importées, les 3 tâches qui les suivent, vont s’exécuter
en parallèle. La première qui s’est terminée, est l’import des reviews depuis Facebook :
Figure 57: Interface 'liste des tâches' après complétion d'importation du Facebook reviews

L’utilisateur peut bien vérifier cela depuis la plateforme myMobilosoft :
Figure 58: Interface ‘liste des reviews de Facebook’ depuis myMobilosoft après la migration
De la même manière, les autres tâches se suivent, il s’agit dans la figure suivante de
l’import de GMB reviews :
Figure 59: Interface 'liste des tâches' après complétion d'importation du GMB reviews

L’utilisateur peut accéder au fichier log de toute tâche terminée. Dans cette figure, on
montre le fichier de journalisation de la tâche ‘import des reviews depuis GMB’ :
Figure 60: Interface 'Visualisation des logs' après complétion d'importation des GMB reviews
L’utilisateur peut accéder à la page des reviews depuis la plateforme, pour voir les avis
des clients insérés :
Figure 61: Interface ‘liste des reviews de Google’ depuis myMobilosoft après la migration

L’utilisateur peut continuer toujours à superviser l’exécution des tâches, pour surveiller
l’achèvement de la tâche principale voire les sous-tâches, on note la complétion de l’import des
reportings :
Figure 62: Interface 'liste des tâches' après complétion de la migration
La figure suivante montre les reportings qui ont été ajoutés pour le site déjà créé depuis
la plateforme :
Figure 63: Interface ‘page des reportings’ depuis myMobilosoft après la migration

Pour plus de visibilité sur le bon déroulement de la tâche de migration, l’utilisateur peut
générer un fichier Excel contenant tous les informations des locations selon les critères qu’il a
saisi en cliquant sur ‘Export Excel’ sur la page des locations du myMobilosoft :
Figure 64: Interface 'liste des locations' après un filtre
Voici la première feuille du fichier Excel contenant tous les informations des locations :
Figure 65: La première feuille 'des données' du fichier Excel exporté
Voici la deuxième feuille du fichier Excel contenant les critères saisis :
Figure 66: La deuxième feuille 'des critères' du fichier Excel exporté

Conclusion
Ce dernier chapitre avait comme finalité de présenter le fruit de mon projet c’est-à-dire
une description de la phase de réalisation du projet. Ensuite on a expliqué les fonctionnalités de
la solution réalisée avec des captures illustratives des interfaces de l’application.

Bilan du stage
Objectifs atteints
Tout au long de la période du stage, j’ai été mené à passer par toutes les phases
inhérentes du développement logiciel. Commençant par la récolte et l’analyse des besoins du
client, jusqu’à la réalisation effective de la solution finale, son implémentation et son test. Tout
ceci, sous une contrainte de délai et de qualité qui m’a forcé à travailler dur et à user de mon
esprit d’analyse pour pouvoir livrer à temps un produit optimal et de qualité.
Obstacles affrontés
Bien que le projet ait été bénéfique en termes de plusieurs aspects, sa réalisation
effective n’a pas été évidente. En effet, j’ai été censé de cerner les concepts clés sur lesquels
reposent la problématique, ainsi que d’exploiter une multitude de Framework’s et d’outils, que
je n’ai pas eu l’occasion de mettre en pratique. Mais l’envie de m’améliorer et de s’intégrer au
processus de développement m’a poussé à se documenter à propos de ces technologies, et aussi
à se renseigner auprès de mes collègues et mon chef de projet pour des informations
complémentaires.
Enseignements personnels
Ce stage a été une expérience plus qu’enrichissante, et ce sur plusieurs niveaux.
Tout d’abord, j’ai encore plus développé mes compétences sociales et surtout le travail
au sein d’une équipe. En tant qu’ingénieur, ma mission principale est de trouver des solutions
aux problèmes qui se présentent ; ce que j’ai appliqué tout au long de ces 5 mois et demi.
Sur le plan technique, ce projet a été une occasion pour moi de connaitre de nouvelles
technologies. J’ai également pu apprendre quelques règles de conception et de développement
pour fournir une solution réutilisable et maintenable dans le temps.
La contribution à un tel projet de grande envergure m’a permet de découvrir les bonnes
pratiques mises en œuvres dans les outils utilisés. J’ai essayé donc de voir comment est organisé
le code, comment il est écrit, quels sont les idiomes et j’ai essayé autant que possible d’en tirer
des leçons pour intégrer ces bonnes pratiques dans mes développements.

La criticité de la qualité des logiciels qui doivent être fournis, a créé en moi un esprit de
rigueur, qui vise la perfection, et qui n’admet pas de compromis. Tout ceci en cherchant les
solutions les plus optimales, que ce soit en termes de temps ou de ressources.
Et finalement, j’ai pris connaissance de nouveaux domaines, ce qui m’a donc permis de
consolider ma culture d’entreprise et de l’environnement informatique en général.

Conclusion générale et perspectives
Mon projet de fin d’études effectué au sein de VirtuoCode, consistait sur l’élaboration
d’une solution de surveillance des taches constituant les scénarios de migration des clients
Mobilosoft.
Pour la réalisation de ce projet, j’ai commencé par une étude fonctionnelle des besoins
spécifiques, ainsi que l’environnement de déploiement tout en respectant les exigences
techniques. Ensuite j’ai abordé la phase de la conception détaillée de la solution qu’on a
élaborée par la suite dans le cadre de mon projet.
La phase de mise en œuvre, m’a permis de mettre en place plusieurs modules

additionnels pour assurer un fonctionnement complet de la solution. L’intégration des
équipements dans la plateforme via une configuration complète en développant de nouveaux
scripts pour les résultats souhaités. Enfin la phase de test qui a offert la validation des
spécifications tracées au début du projet.
L’expérience que j’ai vécue durant ce stage a été enrichissante. Sur le plan technique,
j’ai approfondi mes compétences en ce qui concerne les technologies et outils. Au niveau
relationnel, j’ai compris que l’esprit d’initiative, le sens de la responsabilité et l’aptitude à
communiquer sont de éléments capitaux pour la réussite de tout projet informatique. Enfin, sur
le plan personnel, j’ai développé mon aptitude d’autonomie, de patience et persévérance. Ce
stage m’a permis de consolider mes connaissances acquises pendant ma formation.
Comme perspective d’avenir, il serait intéressant de déployer cette solution de

monitoring dans le Cloud, pour usage de production, puisque on a travaillé en local juste pour
des raisons de développements, tests et initiation avec l’outil Spring Cloud Data Flow.
Ceci va offrir une fonctionnalité de plus ; qui est la planification des tâches, c’est-à-dire
l’utilisation des expressions ‘cron’ pour l’exécution automatique des tâches, à une date et une
heure spécifiée à l'avance.

Webographie
https://docs.spring.io/spring-batch/docs/current/reference/html/index-
single.html
https://docs.spring.io/spring-cloud-
dataflow/docs/current/reference/htmlsingle/
https://github.com/spring-cloud-task-app-starters/composed-task-runner
https://cloud.google.com/sql/docs/postgres
https://www.infoq.com/fr/articles/Multiple-Databases-with-Spring-Boot/
https://www.mobilosoft.com/fr/
https://projects.spring.io/spring-xd/
https://docs.spring.io/spring-batch-admin/trunk/reference/reference.xhtml

Annexes
Annexe 1 : Normes de développement
Règles de nommage
On a mis en place plusieurs règles de nommage pour les identificateurs (noms de
variables, types, fonctions, classes, etc.) :
 Choisir des noms explicites, qui n’ont pas besoin de commentaires pour expliquer.
 Éviter les ambiguïtés, comme par exemple : info, data, argc, etc.
 Choisir des noms facilement prononçables, pour faciliter le travail en équipe.
 Tous les noms sont en anglais.
 Un nom pour concept, par exemple :
Mot-clé Concept
get Pour la sélection
get all Pour la sélection de toutes les données
add Pour ajouter une nouvelle entrée dans la base de données.
alter Pour modifier une entrée dans la base de données.
check Pour la validation.
to Pour convertir a un autre type.
 Implémenter le Camel case dans le nommage.
Fonctions
 Les fonctions doivent être courtes, et ne réaliser qu’un traitement.
 Leurs noms doivent être descriptifs et en général avec un verbe d’action.
 Eviter toute forme de redondance. (Fonctions avec traitements similaires)
Commentaires
On a jugé judicieux d’éviter un très grand nombre de commentaires, car les noms sont
assez explicites. Toutefois, on a décidé de les mettre dans les cas suivants :
 Commentaires TODO : pour se rappeler de ce qu’on doit faire par la suite.

 Commentaires FIXME : pour se rappeler de ce qu’on doit fixer par la suite.

 Documentation d’entête : d’un fichier, classe ou fonction, décrivant son intérêt.
 Commentaires informatifs : faisant référence à une méthode lue quelque part, à un test,
etc.
 Il ne faut pas mettre des commentaires qu’un seul utilisateur comprendra.
Mise en forme
Pour avoir une meilleure lisibilité du code, on a décidé de suivre ces règles :
 Ajouter des lignes vides entre les éléments d’un fichier, comme les fonctions, etc.
 Une seule instruction par ligne.
 La ligne ne doit pas être très longue, c’est-à-dire qu’il faut éviter à avoir à utiliser le
scroll horizontal.
 Utilisation de l’indentation. Les commentaires doivent suivre aussi.

Résumé
Ce rapport constitue le fruit d’un travail accompli dans le cadre du projet de fin d’études
qui m’a été confié durant mon stage au sein de l’entreprise "VirtuoCode".
L’objectif du stage était de participer activement à la conception et la mise en œuvre

d’une solution de monitoring qui consiste à mieux organiser l’ordonnancement des tâches.
Ce sujet peut être décomposé en 2 grands volets, qui, s’ils ne sont pas interdépendants, vont
néanmoins dans le même sens de la mission générale : développement des scenarios de
migration des données sous forme des traitements batchs, et la surveillance, automatisation et
orchestration de leurs exécutions.
La matière première dans ce projet est le contenu généré par les APIs de Google et
Facebook. J’en ai donc puisé dans ces interfaces de programmation applicative, pour obtenir
des données qui sont à jour.
Cette solution est destinée spécialement aux administrateurs du département Back-

office de l’entreprise ‘Mobilosoft’ afin de les aider à mener à terme leur projet de migration.
J’ai veillé à développer cette solution avec les technologies les plus récentes et
performantes, et ceci dans un cadre agile en adoptant l’approche SCRUM.
Ce projet est réalisé avec la partie des traitements Batch à base de Spring Batch, et
Spring Cloud Data Flow pour le monitoring des tâches.
Le présent document représente une synthèse complète de l’élaboration de mon travail,

en détaillant tous les processus mis en place pour que mon projet voie le jour.
Mots-clés: JAVA, J2EE, Spring Boot , Spring Batch, Spring Cloud Data Flow, Traitement
Batch, Monitoring, Facebook API, Google My Business API.

Rapport PFE AALITI Souhaila

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Rapport PFE AALITI Souhaila

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSITE ABDELMALEK ESSAADI

FACULTE DES SCIENCES ET TECHNIQUES DE TANGER

DEPARTEMENT GENIE INFORMATIQUE

MEMOIRE DE PROJET DE FIN D’ÉTUDE

Elaboration d’une solution de monitoring des tâches sous

REALISE PAR : AALITI SOUHAILA

Année Universitaire 2019/2020

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 2

A Allah le Tout Miséricordieux

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 3

Je tiens à exprimer ma profonde gratitude et mes sincères remerciements à mon

Je tiens à adresser mes vifs remerciements à Mr AZOUAGH Noureddine pour son

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 4

L’objectif du stage était de participer activement à la conception et la mise en œuvre

Cette solution est destinée spécialement aux administrateurs du département Back-

Le présent document représente une synthèse complète de l’élaboration de mon travail,

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 5

This document provides a comprehensive synthesis of the development of my work,

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 6

API Application Programming Interface

DSL Domain-Specific Language

EOA End-of-Availability (fin de disponibilité)

EOL End-Of-Life (fin de vie)

EOS End-Of-Support (fin de support)

GMB Google My Business

JAR Java Archive

JMX Java Management Extensions

JSON JavaScript Object Notation

N/A Non Attribué

PDF Portable Document Format

REST REpresentational State Transfer

SCDF Spring Cloud Data Flow

SQL Structured Query Language

UI User Interface (interface utilisateur)

UML Unified Modeling Language

URI Uniform Resource Identifier

URL Uniform Resource Locator (adresse web)

WAR Web application ARchive

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 7

Figure 1 : L’écosystème du groupe Virtuology International .............................................................. 17

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 8

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 9

Tableau 1: Tableau d’analyse des risques .......................................................................................... 28

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 10

Elaboration d’une solution de monitoring des tâches sous Spring ......................................1

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 11

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 12

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 13

Rejoignant cet esprit, il s’avère indispensable d’intégrer un outil de monitoring qui

Ce rapport décrit donc la totalité de mon projet, en détaillant chaque phase

Dans un premier temps, on va définir le contexte général du projet, c’est-à-dire qu’on

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 14

Finalement, on clôture ce rapport avec la réalisation et la mise en œuvre du projet, qui

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 15

Contexte général du projet

Ce chapitre introduit le contexte général du projet. On présente

Pour retrouver par la suite, le contexte du projet, la problématique,

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 16

1.1. Présentation de l’organisme d’accueil

Virtuology International est un groupe d’agences spécialisées dans les métiers du

Figure 1 : L’écosystème du groupe Virtuology International

FSTT | Rapport du projet de fin d’études 2019-2020 © AALITI Souhaila 17

1.1.1.2. Les valeurs

Pour le groupe Virtuology International, développer un groupe d’entreprises n’est pas