Automatisation et

orchestration du
déploiement
d'Applications

Réalisé par :
KAMMOUN HALE
ALOUI ARBIA
BORGI ALA

CII2-SSIR-A
Année Universitaire : 2023-2024
 Table de matières

Introduction Générale ............................................................................................................... 1

Chapitre 1 : Contexte générale de projet .................................................................................. 2

Introduction .......................................................................................................................... 2

1. Présentation de l’entreprise d’accueil ......................................................................... 2

1.1. Les services offerts par Tekup ................................................................................. 2
1.2. Qualités des études ................................................................................................... 2
1.3. Diverses méthodes de financement .......................................................................... 3
1.4. Certifications internationales ................................................................................... 3

2. Présentation du cadre du projet .................................................................................. 3

2.1. Problématique .......................................................................................................... 3
2.2. Etude et critiques de l’existant ................................................................................. 4

3. Objectif du projet .......................................................................................................... 5

4. Étude des besoins ........................................................................................................... 5

4.1. Besoins fonctionnels ................................................................................................ 6
4.2. Besoins non fonctionnels ......................................................................................... 6

5. Planning du projet ......................................................................................................... 8

Conclusion ............................................................................................................................. 8

Chapitre 2 : Etat de l’art ........................................................................................................... 9

Introduction .......................................................................................................................... 9

1. Déploiement automatisé : ............................................................................................. 9

2. Intégration continue (CI) : ........................................................................................... 9

3. Déploiement continu (CD) : .......................................................................................... 9

4. Pipeline CI/CD : ............................................................................................................ 9

5. Scripting et automatisation : ...................................................................................... 11

 6. Comparaison des solutions et outils de DevOps : ..................................................... 12

Conclusion ........................................................................................................................... 15

Chapitre 3 : Réalisation .......................................................................................................... 16

Introduction ........................................................................................................................ 16

1. Architecture de la solution ......................................................................................... 16

2. Étapes de réalisation : ................................................................................................. 18

2.1. Installation et configuration des instances EC2 : ................................................... 18
2.2. Mise en œuvre des outils DevOps : ....................................................................... 19
2.2.1. Intégration entre Github et jenkins : ............................................................... 19
2.2.2. Écriture de Dockerfile & Push du code vers GitHub : ................................... 20
2.2.3. Création et Configuration du Pipeline : .......................................................... 21

Conclusion ........................................................................................................................... 33

Conclusion générale ................................................................................................................ 34

Webographie ............................................................................................................................ 35
 Liste des figures

FIGURE 1: CI/CD PIPELINE ................................................................................................. 10

FIGURE 2: ARCHITECTURE DE LA SOLUTION PROPOSEE ......................................... 16
FIGURE 3: VERIFICATION DE L’INSTALLATION DE ANSIBLE .................................. 18
FIGURE 4: VERIFICATION DE L’INSTALLATION DE JENKINS ET CONFIRMATION
DU SERVICE ................................................................................................................... 18
FIGURE 5: VERIFICATION DE L'INSTALLATION DE MINIKUBE ET DOCKER ........ 19
FIGURE 6: RÉALISATION DE WEBHOOK ........................................................................ 19
FIGURE 7: REALISATION DE PUSH VERS GITHUB ....................................................... 20
FIGURE 8: REALISATION DE PREMIER STAGE SUR JENKINS. .................................. 21
FIGURE 9: LANCEMENT DE « BUILD » POUR LE PREMIER STAGE. ........................ 21
FIGURE 10: VERIFICATION DE PREMIER STAGE. ......................................................... 22
FIGURE 11: AUTOMATISATION DE BUILD DES STAGES. ........................................... 23
FIGURE 12: CONFIGURATION DE DEUXIEME STAGE. ................................................ 23
FIGURE 13: EXECUTION DE DEUXIEME STAGE. .......................................................... 24
FIGURE 14: VERIFICATION DE DEUXIEME STAGE. ..................................................... 24
FIGURE 15: CONFIGURATION DE TROISIEME STAGE. ................................................ 25
FIGURE 16: LANCEMENT DE TROISIEME STAGE AVEC SUCCES ............................. 25
FIGURE 17: CONFIGURATION DE QUATRIEME STAGE. .............................................. 26
FIGURE 18: LANCEMENT DE QUATRIEME BUILD. ....................................................... 26
FIGURE 19: VERIFICATION DE QUATRIEME STAGE. ................................................... 27
FIGURE 21: : VERIFICATION DES IMAGES DANS DOCKERHUB ................................ 28
FIGURE 20: CONFIGURATION ET LANCEMENT DE CINQUIEME STAGE. ............... 28
FIGURE 22: CONTENU DE PLAYBOOK [Link] ...................................... 29
FIGURE 23:CONTENU DE PLAYBOOK [Link].................................................. 29
FIGURE 24:CONTENU DE PLAYBOOK [Link] ................................................. 30
FIGURE 25: CONFIGURATION DE SSH ENTRE K8S ET ANSIBLE. .............................. 30
FIGURE 26: VERIFICATION DE CONNECTIVITE VERS KUBERNETES. .................... 31
FIGURE 27: CONFIGURATION DE SIXIEME STAGE. ..................................................... 31
FIGURE 28: EXECUTION DE SIXIEME STAGE. ............................................................... 32
FIGURE 29: CONFIGURATION DE SEPTIEME STAGE. .................................................. 32
FIGURE 30: EXECUTION DE SEPTIEME STAGE. ............................................................ 33
 Liste des tableaux
