Rapport de projet fin d’année

4ème année
Ingénierie Informatique et Réseaux

Sous le thème

COMPARAISON DES OUTILS DEVOPS POUR

LE DEPLOIEMENT SUR OPENSTACK
(TERRAFORM, HEAT,
ANSIBLE, PUPPET)

Réalisé par :
NADA BENBOUZIYANE
CHAIMAE ELHAOUARI
Encadré par :
Tuteur de l’école : Pr. Imam ALIHAMIDI
Membres du jury : Mme. MOUTAI Fatima Zahra
Dédicace ...................................................................................................................................... 4
Remerciements ............................................................................................................................ 5
Résumé .................................................................................................................................... 6
Chapitre 1 : Étude Préliminaire .................................................................................................. 8
1. Contexte du projet .............................................................................................................. 8
1.2 Objectifs du projet ............................................................................................................ 8
1.3 Motivation ......................................................................................................................... 9
2. Problématique ......................................................................................................................... 9
2.1 Description de la Problématique...................................................................................... 9
2.2 Importance de l’Automatisation .................................................................................... 10
3. Solutions d’Automatisation .................................................................................................. 10
3.1 Présentation des différentes solutions d'automatisation disponibles : ............................. 10
4. Planning (Diagramme de Gantt) .......................................................................................... 11
Conclusion ................................................................................................................................. 12
Chapitre 2 : Revue littérature ................................................................................................... 12
1. Introduction ........................................................................................................................... 12
2. Concepts clés ................................................................................................................ 14
3. Choix des technologies et outils .................................................................................. 14
3.3.1 Avantages d'Ansible :.................................................................................................. 14
Ansible................................................................................................................................... 15
3.3.2 Fonctionnement d'Ansible : ........................................................................................ 15
Puppet .................................................................................................................................... 16
3.3.1 Avantages de Puppet : ................................................................................................. 16
2.2.2 Fonctionnement de Puppet : ....................................................................................... 16
3.3.1 Avantages de Terraform : ........................................................................................... 17
3.3.1 Fonctionnement de Terraform : .................................................................................. 17
Heat (OpenStack Heat) ? ...................................................................................................... 18
32.3.1 Avantages de Heat : .................................................................................................. 18
3.3.2 Fonctionnement de Heat : ........................................................................................... 19
[Link] des Outils ............................................................................................................ 19
4.1 Installation d’Ansible ..................................................................................................... 19
Sur Ubuntu / Debian : ....................................................................................................... 19
Sur Red Hat / CentOS : .................................................................................................... 19
Vérification: ..................................................................................................................... 19
Inventaire simple : ............................................................................................................ 19
4.2 Installation de Puppet .................................................................................................... 19

Page 2 sur 33
 Sur Ubuntu (agent et serveur) : ....................................................................................... 19
4.3 Installation de Terraform ............................................................................................... 20
Sur Ubuntu / Debian : ....................................................................................................... 20
Vérification : .................................................................................................................... 20
Premier test : .................................................................................................................... 20
5.4 Installation de Heat (OpenStack Heat) .......................................................................... 20
Méthode avec DevStack (en environnement de test) : ................................................... 20
Vérification : ..................................................................................................................... 20
Conclusion ................................................................................................................................. 21
Chapitre 3 : Réalisation ........................................................................................................ 22
3. Mise en place de l’environnement............................................................................... 22
3.1 Déploiement avec les outils DevOps ........................................................................ 22
3.2 Scénario de test commun ........................................................................................... 23
3.3 étapes détaillées pour installer OpenStack avec DevStack sur une machine
virtuelle VMware .............................................................................................................. 25
Conclusion ........................................................................................................................ 25
Chapitre 4: Résultats & Discussion............................................................................................ 27
4. Critères d’évaluation ........................................................................................................ 27
4.1 Résultats expérimentaux ................................................................................................ 27
4.2 Analyse comparative ...................................................................................................... 27
4.3 Discussion ....................................................................................................................... 28
Conclusion............................................................................................................................. 28
Conclusion Générale .................................................................................................................. 30
1) Documentation technique ................................................................................................ 31
➤ Description détaillée des configurations et des scripts utilisés................................. 31
➤ Guides d'installation et de configuration d'Ansible et des machines virtuelles ....... 31
2) Captures d’écran des configurations ............................................................................... 31
➤ Images illustrant les configurations des machines virtuelles et des équipements ... 31
➤ Exemples visuels des interfaces et des résultats des tâches automatisées ............... 31
3) Exemples de code de playbooks...................................................................................... 32
➤ Playbooks Ansible utilisés pour les tâches d'automatisation .................................... 32
➤ Exemples de scripts et de commandes pour la gestion des configurations et des
mises à jour ....................................................................................................................... 32
Références ................................................................................................................................. 33
1) Bibliographie .................................................................................................................... 33
2) Liens utiles ........................................................................................................................ 33

Page 3 sur 33
 Dédicace

À mes très chers parents,

Pour tous vos sacrifices silencieux, pour votre amour inconditionnel et vos prières qui m’ont
toujours portée.
Pour ces nuits où vous êtes restés éveillés à vous inquiéter pour moi, et pour ces jours où vous
avez cru en moi plus que moi-même.
À vous, je dédie ce travail, modeste reflet de tant d’efforts, d’espoirs et de confiance.
À ma famille,
Pour votre présence apaisante, vos encouragements, vos sourires réconfortants dans les
moments de doute.
Vous avez été mon refuge et mon énergie dans cette aventure.
À mes amis sincères,
Qui m’ont soutenue, écoutée, motivée.
Merci pour les mots simples, les pauses bienvenues, et les moments de légèreté qui m’ont
permis d’aller jusqu’au bout.
À toutes celles et ceux qui, de près ou de loin, ont contribué à mon chemin…
Cette dédicace vous appartient.

Page 4 sur 33
 Remerciements
Au terme de ce travail, qui marque l’aboutissement d’un projet aussi enrichissant que
formateur, je ressens le besoin sincère d’adresser mes remerciements à toutes celles et ceux
qui, de près ou de loin, ont contribué à sa réalisation.
Avant tout, je tiens à exprimer ma profonde reconnaissance à Monsieur le Professeur
Imam ALIHAMIDI, mon tuteur au sein de l’établissement.
Son accompagnement constant, ses conseils éclairés, sa disponibilité généreuse et sa rigueur
scientifique ont été pour moi une source précieuse d’orientation, de motivation et de progrès.
Grâce à ses observations pertinentes, son exigence bienveillante et sa vision claire, j’ai pu
avancer dans mon travail avec sérénité et méthode.
Je le remercie chaleureusement pour sa confiance, son écoute, et pour le temps qu’il a bien
voulu m’accorder tout au long de ce parcours.
Je souhaite également remercier l’ensemble du corps professoral et les responsables
pédagogiques de l’établissement pour la qualité de la formation qu’ils nous ont transmise,
ainsi que pour leur engagement tout au long de ces années d’études.
Chaque enseignement, chaque échange et chaque projet ont contribué à enrichir mes
connaissances, à élargir mes horizons et à me préparer au monde professionnel avec une
meilleure compréhension des enjeux technologiques actuels.
À ce stade, je ne peux oublier de remercier mes parents, qui ont toujours été là, présents dans
l’ombre, avec leur soutien indéfectible.
Merci pour leur patience, leur amour, leurs encouragements, et leur confiance constante,
même dans les moments les plus exigeants.
Leur présence rassurante a été une force dans les moments de doute ou de fatigue.
Je tiens aussi à remercier ma famille et mes proches, qui m’ont toujours soutenue
moralement, qui ont su faire preuve de compréhension pendant les périodes intenses de
travail, et qui m’ont offert des moments de calme et de réconfort essentiels à mon équilibre.
Enfin, je remercie mes amis pour leur bienveillance, leur aide précieuse, leurs mots simples
mais justes, et leur capacité à me rappeler, même dans les périodes de pression, l’importance
de garder le sourire.
Ce projet n’est pas seulement le fruit d’un travail personnel, mais le reflet d’un
accompagnement collectif, de rencontres humaines inspirantes, et d’un environnement
éducatif porteur.
À toutes celles et ceux qui ont contribué, de près ou de loin, à ce cheminement :
Merci.

