Résumé

Ce projet a pour objectif de développer une application SaaS innovante destinée à la gestion des
opérations d'un pressing. Conçue pour répondre aux besoins spécifiques des utilisateurs tout en
optimisant les processus internes, l'application repose sur une architecture moderne, divisée en
couches distinctes. Le frontend de l'application, développé en React, offre une interface
utilisateur réactive et intuitive. Le backend, construit avec Spring Boot, assure une gestion
robuste des transactions et une intégration fluide avec la base de données PostgreSQL. La
sécurité de l'application a été renforcée par l'implémentation du protocole OAuth2, garantissant
une authentification et une autorisation sécurisées des utilisateurs.

Un aspect clé de ce projet a été l'intégration des pratiques DevOps, qui ont joué un rôle crucial
dans l'amélioration de l'efficacité du cycle de développement et de déploiement. L'adoption d'un
pipeline CI/CD (Continuous Integration/Continuous Deployment) a permis d'automatiser les
processus de test, de validation, et de déploiement du code. Chaque modification apportée à
l'application est ainsi testée de manière exhaustive, ce qui garantit une haute qualité du code et
une rapidité de mise en production. L'utilisation d'outils comme Github Actions pour orchestrer
ce pipeline a permis d'assurer une livraison continue et fiable des nouvelles fonctionnalités avec
l’adoption du principe du GitOps, réduisant ainsi les délais et les coûts associés aux déploiements
manuels.

Le déploiement de l'application a été orchestré à l'aide de Kubernetes, une plateforme de gestion

de conteneurs qui a permis d'assurer la scalabilité et la résilience du système. Grâce à
Kubernetes, l'application peut être déployée, gérée, et mise à l'échelle de manière automatique
en fonction des besoins, garantissant ainsi une utilisation optimale des ressources disponibles. De
plus, la containerisation des services avec Docker a permis de maintenir une cohérence entre les
différents environnements de développement, de test, et de production, assurant une portabilité
maximale des services. Kubernetes a également facilité la gestion des conteneurs en automatisant
les processus de déploiement, de mise à l'échelle, et de redémarrage des services, ce qui a assuré
une disponibilité continue de l'application.

5
 En conclusion, ce projet a non seulement abouti à la création d'une solution logicielle
performante pour la gestion des opérations d'un pressing, mais il a également démontré
l'efficacité des pratiques DevOps et de l'orchestration via Kubernetes pour garantir un
déploiement fiable, sécurisé et évolutif. Ces technologies ont été déterminantes pour atteindre les
objectifs du projet, en permettant une gestion agile et une amélioration continue du logiciel.

Mots clés: Application SaaS, DevOps, Pipeline CI/CD, Kubernetes

6
Sommaire
Dédicace ............................................................................................................ 2
Remerciements................................................................................................... 3
Avant-Propos ...................................................................................................... 4
Résumé .............................................................................................................. 5
Introduction Générale ....................................................................................... 13
1. Contexte ........................................................................................................ 14
2. Problématique ............................................................................................... 14
3. Objectifs ........................................................................................................ 14
Chapitre I : Méthodologie de Réalisation ............................................................ 16
1. Gestion des Processus Métier (BPM) ............................................................... 17
1.1 Introduction à la Gestion des Processus Métier (BPM) ............................... 17
1.2 Application de la BPM dans le Projet ......................................................... 17
1.3 Avantages de la BPM ................................................................................ 18
1.4 Exemple de Modélisation avec BPMN .................................................................19
1.5 BPM et SaaS : Une Synergie Naturelle ....................................................... 20
2. Méthodologie Agile Scrum............................................................................... 21
2.1 Sprints et Livrables .................................................................................. 22
2.2 Avantages de Scrum dans un Projet SaaS ................................................. 22
3. Diagramme de Gantt avec Plotly pour la Visualisation des Données.................. 23
3.1 Utilisation de Plotly pour un Projet SaaS ................................................... 23
3.2 Exemple de Diagramme de Gantt ............................................................. 24
Conclusion ........................................................................................................ 26
Chapitre II : Conception du Système .................................................................. 27
1. Conception de l'Architecture ........................................................................... 28
1.1 Frontend ................................................................................................. 28
1.2 Backend .................................................................................................. 29
1.3 Base de Données..................................................................................... 29
2. Conception UML : Diagramme de Classes ....................................................... 31
2.1 Diagramme UML de Classe ...................................................................... 31
2.2 Relations Entre les Classes ...................................................................... 32
Chapitre III : Développement et Intégration Continue (CI/CD).............................. 34
1. Pipeline CI/CD ................................................................................................ 35
1.1 Intégration Continue (CI) .......................................................................... 35
1.2 Déploiement Continu (CD) ....................................................................... 35
1.3 Outils Utilisés dans le Pipeline CI/CD ....................................................... 36
1.4 Implémentation de Github actions ........................................................................38

7
 Pipeline Name and Triggers .......................................................................................41
Jobs: Build ..................................................................................................................42
1. Setup of Build Environment ..............................................................................42
2. Checkout Source Code ....................................................................................42
3. Setup Java ........................................................................................................42
4. Cache Maven Packages ...................................................................................43
5. Unit Tests .........................................................................................................43
6. Dependency Check ..........................................................................................44
7. Upload Dependency Check Report ..................................................................45
SonarQube Scan ........................................................................................................45
Docker Image Build and Push ....................................................................................47
8. Docker Hub Login ............................................................................................. 47
9. Build and Push Docker Image ..........................................................................47
Chapitre IV : Réalisation de l’Application et Présentation des Interfaces ......................53
1. Présentation des Interfaces Utilisateur .........................................................................54
1.1 Page de Connexion (Login) ..................................................................................54
1.2 Tableau de Bord (Dashboard) ..............................................................................54
1.3 Recherche de Commandes (Search Order) .........................................................56
1.4 Gestion des Commandes (Orders).......................................................................56
1.4 Création de Commandes (New Order) .................................................................57
1.5 Création de Clients (New Client) ..........................................................................57
1.6 Gestion des Employés (Administration) ............................................................... 58
1.7 Gestion des Services et des Prix (Administration) ...............................................58
Chapitre V : Tests et Validation .......................................................................... 59
1. Types de Tests Effectués ................................................................................. 60
1.1 Tests Unitaires ........................................................................................ 60
1.2 Tests d'Intégration ................................................................................... 60
1.3 Tests de Performance .............................................................................. 61
1.4 Tests de Sécurité ..................................................................................... 62
Chapitre VI : Gestion des Risques....................................................................... 63
1. Identification des Risques ............................................................................... 64
1.1 Risques Techniques................................................................................. 64
1.2 Risques de Sécurité ................................................................................. 65
1.3 Risques de Dépendances ........................................................................ 66
1.4 Risques Organisationnels ........................................................................ 66
1.5 Risques liés aux Utilisateurs..................................................................... 66
2. Évaluation et Surveillance des Risques ............................................................ 66
2.1 Matrice d'Évaluation des Risques ............................................................. 67
2.2 Surveillance Continue.............................................................................. 67
Chapitre VII : Retour d'Expérience (Rétrospective) .............................................. 68
1. Leçons Apprises ............................................................................................. 69
1.1 Ce qui a Bien Fonctionné ......................................................................... 69

8
 1.2 Ce qui Peut Être Amélioré ........................................................................ 69
2. Prochaines Étapes .......................................................................................... 70
2.1 Évolutions Futures ................................................................................... 70
2.2 Maintenance et Support ........................................................................... 71
Conclusion Générale ......................................................................................... 72
Bibliographie & Webographie ............................................................................. 74
1. Outils et Technologies .................................................................................... 75
2. Méthodologies................................................................................................ 76
3. Développement et Sécurité ............................................................................. 76