TABLE 1: PLANNING D'ÉXÉCUTION .................................................................................. 8
TABLE 2: COMPARAISON DES OUTILS DEVOPS. ......................................................... 12
 Introduction Générale

La transformation numérique redéfinit comment nous développons et déployons les logiciels.

Les équipes informatiques doivent réagir rapidement aux besoins des utilisateurs tout en
garantissant la fiabilité et la sécurité des systèmes, pour relever ces défis, beaucoup se tournent
vers les pratiques DevOps, qui encouragent la collaboration et l'automatisation des processus.

Le déploiement automatisé des applications, élément clé du DevOps, accélère la mise sur le
marché tout en réduisant les risques, en automatisant les tâches répétitives, les équipes peuvent
améliorer l'efficacité opérationnelle et répondre plus rapidement aux besoins des utilisateurs.

Ce rapport explore en détail cette approche, mettant en lumière ses avantages, ses défis et les
meilleures pratiques pour une mise en œuvre réussie.

En résumé, il vise à fournir une ressource précieuse pour les professionnels de l'informatique
intéressés par le DevOps et le déploiement automatisé des applications, afin de promouvoir
l'innovation et l'excellence opérationnelle dans leurs organisations.

1
 Chapitre 1 : Contexte générale de projet

Introduction

Avant de débuter notre projet, ce premier chapitre établit le contexte de notre étude. Nous
aborderons ensuite la problématique du projet, la comparaison des outils existants, ainsi que la
solution que nous avons choisie, ainsi que les objectifs à atteindre.

1. Présentation de l’entreprise d’accueil

TEK-UP, l'École Privée Supérieure de Technologie et d'Ingénierie, est une institution qui
offre la possibilité de bénéficier d'une éducation académique capable de doter les étudiants des
connaissances, des compétences et du savoir-faire nécessaires pour devenir un ingénieur réussi
dans un proche avenir.

L'université est accréditée par le Ministère de l'Enseignement Supérieur, de la Recherche

Scientifique et des Technologies de l'Information et de la Communication depuis août 2014.
TEK-UP décerne le Diplôme National en Ingénierie Informatique ou Télécommunications.

Leur mission est d'éduquer les ingénieurs et de les coacher pour innover et développer de
nouvelles idées tout en intégrant la technologie dans leurs projets et leur programme. Une
compréhension approfondie du rôle de l'ingénierie sera développée, permettant à nos étudiants
d'identifier les besoins du monde d'aujourd'hui et de concevoir les meilleures solutions
technologiques [1].

1.1. Les services offerts par Tekup

Tekup propose à ses clients plusieurs services qui sont décrits dans ce qui suit.

1.2. Qualités des études

TEK-UP offre un environnement d'apprentissage de haute qualité. L'éducation à

l'université couvre des compétences spécifiques et des méthodes scientifiques qui permettront
aux diplômés d'améliorer leurs qualifications.

2
 1.3. Diverses méthodes de financement

Il existe de nombreuses façons de financer vos études à TEK-UP. Pour vous aider à vous
offrir une éducation adaptée à votre situation financière, TEK-UP peut vous accorder une
méthode de financement spécifique où vous pouvez payer vos études après l'obtention de votre
diplôme une fois que vous avez trouvé un emploi.

1.4. Certifications internationales

Chaque étudiant à l'opportunité de passer près de 12 certifications internationales telles que

CCNA, CCNP, LPIC-1, LPIC-2, Microsoft MCP, Oracle JAVA, etc.

2. Présentation du cadre du projet

Dans cette section, nous présentons la problématique du projet tout en analysant l’état
existant.

2.1. Problématique

Le déploiement manuel des applications présente plusieurs inconvénients majeurs. Tout

d'abord, il nécessite une intervention humaine pour exécuter des tâches répétitives telles que
la création et la configuration des environnements, le déploiement du code et la vérification de
la cohérence des configurations, cette approche est non seulement chronophage, mais elle est
également sujette à des erreurs humaines, ce qui peut entraîner des versions défectueuses, des
conflits de configuration et des temps d'arrêt imprévus.

Lent et sujet aux erreurs :

Les processus manuels impliquent une intervention humaine à chaque étape du déploiement
des applications. Cela signifie que chaque action, de la configuration de l'environnement à la
vérification de la cohérence des configurations, est sujette à des retards dus au temps
nécessaire pour effectuer les tâches et aux possibilités d'erreurs humaines.

Par exemple, une mauvaise configuration ou un oubli lors du déploiement manuel peut
entraîner des problèmes de compatibilité, des pannes ou des dysfonctionnements des
applications. En conséquence, le processus global de déploiement prend plus de temps et peut
entraîner des retards dans la mise à disposition des nouvelles fonctionnalités pour les
utilisateurs.

3
Retards et indisponibilité :

Les déploiements manuels sont souvent lents, ce qui peut entraîner des retards dans la mise à
disposition des nouvelles fonctionnalités ou des correctifs critiques pour les utilisateurs
finaux. De plus, la lenteur des déploiements augmente le risque d'indisponibilité des
applications pendant la phase de déploiement, ce qui peut impacter négativement l'expérience
utilisateur et même entraîner des pertes financières pour l'entreprise. Par exemple, si une mise
à jour doit être déployée rapidement pour corriger une vulnérabilité de sécurité, les retards dus
aux processus manuels peuvent laisser l'application exposée à des attaques potentielles, ce qui
met en danger la sécurité des données et la réputation de l'entreprise.