Page 5 sur 33
 Résumé
Dans un monde numérique en constante évolution, les entreprises sont confrontées à un
besoin croissant d'automatiser et de fiabiliser leurs processus de déploiement. Pour répondre à
ces exigences, les outils DevOps se sont imposés comme des solutions incontournables dans
la gestion moderne des infrastructures informatiques, en particulier dans des environnements
cloud. C’est dans ce contexte que s’inscrit ce projet, qui vise à explorer et comparer plusieurs
outils DevOps utilisés pour le déploiement sur la plateforme OpenStack.
L’objectif principal de ce travail est de réaliser une étude comparative approfondie entre
quatre outils majeurs : Terraform, Heat (OpenStack Heat), Ansible et Puppet. Ces outils
ont été sélectionnés en raison de leur popularité, de leurs approches différentes de
l’automatisation, et de leur compatibilité avec les environnements cloud. La comparaison
porte sur des critères essentiels tels que la facilité d’intégration, la performance, la sécurité,
l’automatisation des processus, et la flexibilité.
Afin de mener cette analyse dans un environnement concret, une infrastructure de test a été
mise en place à l’aide de DevStack, une solution légère permettant d’installer OpenStack sur
une machine virtuelle tournant sous Xubuntu. Ce choix a permis de simuler un
environnement cloud réaliste tout en gardant un certain contrôle technique.
L’approche méthodologique adoptée repose sur plusieurs étapes clés :
 D’abord, l’installation et la configuration manuelle des différents outils sur des ma-
chines virtuelles,
 Ensuite, la création de scripts (playbooks Ansible, manifests Puppet, templates Heat,
fichiers Terraform) permettant d’automatiser le déploiement de machines, services ou
ressources,
 Puis, la comparaison des résultats obtenus selon des critères bien définis (intégration,
évolutivité, support, etc.),
 Enfin, une documentation complète a été rédigée pour illustrer l’ensemble du proces-
sus, avec des extraits de code et des captures d’écran des différentes interfaces et ré-
sultats.
Les résultats de cette étude ont permis de mettre en évidence les points forts de chaque outil.
Ansible s’est montré particulièrement simple d’utilisation, ne nécessitant pas d’agent, et s’est
révélé très souple pour la gestion de configurations.
Puppet, de son côté, est plus adapté aux grandes infrastructures, grâce à son architecture
client-serveur robuste et son langage déclaratif précis.
Terraform a été apprécié pour sa puissance dans le provisioning d’infrastructure multi-cloud,
avec une approche déclarative bien structurée.
Enfin, Heat, en tant que composant natif d’OpenStack, s’intègre parfaitement dans cet
écosystème, bien qu’il soit un peu plus complexe à prendre en main.
En somme, ce projet a permis de développer des compétences concrètes en déploiement
automatisé et de mieux comprendre les enjeux liés au DevOps dans le cloud. Il ouvre
également la voie à des réflexions futures sur l’orchestration hybride, l’optimisation des
workflows de CI/CD, ou encore l’intégration de ces outils dans des environnements plus
complexes.

Page 6 sur 33
 - Table des abréviations
Abrévia-
Signification (Français) Traduction (Anglais)
tion
IaC Infrastructure as Code Infrastructure as Code
VM Machine Virtuelle Virtual Machine
Intégration Continue / Déploiement Con- Continuous Integration / Continuous
CI/CD
tinu Deployment
SSH Secure Shell (connexion sécurisée) Secure Shell
API Interface de Programmation d'Applications Application Programming Interface
OS Système d’exploitation Operating System
YAML Ain't Markup Language (langage
YAML YAML Ain't Markup Language
de configuration)
HOT Heat Orchestration Template Heat Orchestration Template
HCL HashiCorp Configuration Language HashiCorp Configuration Language
VCS Système de gestion de version (Git, SVN...) Version Control System
GUI Interface graphique utilisateur Graphical User Interface
DevOps Développement et Opérations Development and Operations
RAM Mémoire vive Random Access Memory
CPU Processeur Central Processing Unit
DSL Langage spécifique à un domaine Domain Specific Language
OpenStack Plateforme cloud open source Open source cloud platform

Page 7 sur 33
 Chapitre 1 : Étude Préliminaire

1. Contexte du projet
Aujourd’hui, avec le développement rapide du cloud computing, de plus en plus
d’entreprises cherchent à automatiser les tâches techniques liées à leurs infrastructures
informatiques. Ces tâches incluent, par exemple, le déploiement de serveurs, la configuration
des réseaux, ou encore la gestion du stockage.
L’un des outils les plus puissants pour gérer une infrastructure cloud privée est OpenStack,
une plateforme open source qui permet d’orchestrer des ressources informatiques comme des
machines virtuelles, des volumes de stockage, ou des réseaux internes. Grâce à sa modularité,
OpenStack est capable de s’adapter à des environnements très complexes et évolutifs.
Cependant, gérer OpenStack manuellement reste une opération difficile et source de
nombreux problèmes : il faut connaître en détail tous les composants, suivre des procédures
longues, et les erreurs humaines sont fréquentes. Cela peut ralentir les projets, provoquer des
bugs, ou même faire échouer un déploiement.
C’est dans ce contexte que les outils DevOps prennent tout leur sens. Leur but est de
simplifier et d’automatiser ces tâches techniques grâce à des scripts et des configurations
réutilisables. Des outils comme Terraform, Heat, Ansible, ou Puppet proposent chacun une
manière différente de rendre le déploiement plus rapide, plus fiable, et surtout, automatisé.
Ils permettent ainsi de remplacer les tâches manuelles par des processus contrôlés et
reproductibles.
1.2 Objectifs du projet
Ce projet a pour but principal de comparer quatre outils DevOps pour le déploiement
automatique d’infrastructure sur OpenStack. Pour cela, il se base sur quatre objectifs
principaux :
1. Créer un environnement de test commun et contrôlé
Avant de faire des comparaisons fiables, il est important d’avoir un cadre stable. On
installe donc OpenStack grâce à DevStack sur une machine virtuelle Xubuntu. Ainsi,
tous les tests se feront dans les mêmes conditions.
2. Mettre en œuvre les quatre outils DevOps dans des scénarios identiques
On choisit un scénario de déploiement (création de réseau, machine virtuelle, IP flot-
tante, volume) que l’on applique avec chacun des outils : Terraform, Heat, Ansible et
Puppet. Cela permet une comparaison directe et équitable.
3. Évaluer les outils avec plusieurs critères précis
Pour chaque outil, on étudiera des aspects bien définis :
 La facilité d’utilisation (installation, syntaxe, documentation)
 Le temps nécessaire pour déployer
 La flexibilité (adaptation à des cas complexes)
 L’intégration avec OpenStack (compatibilité, modules, API)
 Et la gestion de l’état (capacité à suivre et maintenir les ressources)