9
Liste des Tableaux

- Tableau 1 : Répartition des rôles dans la méthodologie Scrum………………21

- Tableau 2 : Résultats des tests de performance.………………………………53
- Tableau 3 : Estimation des risques du projet.……………………...…………56

10
Liste des Figures

- Figure 1 : Diagramme BPMN du Processus de Traitement des Commandes….19

- Figure 2 : collection des articles par le client depuis le pressing shop………20
- Figure 3 : Diagramme de la Méthode Scrum pour la Gestion de Projet………21
- Figure 4 : Diagramme de Gantt………………………………………………24
- Figure 5 : Diagramme de Gantt avec plotly…………………………………25
- Figure 6 : Architecture de l’application web…………………………………27
- Figure 7 : Diagramme UML de Classe………………………………………29
- Figure 8 : Diagramme de Cas d’utilisation …………………………………30
- Figure 9 : Diagramme de Séquences pour la Création d’une Commande …30
- Figure 10 : Diagramme de Séquences pour la Gestion des Employés ………31
- Figure 11 : Pipeline CD avec les differentes étapes depuis le commit vers le
déploiment en automatique en production……………………………………34
- Figure 12 : les repositories de notre projet pressingshop ……………………36
- Figure 13 : Rapport de qualité du code avec l’outil SonarQube. ……………40
- Figure 14 : Github Actions pipeline de CI/CD………………………………42
- Figure 15 : Application ArgoCD……………………………………………43
- Figure 16 : Projet ArgoCD……………………………………………………43
- Figure 17 : Détails de l’application ArgoCD créée……………………………44
- Figure 18 : Structure du projet Gitops (Kustomize) …………………………44
- Figure 19 : Documentation des api avec Swagger……………………………45
- Figure 20 : Page d’authentification……………………………………………47
- Figure 21 : Dashboard de suivi………………………………………………48
- Figure 22 : Gestion des commandes. …………………………………………49
- Figure 23 : Ajout des commandes. ……………………………………………49
- Figure 24 : Ajout des clients. …………………………………………………50
- Figure 25 : les types des tests des logiciels. …………………………………51

11
Rapport de Projet de Fin d'Études

12
Introduction Générale

13
1. Contexte

Avec l'évolution des technologies numériques, les entreprises traditionnelles,

telles que les pressings, se doivent d'adopter des solutions innovantes pour rester
compétitives. Le projet présenté ici vise à digitaliser les opérations d'un pressing
en développant une application web basée sur le modèle SaaS (Software as a
Service). Ce modèle permet aux utilisateurs d'accéder à l'application via le cloud,
sans avoir à se soucier de la gestion de l'infrastructure sous-jacente. Cette solution
centralise la gestion des commandes, des clients et des employés, tout en assurant
une sécurité renforcée et une scalabilité adaptée aux besoins futurs de l'entreprise.

2. Problématique
Les pressings traditionnels rencontrent de nombreux défis liés à la gestion
manuelle des opérations, tels que des erreurs dans la gestion des commandes, des
retards, et une communication inefficace avec les clients. L'absence de systèmes
centralisés et automatisés conduit souvent à une diminution de la satisfaction
client et à des inefficacités opérationnelles. De plus, les solutions actuelles sur
site nécessitent des ressources importantes pour la maintenance et la mise à jour.
Une solution SaaS permet de surmonter ces défis en offrant une plateforme
centralisée, accessible en ligne, qui automatise et optimise les processus clés, tout
en réduisant les coûts liés à l'infrastructure et à la maintenance.

3. Objectifs
Les principaux objectifs de ce projet sont :

14
- Développement d'une application web SaaS : Concevoir et implémenter une
application permettant de gérer l'ensemble des opérations d'un pressing via une
plateforme en ligne, accessible depuis n'importe quel appareil connecté.
- Sécurité des données : Implémenter des mesures de sécurité robustes, telles que
l'authentification OAuth2, le chiffrement des données, et la protection contre les
attaques, afin de sécuriser les informations sensibles des utilisateurs sur le cloud.
- Interface utilisateur intuitive : Développer une interface utilisateur réactive et
conviviale, qui facilite l'interaction des utilisateurs finaux et des administrateurs
avec l'application SaaS.
- Méthodologie Agile (Scrum) : Utiliser la méthodologie Scrum pour gérer le
projet, permettant une progression itérative, une livraison continue des
fonctionnalités et une adaptation rapide aux besoins des utilisateurs.

15
Chapitre I : Méthodologie de Réalisation

16
1. Gestion des Processus Métier (BPM)

1.1 Introduction à la Gestion des Processus Métier (BPM)

- Définition de la BPM : La Gestion des Processus Métier (BPM) est une

discipline qui vise à améliorer l'efficacité des organisations en modélisant,
analysant et optimisant leurs processus métiers. La BPM permet de visualiser les
workflows, d'identifier les inefficacités, et d'automatiser les tâches répétitives, ce
qui conduit à une augmentation de la productivité et à une meilleure satisfaction
des clients.
- Importance de la BPM dans les projets SaaS : Dans le cadre du développement
d'une solution SaaS, la BPM joue un rôle crucial en permettant de concevoir des
processus métiers efficaces, qui sont ensuite déployés dans un environnement
cloud. La BPM assure que les processus sont bien documentés, compréhensibles
par toutes les parties prenantes, et optimisés pour fonctionner dans un
environnement numérique.

1.2 Application de la BPM dans le Projet

- Modélisation des Processus : Dans ce projet, la BPM a été utilisée pour

modéliser les processus métiers critiques du pressing, tels que l'inscription et
l'authentification des utilisateurs, la gestion des commandes, et la gestion des
employés et des clients. Ces processus ont été modélisés de manière à être
optimisés pour une implémentation SaaS.
- Outils BPM Utilisés : Divers outils de BPM peuvent être utilisés pour modéliser
et gérer les processus métiers. Parmi ces outils, Bizagi a été choisi pour ce projet
en raison de ses capacités à modéliser des processus complexes et à générer des
diagrammes de workflow clairs et précis. Bizagi a permis de traduire les

17
exigences métiers en modèles visuels, facilitant ainsi la compréhension et
l'optimisation des processus.
- Exemple d'Utilisation de Bizagi : Par exemple, le processus de gestion des
commandes a été modélisé dans Bizagi pour inclure toutes les étapes, depuis la
création d'une commande jusqu'à sa livraison. Le diagramme généré a servi de
référence tout au long du développement pour assurer que chaque étape du
processus était bien couverte par l'application SaaS.

1.3 Avantages de la BPM

- Optimisation des Processus : La BPM permet de visualiser les processus métiers

de bout en bout, ce qui facilite l'identification des inefficacités et des goulots
d'étranglement. Cela permet de les optimiser en termes de coûts, de temps et de
ressources.
- Standardisation et Documentation : La modélisation des processus garantit que
toutes les tâches sont standardisées et bien documentées. Cela est particulièrement
important dans un contexte SaaS, où les processus doivent être réplicables et
évolutifs pour répondre à une base d'utilisateurs potentiellement large et
diversifiée.
- Amélioration Continue : En utilisant la BPM, les entreprises peuvent mettre en
place des mécanismes de retour d'information pour surveiller les performances
des processus et les améliorer en continu. Cela permet d'adapter rapidement les
processus aux besoins changeants du marché ou aux nouvelles exigences des
clients.

18
1.4 Exemple de Modélisation avec BPMN

- Pour illustrer l’application de la Gestion des Processus Métier (BPM) dans notre
projet, nous avons modélisé le processus de gestion des commandes en utilisant
un diagramme BPMN réalisé avec Bizagi. Le BPMN (Business Process Model
and Notation) est un standard pour représenter graphiquement les processus
métier, permettant une compréhension claire et partagée des opérations à travers
différents acteurs du système.

