Académique Documents
Professionnel Documents
Culture Documents
PROJET TUTEURE
Présenté par :
AFLOU Monkpokpo
AHIATAKU David
Tuteur :
Mr CEVITO Wilson
02/03/2017
Projet tuteuré
Sommaire
Introduction............................................................................................................................................. 3
I-Description du projet ............................................................................................................................ 3
I.1-Contexte et justification ................................................................................................................. 3
I.2-Problématique................................................................................................................................ 4
II-Analyse du projet ................................................................................................................................. 4
II.1-C’est quoi Ansible ? ....................................................................................................................... 4
II.2-Pourquoi Ansible ? ........................................................................................................................ 5
III-Fonctionnement .................................................................................................................................. 5
III.1-Protocole SSH ............................................................................................................................... 5
III.2-Fichier inventaire de Ansible ........................................................................................................ 6
III.3-Patterns ........................................................................................................................................ 7
III.4-Commande ad-hoc ....................................................................................................................... 8
III.5-Les playbooks ............................................................................................................................. 10
IV-Réalisation......................................................................................................................................... 16
IV.1-Installation de Ansible................................................................................................................ 16
IV.2-Architecture ............................................................................................................................... 17
IV.3-Déploiement .............................................................................................................................. 17
Déploiement I ........................................................................................................................................ 17
Installation et configuration d’un serveur ngnix ................................................................................... 17
Déploiement II ..................................................................................................................................... 25
Configurer Apache Utilisation Ansible sur Ubuntu ........................................................................ 25
Étape 1 - Configuration Ansible................................................................................................... 25
Étape 2 - Création d'un Playbook................................................................................................ 26
Étape 3 - Installation de Apache .................................................................................................. 27
Étape 4 - Configuration des modules Apache .......................................................................... 29
Étape 5 - Configuration des options Apache ............................................................................ 31
Étape 6 - Configuration des hôtes virtuels ................................................................................ 33
Créons une configuration de l'hôte virtuel .................................................................................. 33
Utilisons des variables de template ............................................................................................ 34
Ajoutons un module Template .................................................................................................... 34
Activons l'hôte virtuel.................................................................................................................... 35
Empêcher le travail supplémentaire............................................................................................ 35
2016-2017 Page 1
Projet tuteuré
2016-2017 Page 2
Projet tuteuré
Introduction
Le présent document entre dans le cadre de réalisation du projet tuteuré de
Licence professionnelle en « Maintenance et Réseaux Informatiques » au Centre
Informatique et de Calcul à l’université de Lomé.
Dès lors, l’administrateur a besoin d’un outil efficace pour pouvoir effectuer
plus facilement les tâches d’administration tels que l’installation d’un logiciel, l’arrêt
et le redémarrage d’un service, automatisation des mises à jours, effectuer les
configurations, créer des utilisateurs en plus d’autres à distance sur plusieurs
serveurs parallèlement. Ce qui évitera à l’administrateur de se déplacer sur chaque
serveur pour faire des configurations.
Dans ce document nous utiliserons Ansible qui est une plate-forme logicielle
libre pour effectuer les tâches d’administration à distance à travers le protocole
sécurisé SSH.
I-Description du projet
I.1-Contexte et justification
Administrer c’est de gérer quelque chose. Nous pouvons dire que administrer
un système informatique c’est la gestion d’un parc informatique. Qu’il soit en
2016-2017 Page 3
Projet tuteuré
I.2-Problématique
Le problème qui se pose et de trouver une solution pour effectuer les tâches
d’administration de façon efficace, éliminer les contraintes géographiques, gagner du
temps en gérant plusieurs serveurs en même temps c’est-à-dire de façon parallèle.
II-Analyse du projet
Une solution pour une gestion optimisée des serveurs d’une entreprise est :
Ansible.
2016-2017 Page 4
Projet tuteuré
se rapproche du pur anglais. Les modules Ansible fonctionnent via JSON. Ansible est
extensible avec des modules qu’on peut écrire dans n’importe quel langage de
programmation.
II.2-Pourquoi Ansible ?
Ansible a plusieurs avantages dont nous citons quelques uns :
III-Fonctionnement
III.1-Protocole SSH
Ansible utilise le protocole SSH pour communiquer de façon sécurisée
avec les machines à configurer. Ainsi pour utiliser ansible, il faut installer openssh
et générer une clé sur la machine contrôleur qui sera ensuite copiée sur les serveurs
distants sur lesquels est installé aussi le serveur openssh. Ces étapes peuvent être
réalisées de la façon suivante :
192.168.1.2 webserver1
192.168.1.3 webserver2
192.168.1.4 appserver
192.168.1.5 mailserver
2016-2017 Page 5
Projet tuteuré
$ ssh-keygen
$ ssh-copy-id webserver1
$ ssh-copy-id webserver2
$ ssh-copy-id appserver
$ ssh-copy-id mailserver
Appserver
[servers]
2016-2017 Page 6
Projet tuteuré
webserver1
webserver2
appservver
mailserver
[webservers]
webserver1
webserver2
Explication du fichier :
Dans ce fichier nous avons appserver comme nom d’hôte. Nous avons aussi deux
groupes : [servers] et [webservers]. Le groupe [servers] contient tous les serveurs du
réseau pendant que nous avons mis dans le groupe [webservers] les serveurs web.
Notons cette répartition est faite par l’administrateur selon ses besoins et le but qu’il
poursuit. Un serveur peut appartenir à plusieurs groupes.
III.3-Patterns
Patterns dans ansible est la façon dont nous décidons gérer les hôtes du réseau. Cela
signifie que nous décidons de quel hôte nous voulons communiquer.
Pour utiliser Ansible, nous devons savoir comment dire à Ansible de communiquer
avec les hôtes qui sont dans le fichier inventaire. Ce ci est fait en désignant
particulièrement le nom des hôtes ou un groupe de serveurs.
Les patterns suivants sont équivalents et cible tous les hôtes du fichier inventaire :
all
Il est aussi possible d’adresser un hôte spécifique ou des hôtes par leur nom :
webserver1
appserver
192.168.1.5
192.168.1.*
Les patterns suivants adressent un ou plusieurs groups. Les groupes sont séparés par
deux points. Ce qui veut dire que le serveur peut être dans l’un des groupes.
webservers
2016-2017 Page 7
Projet tuteuré
servers:webservers
On peut exclure les serveurs qui sont à la fois dans le groupe servers et webservers
servers:!webservers
servers:&webservers
*.example.com
*com
one*.com:dbservers
Nous pouvons cibler les hôtes par leurs positions dans un groupe.
[webservers]
Cobweb
Webbing
weber
webservers[0] # ==cobweb
webservers[1] # ==webbing
webservers[2] # ==weber
webservers[0:1] # == cobweb, webbing
III.4-Commande ad-hoc
Une commande ad-hoc est une commande qu’on peut taper pour faire quelque chose
de rapide, mais qu’on ne veut pas enregistrer. D'une manière générale, la vraie
puissance de Ansible réside dans les playbooks mais nous pouvons utiliser les
commandes ad hoc pour de petite et simple tâche. Donnons quelques exemples :
D’une manière générale une commande ad-hoc Ansible se présente sous cette forme :
2016-2017 Page 8
Projet tuteuré
Explication:
< HOST_GROUP > : représente les hôtes sur lesquels on veut exécuter la
commande
Cette commande va exécuter le module de ping vers les serveurs qui sont dans le
groupe webservers.
On copie le fichier "/root/ansible.txt" placé sur la machine ansible à tous les hôtes
définis dans " webservers " dans /tmp pour tous les hôtes. Le -f 2 option indique à
ansible d’ouvrir deux processus pour exécuter cette option.
Définit l'autorisation de fichier à 755 sur tous les hôtes pour le fichier
/tmp/ansibletest.sh
Ceci créera le répertoire /tmp/monster sur tous les hôtes avec 755 autorisations.
2016-2017 Page 9
Projet tuteuré
Le module "utilisateur" de Ansible peut être utilisé pour ajouter et supprimer des hôtes du
système facilement. Pour ajouter un utilisateur, nous devons envoyer un mot de passe chiffré
comme indiqué ci-dessous.
III.5-Les playbooks
Les playbooks sont l'une des principales caractéristiques d’Ansible. Ils disent à
Ansible ce qu'il faut exécuter. Ils sont comme une liste de tâches que Ansible doit
exécuter. Chaque tâche se connecte en interne à un morceau de code appelé module.
2016-2017 Page 10
Projet tuteuré
Les playbooks sont exprimés en format YAML qui est très faciles à lire, alors que les
modules sont un morceau de code qui peut être écrit dans n'importe quelle langage
avec la condition que sa sortie doit être au format JSON. Nous pouvons avoir
plusieurs tâches énumérées dans un playbook et ces tâches seraient exécutées en
série par Ansible. Les jeux d’instructions sont exécutés séquentiellement de haut en
bas. Toutefois, on peut effectuer l'exécution conditionnelle des tâches afin qu'elles
puissent être ignorées si les conditions ne sont pas remplies. Autrement dit, les
playbooks sont la base d'un système de déploiement de gestion de configuration de
plusieurs machines. Ils sont la configuration, le déploiement et le langage
d’orchestration de Ansible. Ils peuvent décrire une politique qu’on veut que les
systèmes distants respectent, ou un ensemble d'étapes dans un processus
informatique général.
La section cible qui définit les hôtes sur lesquels le jeu sera exécuté, et la façon dont
il sera exécuté. C’est là où nous mettons le nom d'utilisateur SSH et d'autres
paramètres liés à SSH.
La section variable qui définit les variables, qui seront mis à la disposition du jeu
en exécution.
La section des tâches qui répertorie tous les modules dans l'ordre que nous voulons
qu'ils soient gérés par Ansible
Nous pouvons inclure autant de jeu d’instruction que nous voulons dans un fichier
YAML unique. Les fichiers YAML commencent avec --- et contiennent de
nombreuses valeurs et listes de clés. En YAML indentation des lignes est utilisée
2016-2017 Page 11
Projet tuteuré
pour indiquer imbrication variable à l'analyseur, ce qui rend également le fichier plus
facile à lire.
La section cible
- hosts: webservers
user: root
Ceci est une version incroyablement simple, mais susceptible d'être tout ce qu'il faut
dans la plupart des cas. Chaque jeu existe dans une liste. Selon la syntaxe YAML, la
ligne doit commencer par un tiret. Les hôtes sur lesquels un jeu sera exécuté doivent
être mentionnés dans la valeur des hôtes. Cette valeur utilise la même syntaxe que
celui utilisé lors de la sélection des hôtes en utilisant la ligne de commande Ansible.
Dans la dernière ligne, l'utilisateur indique au playbook d’Ansible, l’utilisateur
auquel il doit se connecter sur la machine distante.
Les autres lignes que nous pouvons fournir dans cette section sont les suivantes:
sudo: on peut mettre ‘yes’ pour cette option si nous voulons que ansible utilise sudo
pour devenir root une fois connecter aux machines dans le jeu.
user: Ceci définit le nom d'utilisateur pour se connecter à la machine à l' origine,
avant d'exécuter sudo si configuré.
sudo_user: Ceci est l'utilisateur que Ansible va essayer et devenir en utilisant sudo
La section variable
Ici, nous pouvons définir des variables applicables à l'ensemble du jeu sur
toutes les machines.
Les variables dans un playbook sont définies par la clé vars. Cette clé prend une paire
clé-valeur, où la clé est le nom de la variable et la valeur est la valeur réelle de la
variable. Cette variable remplacera les autres variables qui sont définies par un
fichier de variable global ou à partir d'un fichier d'inventaire.
Nous pouvons faire de sorte qu’Ansible demande les variables si elles n’ont pas été
saisies dans la ligne de commande. Ceci permet de rendre plus facilement
maintenable les jeux d’instructions et nous évite modifier les mêmes choses dans
2016-2017 Page 12
Projet tuteuré
plusieurs parties de la pièce. Cela nous permet également d'avoir tout le jeu stocké en
haut, où nous pouvons facilement le lire et le modifier sans se soucier de ce que le
reste du jeu fait.
Les variables dans cette section d'un jeu peuvent être remplacées par des actions de
la machine (ceux qui sont définis par modules), mais ils remplacent eux-mêmes les
faits que nous avons définis dans notre inventaire. Donc, ils sont utiles pour définir
les défauts que nous pourrions collecter dans un module plus tard, mais ils ne
peuvent pas être utilisés pour maintenir les valeurs par défaut pour les variables
d'inventaire, car elles remplaceront ces valeurs par défaut.
Les déclarations de variables, qui se produisent dans la section vars, ressemblent aux
valeurs dans la cible et contient un dictionnaire YAML ou une liste. Un exemple
ressemble au fragment de code suivant:
vars:
apache_version: 2. 6
motd_warning: ' WARNING: Use by ACME Employees ONLY'
testserver: yes
Les variables peuvent également être chargées à partir de fichiers YAML externes en
donnant à Ansible une liste de variable fichiers à charger. Cela se fait d'une manière
similaire en utilisant la directive vars_files. Ensuite nous pouvons tout simplement
fournir le nom d'un autre fichier YAML qui contient son propre dictionnaire. Ceci
veut dire qu’au lieu de stocker les variables dans le même fichier, elles peuvent être
stockées et distribuées séparément, ce qui nous permet de partager notre playbook
avec d'autres.
En utilisant vars_files, les fichiers ressemblent à l'extrait de code suivant dans notre
manuel:
vars_files:
conf/country-AU.yml
conf/datacenter-SYD.yml
conf/cluster-mysql.yml
- - -
ntp: ntp1. au. example. com
TZ: Australia/Sydney
Enfin, nous pouvons faire de sorte qu’Ansible demande à l'utilisateur pour chaque
variable interactivement. C'est utile lorsque nous avons des variables que nous ne
voulons pas rendre disponibles pour l'automatisation, exigent une contribution
2016-2017 Page 13
Projet tuteuré
humaine. Un exemple où cela est utile est lorsque vous demandez les mots de passe
utilisés pour décrypter les clés secrètes des serveurs HTTPS.
Nous pouvons demander à Ansible de demander des variables avec l'extrait de code
suivant:
vars_prompt:
- name: https_passphrase
prompt: Key Passphrase
private: yes
La section de tâche est la dernière section de chaque jeu. Il contient une liste d'actions
que nous voulons qu’Ansible effectue dans l'ordre que nous voulons qu'ils soient
effectués. Il existe plusieurs styles dans lesquels nous pouvons exprimer les
arguments de chaque module. L'extrait de code suivant est une section de tâches
ressemblant à trois styles montrés:
tasks:
- name: install apache
action: yum name=httpd state=installed
- name: configure apache
copy: src=files/httpd. conf dest=/etc/httpd/conf/httpd. conf
- name: restart apache
service:
name: httpd
state: restarted
2016-2017 Page 14
Projet tuteuré
Nous voyons ici les trois différents styles de syntaxe utilisés pour installer, configurer
et démarrer le serveur Web Apache comme il sera le cas sur une machine CentOS. La
première tâche nous montre comment installer Apache en utilisant la syntaxe
originale, ce qui nous oblige à appeler le module comme le premier dans une clé
d'action. La deuxième tâche copie le fichier de configuration d'Apache en utilisant le
deuxième style de la tâche. Dans ce style, on utilise le nom du module à l’action et sa
valeur devient simplement son argument. Enfin, la dernière tâche, le troisième style,
montre comment utiliser le module de service pour redémarrer Apache. Dans ce
style, nous utilisons le module comme la clé, mais nous fournissons les arguments en
tant que dictionnaire YAML.
Cela peut être pratique lorsque nous fournissons un grand nombre d'arguments à un
seul module, ou si le module veut les arguments sous une forme complexe. Ce
dernier style devient rapidement la manière préférée d'écrire car un nombre croissant
de modules nécessitent des arguments complexes.
Notons que les noms ne sont pas requis pour les tâches. Cependant, ils font de la
documentation et nous nous référons à chaque tâche plus tard, si nécessaire.
Les noms sont également envoyés à la console lorsque le playbook est exécuté, de
sorte que l'utilisateur peut dire ce qui se passe.
- - -
- hosts: dhcp
tasks:
- name: update to latest DHCP
yum
name: dhcp
2016-2017 Page 15
Projet tuteuré
state: latest
notify: restart dhcp
- name: copy the DHCP config
copy:
src: dhcp/dhcpd. conf
dest: /etc/dhcp/dhcpd. conf
notify: restart dhcp
- name: start DHCP at boot
service:
name: dhcpd
state: started
enabled: yes
handlers:
- name: restart dhcp
service:
name: dhcpd
state: restarted
IV-Réalisation
IV.1-Installation de Ansible
Actuellement Ansible peut être exécuté à partir de toute machine avec Python 2.6 ou
2.7 installé. Les Windows ne sont pas pris en charge pour la machine de contrôle.
Ubuntu / Debian
$ sudo apt-get install software-properties-common
$ sudo apt-ppa add-référentiel: ansible / ansible
$ sudo apt-get update
$ sudo apt-get install ansible
Une fois qu’Ansible est installé, pour s’assurer qu'il fonctionne correctement en entrant
ansible --version dans la ligne de commande on peut retrouver la version.
$ ansible –version
2016-2017 Page 16
Projet tuteuré
IV.2-Architecture
Pour cette architecture nous allons utiliser quatre machines dont nous allons installer
Ansible sur une qui sera le contrôleur et les autres seront contrôlées à distance.
IV.3-Déploiement
Déploiement I
Les rôles
Afin de mieux organiser nos tâches, on va les séparé dans des rôles afin de pouvoir
les réutiliser plus simplement.
2016-2017 Page 17
Projet tuteuré
Les dossiers tasks vont contenir les tâches, le fichier main.yml sera chargé en
premier par défaut et peut inclure d'autres fichiers de tâches via un include.
Les dossiers handlers vont contenir des tâches à effectuer lors de la réussite
d'autres tâches (comme le redémarrage de nginx par exemple).
Les dossiers defaults vont contenir les variables par défaut pour ce role. Ces
variables peuvent être modifiées dans le playbook qui chargera ce role.
2016-2017 Page 18
Projet tuteuré
[web]
192.168.1.10
Les crochets permettent de définir des groupes. On pourra ainsi appliquer la même
conf à tous les serveurs web. Un serveur peut appartenir à plusieurs groupes
Ici on précise que l'on a un groupe "web" qui contient un seul serveur. On peut
définir plusieurs groupes afin de séparer les serveurs suivant la configuration à y
effectuer (si on a des serveurs pour la base de données et des serveurs pour le
serveur web par exemple).
Création du playbook
Ensuite créons le fichier YAML que nous nommons playbook.yml qui va permettre de
décrire notre tâche :
---
- name: Installation des serveurs web
hosts: web
remote_user: root
var:
user: volibear
domains:
- domain: local.dev
php: no
- domain: demo.fr
php: yes
roles:
-utils
-user
-ngnix
...
2016-2017 Page 19
Projet tuteuré
Fichier handlers/main.yml
Fichier tasks/main.yml
2016-2017 Page 20
Projet tuteuré
Fichier tasks/php.yml
tasks/site.yml
2016-2017 Page 21
Projet tuteuré
templates/ngnix.j2
tasks/main.yml
2016-2017 Page 22
Projet tuteuré
tasks/main.yml
Lancement du déployement
ansible-playbook -i
i hosts playbook.yml
2016-2017 Page 23
Projet tuteuré
Allons vérifier maintenant que git a été bien installé sur la machine distante :
2016-2017 Page 24
Projet tuteuré
Déploiement II
Configurer Apache Utilisation Ansible sur Ubuntu
Apache est l'un des serveurs Web les plus populaires actuellement utilisés sur
Internet. Il est facile à installer et à configurer sur les distributions Linux comme
Ubuntu et Debian, comme il vient dans les dépôts de paquets et comprend une
configuration par défaut qui fonctionne hors de la boîte.
Créons un nouveau répertoire que nous allons utiliser pour cette configuration :
mkdir ansible-apache
cd ~/ansible-apache/
nano ansible.cfg
Dans ce fichier, nous voulons ajouter l’option de configuration hostfile avec la
valeur hosts, au sein du groupe [defaults]. Copions le texte suivant dans le fichier
ansible.cfg, puis enregistrons et fermons-le.
[defaults]
hostfile = hosts
Ensuite, le fichier hosts doit être éditeé. Il y a beaucoup d'options disponibles pour
le fichier hosts. Cependant, nous pouvons commencer avec quelque chose de très
simple.
nano hosts
Copions le texte suivant dans le fichier hosts.
[apache]
secondary_server_ip ansible_ssh_user=username
2016-2017 Page 25
Projet tuteuré
Ceci spécifie un groupe d'hôtes appelé apache qui contient un hôte. Nous pouvons
remplacer secondary_server_ip avec le nom d'hôte ou l'adresse IP du serveur
secondaire ou distant qu’on veut configurer, et username avec notre nom
d' utilisateur SSH. Maintenant Ansible devrait être en mesure de se connecter à notre
serveur.
Pour vérifier que Ansible fonctionne et peut communiquer à notre hôte, nous
pouvons exécuter une commande de base ansible.
Nous allons créer une version basique de playbook de la commande hello server
ci - dessus.
nano apache.yml
Copions le texte suivant dans le fichier, puis enregistrons et fermons-le.
---
- hosts: apache
tasks:
- name: run echo command
command: /bin/echo hello server
2016-2017 Page 26
Projet tuteuré
La déclaration hosts: apache en haut, qui dit à Ansible que nous utilisons
le groupe d'hôtes apache. Dans cet exemple, nous avons une tâche avec le
nom run echo command. Ceci est simplement une description destinée à
l'utilisateur de comprendre ce que la tâche est en train de faire. Enfin, la
ligne command: /bin/echo hello server exécute le module command avec
les arguments /bin/echo hello server.
ansible-playbook apache.yml
La sortie devrait ressembler à ceci.
PLAY [apache]
**************************************************************
***
GATHERING FACTS
**************************************************************
*
ok: [111.111.111.111]
PLAY RECAP
**************************************************************
******
111.111.111.111 : ok=2 changed=1
unreachable=0 failed=0
La chose la plus importante à noter ici est que playbooks ne renvoient pas la sortie
du module, donc contrairement à la commande directe, que nous avons utilisé à
l' étape 1, on ne peut pas voir si hello server a été effectivement imprimé. Cela
signifie que les playbooks sont mieux adaptés pour les tâches où vous n'avez pas
besoin de voir la sortie. Ansible nous dira s'il y avait une erreur lors de l'exécution
d'un module, de sorte que nous avons seulement besoin de cela pour savoir si
quelque chose va mal.
2016-2017 Page 27
Projet tuteuré
name : Le nom du package à installer, soit un nom de paquet unique ou une liste de
paquets.
state : Accepte soit latest, absent ou present. latest assure l’installation de
la dernière version , present vérifie simplement qu'il est installé, et absen il
supprime si elle est installée.
update_cache : Mise à jour du cache (via apt-get update) si elle est activée,
pour nous assurer qu'il est à jour.
Maintenant , nous allons mettre à jour notre Playbook apache.yml avec le module
apt au lieu du module command. Ouvrez le fichier apache.yml pour l’éditer
à nouveau.
nano apache.yml
Supprimons l’ancien texte et copions le texte suivant dan celui-ci :
---
- hosts: apache
sudo: yes
tasks:
- name: install apache2
apt: name=apache2 update_cache=yes state=latest
La ligne apt installe le package apache2 ( name=apache2) et garantit que nous
avons mis à jour le cache ( update_cache=yes).
PLAY [apache]
**************************************************************
***
GATHERING FACTS
**************************************************************
*
ok: [111.111.111.111]
2016-2017 Page 28
Projet tuteuré
PLAY RECAP
**************************************************************
******
111.111.111.111 : ok=2 changed=1
unreachable=0 failed=0
Si nous visitons le nom d'hôte de votre serveur secondaire ou l' adresse IP dans votre
navigateur, nous devrions maintenant obtenir une page par défaut Apache2
Ubuntu pour nous saluer. Cela signifie que nous avons une installation fonctionnelle
d’Apache sur notre serveur, et que nous ne somme pas connecté manuellement
avant d’exécuter une commande.
Un concept important à noter à ce stade est idempotence , qui sous - tend la façon dont
les modules ansible sont censés se comporter. L'idée est que nous pouvons exécuter
la même commande à plusieurs reprises, mais si tout a été configuré sur la première
manche, les essais ultérieurs ne feront aucun changement.
PLAY [apache]
**************************************************************
***
GATHERING FACTS
**************************************************************
*
ok: [111.111.111.111]
PLAY RECAP
**************************************************************
******
111.111.111.111 : ok=2 changed=0
unreachable=0 failed=0
Cela nous indique que le paquet apache2 a déjà été installé, donc rien n’a changé.
Faisons en sorte que le module mod_rewrite soit activé pour Apache. Via SSH,
cela peut se faire facilement en utilisant a2enmod et redémarrer
Apache. Cependant, nous pouvons aussi le faire très facilement avec Ansible
2016-2017 Page 29
Projet tuteuré
nano apache.yml
Mettons à jour le fichier pour inclure cette tâche. Le fichier devrait ressembler à ceci:
---
- hosts: apache
sudo: yes
tasks:
- name: install apache2
apt: name=apache2 update_cache=yes state=latest
---
- hosts: apache
sudo: yes
tasks:
- name: install apache2
apt: name=apache2 update_cache=yes state=latest
handlers:
- name: restart apache2
2016-2017 Page 30
Projet tuteuré
PLAY [apache]
**************************************************************
***
GATHERING FACTS
**************************************************************
*
ok: [111.111.111.111]
PLAY RECAP
**************************************************************
******
111.111.111.111 : ok=4 changed=2
unreachable=0 failed=0
Par défaut Apache écoute sur le port 80 pour tout le trafic HTTP. Nous voulons
qu’Apache écoute sur le port 8081 à la place de 80. Avec la configuration par défaut
d'Apache sur Ubuntu , il y a deux fichiers qui doivent être mis à jour:
/etc/apache2/ports.conf
Listen 80
/etc/apache2/sites-available/000-default.conf
<VirtualHost *:80>
Pour ce faire, nous pouvons utiliser le module lineinfile . Ce module est
incroyablement puissant et par l'utilisation de ses nombreuses options de
configuration différentes, il nous permet d'effectuer toutes sortes de modifications
2016-2017 Page 31
Projet tuteuré
apportées à un fichier existant sur l'hôte. Pour cet exemple, nous allons utiliser les
options suivantes:
nano apache.yml
Modifions les lignes supplémentaires afin que le fichier ressemble à ceci:
---
- hosts: apache
sudo: yes
tasks:
- name: install apache2
apt: name=apache2 update_cache=yes state=latest
handlers:
- name: restart apache2
service: name=apache2 state=restarted
Il est important de noter que nous avons également besoin de redémarrer apache2
dans le cadre de ce processus, et que nous pouvons réutiliser le même gestionnaire
2016-2017 Page 32
Projet tuteuré
, mais le hanlder ne sera déclenchée une fois que malgré les multiples tâches
modifiées.
Une fois que Ansible a terminée, nous devriez être en mesure de visiter notre hôte
dans notre navigateur et il répondra sur le port 8081, plutôt que le port 80. Dans
la plupart des navigateurs web, ceci peut être facilement obtenue en ajoutant :port
à l'extrémité de l'URL suivante : .http://111.111.111.111:8081/
Dans cette section, nous allons utiliser le module template pour configurer un
nouvel hôte virtuel sur votre serveur
<VirtualHost *:8081>
ServerAdmin webmaster@example.com
ServerName example.com
ServerAlias www.example.com
DocumentRoot /var/www/example.com
ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
Créons un nouveau fichier appelé virtualhost.conf.
nano virtualhost.conf
Collons le texte suivant dans virtualhost.conf. Parce que nous utilisons
des templates, il est une bonne idée de changer les valeurs codées dures ci - dessus
pour les variables, pour les rendre faciles à changer dans l'avenir.
2016-2017 Page 33
Projet tuteuré
La première étape consiste à ajouter dans une section le jeu pour les variables. Il
est appelé vars et va sur le même niveau que hosts, sudo, tasks
et handlers. Nous devons mettre les deux variables utilisées dans le template ci -
dessus, et nous allons changer le port vers 80 dans le processus.
---
- hosts: apache
sudo: yes
vars:
http_port: 80
domain: example.com
tasks:
- name: install apache2
...
Les variables peuvent être utilisées dans les tâches et les templates, afin que nous
puissions mettre à jour nos existants modules lineinfile à utiliser le http_port
spécifié, plutôt que 8081 nous avons précisé auparavant. La variable doit être
ajoutée dans la ligne, et l'option regexp doit être mis à jour de sorte qu'il ne cherche
pas un port spécifique. Les changements vont ressembler à ceci:
dest - Le chemin du fichier de destination pour enregistrer le template mis à jour sur
l'hôte, soit/etc/apache2/sites-available/{{ domain }}.conf.
src - Le fichier template de la source, à savoir virtualhost.conf.
En appliquant ces derniers à notre Playbook, cela se traduira par une tâche qui
ressemble à ceci:
2016-2017 Page 34
Projet tuteuré
Ceci est fait en utilisant l'option creates, qui vous permet de dire au module quel
fichier est créé lors de l'exécution du module. Si le fichier existe, le module ne
fonctionne pas
2016-2017 Page 35
Projet tuteuré
nano apache.yml
Avec tous les changements ci - dessus, changeons notre playbook apache.yml
pour ressembler à ceci.
---
- hosts: apache
sudo: yes
vars:
http_port: 80
domain: example.com
tasks:
- name: install apache2
apt: name=apache2 update_cache=yes state=latest
handlers:
- name: restart apache2
service: name=apache2 state=restarted
Enregistrons et fermons le fichier, puis exécutons le playbook.
2016-2017 Page 36
Projet tuteuré
Si nous visitez maintenant le nom d' hôte ou l' adresse IP de notre serveur
secondaire dans notre navigateur, nous verrons qu'il répond sur le port 80 à
nouveau, pas le port 8081. Ensuite, visitons le domaine que nous avons spécifié
pour le nouvel hôte virtuel. Parce que nous n'avons pas ajouté de fichiers encore, il
devrait montrer une page Apache 404 d'erreur plutôt que la page d'accueil Apache.
Ouvrons à apache.ymlnouveau.
nano apache.yml
---
- hosts: apache
sudo: yes
vars:
http_port: 80
domain: example.com
2016-2017 Page 37
Projet tuteuré
tasks:
handlers:
- name: restart apache2
service: name=apache2 state=restarted
Enregistrons le fichier et lançons le playbook.
Nous devrions maintenant voir autre chose qu'une erreur 404 lorsque nous visitons
l'hôte virtuel à partir de l'étape 6.
2016-2017 Page 38
Projet tuteuré
Conclusion
En somme, ansible est un outil puissant permettant la gestion de plusieurs
machines à distance. A travers ce document nous avons montré quelques tâches
qu’on peut effectuer avec ansible. Ce dernier nous a permis de déployer des
applications, de démarrer les services, de configurer et de déployer les serveurs web
à distance.
2016-2017 Page 39
Projet tuteuré
REFERENCE
[1] Ansible Documentation, 24 Fevrier 2017 [En ligne]. Disponible :
http://docs.ansible.com/ansible. [Consulté le 02 Février 2017].
[2] Automatiser deploiement gestion serveurs ansible, Février 2016. [En ligne]. Disponible :
https://buzut.fr/automatiser-deploiement-gestion-serveurs-ansible/ [Consulté le
02 02 Février 2017].
2016-2017 Page 40