Page 8 sur 33
 4. Fournir un guide de choix clair à la fin du projet
Enfin, une synthèse des résultats permettra d’orienter les équipes techniques : quel ou-
til choisir selon les besoins, le budget, ou le niveau de compétence de l’équipe.

1.3 Motivation
Dans les entreprises, le déploiement manuel d’infrastructure sur OpenStack est une tâche
lourde, lente, et sujette aux erreurs. Il faut souvent répéter les mêmes étapes, configurer les
composants un par un, et faire attention à tous les détails techniques. Cela demande du temps
et beaucoup de rigueur.
Le problème est que ce type de déploiement ralentit les projets informatiques. Il devient
difficile de livrer rapidement des environnements de test ou de production. Les erreurs de
configuration peuvent coûter cher et provoquer des arrêts de service.
C’est pour répondre à ces défis que ce projet a été lancé. Il vise à étudier les outils DevOps
qui peuvent automatiser ces tâches, les rendre plus fiables, et surtout plus rapides. Grâce à une
comparaison claire et pratique entre les outils les plus utilisés (Terraform, Heat, Ansible,
Puppet), ce travail permettra de donner des recommandations concrètes aux équipes
techniques. L’objectif est de transformer des tâches longues et risquées en processus
automatisés, efficaces et reproductibles.

2. Problématique
L'automatisation du déploiement d'infrastructure cloud est aujourd'hui un enjeu central pour
les organisations. Malgré les avantages offerts par les plateformes comme OpenStack, la
gestion manuelle des ressources reste encore largement répandue, créant des freins majeurs à
la productivité, à la stabilité et à l’évolutivité des systèmes.
Dans ce contexte, les outils DevOps apparaissent comme des solutions prometteuses.
Cependant, face à la diversité des outils disponibles (Terraform, Heat, Ansible, Puppet…), un
problème se pose : comment choisir l’outil le plus adapté aux besoins spécifiques d’un
projet sur OpenStack ?
Cette question soulève des enjeux d'efficacité, de maintenabilité, et d’intégration technique
que ce projet vise à éclairer.
2.1 Description de la Problématique
Le déploiement d’une infrastructure cloud avec OpenStack reste une tâche complexe
lorsqu’elle est effectuée manuellement. Chaque étape – création de réseaux, lancement
d’instances, gestion du stockage – requiert des interventions précises, longues et sujettes aux
erreurs humaines.
Cette complexité se traduit par :
 Des délais de déploiement allongés,
 Une faible reproductibilité des environnements,
 Un risque élevé d’erreurs de configuration,
 Une difficulté à maintenir la cohérence entre l’infrastructure réelle et la documenta-
tion.
De plus, chaque équipe technique peut avoir des compétences variées et des exigences
différentes selon le projet. Ainsi, l’absence de standardisation dans les méthodes de
déploiement nuit à la performance globale des systèmes.

Page 9 sur 33
 C’est dans cette optique que nous avons identifié la nécessité d’automatiser ces tâches via des
outils DevOps, tout en prenant le temps de comparer leurs avantages, leurs limites et leur
intégration avec OpenStack.

2.2 Importance de l’Automatisation

L’automatisation du déploiement d’infrastructure n’est plus un luxe, mais une nécessité
stratégique pour les entreprises. Elle permet :
 De réduire les erreurs humaines,
 De gagner du temps lors des déploiements,
 De standardiser les processus,
 D’améliorer la traçabilité et la gestion des changements,
Dans un environnement cloud dynamique comme OpenStack, où les ressources évoluent
constamment, l’automatisation offre une réponse efficace pour maintenir une infrastructure
stable, évolutive et facile à administrer.
Ce projet s’inscrit donc dans une volonté claire de rationaliser les pratiques de déploiement en
évaluant les outils DevOps capables de répondre à ces enjeux.

3. Solutions d’Automatisation
3.1 Présentation des différentes solutions d'automatisation
disponibles :
Dans le contexte du cloud computing et de la gestion automatisée des infrastructures,
plusieurs outils DevOps se démarquent pour automatiser le déploiement et la configuration de
ressources. Voici une présentation des principales solutions d'automatisation compatibles
avec OpenStack, accompagnée de leurs avantages et inconvénients.
Outil Avantages Inconvénients
Terraform
- Approche déclarative claire. - Moins adapté à la configuration post-dé-
- Support multi-cloud. ploiement.
- Gestion efficace de l’état. - Syntaxe HCL déroutante.
- Modulaire et réutilisable. - Dépendance au fichier d’état.

Heat
- Moins flexible.
- Orchestrateur natif d’OpenStack.
- Courbe d’apprentissage élevée.
- Gestion automatique des dépen-
- Moins adapté aux environnements hy-
dances.
brides.
- Utilise YAML standardisé.

Ansible - Facilité d’utilisation.

- Pas de gestion d’état native.
- Fonctionne sans agent.
- Moins performant pour le provisioning ini-
- Large écosystème de modules.
tial.
- Parfait pour la configuration post-
- Nécessite une bonne structuration.
déploiement.

Page 10 sur 33
Outil Avantages Inconvénients
Puppet - Gestion de configurations com-
- Nécessite des agents.
plexes.
- Courbe d’apprentissage élevée.
- Architecture client-serveur.
- Configuration et maintenance complexes.
- Bon support des modules.

3.2 Comparaison des solutions :

Le tableau de comparaison présente une évaluation des différentes solutions d'automatisation
disponibles en fonction de plusieurs critères clés. Les solutions comparées incluent Terra-
form, Heat (OpenStack Heat), Ansible, et Puppet.
Chaque solution est évaluée sur les aspects suivants :
Heat (OpenS-
Critère Terraform Ansible Puppet
tack Heat)
Facilité d'intégra- Intégré à OpenS-
Sans agents Sans agents Agents requis
tion tack
Automatisation HCL (HashiCorp Confi- Templates HOT Playbooks en Modèle décla-
des processus guration Language) en YAML YAML ratif
Gestion des se- Gestion des Gestion des
Sécurité Gestion des secrets
crets secrets secrets
Gestion des chan-
Sans interruption Contrôle Contrôle Contrôle
gements
Support com- Support com- Support com-
Scalabilité Adaptabilité
plexe plexe plexe
Performances Efficace Performant Performant Performant
Personnali- Personnali-
Flexibilité Personnalisable Personnalisable
sable sable
Coût Compétitif Compétitif Compétitif Compétitif
Support client et Support profes- Communauté Support pro-
Communauté active
doc. sionnel active fessionnel

4. Planning (Diagramme de Gantt)

Le tableau comparatif présenté ci-dessus nous a permis de dégager une vision plus précise des
avantages et des limites de chaque outil DevOps dans un contexte de déploiement sur
OpenStack. Toutefois, une comparaison théorique reste incomplète sans une mise en
pratique concrète. C’est pourquoi, dans la suite de ce travail, nous allons expérimenter
chaque outil à travers des scénarios réels de déploiement, afin de valider ou nuancer les
observations du tableau. Cette approche permettra de confirmer les résultats théoriques par
une évaluation pratique basée sur des critères mesurables comme le temps d’exécution, la
facilité d’automatisation et la stabilité des déploiements.
Période Tâches
Semaine 1 Étude bibliographique et installation de l’environnement
Semaine 2 Prise en main des outils Terraform et Heat
Semaine 3 Prise en main des outils Ansible et Puppet
Semaine 4 Déploiement de scénarios sur OpenStack

