TP Ansible débutant : déployer une stack complète en un seul playbook

Objectif

Combiner tout ce qui a été appris depuis le début de la formation dans un seul playbook d’orchestration : provisionner les comptes, déployer Apache, déployer MariaDB, avec secrets vaultés, rôles et tags — le tout en une seule exécution ciblant les bons groupes.

Environnement disponible

Vous disposez de :

1 serveur de contrôle avec Ansible installé
2 clients Debian
- nrd-web1
- nrd-db1

Informations de connexion

Utilisateur : root
Mot de passe : formation

⚠️ Les conteneurs de ce lab repartent de zéro à chaque session. Les premières étapes ci-dessous refont donc systématiquement tout le bootstrap.

Ce que vous allez réaliser

Installer Ansible
Générer une clé SSH et la déployer sur les deux clients
Localiser les IP et créer l’inventaire avec les groupes webservers et databases
Créer le rôle apache (repris du TP 6)
Créer le rôle mariadb, avec ses secrets vaultés (repris du TP 8)
Créer le rôle utilisateurs, avec un compte admin commun aux deux machines
Écrire le playbook d’orchestration final, avec tags et vérification de connectivité initiale
Exécuter le tout, puis rejouer pour confirmer l’idempotence globale

Conseils

Réutilisez directement les rôles et fichiers déjà écrits dans les TP précédents plutôt que de tout retaper — c’est exactement l’intérêt d’avoir structuré ce travail en rôles depuis la section 6.
Le rôle utilisateurs cible all (les deux groupes), contrairement à apache et mariadb qui ciblent chacun un seul groupe.
Pensez à ansible.cfg pour ne pas avoir à retaper le mot de passe Vault à chaque exécution.

🧪 Lab · membre · 30 min

🧪 Lancer le lab

Voir la solutionMasquer la solution

Générer une clé SSH et la déployer sur les deux clients

ssh-keygen -t ed25519 -C "ansible@control-serveur" -f ~/.ssh/id_ed25519 -N ""

ssh root@nrd-web1
nano .ssh/authorized_keys
# Coller la clé publique

ssh root@nrd-db1
nano .ssh/authorized_keys
# Coller la même clé publique

Localiser les IP et créer l’inventaire

ping nrd-web1
ping nrd-db1

mkdir -p ansible/roles && cd ansible
nano inventaire.yaml

# inventaire.yaml
all:
  hosts:
    nrd-web1:
      ansible_host: <IP>
    nrd-db1:
      ansible_host: <IP>
  children:
    webservers:
      hosts:
        nrd-web1:
    databases:
      hosts:
        nrd-db1:

ansible all -i inventaire.yaml -m ping

Créer le rôle apache

cd roles && ansible-galaxy init apache && cd ..

# roles/apache/tasks/main.yml
---
- name: Installer Apache
  ansible.builtin.apt:
    name: apache2
    state: present
    update_cache: yes
  tags: install

- name: Déployer le VirtualHost depuis le template
  ansible.builtin.template:
    src: nordika.conf.j2
    dest: /etc/apache2/sites-available/nordika.conf
  notify: Redémarrer Apache
  tags: config

- name: Activer le site
  ansible.builtin.command: a2ensite nordika.conf
  args:
    creates: /etc/apache2/sites-enabled/nordika.conf
  notify: Redémarrer Apache
  tags: config

# roles/apache/handlers/main.yml
---
- name: Redémarrer Apache
  ansible.builtin.service:
    name: apache2
    state: restarted

# roles/apache/templates/nordika.conf.j2
<VirtualHost *:80>
    ServerName nordika.local
    DocumentRoot /var/www/html
</VirtualHost>

Créer le rôle mariadb

cd roles && ansible-galaxy init mariadb && cd ..

# roles/mariadb/tasks/main.yml
---
- name: Installer MariaDB
  ansible.builtin.apt:
    name:
      - mariadb-server
      - python3-pymysql
    state: present
    update_cache: yes
  tags: install