Coûts élevés :

La gestion manuelle des déploiements nécessite des ressources importantes en termes de

main-d'œuvre et de temps. Les équipes doivent consacrer des heures à effectuer les tâches de
déploiement, ce qui peut entraîner une augmentation des coûts de main-d'œuvre.

De plus, les erreurs humaines peuvent entraîner des coûts supplémentaires liés aux temps
d'arrêt, aux réparations et aux retours en arrière pour corriger les problèmes causés par les
déploiements manuels. En automatisant ces processus, les entreprises peuvent réduire les
coûts de main-d'œuvre, minimiser les erreurs humaines et optimiser l'utilisation des
ressources, ce qui entraîne une réduction globale des coûts de maintenance.

2.2. Etude et critiques de l’existant

Pour réussir notre projet, il est crucial de comparer les solutions utilisées, disponibles
sur le marché Dans le domaine du développement logiciel, il existe une variété de méthodes et
d'approches pour le déploiement des applications, chacune avec ses propres avantages et
inconvénients. Les méthodes traditionnelles de déploiement manuel impliquent généralement
une série d'étapes réalisées par des opérateurs humains, depuis la configuration des serveurs
jusqu'à la mise en production des applications. Bien que largement utilisées par le passé, ces
méthodes manuelles sont de plus en plus considérées comme inefficaces dans un
environnement de développement moderne.

Cependant, au fil des ans, de nouvelles approches ont émergé pour répondre à ces défis.
Parmi celles-ci, les pratiques DevOps et l'automatisation du déploiement des applications ont
gagné en popularité en raison de leur capacité à accélérer les cycles de développement, à

4
améliorer la qualité des logiciels et à réduire les coûts opérationnels. Les équipes DevOps
adoptent une approche intégrée du développement et de l'exploitation, favorisant la
collaboration, l'automatisation et l'amélioration continue des processus.

En outre, de nombreuses entreprises ont adopté ces pratiques et ces outils avec succès, ce
qui témoigne de leur efficacité et de leur pertinence dans un large éventail de contextes
industriels. Des études de cas et des exemples concrets montrent comment l'automatisation du
déploiement des applications a permis d'améliorer l'efficacité opérationnelle, de réduire les
délais de mise sur le marché et d'augmenter la qualité des [Link] de choisir celle qui
répondra le mieux à nos besoins.

Renforcer la sécurité des déploiements :

En intégrant des pratiques de sécurité dès le processus de développement, nous visons à

renforcer la sécurité des déploiements. L'automatisation des tests de sécurité et la gestion
sécurisée des secrets avec Ansible et Vault contribueront à réduire les risques de failles
sécurisée des secrets avec Ansible et Vault contribueront à réduire les risques de failles de
sécurité.

3. Objectif du projet

L'objectif de notre projet est de mettre en place une infrastructure DevOps robuste et
automatisée pour faciliter le développement, le déploiement et la gestion des applications.
Plus précisément, nous visons à atteindre les objectifs suivants :

Optimiser l'utilisation des ressources :

En utilisant des conteneurs Docker et une orchestration avec Kubernetes, notre objectif est
d'optimiser l'utilisation des ressources informatiques.

Nous pourrons ainsi scaler dynamiquement les applications en fonction de la charge,

maximisant ainsi l'efficacité opérationnelle et réduisant les coûts.

4. Étude des besoins

L'étude des besoins dans notre projet de déploiement automatisé des applications DevOps est
cruciale pour garantir que l'architecture mise en place réponde efficacement aux exigences de
l'organisation. Voici les principaux aspects abordés dans cette étude :

5
 4.1. Besoins fonctionnels

Automatisation du processus de déploiement :

Il est essentiel que le processus de déploiement des applications soit entièrement automatisé,
depuis la compilation du code jusqu'à son déploiement sur l'infrastructure cible.

Gestion des environnements :

Nous devons être en mesure de gérer efficacement les environnements de développement, de

test et de production, en assurant la cohérence des configurations et des versions déployées.

Intégration continue et déploiement continu (CI/CD) :

Nous avons besoin d'une intégration continue fluide et de déploiements continus fiables pour
garantir des mises à jour régulières et sans heurts des applications.

Scalabilité et haute disponibilité :

L'architecture doit être conçue pour être scalable et hautement disponible, afin de pouvoir
répondre aux fluctuations de la charge et garantir une disponibilité optimale des applications.

Sécurité :

La sécurité des déploiements et des données est une priorité. Nous devons mettre en place des
mécanismes de sécurité robustes pour protéger les applications contre les menaces et les
vulnérabilités.

Suivi et monitoring :

Un système de suivi et de monitoring complet est nécessaire pour surveiller les performances
des applications, détecter les problèmes et les erreurs, et réagir rapidement en cas d'incidents.

4.2. Besoins non fonctionnels

Facilité d'utilisation :

Les outils et les processus doivent être intuitifs et faciles à utiliser pour l'ensemble des équipes
impliquées, des développeurs aux opérationnels.

Performance :

6
L'architecture doit être optimisée pour garantir des performances élevées et des temps de
réponse rapides, même dans des environnements à haute charge.

Flexibilité :

Il est important que l'architecture soit flexible et extensible, capable de s'adapter aux
évolutions futures des besoins de l'organisation.

Coût :

L'optimisation des coûts est un facteur important. Nous devons choisir des solutions qui
offrent un bon rapport qualité-prix tout en répondant à nos besoins opérationnels.