1- workflow de l’Interaction Client et le Traitement des Commandes dans le

Pressing Shop

Figure 1 : Diagramme BPMN du Processus de Traitement des Commandes

19
2 - Workflow de la collecte des articles par le client depuis le pressing shop.

Figure 2 : collection des articles par le client depuis le pressing shop

1.5 BPM et SaaS : Une Synergie Naturelle

- Scalabilité et Flexibilité : L'intégration de la BPM dans un projet SaaS permet

de créer des processus métiers qui sont non seulement efficaces, mais aussi
hautement évolutifs. Les processus peuvent être facilement adaptés à une
augmentation de la charge ou à des modifications des besoins des utilisateurs.
- Réduction des Coûts : En optimisant les processus métiers avant de les déployer
dans un environnement SaaS, les entreprises peuvent réduire les coûts
opérationnels en automatisant les tâches répétitives et en minimisant les erreurs
humaines.
- Exemples Concrets : Dans ce projet, l'utilisation de Bizagi pour la BPM a permis
d'améliorer la gestion des flux de travail et de garantir une exécution fluide des
processus critiques dans l'environnement SaaS.

20
2. Méthodologie Agile Scrum

Figure 3 : Diagramme de la Méthode Scrum pour la Gestion de Projet

Tableau 1 : Répartition des rôles dans la méthodologie Scrum

Responsabilités spécifiques
Rôle Responsabilités générales
dans le projet
- Collaboration avec les
- Gestion du backlog produit utilisateurs finaux pour définir
les priorités
Product - Hiérarchisation des
Owner - Priorisation des tâches fonctionnalités de l’application
SaaS
- Communication avec les parties prenantes

- Organisation des stand-ups

- Facilitation des réunions Scrum
quotidiens
- Résolution des obstacles (impediments) - - Résolution des problèmes
Scrum Master
Veille au respect des pratiques Scrum techniques et des retards
- Facilitation des rétrospectives
et revue de sprint
- Développement, test et livraison des - Développement du backend
fonctionnalités avec Spring Boot
Équipe de - Collaboration dans un cadre itératif et - Développement du frontend
développement incrémental avec React
- Gestion des tests automatisés
et intégration continue

21
2.1 Sprints et Livrables

- Sprints : Le projet SaaS a été organisé en sprints de deux semaines, avec chaque
sprint visant à livrer un ensemble spécifique de fonctionnalités. Les premiers
sprints ont été axés sur le développement des fonctions de base, telles que
l'authentification des utilisateurs et la gestion des commandes. Les sprints
suivants ont intégré les fonctionnalités avancées et les aspects de sécurité liés au
modèle SaaS.
- Réunions Quotidiennes : Des réunions quotidiennes ont été organisées pour
évaluer les progrès réalisés, identifier les obstacles, et ajuster les priorités selon
les besoins. Ces réunions ont permis de maintenir un rythme de travail soutenu et
coordonné, essentiel dans un projet SaaS où la rapidité de livraison est cruciale.
- Rétrospectives : À la fin de chaque sprint, une rétrospective a été réalisée pour
analyser ce qui a bien fonctionné et ce qui doit être amélioré. Cette approche
itérative a permis d'affiner les processus de développement et d'améliorer
continuellement la qualité du produit.

2.2 Avantages de Scrum dans un Projet SaaS

- Flexibilité et Adaptabilité : Scrum a offert la flexibilité nécessaire pour ajuster
rapidement les priorités en fonction des retours des utilisateurs et des
changements de marché, un aspect crucial dans le développement d'une solution
SaaS.
- Livraison Incrémentale : Le modèle Scrum a permis une livraison continue de
fonctionnalités, ce qui a ajouté de la valeur au produit dès les premières itérations.
Les utilisateurs finaux ont ainsi pu tester et donner des retours sur les
fonctionnalités déployées, permettant d'ajuster rapidement le produit aux besoins
réels.

22
- Amélioration Continue : Les rétrospectives régulières ont joué un rôle clé dans
l'amélioration continue des processus de développement, garantissant ainsi la
qualité et la fiabilité de l'application SaaS.

3. Diagramme de Gantt

3.1 Utilisation de Plotly pour un Projet SaaS

- Visualisation Dynamique : Pour planifier et suivre l'avancement du projet, un

diagramme de Gantt interactif a été créé avec Plotly. Cet outil a permis de
visualiser les différentes phases du projet SaaS, de suivre les dépendances entre
les tâches, et de gérer les délais critiques. Plotly s'est avéré être un outil efficace
pour la gestion de projet dans un environnement SaaS, où la flexibilité et la
capacité à ajuster rapidement les plannings sont essentielles.
- Optimisation des Délais : Le diagramme de Gantt a été conçu pour optimiser le
calendrier du projet, permettant l'exécution parallèle des tâches lorsque cela était
possible. Par exemple, le développement du frontend et du backend a été planifié
de manière à maximiser l'efficacité et à réduire les temps d'attente.

3.2 Exemple de Diagramme de Gantt

- Présentation visuelle :
Deux diagrammes de Gantt ont été utilisés pour la planification du projet.
- Le premier diagramme, réalisé avec Gantt Online, présente une vue initiale et
simple des différentes phases du projet. Cet outil en ligne permet de structurer
rapidement les tâches et de visualiser les relations entre elles, offrant une
représentation claire des dépendances et des échéances.
- Le deuxième diagramme, généré avec Plotly en Python, offre une vue
d’ensemble de toutes les tâches du projet, de l’initialisation à la clôture. Chaque
tâche est représentée par une barre colorée, facilitant la visualisation des étapes et
la gestion des ressources. Ce diagramme est un outil clé pour assurer que le projet
SaaS reste sur la bonne voie et respecte les délais impartis.

23
Figure 4 : Diagramme de Gantt

24
 Figure 5: Diagramme de Gantt avec plotly

Conclusion

En combinant la modélisation des processus métiers (BPM) avec Bizagi, la

méthodologie Agile Scrum, et les capacités de visualisation de données de Plotly,
nous avons réussi à gérer efficacement le projet de digitalisation des opérations
de pressing sous forme de SaaS. Cette approche nous a permis d'optimiser les
processus, d'améliorer la communication au sein de l'équipe, et d'assurer une
livraison rapide et de qualité. Le diagramme de Gantt a été particulièrement utile
pour suivre l'avancement des tâches et garantir que toutes les échéances ont été
respectées.
Vous avez raison, la conception de l'architecture avec des exemples concrets, tels
qu'un diagramme UML de classe, est un élément crucial à inclure dans un rapport
de projet. Je vais donc ajouter une section dédiée à la conception, en intégrant un
diagramme UML de classe comme exemple pour illustrer la structure de
l'application.

25
Chapitre II : Conception du Système

26
1. Conception de l'Architecture

Figure 6: Architecture de l’application web

L'architecture du système repose sur une structure en couches, typique des
applications web modernes, avec une séparation claire entre le frontend, le
backend, et la base de données. Cette architecture garantit non seulement la
modularité et la maintenabilité de l'application, mais elle est également conçue
pour tirer parti des avantages offerts par le modèle SaaS.

1.1 Frontend

- Technologie Utilisée : Le frontend de l'application est développé en React, une

bibliothèque JavaScript réputée pour la création d'interfaces utilisateur réactives
et performantes. React permet de créer des composants réutilisables, facilitant la
maintenance et l'évolution de l'interface utilisateur.
- Responsabilités du Frontend : Le frontend est responsable de l'interaction avec
l'utilisateur final. Il gère l'affichage des données, la navigation, ainsi que la