Page 11 sur 33
Période Tâches
Semaine 5 Analyse comparative des résultats
Semaine 6 Rédaction du rapport final et préparation de la soutenance
Table 1 : répartition dans le temps des différentes tâches du projet

Conclusion
Ce premier chapitre nous a permis de poser les bases théoriques et contextuelles de notre
projet. Nous avons tout d’abord exploré le contexte général du cloud computing, en mettant
l’accent sur l’un des acteurs clés de ce domaine : OpenStack. Bien qu’il soit puissant et
modulable, OpenStack présente une complexité certaine lorsqu’il s’agit de déployer
manuellement une infrastructure complète. Ce constat justifie pleinement le recours à des
solutions d’automatisation.
Nous avons ensuite identifié une problématique centrale : comment choisir l’outil DevOps
le plus adapté pour automatiser le déploiement d’infrastructures sur OpenStack, parmi les
nombreuses solutions existantes telles que Terraform, Heat, Ansible ou Puppet ?
Cette question soulève des enjeux concrets liés à la productivité, à la réduction des erreurs,
à la reproductibilité des déploiements et à la cohérence technique des environnements.
Face à cela, le projet s’est donné pour objectif clair de comparer ces quatre outils selon des
critères rigoureux et concrets, à travers la mise en place d’un environnement de test
homogène. Nous avons défini une démarche structurée, basée sur des scénarios réels de
déploiement, afin de pouvoir évaluer objectivement chaque solution selon ses forces, ses
limites, et son intégration avec OpenStack.
Par ailleurs, la motivation du projet est fortement ancrée dans la réalité des entreprises.
Celles-ci ont aujourd’hui un besoin urgent de rapidité, de fiabilité, et de standardisation
dans la gestion de leurs infrastructures cloud. L’automatisation devient donc une nécessité
stratégique, et non plus un simple choix technique.
Enfin, la présentation des solutions DevOps disponibles et leur première analyse
comparative nous ont permis de mieux comprendre les approches proposées par chaque
outil, qu’il s’agisse de gestion de configuration, d’orchestration, ou de provisioning. Ces
éléments serviront de point de départ pour la suite du projet, où ces outils seront testés dans
des conditions identiques afin de valider les hypothèses posées ici.

Page 12 sur 33
Ainsi, ce chapitre préliminaire constitue un socle essentiel sur lequel reposera toute la partie
pratique à venir. Il prépare le terrain pour une évaluation méthodique et mesurable, qui
nous permettra d’identifier, de manière argumentée, l’outil le plus adapté aux besoins
spécifiques d’un déploiement OpenStack automatisé

Page 13 sur 33
 Chapitre 2 : Revue de littérature

1. Introduction
La revue de littérature a pour objectif de situer notre projet dans le cadre des travaux déjà
réalisés et de mieux comprendre les outils DevOps utilisés pour automatiser le déploiement
sur OpenStack. Elle nous permet d’explorer les principes fondamentaux liés à ce domaine,
ainsi que les outils technologiques qui y sont couramment utilisés. Cette partie du travail
s’articule autour de deux grands axes : d’abord, une présentation générale des concepts clés
comme le DevOps, l’Infrastructure as Code et OpenStack ; ensuite, une analyse plus
approfondie des quatre outils sélectionnés pour ce projet, à savoir Terraform, Heat, Ansible
et Puppet. Cette étape est essentielle pour préparer l’étude comparative, en s’appuyant sur
une base théorique solide.
2. Concepts clés
DevOps est une méthode qui cherche à rapprocher deux équipes importantes dans le monde
informatique : le développement logiciel, appelé « Dev », et les opérations informatiques,
appelées « Ops ». L’objectif est de travailler ensemble de manière plus fluide. Pour cela,
DevOps mise beaucoup sur l’automatisation des tâches répétitives, sur la collaboration entre
les équipes, et sur l’intégration continue, c’est-à-dire le fait de mettre à jour régulièrement les
logiciels. Grâce à cela, on obtient des livraisons de logiciels plus rapides, plus fiables, et de
meilleure qualité.
Le deuxième concept clé est l’Infrastructure as Code, ou IaC. C’est une idée importante
dans DevOps. Au lieu de configurer manuellement les serveurs, les réseaux ou le stockage, on
écrit des fichiers de configuration, comme s’il s’agissait de code informatique. Ces fichiers
décrivent précisément comment doit être construite l’infrastructure. Cette méthode facilite la
répétition exacte des configurations, assure un suivi clair des changements, et permet
d’automatiser tout le processus.
Enfin, OpenStack est une plateforme de cloud computing open source. Elle sert à gérer de
grandes quantités de ressources informatiques comme la puissance de calcul, le stockage de
données, et les réseaux. OpenStack fonctionne grâce à plusieurs modules spécialisés, par
exemple Nova pour la gestion des machines virtuelles, Neutron pour le réseau, et Glance pour
les images système. Cette plateforme est très utilisée dans les clouds privés, c’est-à-dire des
infrastructures dédiées à une seule organisation
3. Choix des technologies et outils
3.3.1 Avantages d'Ansible :
Ansible offre de nombreux avantages qui le rendent attrayant pour les entreprises cherchant à
automatiser leurs infrastructures IT. Voici quelques-uns des principaux avantages :
 Simplicité d'Utilisation :
Ansible utilise une syntaxe simple basée sur YAML, ce qui rend l'écriture des play-
books intuitive et facile à comprendre.
 Pas d'Agents Nécessaires :
Contrairement à certains autres outils d'automatisation, Ansible ne nécessite pas l'ins-
tallation d'agents sur les nœuds gérés, simplifiant ainsi le déploiement et la mainte-
nance.

Page 14 sur 33
  Extensibilité et Modularité :
Ansible est hautement extensible grâce à ses modules, qui permettent d'automatiser
une large gamme de tâches, des configurations de systèmes aux déploiements d'appli-
cations.
 Automatisation des Tâches Répétitives :
Ansible automatise les tâches répétitives et chronophages, permettant aux équipes IT
de se concentrer sur des tâches plus stratégiques et à valeur ajoutée.
 Orchestration :
Il permet l’orchestration de processus complexes impliquant plusieurs systèmes et ap-
plications.
 Sécurité :
Ansible utilise des protocoles sécurisés, comme SSH, pour la communication entre le
nœud de contrôle et les nœuds gérés, assurant la confidentialité et l’intégrité des don-
nées.
Ansible
Ansible est un outil open source d'automatisation informatique développé par Red Hat.
Il est utilisé pour automatiser la gestion des configurations, le déploiement des applications,
l'orchestration de tâches complexes et la gestion des infrastructures IT.
Conçu pour être simple à utiliser, Ansible permet aux utilisateurs d'automatiser des tâches
répétitives sans avoir besoin de compétences avancées en programmation.
L'un des principaux atouts d'Ansible est sa syntaxe simple et lisible, basée sur YAML, qui
facilite la rédaction et la compréhension des scripts d'automatisation, appelés playbooks.
Contrairement à d'autres outils d'automatisation, Ansible n'exige pas l'installation d'agents sur
les machines gérées, ce qui simplifie son déploiement et réduit les risques de sécurité.
Ansible suit un modèle de type push, où les commandes et les configurations sont envoyées
depuis un nœud de contrôle (control node) vers les nœuds gérés (managed nodes) via SSH ou
d'autres protocoles sécurisés.
Cela permet une gestion centralisée et cohérente des infrastructures, qu'elles soient composées
de quelques serveurs ou de milliers de machines réparties dans le monde entier.
3.3.2 Fonctionnement d'Ansible :
Ansible fonctionne sur un modèle de type push, où les configurations et les commandes sont
envoyées depuis un nœud de contrôle (control node) vers les nœuds gérés (managed nodes).