7
 5. Planning du projet

La planification est la clé principale de la réussite d'un projet. En effet, le planning aide bien
subdiviser le travail et séparer les tâches à réaliser, il offre une meilleure estimation et gestion
de temps nécessaire pour chaque tâche. L’objectif principal de la planification des tâches est
de fournir une vision du projet et de son déroulement. Elle permet de diriger la réalisation
d'une étape et la durée qui lui a déjà été consacrée, ainsi que l'avancement du projet dans son
ensemble, avec répercussions de chaque tâche sur la date de fin du projet.

Le tableau 2 montre le planning que nous avons adapté pour mener à bien notre réalisation
des différentes parties du projet.

Table [Link]Planning
Tableau Planningd'éxécution
d'exécution

Conclusion

Nous avons consacré ce premier chapitre à l’introduction du cadre général du projet à

travers une présentation du contexte. Par la suite, nous avons étudié les différentes technologies
candidates pour la réalisation du projet et cela à travers une étude comparative entre elles.

8
 Chapitre 2 : Etat de l’art

Introduction

Dans ce chapitre, nous exposons l'impératif d’automatiser le déploiement. Pour ce faire,

nous commençons par définir quelques concepts de base qui éclairent notre compréhension du
projet.

1. Déploiement automatisé :

Le déploiement automatisé fait référence au processus de déploiement d'applications et de

services de manière automatisée, sans intervention manuelle significative. Il vise à réduire les
erreurs, à accélérer les déploiements et à améliorer la cohérence des environnements de
production.

2. Intégration continue (CI) :

L'intégration continue est une pratique de développement logiciel dans laquelle les
développeurs fusionnent régulièrement leur code dans un référentiel partagé. Chaque fusion
déclenche des builds automatisés et des tests pour vérifier l'intégrité du code.

3. Déploiement continu (CD) :

Le déploiement continu étend le concept d'intégration continue en automatisant également le

déploiement du code vers l'environnement de production ou de test. Il vise à rendre les
déploiements plus rapides, plus sûrs et plus fiables.

4. Pipeline CI/CD :

Un pipeline CI/CD est une série d'étapes automatisées qui permettent de construire, de tester
et de déployer une application de manière cohérente et reproductible. Il peut inclure des
phases telles que la compilation du code, les tests unitaires, les tests d'intégration, la création
d'images Docker et le déploiement sur un cluster Kubernetes.

9
 Figure 1: CI/CD Pipeline

La figure 2 précédente présente un diagramme qui illustre les étapes clés du pipeline
d'intégration continue et de livraison continue (CI/CD) pour le développement et le
déploiement d'applications logicielles. Il met l'accent sur la nature automatisée et itérative du
processus, garantissant une livraison de logiciels efficace et fiable, ces étapes clés sont les
suivants :

Planification :

Cette étape consiste à définir les objectifs de développement, les tâches et le calendrier du
projet. Elle établit la direction et la portée globales du processus de développement logiciel.

Codage :

Les développeurs écrivent le code de l'application, en respectant les normes de codage et les
bonnes pratiques. Cela comprend la mise en œuvre de fonctionnalités, la correction de bogues
et l'amélioration des fonctionnalités de l'application.

Tests :

Des outils de test automatisés sont utilisés pour évaluer en permanence la qualité et la
fonctionnalité du code. Ces tests identifient et signalent toute erreur ou défaut, garantissant
que le code répond aux spécifications souhaitées.

10
Construction :

Le code est compilé et assemblé en un package déployable. Ce processus implique

l'intégration de différents composants de l'application et sa préparation pour le déploiement.

Déploiement :

Le package déployable est automatiquement publié sur l'environnement cible, tel qu'un
serveur de staging ou de production. Cela rend la version mise à jour de l'application
accessible aux utilisateurs.

Surveillance :

L'application déployée est continuellement surveillée en matière de performances, de stabilité

et de sécurité. Cette approche proactive permet d'identifier et de résoudre les problèmes
potentiels avant qu'ils n'impactent les utilisateurs.

Retour d'information :

Le feedback est recueilli auprès des utilisateurs, des testeurs et d'autres parties prenantes pour
évaluer les performances de l'application et identifier les points à améliorer. Ce feedback est
intégré aux futurs cycles de développement.

Dans l'ensemble, le CI/CD est devenu une pratique essentielle dans le développement de
logiciels moderne, permettant aux équipes de fournir des applications de haute qualité avec
une plus grande agilité et efficacité.

5. Scripting et automatisation :

Le Scripting et l'automatisation consistent à écrire des scripts ou des configurations qui

automatisent les tâches répétitives et manuelles associées au déploiement et à la gestion des
applications. Cela peut inclure des scripts pour la configuration des serveurs, le déploiement
d'applications et la mise à jour des environnements.

En comprenant ces concepts de base, nous sommes en mesure d'apprécier pleinement

l'importance de l'automatisation du déploiement dans notre projet DevOps. En automatisant
les processus de build, de test et de déploiement, nous visons à accélérer les cycles de
développement, à réduire les erreurs humaines et à garantir des déploiements plus fiables et
cohérents. Ce chapitre jettera les bases nécessaires pour explorer en profondeur la mise en
œuvre de l'automatisation du déploiement dans les sections suivantes du rapport.

11
 6. Comparaison des solutions et outils de DevOps :

Table 2: Comparaison des outils DevOps.

Outil Avantages Inconvénients