27
communication avec le backend via des appels API RESTful. La conception
responsive garantit que l'application est accessible depuis différents appareils, y
compris les smartphones et les tablettes.

1.2 Backend

- Technologie Utilisée : Le backend est développé en Spring Boot, un framework

Java basé sur Spring qui simplifie la création de microservices et d'applications
web robustes. Spring Boot est choisi pour sa capacité à gérer les transactions
complexes, la sécurité et l'intégration avec divers services externes.
- Responsabilités du Backend : Le backend gère la logique métier, les
transactions, et l'intégration avec la base de données. Il expose des API RESTful
utilisées par le frontend pour accéder aux données et aux services du système. Le
backend est également responsable de la gestion des utilisateurs, des commandes,
des employés et des clients, ainsi que de l'authentification et de l'autorisation.

1.3 Base de Données

- Technologie Utilisée : PostgreSQL a été choisi comme système de gestion de

base de données (SGBD). PostgreSQL est une base de données relationnelle
puissante, réputée pour sa robustesse, sa conformité aux normes SQL, et ses
capacités d'extension.
- Schéma de la Base de Données : Le schéma de la base de données est conçu
pour refléter les processus métiers modélisés, avec des tables représentant les
utilisateurs, les commandes, les employés, et les clients. Les relations entre ces
entités sont définies pour assurer l'intégrité référentielle et optimiser les requêtes

28
2. Conception UML : Diagramme de Classes

2.1 Diagramme UML de Classe

Le diagramme UML ci-dessous représente la structure des principales classes de

l'application, ainsi que leurs relations. Ce diagramme permet de visualiser
l'organisation des entités dans le système, en mettant en évidence les attributs et
les méthodes de chaque classe, ainsi que les associations entre elles.

Figure 7 : Diagramme UML de Classe

29
 Figure 8 : Diagramme de Cas d’utilisation

Figure 9 : Diagramme de Séquences pour la Création d’une Commande (pour un Agent ou

Propriétaire)

30
Figure 10 : Diagramme de Séquences pour la Gestion des Employés (pour un Administrateur
ou Propriétaire)

2.2 Relations Entre les Classes

- Users: La classe Users représente les employés, les administrateurs du système,

ou les clients. Elle contient des attributs tels que username, email, password,
phone_1, phone_2, et address. Chaque utilisateur est lié à un rôle (Roles) et à un
magasin (Shops), définissant ainsi ses privilèges dans le système et son lieu de
travail.
- Orders: La classe Orders est responsable de la gestion des commandes effectuées
par les clients. Elle inclut des attributs tels que title, status, created_at, updated_at,
et note. Chaque commande est associée à un utilisateur via l’attribut users_id
(l’utilisateur qui gère la commande), et elle peut contenir plusieurs articles (Items)
et services (Services) via la relation avec Items_Orders.
- Roles: La classe Roles représente les rôles attribués aux utilisateurs (employés
ou administrateurs) dans le système. Elle inclut un attribut name (par exemple,
admin, manager). Chaque rôle peut être associé à un ensemble de permissions via
la classe intermédiaire Permissions_Roles, ce qui définit les actions qu’un rôle
particulier est autorisé à effectuer dans le système.

31
- Permissions: La classe Permissions gère les autorisations spécifiques qui
déterminent ce qu’un utilisateur peut faire dans le système. Chaque permission
est liée à un ou plusieurs rôles via Permissions_Roles.
- Shops: La classe Shops représente les différents magasins de pressing. Elle
inclut des attributs comme name, adress, city, et phone. Chaque magasin peut
avoir plusieurs utilisateurs associés (employés ou administrateurs) à travers la
relation avec la classe Users.
- Items: La classe Items représente les articles (vêtements ou autres) pris en
charge par le pressing. Les attributs incluent type, material, color, et note. Chaque
article peut être inclus dans une commande via la relation avec Items_Orders.
- Services: La classe Services décrit les services proposés par le pressing (par
exemple, lavage, repassage, nettoyage à sec). Elle contient des attributs tels que
name, price, et description. Chaque service peut être lié à un ou plusieurs articles
et commandes via Items_Orders.
- Items_Orders: Cette classe intermédiaire gère la relation many-to-many entre
Orders, Items, et Services. Elle inclut des attributs tels que items_id, orders_id,
services_id, et note. Cela permet de relier plusieurs articles et services à une
commande spécifique.
- Permissions_Roles: La classe Permissions_Roles gère la relation many-to-many
entre les Roles et les Permissions. Cela permet d’attribuer plusieurs permissions
à chaque rôle dans le système, en définissant clairement les droits des utilisateurs.
Résumé des Relations :
- Users est lié à Roles (chaque utilisateur a un rôle) et Shops (chaque utilisateur
peut travailler dans un magasin).
- Orders est lié à Users (une commande est gérée par un utilisateur) et à
Items_Orders (pour lier des articles et services à une commande).
- Items_Orders relie Items, Orders, et Services, créant une relation many-to-many
entre eux.
- Roles et Permissions sont reliés via une table intermédiaire Permissions_Roles.

32
Chapitre III : Développement et Intégration
Continue (CI/CD)

33
1. Pipeline CI/CD

L'intégration continue (CI) et le déploiement continu (CD) sont des pratiques

essentielles pour assurer la qualité et la rapidité de livraison dans un projet SaaS.
Un pipeline CI/CD a été mis en place pour automatiser le processus de
construction, de test et de déploiement de l'application.

Figure 11 : Pipeline CD avec les differentes étapes depuis le commit vers le déploiment en
automatique en production

1.1 Intégration Continue (CI)

- Automatisation des Tests : Le pipeline CI est configuré pour exécuter

automatiquement une suite de tests unitaires et d'intégration à chaque commit de
code. Cela permet de détecter rapidement les régressions et de s'assurer que les
nouvelles fonctionnalités n'introduisent pas de bugs. Les tests unitaires couvrent
les fonctions individuelles du code, tandis que les tests d'intégration vérifient
l'interaction correcte entre les différentes parties du système.

34
- Analyse Statique du Code : Des outils d'analyse statique du code, tels que
SonarQube, sont intégrés au pipeline CI pour identifier les problèmes de qualité
du code, les vulnérabilités de sécurité, et les violations des bonnes pratiques de
programmation. L'analyse statique permet d'identifier les erreurs potentielles
avant même que le code ne soit exécuté, ce qui contribue à améliorer la qualité
globale du logiciel.

1.2 Déploiement Continu (CD)

- Automatisation du Déploiement : Le pipeline CD automatise le déploiement de

l'application sur les environnements de test, de staging et de production. À chaque
étape, des tests de validation sont effectués pour s'assurer que le déploiement a
été effectué correctement. Cette approche permet de réduire le temps de mise en
production des nouvelles fonctionnalités et de minimiser les risques d'erreurs
humaines lors du déploiement.
- Rollback Automatique : En cas d'échec lors du déploiement sur un
environnement, le pipeline CD est configuré pour effectuer un rollback
automatique à la version précédente, minimisant ainsi les interruptions de service.
Cette fonctionnalité est cruciale pour garantir la disponibilité continue de
l'application, même en cas de problème lors d'un déploiement.

1.3 Outils Utilisés dans le Pipeline CI/CD

- Github : nous avons utilisé GitHub comme Git Provider pour la gestion du code
source. en créant une organisation nommée pressingshop pour centraliser et
structurer les différents repositories. GitHub offre une plateforme fiable et
largement adoptée, facilitant la collaboration grâce aux pull requests, à la gestion
des branches, et aux intégrations continues avec des outils comme GitHub