Page 15 sur 33
Voici les principaux composants et étapes du fonctionnement d'Ansible :
- Inventaire (Inventory) :
Fichier listant les nœuds gérés, identifié par leurs adresses IP ou noms d'hôte.
- Playbooks :
Fichiers YAML où sont définies les tâches à exécuter.
Un playbook contient une série de plays, chaque play appliquant des tâches à un
groupe de nœuds.
- Modules :
Briques de base des playbooks, correspondant à des tâches spécifiques telles que l'ins-
tallation de logiciels, la gestion de services ou la configuration de réseaux.
- Gestion des connexions :
Ansible utilise SSH pour se connecter aux nœuds gérés.
Il peut également utiliser des protocoles comme WinRM pour les systèmes Windows.
- Exécution des tâches :
Les tâches définies dans les playbooks sont exécutées séquentiellement sur les nœuds
gérés, permettant une automatisation cohérente et reproductible des configurations.
Puppet
Puppet est un outil open source de gestion de configuration et d’automatisation des
infrastructures informatiques.
Il est principalement utilisé dans les grandes entreprises pour garantir que les serveurs et
équipements restent conformes à des règles précises.
Puppet permet de décrire l’état souhaité des systèmes (logiciels installés, services actifs,
fichiers configurés) grâce à un langage déclaratif simple.
Il fonctionne selon un modèle client-serveur où un serveur central, appelé master Puppet,
communique avec des agents Puppet installés sur chaque machine à gérer.
Les agents récupèrent les configurations depuis le master, appliquent les changements
nécessaires, et assurent que les systèmes restent toujours conformes aux règles définies.
3.3.1 Avantages de Puppet :
 Gestion centralisée :
Puppet permet de contrôler la configuration de centaines voire milliers de serveurs de-
puis un seul point.

Page 16 sur 33
  Automatisation avancée :
Il automatise la gestion des configurations, réduisant les erreurs manuelles et accélé-
rant les déploiements.
 Langage déclaratif puissant :
Permet de définir des règles complexes et précises sur l’état des systèmes.
 Conformité garantie :
Puppet vérifie régulièrement que les machines respectent les configurations définies et
corrige automatiquement les écarts.
 Adapté aux grandes infrastructures :
Très utilisé dans les environnements professionnels à grande échelle.

2.2.2 Fonctionnement de Puppet :

 Architecture client-serveur :
Puppet fonctionne avec un serveur central (master) et des agents installés sur chaque
machine.

 Manifests :
Ce sont des fichiers écrits dans le langage Puppet, qui décrivent l’état désiré des res-
sources (paquets, services, fichiers, utilisateurs, etc.).
 Cycle d’application :
Les agents Puppet contactent régulièrement le master pour récupérer les manifests.
Ils appliquent les configurations et rapportent leur état.
 Vérification et correction :
Puppet contrôle que la configuration appliquée est correcte et répare automatiquement
les écarts.
Communication sécurisée :
Les échanges entre master et agents sont sécurisés via TLS (Transport Layer Securi4.1)
Terraform
Terraform est un outil open source d’infrastructure as code (IaC) développé par HashiCorp.
Il permet de définir, provisionner et gérer des ressources cloud et locales via du code lisible et
déclaratif.
Terraform utilise un langage spécifique appelé HCL (HashiCorp Configuration Language)
qui permet de décrire l’état souhaité de l’infrastructure (machines virtuelles, réseaux, bases de
données, etc.).

Page 17 sur 33
Cet outil est multi-cloud, il peut gérer des infrastructures sur plusieurs plateformes comme
OpenStack, AWS, Azure, Google Cloud, et d’autres.

3.3.1 Avantages de Terraform :

 Multi-cloud :
Terraform supporte de nombreux fournisseurs cloud et environnements.
 Infrastructure as Code :
L’infrastructure est décrite dans du code versionné, facilitant la traçabilité et la repro-
ductibilité.
 Planification des changements :
Terraform crée un plan d’action avant d’appliquer les modifications, limitant les er-
reurs.
 Sans agents :
Terraform ne nécessite pas d’installer d’agents sur les ressources gérées.
 Communauté active :
Large communauté et nombreux modules (providers) disponibles.
3.3.1 Fonctionnement de Terraform :
 Fichiers de configuration :
On écrit des fichiers en HCL décrivant les ressources et leur configuration.

 Planification (plan) :
Terraform analyse la configuration et génère un plan qui montre ce qui sera créé, mo-
difié ou supprimé.
 Application (apply) :
Terraform applique les changements pour faire correspondre l’infrastructure à la con-
figuration désirée.
 State :
Terraform maintient un fichier d’état qui garde la trace des ressources gérées.
 Providers :
Ce sont des plugins qui permettent de gérer différents types de ressources selon le
fournisseur (cloud, VM, réseau, etc.).

Page 18 sur 33
Heat (OpenStack Heat) ?
Heat est le service d’orchestration natif d’OpenStack, une plateforme cloud open source.
Il sert à automatiser la création, la gestion et la mise à jour des ressources dans un cloud
OpenStack.
Heat utilise des templates écrits en YAML dans un format appelé HOT (Heat Orchestration
Template).
Ces templates décrivent les ressources (machines, réseaux, volumes) et leurs dépendances.
Heat orchestre la création des ressources dans l’ordre correct, gère les mises à jour et permet
le rollback en cas d’erreur.
32.3.1 Avantages de Heat :
 Intégration native OpenStack :
Heat est conçu pour fonctionner parfaitement avec OpenStack.
 Gestion des dépendances :
Heat comprend les relations complexes entre ressources et les gère automatiquement.
 Automatisation des déploiements complexes :
Permet de déployer rapidement des infrastructures complètes et répétables.
 Mises à jour et rollback :
Heat peut mettre à jour une infrastructure en conservant sa cohérence et revenir en ar-
rière en cas de problème.
3.3.2 Fonctionnement de Heat :
 Templates HOT :
Fichiers YAML qui décrivent l’infrastructure à créer.
 Stack :
Une instance de template déployée est appelée une stack.
 Orchestration :
Heat déploie les ressources dans l’ordre défini par les dépendances du template.
 Gestion du cycle de vie :
Heat peut créer, mettre à jour, suspendre ou supprimer une stack.
 API OpenStack :
Heat utilise les API d’OpenStack pour communiquer avec les différents services
(Compute, Network, Storage)

4. Installation des Outils

4.1) Installation d’Ansible

Sur Ubuntu / Debian :
sudo apt update
sudo apt install ansible -y

Sur Red Hat / CentOS :

sudo dnf install epel-release -y
sudo dnf install ansible -
Vérification:
ansible --version

Page 19 sur 33
Inventaire simple :
Créer un fichier hosts :
[webservers]
[Link]
[Link]
Test de connexion :
ansible all -i hosts -m ping

4.2) Installation de Puppet

Sur Ubuntu (agent et serveur) :
Sur le serveur (Puppet master) :
wget [Link]
sudo dpkg -i [Link]
sudo apt update
sudo apt install puppetserver -y
Lancer le service Puppet:
sudo systemctl start puppetserver
sudo systemctl enable puppetserver
Sur les nœuds (agents Puppet) :
sudo apt install puppet-agent -y
Configurer le fichier /etc/puppetlabs/puppet/[Link] avec le nom du serveur master :
[main]
server = [Link]
Lancer l’agent Puppet :
sudo /opt/puppetlabs/bin/puppet agent -t