Git - Versionnement efficace du - Courbe d'apprentissage initiale pour
code - Gestion flexible des les utilisateurs novices - Besoin d'une
branches - Large adoption et bonne gestion des conflits de fusion
support communautaire
Subversion - Facilité d'utilisation pour les - Performance moindre pour les
utilisateurs novices - Support grands dépôts - Moins d'options pour
centralisé et robuste la gestion des branches par rapport à
Git
GitHub - Plateforme de partage de code - Certaines fonctionnalités avancées
largement utilisée - sont limitées aux comptes premium -
Fonctionnalités sociales et de Dépendance à un service tiers pour
collaboration avancées l'hébergement
GitLab - Solution complète avec - Courbe d'apprentissage initiale pour
intégration continue et les utilisateurs novices - Certaines
déploiement continu intégrés - fonctionnalités peuvent être
Possibilité d'hébergement en complexes à configurer
interne
Bitbucket - Intégration transparente avec - Moins de fonctionnalités sociales et
d'autres produits Atlassian de collaboration par rapport à GitHub
comme Jira et Trello - Option - Peut sembler moins intuitif pour
pour un hébergement en interne certains utilisateurs
Jenkins - Hautement personnalisable - Interface utilisateur datée et moins
avec une grande variété de intuitive que certaines alternatives -
plugins disponibles - Forte Gestion complexe des configurations
communauté d'utilisateurs pour les pipelines
Ansible - Facile à apprendre et à mettre - Moins adapté à des scénarios
en œuvre - Aucun agent requis complexes que certains outils de
sur les nœuds cibles gestion de configuration comme
Puppet ou Chef

12
Puppet - Gestion centralisée de la - Courbe d'apprentissage initiale plus
configuration - Déclaration de longue que certains outils comme
l'état désiré pour garantir la Ansible - Configuration initiale peut
cohérence de la configuration être complexe
Chef - Scalabilité et gestion - Courbe d'apprentissage initiale plus
centralisée - Flexibilité pour longue que certains outils comme
gérer des configurations Ansible - Configuration peut être
complexes complexe
Docker - Isolation efficace des - Configuration réseau parfois
applications - Portabilité entre complexe - Gestion de la persistance
les environnements de des données pour les conteneurs
développement, de test et de
production
Kubernetes - Orchestration des conteneurs - Courbe d'apprentissage abrupte
pour le déploiement et la gestion pour les nouveaux utilisateurs -
à grande échelle - Scalabilité et Gestion complexe des ressources et
haute disponibilité des configurations
Terraform - Provisioning d'infrastructure - Courbe d'apprentissage initiale pour
multi-cloud - Déclaration de les utilisateurs novices - Complexité
l'infrastructure comme code accrue pour les infrastructures
complexes
Grafana - Interface utilisateur élégante et - Configuration initiale peut être
conviviale - Prise en charge de complexe pour les nouveaux
diverses sources de données et utilisateurs - Moins d'options de
de visualisations personnalisation par rapport à
certaines alternatives
Prometheus - Métriques puissantes et - Courbe d'apprentissage initiale pour
collecte de données - Facilité les utilisateurs novices - Gestion des
d'intégration avec d'autres outils alertes peut nécessiter une
DevOps configuration minutieuse
ELK Stack - Analyse de logs performante - - Configuration initiale peut être
Visualisation avancée des complexe pour les nouveaux

13
 données - Évolutivité et utilisateurs - Gestion des pipelines
flexibilité peut être complexe

À la suite de l'analyse comparative de toutes les solutions, Après une analyse comparative
approfondie de toutes les solutions disponibles, notre choix s'est porté sur Jenkins, Ansible,
Kubernetes, GitHub et Docker pour plusieurs raisons clés.

Jenkins :

Jenkins est choisi pour son haut degré de personnalisation et sa grande variété de plugins
disponibles, ce qui nous permet de répondre efficacement à nos besoins spécifiques en
matière d'intégration continue et de déploiement continu. Sa forte communauté d'utilisateurs
et son historique de fiabilité en font un choix solide pour automatiser nos pipelines de
développement.

Ansible :

Ansible a été retenu en raison de sa facilité d'apprentissage et de sa mise en œuvre, ainsi que
de son approche agentless, ce qui élimine le besoin d'installer des agents sur les nœuds cibles.
Sa capacité à gérer la configuration des serveurs de manière simple et efficace correspond à
nos besoins en matière d'automatisation des opérations système.

Kubernetes :

Kubernetes est notre choix pour l'orchestration des conteneurs en raison de sa capacité à gérer
le déploiement et la gestion des applications à grande échelle de manière efficace et fiable. Sa
scalabilité, sa haute disponibilité et sa flexibilité répondent à nos exigences croissantes en
matière de déploiement d'applications conteneurisées dans des environnements complexes.

GitHub :

GitHub est sélectionné comme plateforme de gestion de code source en raison de sa large
adoption, de ses fonctionnalités sociales et de collaboration avancées, ainsi que de son
intégration transparente avec nos outils de développement existants. Sa robustesse et sa
popularité en font un choix idéal pour héberger nos dépôts de code et faciliter la collaboration
entre les membres de l'équipe.

14
Docker :

Docker est notre choix pour la conteneurisation des applications en raison de sa simplicité, de
son efficacité et de sa portabilité. Sa capacité à isoler les applications avec tous leurs éléments
nécessaires et à garantir une cohérence entre les environnements de développement, de test et
de production répond à nos besoins en matière de déploiement d'applications dans des
environnements hétérogènes.