35
Actions. De plus, il permet un suivi efficace des modifications et des
contributions, tout en garantissant la sécurité du code avec des options de gestion
des accès et des permissions. Les captures d'écran ci-dessous illustrent son
utilisation dans notre flux de travail.

Figure 12 : les repositories de notre projet pressingshop ( Organisation github)

- GitHub Actions : GitHub Actions a été utilisé comme outil d'intégration

continue pour orchestrer les différentes étapes du pipeline CI/CD. Il permet de
déclencher automatiquement les builds, les tests, et les déploiements en réponse
aux changements de code.
- Docker : Docker a été utilisé pour containeriser les différentes parties de
l'application, garantissant que l'environnement de déploiement est identique sur
toutes les machines, du développement à la production.
- Kubernetes : Pour la gestion des déploiements en production, nous avons utilisé
Kapsule de Scaleway pour déployer un cluster Kubernetes, assurant ainsi
l'orchestration des conteneurs Docker. Cette solution a permis de garantir la
scalabilité et la résilience de l'application. À l'intérieur du cluster, nous avons
installé plusieurs outils essentiels, notamment SonarQube pour l'analyse de la
qualité du code et ArgoCD pour la gestion des déploiements continus (CI/CD).
Notre application a ensuite été déployée dans ce même environnement

36
Kubernetes, assurant une intégration continue optimisée et un suivi qualité
rigoureux.
- GitOps: est une approche moderne de gestion des infrastructures et des
déploiements applicatifs qui repose sur l'utilisation de Git comme source unique
de vérité. En GitOps, l'ensemble de la configuration de l'infrastructure et des
applications est versionné et stocké dans un dépôt Git, permettant ainsi un suivi
des changements clair et auditable. Les modifications apportées à l'infrastructure
sont effectuées via des pull requests, et on a utilisé ArgoCD pour synchroniser
automatiquement l'état du cluster avec celui défini dans le dépôt Git. Cela garantit
une livraison continue fiable, en évitant les divergences entre l'état souhaité et
l'état réel, tout en améliorant la sécurité et la collaboration au sein des équipes
DevOps.

1.4 Implémentation de Github actions

Pour configurer github actions il suffit de définir des workflows sous forme de
fichiers YAML dans le répertoire .github/workflows de notre projet. Ces
workflows peuvent être déclenchés par des événements spécifiques comme un
push, une pull request ou un tag. Chaque workflow décrit une série de jobs qui
s'exécutent dans des environnements virtuels, dans notre cas on a pas utilisé
notre propre runner, on a garder celui de Github

Pipeline Name and Triggers

name: Pipeline

37
Explication : Le pipeline est nommé simplement "Pipeline". Ce nom est
purement descriptif et permet d'identifier le processus d'intégration continue
(CI).

Explication : Le pipeline se déclenche automatiquement lors d'une action push

ou pull_request sur les branches main et dev. Les fichiers .md et .gitignore sont
ignorés pour éviter de déclencher le pipeline inutilement lorsqu'ils sont
modifiés, car ils ne concernent pas directement le code source.

Jobs: Build

1. Setup of Build Environment

runs-on: ubuntu-latest
name: Build

Explication : Le job s'exécute dans un environnement Ubuntu à jour (ubuntu-

latest). Il s'agit du système d'exploitation sur lequel les étapes de construction,
de test et de vérification seront effectuées.

2. Checkout Source Code

- name: Checkout source code

uses: actions/checkout@v3

Explication : Cette étape utilise l'action checkout pour récupérer le code source
du dépôt GitHub afin qu'il soit disponible localement pour les étapes suivantes.
Cela permet de préparer le contexte de travail.

3. Setup Java

38
Explication : Cette étape installe la version Java 17, en spécifiant la distribution
Temurin, qui est un environnement d'exécution Java (JDK) très répandu et
performant. Le paramètre cache: maven optimise le processus en mettant en
cache les dépendances Maven, réduisant ainsi le temps de construction.

4. Cache Maven Packages

Explication : Ici, le pipeline met en cache le répertoire des dépendances Maven

(localisé dans ~/.m2/repository). L'utilisation de ce cache réduit le temps de
téléchargement des dépendances lors des futures exécutions du pipeline, en
réutilisant les dépendances précédemment téléchargées.

5. Unit Tests

Explication : Cette étape exécute Maven pour effectuer une compilation et une
installation des modules, Cette configuration est utile pour valider le processus
de compilation dans le cadre d'une construction rapide. L'exécution est
conditionnée par un push ou un pull_request, ainsi execute les test unitaire.

6. Dependency Check

Explication : Cette étape utilise OWASP Dependency-Check pour analyser

les dépendances du projet à la recherche de vulnérabilités connues. Le résultat
est généré au format HTML et sauvegardé dans le répertoire reports. Cela
permet de s'assurer que le projet ne contient pas de dépendances vulnérables.

7. Upload Dependency Check Report

Explication : Le rapport généré par Dependency-Check est téléchargé en tant

qu'artefact dans GitHub Actions. Cela permet aux développeurs et aux parties
prenantes de visualiser le rapport de sécurité après l'exécution du pipeline.

SonarQube Scan

39
Explication : SonarQube est utilisé ici pour effectuer une analyse de la qualité
du code. Il vérifie les bugs potentiels, les vulnérabilités, et les mauvaises
pratiques dans le code. Un certificat SSL est importé pour sécuriser les
communications avec le serveur SonarQube. L'analyse est réalisée via Maven
avec la commande sonar:sonar. Les informations d'authentification sont fournies
à l'aide de secrets stockés dans GitHub.

Le rapport généré sur la platforme Sonarqube.

Figure 13 : Rapport de qualité du code avec l’outil SonarQube.

Docker Image Build and Push

8. Docker Hub Login

40
Explication : Cette étape utilise l'action officielle Docker pour se connecter à
Docker Hub en utilisant les identifiants fournis via les secrets GitHub
(DOCKERHUB_USERNAME et DOCKERHUB_TOKEN). Cela est nécessaire
pour pouvoir pousser des images Docker dans le registre.

9. Build and Push Docker Image

Explication : Cette étape utilise le plugin Jib pour construire une image Docker
sans avoir besoin d'un Dockerfile, directement à partir du projet Maven. L'image
générée est ensuite poussée dans Docker Hub sous l'étiquette latest. Cela permet
de rendre l'image disponible pour déploiement ou utilisation dans un
environnement de production ou de test.

10. Déploiement via argocd

Explication : Le script utilise ArgoCD pour synchroniser une application

backend, ici “dev-pressing-backend”, avec la dernière version de l’image
récupérée depuis un pipeline de build. Il commence par exporter un jeton
d’authentification, obtenu de manière sécurisée via un système de gestion des
secrets. Ce jeton est indispensable pour l’authentification auprès du serveur
ArgoCD.

Ensuite, le script configure l’application backend en spécifiant l’image mise à

jour, qui a été créée et étiquetée au cours du pipeline. Cela garantit qu’ArgoCD
déploie la dernière version de l’image sur le service backend. Une fois l’image
configurée, le processus de synchronisation entre ArgoCD et le backend est
lancé, afin de s’assurer que la version la plus récente de la configuration et de
l’image est bien déployée.

Le script utilise également des options comme --prune et --force pour supprimer
les ressources inutilisées et forcer le déploiement des mises à jour. L’option --

41
insecure permet de contourner la validation de sécurité, principalement dans des
environnements non critiques.

En résumé, ce script automatise la mise à jour de l’application backend en

déployant la version la plus récente de l’image via ArgoCD, tout en
synchronisant le serveur et en nettoyant les ressources obsolètes.

Figure 14 : Github Actions pipeline de CI/CD

42
L’interface de Argocd avec les différents workloads déployé.