4.3) Installation de Terraform

Sur Ubuntu / Debian :
sudo apt update
sudo apt install -y gnupg software-properties-common curl
curl -fsSL [Link] | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-
[Link]
echo "deb [signed-by=/usr/share/keyrings/[Link]] [Link]
$(lsb_release -cs) main" | sudo tee /etc/apt/[Link].d/[Link]
sudo apt update
sudo apt install terraform -y
Vérification :
terraform version
Premier test :
terraform init

5.4) Installation de Heat (OpenStack Heat)

Note importante : Heat est intégré dans OpenStack. Il n'est pas installé seul. Il faut d’abord
une instance fonctionnelle d’OpenStack.
Méthode avec DevStack (en environnement de test) :
git clone [Link]
cd devstack

Page 20 sur 33
Créer un fichier [Link] :
[[local|localrc]]
ADMIN_PASSWORD=password
DATABASE_PASSWORD=password
RABBIT_PASSWORD=password
SERVICE_PASSWORD=password
enable_plugin heat [Link]
enable_service h-eng h-api h-api-cfn h-api-cw
Puis lancer l’installation :
./[Link]
- Après l’installation :
 Le service Heat est disponible via l’interface Horizon ou en ligne de commande.
On peut lancer des stacks à partir de templates HOT.
Vérification :
openstack orchestration service list

Conclusion
Ce deuxième chapitre a permis de poser les fondations théoriques indispensables à la
compréhension de notre projet. Il a d’abord permis de clarifier les principaux concepts
techniques, tels que DevOps, l’Infrastructure as Code (IaC), ainsi que le fonctionnement
d’OpenStack, afin de mieux situer notre sujet dans le domaine plus large de l’automatisation
d’infrastructure cloud.
La revue de littérature a ensuite été l’occasion de présenter et analyser les outils DevOps
sélectionnés pour ce projet : Ansible, Puppet, Terraform et Heat. Pour chacun d’eux, nous
avons étudié non seulement leur définition, mais aussi leurs principaux avantages et leurs
mécanismes de fonctionnement, en mettant en évidence leurs forces et limites respectives.
Nous avons observé que chaque outil adopte une approche différente :
 Ansible privilégie la simplicité, sans agent, avec une syntaxe lisible en YAML, adap-
tée à la configuration post-déploiement.
 Puppet, plus structuré, repose sur une architecture client-serveur robuste, idéale pour
les grandes infrastructures et les règles complexes.
 Terraform se démarque par sa capacité à gérer l’infrastructure dès la création, dans
un contexte multi-cloud, avec une bonne gestion de l’état.
 Heat, quant à lui, est parfaitement intégré à OpenStack, et bien qu’il soit moins
flexible, il permet de tirer parti de l’écosystème OpenStack de manière native.
La section consacrée à l’installation de ces outils a également montré les exigences
techniques minimales pour leur mise en œuvre, soulignant les différences de complexité et de
préparation requises selon les cas.
Ainsi, cette revue a permis de mieux cerner les spécificités de chaque outil, en fournissant
un aperçu théorique solide et documenté. Elle constitue une base de comparaison essentielle
qui va nous guider dans la suite du projet.
Dans le chapitre suivant, nous allons mettre en pratique les connaissances acquises, en
testant chacun de ces outils à travers des scénarios réels de déploiement sur OpenStack. Cette
démarche expérimentale permettra de valider ou nuancer les éléments analysés dans cette
revue, et d’apporter des résultats concrets à notre étude comparative.

Page 21 sur 33
 Chapitre 3 : Réalisation
3. Mise en place de l’environnement
Dans le cadre de ce projet, nous avons commencé par mettre en place un environnement de
travail virtuel. Pour cela, nous avons utilisé une machine virtuelle fonctionnant sous le
système d’exploitation Xubuntu, dans sa version 22.04 LTS. Cette machine virtuelle a été
hébergée sur le logiciel VMware Workstation, un outil qui permet de simuler des
ordinateurs virtuels sur une seule machine physique.
L’environnement cloud a été installé à l’aide de DevStack, un outil léger et rapide conçu pour
faciliter l’installation d’OpenStack. DevStack est particulièrement adapté pour les tests et les
environnements de développement, car il permet une installation simplifiée de tous les
composants nécessaires.
La configuration de la machine virtuelle était la suivante :
 Le système d’exploitation utilisé est Xubuntu 22.04 LTS.
 La machine dispose de 8 Go de mémoire RAM.
 Elle est équipée de 4 cœurs de processeur (CPU).
 Un espace disque de 100 Go a été alloué.
 Pour la connexion réseau, nous avons activé à la fois le mode NAT et le mode Bridge.
L’installation de DevStack s’est faite en plusieurs étapes.
D’abord, nous avons cloné le dépôt officiel de DevStack depuis GitHub. Ensuite, nous avons
créé un fichier de configuration local, nommé [Link]. Ce fichier contient les informations
nécessaires à l’installation, comme les mots de passe, les services à activer, ou encore les
paramètres réseau. Une fois le fichier prêt, nous avons lancé le script d’installation. Après
l’installation complète, nous avons pu accéder à l’interface web Horizon, qui est le tableau
de bord d’OpenStack, à partir de notre navigateur.

3.1 Déploiement avec les outils DevOps

Dans cette étape, nous avons utilisé quatre outils DevOps pour effectuer des déploiements
sur notre environnement OpenStack : Terraform, Heat, Ansible, et Puppet. Chaque outil a
été utilisé selon sa méthode propre.
Avec Terraform, nous avons commencé par créer des fichiers de configuration portant
l’extension .tf. Ces fichiers décrivent les ressources à déployer, comme une instance virtuelle,
un réseau ou un volume de stockage. Pour que Terraform puisse interagir avec OpenStack,
nous avons utilisé un provider OpenStack, qui permet de connecter Terraform à notre
environnement cloud. Les principales commandes utilisées étaient terraform init, terraform plan
et terraform apply.
Avec Heat, nous avons rédigé des fichiers de template au format YAML, appelés HOT
(Heat Orchestration Template). Ces templates décrivent les ressources et leur agencement. Le
déploiement des templates a été effectué soit par l’interface graphique Horizon, soit en
passant par la ligne de commande (CLI).
En ce qui concerne Ansible, nous avons rédigé des playbooks, c’est-à-dire des fichiers qui
contiennent des instructions précises pour automatiser certaines tâches. Ces playbooks
utilisent des modules spécifiques à OpenStack, comme os_server ou os_network. Grâce à eux,

Page 22 sur 33
nous avons pu créer et gérer des ressources dans OpenStack. Une commande typique utilisée
était ansible-playbook, suivie du nom du fichier à exécuter.
Enfin, avec Puppet, nous avons défini des manifests, qui sont des fichiers écrits dans un
langage déclaratif. Ces manifests décrivent comment les ressources doivent être configurées.
Nous avons utilisé des modules Puppet adaptés à OpenStack pour simplifier le processus.
Les configurations ont ensuite été appliquées soit automatiquement par l’agent Puppet, soit
manuellement avec la commande puppet apply.
3.2 étapes détaillées pour installer OpenStack avec DevStack
Prérequis
1. VMware Workstation / VMware Player installé sur votre machine.
2. Une image ISO Ubuntu 22.04 LTS (ou Xubuntu pour plus de légèreté).
3. Une connexion internet stable.
4. Au moins 8 Go de RAM, 2 à 4 CPU, et 100 Go de disque.