En combinant ces outils, nous sommes en mesure de construire un pipeline DevOps robuste et
efficace, depuis le développement et les tests jusqu'au déploiement et à la gestion des
applications en production. Chaque outil a été sélectionné pour ses fonctionnalités spécifiques
et sa capacité à répondre à nos besoins opérationnels, tout en contribuant à notre objectif
global d'amélioration de la collaboration, de l'efficacité et de la fiabilité de nos processus de
développement logiciel.

Conclusion
Dans ce chapitre, nous avons expliqué les notions théoriques et fondamentales des
technologies utilisées pour réaliser notre solution proposée.

15
 Chapitre 3 : Réalisation

Introduction

Dans ce chapitre dédié à la réalisation, nous abordons la phase concrète de notre projet. Nous
plongerons dans les détails opérationnels, explorant les étapes spécifiques qui ont transformé
notre vision en une réalité tangible.

1. Architecture de la solution

Cette figure présente les étapes clés de l’architecture supportée pour la publication d'une
application web sur le web.

Figure 2: Architecture de la solution proposée

Notre projet vise à mettre en place une architecture de déploiement automatisé des
applications, intégrant les meilleures pratiques DevOps pour garantir un développement logiciel
efficace, rapide et fiable. Cette architecture repose sur l'utilisation synergique des technologies
suivantes : Docker, GitHub, Jenkins, Ansible et Kubernetes.

16
 L'objectif principal est de créer un pipeline de déploiement continu robuste, depuis
l'écriture du code par les développeurs jusqu'à la mise en production des applications sur un
cluster Kubernetes. Pour ce faire, nous avons conçu un processus fluide et automatisé,
permettant une intégration continue, des tests automatisés et un déploiement sans interruption.

Le développement commence avec la rédaction d'un Dockerfile par les développeurs,

décrivant les dépendances et les étapes de construction de l'image Docker de l'application. Une
fois le code et le Dockerfile poussés vers GitHub, Jenkins est notifié via un webhook pour
déclencher un processus de build.

Jenkins récupère le code source depuis GitHub, construit l'image Docker et la pousse
vers Docker Hub. En parallèle, Jenkins établit une connexion SSH avec Ansible, qui orchestre
le déploiement de l'application sur le cluster Kubernetes. Ansible utilise le Dockerfile pour
construire l'image Docker et la déployer sur le cluster Kubernetes.

Une fois l'application déployée sur le cluster, elle est accessible via une adresse IP et un
port spécifié dans le service Kubernetes, assurant ainsi une disponibilité continue pour les
utilisateurs finaux.

Cette architecture offre de nombreux avantages, notamment une automatisation

complète du processus de déploiement, une meilleure gestion des environnements de
développement et de production, une scalabilité et une fiabilité accrue, ainsi qu'une réduction
significative des délais de déploiement et des erreurs humaines. En fin de compte, notre objectif
est de fournir une solution DevOps hautement efficace et performante, répondant aux besoins
évolutifs de notre organisation en matière de développement logiciel.

17
 2. Étapes de réalisation :

Le projet sera réalisé en plusieurs étapes :

[Link] et configuration des instances EC2 :

Nous avons créé trois instances EC2 : une pour Jenkins, une pour Ansible et une pour
Kubernetes, ainsi on a utilisé PUTTY comme ssh agent.

Figure 3: Vérification de l’installation de ansible

La figure 3 démontre l’installation de ansible-core avec succès.

Figure 4: Vérification de l’installation de Jenkins et Confirmation du Service

La figure 4 démontre la confirmation de son installation réussie en tant que service.

18
 Figure 5: vérification de l'installation de minikube et docker

La figure 5 démontre la version de minikube ainsi que docker d’où la confirmation de

l’installation.

[Link] en œuvre des outils DevOps :

Nous avons ensuite configuré les intégrations entre les outils :

2.2.1. Intégration entre Github et jenkins :

Nous avons configuré un webhook entre github et jenkins en précisant l’adresse ip pubilc de
l’instance jenkins, pour le notifier à chaque fois un développeur réalise un « push » dans le
répertoire « devops_project »

Figure 6: Réalisation de webhook

19
 2.2.2. Écriture de Dockerfile & Push du code vers GitHub :

Le développeur crée un fichier Dockerfile qui définit l'environnement de développement et de

construction de l'application.

Le Dockerfile spécifie les dépendances, les instructions de build et l'image Docker finale.

Ensuite, le développeur affecte un Push du code vers GitHub ainsi, jenkins sera notifié
automatiquement grâce au webhook déjà configuré.

Figure 7: Réalisation de push vers Github

20
 2.2.3. Création et Configuration du Pipeline :

Nous avons initié la création d'un pipeline nommé "our_first_pipeline", les étapes suivantes
ont été effectuées :

Le premier stage « git checkout » :

pour accéder au répertoire contenant le Dockerfile sur GitHub come montre la figure 8.

Figure 8: Réalisation de premier stage sur jenkins.

La figure 9 montre que le stage est lancé avec succès.

Figure 9: Lancement de « build » pour le premier stage.

Lorsqu’on a vérifié dans la machine nous avons remarqué que le répertoire existant dans le
github est transféré avec succès dans les répertoires de Jenkins.

21
La figure 10 démontre que dockerfile a été transsféré à jenkins sous le chemin par défaut
« /var/lib/jenkins/workspace/our_first_pipeline/ »

Figure 10: Vérification de premier stage.