Figure 15 : Application ArgoCD

Pour arriver à ce stade on installé Argocd sur notre cluster Kapsule de Scaleway
sur un namespace argocd, puis on a créer un namespace avec la commande kubect
create ns dev-pressing, et puis on entame la configuration de ArgoCD.

On crée d’abord notre projet sur argocd, puis on crée une application dans ce
dernier, et on connecte cette application à un répositories sur notre repository
github avec un path bien défini de notre workloads.

Notre projet pressing sur Argocd est bien créé

43
 Figure 16 : Projet ArgoCD

Notre Application est bien créée.

Figure 17 : Détails de l’application ArgoCD créée

Là il suffit de synchroniser depuis l’interface graphique pour créer ces ressources

sur le namespace définit dans notre projet GitOps sur Github

44
 Figure 18 : Structure du projet Gitops ( Kustomize )

Ce projet GitOps est développé en respectant la syntaxe de Kustomize, un outil

natif de Kubernetes qui permet de personnaliser les configurations sans modifier
les fichiers YAML d'origine. Il superpose des transformations pour adapter les
ressources à différents environnements (dev, prod, etc.). Cela simplifie la gestion
des déploiements multi-environnements et évite la duplication des fichiers.
Kustomize est intégré dans kubectl, facilitant son utilisation dans les pipelines
CI/CD.
Nous avons intégré Swagger afin de générer automatiquement la documentation
des API REST. Swagger permet de décrire l'ensemble des endpoints de notre
application, en détaillant les méthodes disponibles, les paramètres requis, les
types de réponses, ainsi que les codes d'erreur associés. Grâce à son interface
utilisateur interactive, les développeurs et utilisateurs peuvent tester directement
les API depuis une page web dédiée, facilitant ainsi le processus de validation et
de compréhension des différents services exposés. L'intégration de Swagger
améliore non seulement la clarté et la maintenabilité du projet, mais elle simplifie
également la collaboration entre les équipes de développement et les parties
prenantes.

45
 Figure 19 : Documentation des api avec Swagger

Chapitre IV : Réalisation de l’Application et

Présentation des Interfaces

46
1. Présentation des Interfaces Utilisateur

1.1 Page de Connexion (Login)

La page de connexion permet aux utilisateurs (administrateurs, employés, et

clients) d’accéder à leurs espaces personnels. Les administrateurs et employés ont
des privilèges spécifiques pour gérer les opérations tandis que les clients peuvent
suivre l’état de leurs commandes.

47
 Figure 20 : Page d’authentification

1.2 Tableau de Bord (Dashboard)

Le tableau de bord donne un aperçu général des opérations en cours, incluant les
commandes en attente, les statistiques de performance, et les alertes importantes.
Il permet aux administrateurs et aux employés de gérer efficacement les activités
quotidiennes.

48
 Figure 21 : Dashboard de suivi

1.3 Recherche de Commandes (Search Order)

Cette fonctionnalité permet de rechercher une commande en fonction du numéro

de commande ou du numéro de téléphone du client. Cela simplifie la gestion des
commandes et permet une réponse rapide aux demandes des clients.

1.4 Gestion des Commandes (Orders)

Le module de gestion des commandes permet aux utilisateurs de consulter,

modifier ou supprimer des commandes. Il affiche également l’état des
commandes (en attente, en cours, terminées).

49
 Figure 22 : Gestion des commandes.

1.4 Création de Commandes (New Order)

L’interface de création de commande permet aux employés d’ajouter de nouvelles

commandes dans le système, en sélectionnant les services concernés. Les prix
sont calculés automatiquement en fonction des services ajoutés.

Figure 23 : Ajout des commandes.

50
1.5 Création de Clients (New Client)

Le module de création de client permet de créer un nouveau profil client, en

saisissant les informations nécessaires telles que le nom, le numéro de téléphone
et l’adresse. Cela facilite l’ajout rapide de clients dans le système.

Figure 24 : Ajout des client.

1.6 Gestion des Employés (Administration)

L’administration dispose d’une section dédiée à la gestion des employés. Cela

inclut l’ajout, la modification ou la suppression d’employés, ainsi que la
définition de leurs rôles dans l’organisation.

1.7 Gestion des Services et des Prix (Administration)

L’administration gère également les services proposés par le pressing ainsi que
leurs prix. Les administrateurs peuvent ajouter ou mettre à jour les services (ex :
nettoyage à sec, repassage, lavage, etc.) et ajuster leurs prix en fonction des
besoins de l’entreprise.

51
Chapitre V : Tests et Validation

Figure 25 : les types des tests des logiciels.

52
1. Types de Tests Effectués

Pour garantir la qualité et la robustesse de l'application, différents types de tests

ont été réalisés tout au long du projet.

1.1 Tests Unitaires

- Couverture des Tests : Les tests unitaires ont été écrits pour couvrir la majorité
des composants de l'application, en particulier ceux du backend. L'objectif était
de vérifier que chaque composant fonctionne correctement en isolation. Une
couverture de test élevée est essentielle pour réduire les risques de régression lors
des modifications du code.
- Outils utilisés : JUnit a été utilisé pour les tests unitaires du backend, tandis que
Jest a été utilisé pour tester les composants React du frontend. Ces outils
permettent de structurer les tests, de les exécuter de manière automatisée, et de
générer des rapports de couverture.

1.2 Tests d'Intégration

- Scénarios de Test : Les tests d'intégration ont été effectués pour vérifier que les
différents modules de l'application interagissent correctement entre eux. Par
exemple, les tests ont vérifié que les appels API entre le frontend et le backend
renvoient les réponses attendues. Les scénarios de test d'intégration incluent des
cas où plusieurs services doivent travailler ensemble pour accomplir une tâche.
- Environnements de Test : Les tests d'intégration ont été exécutés dans un
environnement de test qui reproduit aussi fidèlement que possible
l'environnement de production. Cela inclut l'utilisation de bases de données

53
réelles, de configurations de réseau similaires, et de conditions de charge
représentatives.

1.3 Tests de Performance

- Objectifs des Tests de Performance : Les tests de performance ont été réalisés
pour évaluer la capacité de l'application à gérer des charges élevées, telles qu'un
grand nombre de requêtes simultanées ou des volumes de données importants.
L'objectif est de s'assurer que l'application reste réactive et stable même sous des
conditions de charge élevée.
- Outils Utilisés : JMeter a été utilisé pour simuler des charges sur l'application et
mesurer les temps de réponse, la consommation des ressources, et le
comportement sous stress. Les résultats des tests de performance ont été utilisés
pour identifier les goulots d'étranglement et optimiser les performances de
l'application.

Tableau 2 : Résultats des tests de performance.

Test de Scénario Résultats

Seuil Acceptable Statut
Performance de Test Mesurés

Temps de 100
réponse utilisateurs 1.2 secondes < 2 secondes Réussi
(latence) simultanés

Chargement
Utilisation de 1000 75% d’utilisation
< 80% Réussi
de la CPU commandes de la CPU
en 1 minute

54
 Utilisation 500
de la requêtes par 850 Mo < 1 Go Réussi
mémoire minute

Temps de
200
traitement
commandes 3.5 secondes < 4 secondes Réussi
des
simultanées
commandes

500
Test de utilisateurs
Système stable,
montée en simultanés Stable Réussi
aucune erreur
charge pendant 10
min

1.4 Tests de Sécurité

- Vérification des vulnérabilités : Des tests de sécurité, y compris des tests de