Étape 1 : Créer la machine virtuelle

 Ouvrir VMware.
 Créer une nouvelle VM.
 Choisir Ubuntu 64 bits comme système.
 Allouer :
o 8 Go de RAM (minimum).
o 4 processeurs (2 cœurs si limité).
o 100 Go d’espace disque (dynamique).
 Installer Ubuntu / Xubuntu via l’ISO.

Étape 2 : Installer les paquets nécessaires

Une fois connecté à votre VM Ubuntu :
sudo apt update
sudo apt install git -y
sudo apt install python3-pip -y
sudo apt install net-tools -y # pour vérifier IP et interfaces

Étape 3 : Télécharger DevStack

://[Link]/openstack/devstack
cd devstack

Étape 4 : Créer le fichier de configuration [Link]

nano [Link]
Copie ce contenu minimal :
[[local|localrc]]
ADMIN_PASSWORD=pass
DATABASE_PASSWORD=pass
RABBIT_PASSWORD=pass

Page 23 sur 33
SERVICE_PASSWORD=pass
HOST_IP=[Link]
RECLONE=yes
Remplace HOST_IP par l’adresse IP locale de ta VM (ip a pour la trouver).

Étape 5 : Lancer l’installation

./[Link]
Cette étape peut prendre 20 à 40 minutes selon la vitesse réseau.

Étape 6 : Accéder à l’interface Horizon

Une fois l’installation terminée :
 Ouvre un navigateur dans la VM.
 Accède à : [Link]
 Identifiants par défaut :
o Username : admin

o Password : celui défini dans [Link] (pass ici)

Page 24 sur 33
3.3 Scénario de test commun
Pour comparer les outils DevOps de manière équitable, nous avons défini un scénario de test
commun, que chaque outil devait suivre exactement.
Le scénario comporte quatre étapes principales :
1. La création d’un réseau privé, qui servira de base pour connecter les ressources.
2. Le déploiement d’une instance (machine virtuelle) avec une clé SSH, afin de
permettre une connexion sécurisée.
3. L’attribution d’une adresse IP flottante, permettant d’accéder à l’instance depuis
l’extérieur.
4. L’attachement d’un volume de stockage à l’instance, pour simuler un besoin réel en
ressources supplémentaires.
Chaque outil – Terraform, Heat, Ansible et Puppet – a été utilisé pour exécuter ce même
scénario. Les résultats de chaque exécution ont été soigneusement notés. Ces résultats
serviront plus tard pour l’analyse comparative entre les outils

Conclusion
Ce chapitre a constitué le cœur pratique de notre projet. Il a permis la mise en place
concrète de l’environnement de travail, ainsi que la réalisation des déploiements automatisés à
l’aide des outils DevOps sélectionnés.
Nous avons commencé par créer une infrastructure de test fonctionnelle en utilisant une
machine virtuelle Xubuntu hébergée sur VMware Workstation. Grâce à DevStack,
l’installation d’OpenStack a pu être réalisée de manière simplifiée, en intégrant les
composants nécessaires à notre expérimentation. L’environnement ainsi obtenu, accessible
via l’interface web Horizon, a constitué la base stable pour tous les scénarios de déploiement.
Dans un second temps, nous avons mis en œuvre les quatre outils DevOps au cœur de notre
étude : Terraform, Heat, Ansible et Puppet. Chacun a été configuré, testé et utilisé pour
exécuter des actions d’orchestration et de gestion de ressources dans OpenStack. À travers
cette phase, nous avons pu découvrir les forces et spécificités pratiques de chaque outil, non
plus en théorie, mais dans un contexte réel et maîtrisé.
Afin d’assurer une comparaison équitable, un scénario commun a été défini. Il comprend la
création d’un réseau privé, le lancement d’une instance, l’attribution d’une adresse IP flottante
et l’attachement d’un volume de stockage. Ce scénario a été reproduit fidèlement avec chacun
des outils, dans les mêmes conditions.
Page 25 sur 33
Les résultats obtenus ont été rigoureusement enregistrés, ce qui nous permettra, dans le
chapitre suivant, de procéder à une analyse comparative détaillée. Cette analyse portera sur
des critères objectifs comme le temps d’exécution, la simplicité de mise en œuvre, la stabilité
du déploiement et la flexibilité des outils.
En somme, ce chapitre a permis de transformer la réflexion théorique menée dans les
chapitres précédents en actions concrètes, ouvrant ainsi la voie à une évaluation mesurable et
argumentée.

Page 26 sur 33
 Chapitre 4 : Résultats & Discussion
4. Critères d’évaluation
Afin de comparer les différents outils DevOps utilisés pour le déploiement sur la plateforme
OpenStack, nous avons établi un ensemble de critères d’évaluation. Ces critères nous ont
permis d’analyser chaque outil de manière équitable et structurée.
Le premier critère est la facilité d’utilisation. Cela comprend la clarté de la syntaxe de l’outil,
la qualité de sa documentation, ainsi que la courbe d’apprentissage nécessaire pour le prendre
en main. Un outil simple à comprendre et bien documenté est souvent plus accessible pour les
équipes techniques.
Le deuxième critère est le temps de déploiement, c’est-à-dire la durée qu’il faut à chaque
outil pour exécuter entièrement le scénario de test que nous avons défini.
Le troisième critère concerne la flexibilité. Nous avons évalué la capacité de chaque outil à
s’adapter à des besoins particuliers, à gérer des configurations complexes et à répondre à des
cas d’usage variés.
Le quatrième critère est l’intégration avec OpenStack. Cela inclut la compatibilité native de
l’outil avec la plateforme, la disponibilité de modules ou de plugins spécifiques, et la facilité
avec laquelle l’outil interagit avec les services d’OpenStack.
Enfin, nous avons pris en compte la gestion de l’état. Ce critère mesure la capacité de l’outil
à suivre l’état des ressources déployées, à détecter les modifications effectuées, et à maintenir
une cohérence entre le code et l’infrastructure réelle.

4.1 Résultats expérimentaux

Facilité Temps de Intégration Gestion de
Outil Flexibilité
d’utilisation déploiement OpenStack l’état
Bonne (provider
Terraform ★★★★☆ Rapide ★★★★☆ Très bonne
dédié)
Heat ★★★☆☆ Moyen ★★☆☆☆ Excellente (natif) Moyenne
Bonne (modules
Ansible ★★★★★ Rapide ★★★★★ Faible
API)
Puppet ★★☆☆☆ Lent ★★★★☆ Moyenne Bonne
Table 2 : comparaison entre les outils

4.2 Analyse comparative

 Terraform s’est distingué par sa capacité à gérer l’état de l’infrastructure et sa rapidité
d’exécution. Il est idéal pour le provisioning initial, mais moins adapté à la configuration fine
post-déploiement.

 Heat, bien qu’intégrée nativement à OpenStack, présente une syntaxe plus complexe et une
flexibilité limitée. Il est utile pour des déploiements standards mais devient difficile à
maintenir pour des scénarios évolutifs.

Page 27 sur 33
 Ansible est le plus simple à prendre en main et offre une grande souplesse pour la
configuration des machines. Cependant, il ne gère pas l’état de l’infrastructure, ce qui peut
poser problème dans des environnements dynamiques.

 Puppet est puissant pour la gestion de configurations complexes, mais son modèle client-
serveur et sa courbe d’apprentissage le rendent moins accessible pour des projets de petite ou
moyenne envergure.