Pour automatiser ce processus de build, nous avons effectué les actions suivantes :

Dans Jenkins :

Accès à la configuration du projet.

- Configuration des déclencheurs de build en sélectionnant "GitHub hook trigger for

GITScm polling" en appliquant et sauvegardant les modifications.

Dans GitHub :

- Accès aux paramètres du répertoire.

- Ajout d'un webhook en spécifiant l'URL de Jenkins ([Link]
webhook/) et en choisissant le type JSON.
- Saisie du secret avec le jeton généré depuis Jenkins.
- Enregistrement et rafraîchissement de la page.

Pour confirmer que le build est automatisé, nous avons effectué les actions suivantes :

- Modification du Dockerfile
- Utilisation des commandes Git pour ajouter, commettre et pousser les modifications
vers GitHub.
- Observation de l'automatisation du build dans l'historique des builds (#2) comme
montre la figure 11 suivante.

22
 Figure 11: automatisation de build des stages.

Le deuxième stage « sending the dockerfile to ansible » :

Pour la transmission du Dockerfile de Jenkins à Ansible via SSH et pour automatiser l'envoi
du Dockerfile de Jenkins à Ansible, nous avons utilisé SSH Agent pour permettre une
connexion sécurisée sans mot de passe.

Voici les étapes suivies :

Ajout de la clé privée [Link] dans le pipeline Jenkins via l'interface Pipeline Syntax.

Intégration d'une étape de SSH dans le script du pipeline pour transférer le Dockerfile vers
Ansible.

Enregistrement des modifications, puis exécution d'un nouveau build (#4).

Figure 12: Configuration de deuxième stage.

23
La figure 13 suivante montre que le stage est réalisé avec succès.

Figure 13: Exécution de deuxième stage.

Après le transfert du Dockerfile à Ansible, nous avons vérifié que le processus s'est déroulé
avec succès :

Dans Ansible :
Connexion en tant que superutilisateur (sudo su).
Vérification du répertoire pour s'assurer que le Dockerfile a été supprimé (ls).
Reconstruction du Dockerfile en relançant le build (#5).
Vérification que le Dockerfile a été recréé (ls).
La figure si dessous montre le processus de vérification de deuxième stage.

Figure 14: Vérification de deuxième stage.

24
Cette étape garantit que le Dockerfile est correctement transmis à Ansible et que le processus
de création fonctionne comme prévu.

Le troisième stage « Docker build the image »

C’est pour la construction d'image dans Ansible :

Afin de construire l'image dans Ansible, nous avons ajouté une troisième étape au pipeline
Jenkins pour effectuer le SSH vers le serveur Ansible et construire l'image Docker.

Nous avons ajouté une nouvelle étape au script du pipeline Jenkins pour effectuer la
connexion SSH vers le serveur Ansible et réaliser la construction de l'image Docker comme
montre la figure 15.

Figure 15: configuration de troisième stage.

Puis nous avons enregistré des modifications et nous avons lancé le Build comme montre la
figure 16 suivante.

Figure 16: lancement de troisième stage avec succès

25
Le quatrième stage « Docker image tagging » :
Ce stage est pour tagger les images pour distinguer les versions des images et surtout de
distinguer la dernière image «Latest ».

Cette étape assure que l'image Docker est construite dans l'environnement Ansible conformé,
la figure 17 suivante montre la configuration nécessaire de ce stage.

Figure 17: Configuration de quatrième stage.

Ensuite, nous avons enregistré des modifications et nous avons lancé le Build comme montre
la figure 16 suivante.

Figure 18: Lancement de quatrième build.

26
Pour vérifier que l'image a été construite avec succès et correctement taggée, nous avons
effectué la commande « podman images » pour vérifier la présence de l'image Docker comme
montre la figure suivante.

Figure 19: Vérification de quatrième stage.

Cette étape assure que l'image Docker est construite dans l'environnement Ansible
conformément aux exigences du projet, et qu'elle est correctement taggée pour une référence
future.

Le cinquième stage « Push docker images to Dockerhub » :

est pour pousser les Images Taggées depuis Ansible vers Docker Hub comma montre la figure
20:

Pour publier les images taggées depuis Ansible vers Docker Hub, nous avons mis en place un
stage supplémentaire dans le pipeline Jenkins pour effectuer les actions suivantes :

- SSH vers le serveur Ansible.

- Connexion à Docker Hub.
- Utilisation de Podman pour pousser l'image taggée vers Docker Hub.
- Connexion à Docker Hub :
Dans Ansible, nous nous sommes connectés à Docker Hub en utilisant la
commande podman login [Link].
- Construction du Nouveau Stage :
Nous avons ajouté les commandes nécessaires pour effectuer la connexion et le
push dans le pipeline Jenkins.

Puis nous avons enregistré des modifications et nous avons lancé le Build comme montre
la figure 20 et 21 suivantes :

27
 Figure 21: Configuration et lancement de cinquième stage.

Après avoir poussé les images taggées vers Docker Hub, nous avons vérifié leur disponibilité
et leur mise à jour sur Docker Hub ainsi, nous avons confirmé que l'image "latest" était
correcteme nt mise à jour avec la dernière version poussée depuis Ansible.

Figure 20: : Vérification des images dans DockerHub

28
Cela garantit que les images taggées sont publiées avec succès sur Docker Hub et que l'image
"latest" est toujours synchronisée avec la version la plus récente construite par Docker.

Le sixième stage « Copy files from ansible to k8s »:

Nous avons tous d’abord créé les fichiers [Link], [Link] et [Link].

Ensuite, Nous avons ajouté les configurations nécessaires à ces fichiers comme montre les
figures 22, 23 et 24 suivantes.

Puis, nous avons effectué un "git push" pour sauvegarder les modifications.

Figure 22: Contenu de playbook [Link]

Figure 23:Contenu de playbook [Link]

29
 Figure 24:Contenu de playbook [Link]
Après nous avons configuré l'accès SSH entre Ansible et Kubernetes :

- Nous avons défini un mot de passe pour l'utilisateur Ubuntu de Kubernetes en tant
que root.
- Pour autoriser la connexion à root avec mot de passe, nous avons modifié les
paramètres SSH dans /etc/ssh/sshd_config sur le serveur Kubernetes.
- Après cela, nous avons redémarré le service SSH sur le serveur Kubernetes.
- Sur le serveur Ansible, nous avons généré une paire de clés SSH avec ssh-keygen.
- Enfin, nous avons envoyé la clé publique au serveur Kubernetes avec la
commande ssh-copy-id.

La figure 25 suivante montre les procédures faites :

Figure 25: configuration de ssh entre k8s et ansible.

30
Ensuite, nous avons ajouté l'adresse du serveur Kubernetes dans le fichier hosts d'Ansible :

Nous avons modifié le fichier hosts d'Ansible pour inclure l'adresse IP publique du serveur
Kubernetes.

Pour vérifier la connectivité avec le serveur Kubernetes, nous avons utilisé la commande
"ansible -m ping node" comme montre la figure 26 suivante.

Figure 26: vérification de connectivité vers kubernetes.

Nous avons ajouté la clé privée du serveur Kubernetes aux identifiants de Jenkins.

Ensuite, nous avons configuré le stage dans Jenkins pour transférer les fichiers vers
Kubernetes, la figure 27 montre le contenu de stage.

Figure 27: configuration de sixième stage.

31
Pour réaliser le transfert des fichiers depuis Jenkins vers Kubernetes, nous avons utilisé la
commande scp dans ce dernier stage.

Nous avons également généré une nouvelle paire de clés SSH sur Jenkins et l'avons envoyée
au serveur Kubernetes la figure suivante démontre la réalisation de stage avec succès.

Figure 28: Exécution de sixième stage.

Septième stage « k8s deployment using ansible »:

Nous avons déjà configuré les tâches nécessaires dans le playbook Ansible pour le
déploiement sur Kubernetes.

Enfin, nous avons exécuté le playbook [Link] pour déployer les applications sur le
cluster Kubernetes comme montre les figure 29 et 30 suivantes.

Figure 29: configuration de septième stage.

32
 Figure 30: Exécution de septième stage.

Conclusion

En résumé, ce chapitre nous a plongés dans la mise en œuvre pratique de notre projet. Nous
avons détaillé chaque étape, depuis la configuration des serveurs EC2 jusqu'à l'orchestration
des déploiements sur Kubernetes. En utilisant une combinaison intelligente d'outils comme
Docker, GitHub, Jenkins, Ansible et Kubernetes, nous avons automatisé le processus de
développement et de déploiement, ce qui nous a permis d'accroître l'efficacité et la fiabilité de
notre workflow. En fin de compte, notre objectif était de créer une solution DevOps robuste et
performante, et ce chapitre représente une avancée majeure vers la réalisation de cet objectif.

33
 Conclusion générale

Dans l'ensemble, ce projet représente une exploration approfondie et une mise en pratique des
principes fondamentaux de DevOps pour améliorer le cycle de vie du développement logiciel.
En combinant une gamme d'outils modernes et en adoptant une approche méthodique, nous
avons réussi à transformer une vision théorique en une réalité opérationnelle.

À travers les différentes phases du projet, de la conception initiale à la réalisation concrète,

nous avons démontré l'importance de l'automatisation, de la collaboration et de la mise en
œuvre efficace des pratiques DevOps. En intégrant des outils tels que Docker, GitHub,
Jenkins, Ansible et Kubernetes, nous avons créé un écosystème cohérent et interconnecté,
permettant un déploiement continu et fiable des applications.

Les bénéfices de cette approche sont multiples : une réduction significative des délais de
déploiement, une amélioration de la qualité du logiciel grâce à des tests automatisés et une
meilleure gestion des environnements de développement et de production. De plus, cette
démarche favorise une collaboration étroite entre les équipes de développement et
d'exploitation, renforçant ainsi la culture DevOps au sein de notre organisation.

En conclusion, ce projet illustre le potentiel transformatif de DevOps dans le domaine du

développement logiciel. En adoptant une approche centrée sur l'automatisation, la
collaboration et l'amélioration continue, nous avons posé les bases d'une infrastructure robuste
et adaptable, capable de répondre aux défis futurs de manière agile et efficace.

34
 Webographie

[1] Présentation de TEK-UP University.

[Link]

[2] Documentation Ansible

[Link]

[3] Site officiel de Docker

[Link]

[4] Tutoriel Docker pour débutants

[Link]
examples/

[5] Site officiel de GitHub

[Link]

[6] Cours Git et Github pour débutants

[Link]

[7] Site officiel de Jenkins

[Link]

[8] Tutoriel Jenkins pour débutants

[Link]

[10] Introduction à Ansible

[Link]

[11] Site officiel de Kubernetes

[Link]

[12] Guide Kubernetes pour débutants

[Link]

35