pénétration, ont été effectués pour identifier et corriger les vulnérabilités du
système. Ces tests ont inclus des tentatives d'exploiter des vulnérabilités connues
et des analyses de sécurité automatisées.
- Simulations d'attaques : Des simulations d'attaques courantes, telles que
l'injection SQL et les attaques Cross-Site Scripting (XSS), ont été menées pour
s'assurer que le système est protégé contre ces menaces. Les résultats de ces
simulations ont permis de renforcer la sécurité de l'application avant sa mise en
production.

55
Chapitre VI : Gestion des Risques

56
1. Identification des Risques

La gestion des risques est une composante essentielle de tout projet logiciel, en
particulier dans le contexte du développement d'une application SaaS où les
données des utilisateurs sont sensibles et où la disponibilité du service est critique.
Voici les principaux risques identifiés au cours du projet, ainsi que les stratégies
mises en place pour les atténuer.

Tableau 3 : Estimation des risques du projet.

Stratégie
Risque Probabilité Impact
d’atténuation

Planifier des sprints

Retard dans le
Élevée Important de rattrapage et
développement
ajuster les délais

Mettre en place un
Défaillance du système de
Moyenne Critique
serveur sauvegarde et de
redondance

Utiliser des pratiques

de sécurité
Failles de sécurité Faible Critique
rigoureuses (ex :
OAuth2, SSL)

57
 Prévoir des périodes
Changements dans d’ajustement et
Moyenne Modéré
les exigences sprints
supplémentaires

Planifier la
réallocation des
Manque de
Moyenne Important ressources ou
ressources
envisager
l’externalisation

1.1 Risques Techniques

- Panne de Serveur : Le risque de panne de serveur est critique dans une
application SaaS, car il peut entraîner une interruption du service pour tous les
utilisateurs.
- Stratégie d'Atténuation : Mise en place d'une infrastructure de redondance avec
des serveurs de secours et un basculement automatique (failover) en cas de panne.
De plus, l'utilisation de services cloud avec une haute disponibilité garantit que
l'application reste en ligne même en cas de panne matérielle.

- Problèmes de Performance : Une mauvaise gestion de la charge ou des

ressources peut entraîner des temps de réponse lents ou des plantages de
l'application.
- Stratégie d'atténuation : Réalisation de tests de performance réguliers pour
identifier les goulots d'étranglement et optimisation continue du code et des

58
requêtes SQL. Utilisation de l'auto scaling dans le cloud pour ajuster
automatiquement les ressources en fonction de la demande.

1.2 Risques de Sécurité

- Violation de Données : Le risque de violation de données est particulièrement

élevé dans une application qui gère des informations sensibles sur les utilisateurs.
- Stratégie d'atténuation : Mise en œuvre de pratiques de sécurité strictes, telles
que le chiffrement des données au repos et en transit, l'utilisation de protocoles
sécurisés (HTTPS), et la mise en place d'un pare-feu applicatif pour protéger
contre les attaques courantes.

- Attaques par DDoS : Les attaques par déni de service distribué (DDoS) peuvent
rendre l'application inaccessible en surchargeant les serveurs avec un trafic
malveillant.
- Stratégie d'Atténuation : Utilisation de services de protection DDoS fournis par
les fournisseurs de cloud, ainsi que la mise en place de stratégies de limitation de
débit et de filtrage du trafic pour atténuer l'impact de telles attaques.

1.3 Risques de Dépendances

- Dépendance aux Services Tiers : L'application SaaS repose sur plusieurs

services tiers, tels que les passerelles de paiement et les API externes. Une
défaillance de ces services pourrait affecter l'application.
- Stratégie d'atténuation : Mise en place de mécanismes de reprise automatique
en cas d'échec de services tiers, et intégration de services de secours ou alternatifs
lorsque cela est possible.

59
1.4 Risques Organisationnels

- Retards dans les Sprints : Des retards dans l'achèvement des sprints peuvent
entraîner des dépassements de délais et une mise en production retardée.
- Stratégie d'atténuation : Suivi rigoureux des jalons du projet à l'aide du
diagramme de Gantt et des outils de gestion de projet. Mise en place de sprints de
rattrapage pour compenser les retards et ajustement des priorités en fonction de
la situation.

1.5 Risques liés aux Utilisateurs

- Adoption par les Utilisateurs : Il existe un risque que les utilisateurs finaux
n'adoptent pas facilement la nouvelle application en raison de la résistance au
changement ou d'une courbe d'apprentissage élevée.
- Stratégie d'atténuation : Organisation de sessions de formation et de
démonstrations pour les utilisateurs, ainsi que la fourniture de guides d'utilisation
détaillés. Écoute active des retours des utilisateurs pour apporter des
améliorations et faciliter l'adoption.

2. Évaluation et Surveillance des Risques

L'évaluation continue des risques est cruciale pour ajuster les stratégies
d'atténuation et réagir rapidement à toute menace émergente. Voici comment les
risques ont été surveillés et gérés tout au long du projet.

2.1 Matrice d'Évaluation des Risques

Une matrice des risques a été utilisée pour évaluer la probabilité et l'impact de
chaque risque. Chaque risque a été classé selon son niveau de criticité (faible,

60
moyen, élevé), et des plans d'action spécifiques ont été définis pour les risques les
plus critiques.

2.2 Surveillance Continue

- Tableau de Bord des Risques : Un tableau de bord a été mis en place pour
surveiller les risques en temps réel, avec des indicateurs clés de performance
(KPI) pour chaque risque identifié. Ce tableau de bord est régulièrement mis à
jour et discuté lors des réunions de projet.
- Revues de Risques : Des revues de risques régulières ont été organisées pour
réévaluer les risques existants, identifier de nouveaux risques, et ajuster les
stratégies d'atténuation en conséquence. Ces revues ont permis de maintenir une
vigilance constante sur les aspects critiques du projet.

61
Chapitre VII : Retour d'Expérience
(Rétrospective)

62
1. Leçons Apprises

Le retour d'expérience, ou rétrospective, est une pratique essentielle dans la

méthodologie Scrum. Elle permet à l'équipe de réfléchir sur le projet, d'identifier
ce qui a bien fonctionné, et de reconnaître les domaines où des améliorations sont
nécessaires.

1.1 Ce qui a Bien Fonctionné

- Méthodologie Agile : L'adoption de Scrum a permis une grande flexibilité tout

au long du projet. Les sprints courts ont favorisé une livraison continue de
fonctionnalités, permettant de répondre rapidement aux besoins changeants des
utilisateurs et aux retours du marché.
- Collaboration Inter-Équipe : La collaboration étroite entre les équipes de
développement, de sécurité, et de déploiement a été un facteur clé de succès. Les
réunions quotidiennes ont permis de résoudre rapidement les problèmes et de
maintenir une bonne communication entre les différentes parties prenantes.
- Automatisation CI/CD : La mise en place du pipeline CI/CD a largement
contribué à l'efficacité du projet. L'automatisation des tests et des déploiements a
non seulement accéléré le cycle de développement, mais a également amélioré la
qualité du produit final en détectant rapidement les régressions.

1.2 Ce qui Peut Être Amélioré

- Planification des Ressources : Bien que les sprints aient été efficaces, une
meilleure planification des ressources aurait permis d'éviter certains goulots
d'étranglement, notamment dans les phases critiques du projet. Une analyse plus

63
approfondie des besoins en ressources au début de chaque sprint pourrait
améliorer encore la répartition des tâches.
- Gestion des Dépendances : La gestion des dépendances avec les services tiers
s'est avérée parfois complexe, en raison de la variabilité des services externes.
Une stratégie plus robuste de gestion des risques associés aux dépendances
pourrait inclure la planification de solutions alternatives plus détaillées et des tests
de résilience pour ces services.
- Formation Continue des Utilisateurs : Bien que des formations aient été
organisées, un programme de formation continue et de support aurait permis une
adoption encore plus fluide de l'application par les utilisateurs finaux. Des
webinaires réguliers ou des ateliers pratiques pourraient être mis en place pour
renforcer l'engagement des utilisateurs.