4.3 Discussion
Le choix de l’outil dépend fortement du contexte d’utilisation :

 Pour un provisioning initial avec suivi d’état, Terraform est recommandé.

 Pour une intégration native avec OpenStack, Heat reste une option viable.

 Pour une configuration post-déploiement rapide et flexible, Ansible est idéal.

 Pour une gestion centralisée et évolutive, Puppet convient mieux aux grandes
infrastructures.

Conclusion
Ce chapitre a constitué le cœur pratique de notre projet. Il a permis la mise en place
concrète de l’environnement de travail, ainsi que la réalisation des déploiements automatisés à
l’aide des outils DevOps sélectionnés.
Nous avons commencé par créer une infrastructure de test fonctionnelle en utilisant une
machine virtuelle Xubuntu hébergée sur VMware Workstation. Grâce à DevStack,
l’installation d’OpenStack a pu être réalisée de manière simplifiée, en intégrant les
composants nécessaires à notre expérimentation. L’environnement ainsi obtenu, accessible
via l’interface web Horizon, a constitué la base stable pour tous les scénarios de déploiement.
Dans un second temps, nous avons mis en œuvre les quatre outils DevOps au cœur de notre
étude : Terraform, Heat, Ansible et Puppet. Chacun a été configuré, testé et utilisé pour
exécuter des actions d’orchestration et de gestion de ressources dans OpenStack. À travers
cette phase, nous avons pu découvrir les forces et spécificités pratiques de chaque outil, non
plus en théorie, mais dans un contexte réel et maîtrisé.
Afin d’assurer une comparaison équitable, un scénario commun a été défini. Il comprend la
création d’un réseau privé, le lancement d’une instance, l’attribution d’une adresse IP flottante
et l’attachement d’un volume de stockage. Ce scénario a été reproduit fidèlement avec chacun
des outils, dans les mêmes conditions.
Les résultats obtenus ont été rigoureusement enregistrés, ce qui nous permettra, dans le
chapitre suivant, de procéder à une analyse comparative détaillée. Cette analyse portera sur
des critères objectifs comme le temps d’exécution, la simplicité de mise en œuvre, la stabilité
du déploiement et la flexibilité des outils.

Page 28 sur 33
En somme, ce chapitre a permis de transformer la réflexion théorique menée dans les
chapitres précédents en actions concrètes, ouvrant ainsi la voie à une évaluation mesurable et
argumentée.

Page 29 sur 33
 Conclusion Générale
Dans ce projet, nous avons étudié et comparé quatre outils DevOps : Terraform, Heat,
Ansible et Puppet. Ces outils ont été testés dans un contexte de déploiement d’infrastructure
sur une plateforme OpenStack, installée à l’aide de DevStack sur une machine virtuelle
Xubuntu. Cette démarche nous a permis de mieux comprendre les bases de l’Infrastructure
as Code (IaC), les principes de l’automatisation dans un environnement cloud, ainsi que les
points forts et les limites de chaque outil. À travers les expérimentations réalisées, nous avons
observé que Terraform est particulièrement adapté pour le déploiement initial de
l’infrastructure, notamment grâce à sa gestion d’état et sa compatibilité avec plusieurs
fournisseurs cloud. De son côté, Heat, bien qu’il soit intégré nativement à OpenStack, offre
une flexibilité réduite dans certaines situations. Ansible s’est démarqué par sa simplicité
d’utilisation et son efficacité dans les tâches de configuration après le déploiement. Quant à
Puppet, il convient surtout aux environnements complexes qui nécessitent une gestion
rigoureuse et centralisée des configurations. Ainsi, le choix entre ces outils dépend
essentiellement des besoins spécifiques du projet, des compétences disponibles dans l’équipe,
et des objectifs à atteindre. Ce travail nous a permis d’acquérir des compétences concrètes en
déploiement cloud, en automatisation, et en évaluation technique de solutions DevOps.

Page 30 sur 33
 Annexes
1) Documentation technique
➤ Description détaillée des configurations et des scripts utilisés
Cette partie présente une explication complète des configurations mises en place dans le
projet :
 Paramètres des machines virtuelles :
Définition des ressources attribuées aux VM : nombre de CPU, quantité de RAM, ca-
pacité de stockage, et système d’exploitation installé (par exemple Ubuntu 20.04
LTS).
 Réseau configuré :
Description des modes réseau utilisés (NAT, Bridge), des adresses IP statiques/dyna-
miques attribuées, des sous-réseaux, et de la connectivité entre les nœuds.
 Scripts d'automatisation utilisés :
Présentation des différents types de scripts :
o Playbooks Ansible
o Manifests Puppet
o Templates Heat (HOT)
o Fichiers Terraform (.tf)
Chaque script est accompagné d’une explication de son fonctionnement, ligne
par ligne si nécessaire, pour faciliter la compréhension de sa logique.
➤ Guides d'installation et de configuration d'Ansible et des machines virtuelles
Cette section comprend les étapes détaillées d’installation et de configuration :
 Installation d’Ansible sous Ubuntu/Debian et CentOS/RHEL via les dépôts officiels.
 Création des machines virtuelles via VirtualBox ou VMware : choix du système, al-
location des ressources, installation OS.
 Configuration de l’inventaire Ansible (/etc/ansible/hosts) pour regrouper les machines
selon leurs rôles.
 Connexion SSH entre le nœud de contrôle (machine Ansible) et les nœuds gérés (ser-
veurs), avec authentification par clé.
2) Captures d’écran des configurations
➤ Images illustrant les configurations des machines virtuelles et des équipements
 Captures de l’interface de VirtualBox/VMware pendant la création des VM.
 Réglages des ressources matérielles (mémoire, disque, CPU).
 Configuration des interfaces réseau (bridge ou NAT).
 Paramétrage de l’inventaire Ansible.
➤ Exemples visuels des interfaces et des résultats des tâches automatisées
 Capture de terminal affichant les résultats de ansible-playbook (tâches réussies, états
"ok", "changed").
 Screenshots de l’interface Horizon d’OpenStack avec les stacks Heat déployées.
Page 31 sur 33
  Résultats Terraform montrant les ressources créées ( terraform apply).
 État des services Puppet sur les agents (logs ou interface Puppetboard si utilisée).

3) Exemples de code de playbooks

➤ Playbooks Ansible utilisés pour les tâches d'automatisation
Quelques exemples concrets de playbooks développés dans le cadre du projet, par exemple :
 Installation et démarrage du serveur Apache
 Déploiement d’une application web
 Création d’utilisateurs et modification de fichiers de configuration
Chaque exemple est commenté avec explication de la syntaxe YAML.
➤ Exemples de scripts et de commandes pour la gestion des configurations et des mises à
jour
 Manifests Puppet pour l’installation de paquets, la gestion des services, ou la vérifi-
cation d’état.
 Templates Heat en YAML définissant des stacks OpenStack (serveurs, volumes, ré-
seaux).
 Scripts Terraform (fichiers .tf) définissant l’infrastructure : VMs, réseaux, groupes de
sécurité.

Page 32 sur 33
 Références
1) Bibliographie
 Jeff Geerling, Ansible for DevOps: Server and Configuration Management for Hu-
mans, Leanpub.
 Lorin Hochstein, Ansible: Up and Running, O’Reilly Media.
 Kief Morris, Infrastructure as Code: Managing Servers in the Cloud, O’Reilly Me-
dia.

2) Liens utiles
 Site officiel d’Ansible
 Documentation officielle Ansible
 Tutoriels Ansible sur YouTube (ex. Jeff Geerling, NetworkChuck)
 Documentation officielle Terraform
 Documentation Puppet
 Documentation Heat – OpenStack

Page 33 sur 33