- name: Démarrer MariaDB
  ansible.builtin.service:
    name: mariadb
    state: started
    enabled: yes
  tags: install

- name: Définir le mot de passe root
  community.mysql.mysql_user:
    name: root
    host: localhost
    password: "{{ mysql_root_password }}"
    login_unix_socket: /run/mysqld/mysqld.sock
    check_implicit_admin: true
    priv: "*.*:ALL,GRANT"
  tags: config

- name: Créer la base applicative
  community.mysql.mysql_db:
    name: "{{ app_db }}"
    state: present
    login_user: root
    login_password: "{{ mysql_root_password }}"
  tags: config

- name: Créer l'utilisateur applicatif
  community.mysql.mysql_user:
    name: "{{ app_user }}"
    password: "{{ app_password }}"
    priv: "{{ app_db }}.*:ALL"
    host: "%"
    state: present
    login_user: root
    login_password: "{{ mysql_root_password }}"
  tags: config

Créer le rôle utilisateurs

cd roles && ansible-galaxy init utilisateurs && cd ..

# roles/utilisateurs/tasks/main.yml
---
- name: Créer le groupe admin
  ansible.builtin.group:
    name: admin
    state: present
  tags: users

- name: Créer le compte administrateur
  ansible.builtin.user:
    name: admin_nordika
    groups: admin
    append: yes
    create_home: yes
    state: present
  tags: users

- name: Déployer la clé publique de l'administrateur
  ansible.posix.authorized_key:
    user: admin_nordika
    state: present
    key: "{{ lookup('file', '~/.ssh/id_ed25519.pub') }}"
  tags: users

Configurer le Vault pour les secrets MariaDB

echo "MonMotDePasseVault123" > .vault_pass.txt
chmod 600 .vault_pass.txt

nano ansible.cfg

# ansible.cfg
[defaults]
vault_password_file = .vault_pass.txt

ansible-vault encrypt_string 'SuperRoot123!' --name 'mysql_root_password' --vault-password-file .vault_pass.txt
ansible-vault encrypt_string 'AppPass123!' --name 'app_password' --vault-password-file .vault_pass.txt

mkdir group_vars
nano group_vars/databases.yml

# group_vars/databases.yml
app_db: appdb
app_user: appuser
mysql_root_password: !vault |
          $ANSIBLE_VAULT;1.1;AES256
          <collez le bloc généré>
app_password: !vault |
          $ANSIBLE_VAULT;1.1;AES256
          <collez le bloc généré>

Écrire le playbook d’orchestration final

nano playbook_nordika_complet.yaml

# playbook_nordika_complet.yaml
---
- name: Vérifier la connectivité avant tout déploiement
  hosts: webservers:databases
  gather_facts: yes
  tasks:
    - name: Ping de toute la flotte concernée
      ansible.builtin.ping:
      tags: always

- name: Provisionner les comptes administrateurs
  hosts: webservers:databases
  become: yes
  roles:
    - role: utilisateurs
      tags: users

- name: Déployer la partie web
  hosts: webservers
  become: yes
  roles:
    - role: apache
      tags: apache

- name: Déployer la partie base de données
  hosts: databases
  become: yes
  roles:
    - role: mariadb
      tags: mariadb

Exécuter le tout

ansible-playbook playbook_nordika_complet.yaml -i inventaire.yaml -v

Vous devriez voir les quatre plays s’enchaîner : vérification de connectivité, comptes utilisateurs sur les deux machines, Apache sur nrd-web1 uniquement, MariaDB sur nrd-db1 uniquement.

Rejouer pour confirmer l’idempotence globale

ansible-playbook playbook_nordika_complet.yaml -i inventaire.yaml -v

changed=0 sur l’ensemble des tâches, sur les deux hôtes : toute la stack Nordika est déjà dans l’état voulu.

Tester un rejeu ciblé avec les tags

ansible-playbook playbook_nordika_complet.yaml -i inventaire.yaml --tags "apache,config"

Seule la partie configuration Apache est rejouée — les comptes utilisateurs et MariaDB ne sont même pas évalués.