2. Prochaines Étapes

2.1 Évolutions Futures

- Amélioration des Fonctionnalités : Sur la base des retours des utilisateurs,

plusieurs fonctionnalités sont déjà en cours de développement pour les prochaines
versions de l'application. Cela inclut l'intégration de nouvelles méthodes de
paiement, des fonctionnalités de reporting avancées, et une amélioration de
l'interface utilisateur pour une navigation encore plus intuitive.
- Extension de la Portée du Projet : L'application pourrait être étendue pour
couvrir d'autres aspects des opérations de pressing, tels que la gestion des stocks
de produits chimiques et la planification des maintenances des machines. De plus,
une extension vers d'autres marchés (par exemple, d'autres types de services de
nettoyage) pourrait être envisagée.
- Analyse de Données et IA : L'intégration de l'intelligence artificielle (IA) et du
machine learning pour analyser les données d'utilisation et offrir des

64
recommandations personnalisées aux utilisateurs est également une piste
prometteuse. Cela pourrait améliorer encore la satisfaction client en offrant des
services plus adaptés à leurs besoins individuels.
- Développement d'applications Mobiles : Afin de faciliter l’accès aux services,
des applications Android et iOS sont en cours de planification. Ces applications
permettront aux clients de consulter le statut de leurs commandes, de mettre à jour
leurs informations personnelles, et de recevoir des notifications push lorsque le
statut de leur commande est mis à jour. Si le client est un invité ou si l’application
n’est pas installée, une notification par SMS sera envoyée pour garantir que toutes
les informations importantes soient communiquées de manière efficace.

2.2 Maintenance et Support

- Suivi et Maintenance : Un plan de maintenance continue a été élaboré pour

surveiller la performance de l'application en production, appliquer les correctifs
nécessaires, et assurer que le système reste à jour avec les dernières normes de
sécurité et les nouvelles technologies.
- Support aux Utilisateurs : Un support technique réactif est en place pour
répondre aux questions des utilisateurs, résoudre les problèmes techniques, et
recueillir les retours pour les futures améliorations. Un portail dédié aux
utilisateurs, comprenant une base de connaissances, des FAQ, et un système de
ticketing, est également disponible pour faciliter l'accès au support.

65
Conclusion Générale

66
Le projet de développement de cette application SaaS pour la gestion des
pressings a démontré l'importance d'une approche intégrée combinant la Gestion
des Processus Métier (BPM), la méthodologie Agile Scrum, et des outils
modernes de développement et de déploiement. Grâce à cette combinaison,
l'application a pu être développée et déployée avec succès, offrant aux utilisateurs
une solution robuste, sécurisée, et facile à utiliser pour la gestion quotidienne de
leurs opérations.

Les pratiques mises en œuvre tout au long du projet, notamment l'adoption d'une
architecture modulaire, l'automatisation des tests et des déploiements, et la
gestion proactive des risques, ont permis de garantir non seulement la qualité du
produit final, mais aussi la satisfaction des utilisateurs finaux. Le succès de ce
projet pose les bases d'une plateforme évolutive et adaptable, prête à accueillir de
futures évolutions technologiques et à répondre aux besoins changeants du
marché.

Le retour d'expérience a permis d'identifier les forces du projet ainsi que les
domaines où des améliorations sont possibles, offrant ainsi des perspectives pour
de futurs projets. Les prochaines étapes incluent l'extension des fonctionnalités
de l'application, l'intégration de technologies avancées comme l'IA, et
l'élargissement du périmètre d'application de la solution à d'autres secteurs.

67
Bibliographie & Webographie

68
1. Outils et Technologies

1.1 Plotly
- Plotly Technologies Inc., *Plotly Python Open Source Graphing Library*,
2021. Disponible en ligne : [Link]
- Plotly Technologies Inc., *Dash Enterprise User Guide*, 2021. Disponible en
ligne : [Link]

1.2 Google Colab

- Google, *Google Colaboratory User Guide*, Google, 2021. Disponible en
ligne : [Link]
- Google, *Using Google Colab for Data Science and Machine Learning*,
Google Developers, 2022. Disponible en ligne :
[Link]

1.3 GitHub
- GitHub, *Using GitHub Repositories*, GitHub Documentation, 2023.
Disponible en ligne : [Link]
- GitHub, *GitHub Actions Documentation*, GitHub, 2023. Disponible en
ligne : [Link]
1.4 Bizagi
- Bizagi, Bizagi Modeler User Guide, Bizagi, 2021. Disponible en ligne :
[Link]
- Bizagi, Bizagi Documentation - Modélisation des Processus, Bizagi, 2022.
Disponible en ligne : [Link]
1.5 Online gantt
- Online Gantt - Create Gantt Charts Online.
Disponible en ligne : [Link]

69
1.6 swagger
- Site officiel : [Link]
1.7 kustomize

- site officiel : [Link]

2. Méthodologies

2.1 Scrum
- [Link], *The Scrum Guide*, 2020. Disponible en ligne :
[Link]
- Atlassian, *What is Scrum?*, 2022. Disponible en ligne :
[Link]
2.2 Gantt
- Office Timeline, *Guide du Diagramme de Gantt*, 2022. Disponible en ligne
: [Link]
- Smartsheet, *What is a Gantt Chart?*, 2022. Disponible en ligne :
[Link]

2.3 BPM (Gestion des Processus Métier)

- Bizagi, *Bizagi Modeler User Guide*, Bizagi, 2021. Disponible en ligne :
[Link]
- IBM, *What is Business Process Management (BPM)?*, 2022. Disponible en
ligne : [Link]

70
3. Développement et Sécurité

3.1 React
- Meta (anciennement Facebook), *React: A JavaScript library for building user
interfaces*, Meta Open Source, 2021. Disponible en ligne : [Link]
- Meta, *React Documentation*, 2021. Disponible en ligne :
[Link]

3.2 npm (Node Package Manager)

- npm, Inc., *npm Docs: Using npm as a JavaScript developer*, 2021.
Disponible en ligne : [Link]
- [Link] Foundation, *[Link] Documentation*, 2021. Disponible en ligne :
[Link]

3.3 Spring Boot

- [Link], *Spring Boot Documentation*, Pivotal Software, 2020. Disponible
en ligne : [Link]
- Baeldung, *Spring Boot Tutorial*, 2021. Disponible en ligne :
[Link]

3.4 PostgreSQL
- PostgreSQL Global Development Group, *PostgreSQL Documentation*,
2021. Disponible en ligne : [Link]
- DigitalOcean, *How To Install and Use PostgreSQL on Ubuntu*, 2021.
Disponible en ligne : [Link]
install-and-use-postgresql-on-ubuntu-20-04

3.5 OAuth2 et Sécurité

71
 - [Link], *OAuth 2.0 Authorization Framework*, 2022. Disponible en ligne
: [Link]
- OWASP, *OWASP Top Ten Security Risks*, 2021. Disponible en ligne :
[Link]

4. Outils de Gestion de Projet et CI/CD

4.1 Github Actions

- GitHub Documentation. GitHub Actions. GitHub, 2024. Disponible à l'adresse
: [Link] Cette documentation officielle fournit des
informations complètes sur l’utilisation de GitHub Actions, y compris la création
de workflows d’automatisation pour les pipelines CI/CD.

4.2 Docker et Kubernetes

- Docker, *Docker Documentation*, Docker Inc., 2021. Disponible en ligne :
[Link]
- [Link], *Kubernetes Documentation*, The Kubernetes Authors, 2021.
Disponible en ligne : [Link]

72