Introduction au déploiement applicatif avec Ansible

Après avoir audité et configuré la base de nos serveurs dans l'exercice précédent, nous allons maintenant aborder un cas d'usage très courant pour Ansible : le déploiement d'applications. Dans cet exercice, nous nous concentrerons sur le déploiement d'une application web statique simple. Cela implique l'installation d'un serveur web, sa configuration minimale, et la mise en place des fichiers de notre application.

L'objectif est de vous montrer comment Ansible peut orchestrer plusieurs étapes pour aboutir à une application fonctionnelle et accessible. Vous apprendrez à utiliser des modules pour installer des logiciels, copier des fichiers du noeud de contrôle vers les noeuds gérés, et gérer l'état des services système. Cet exercice renforcera votre compréhension de la création de playbooks plus élaborés.

Nous utiliserons Nginx comme serveur web, mais les principes seraient similaires avec Apache ou tout autre serveur web. Nous allons créer une page HTML basique localement, puis écrire un playbook Ansible pour la déployer sur l'un de nos noeuds gérés.

Etape 1 : Préparer votre application web statique (fichier index.html)

Avant d'écrire notre playbook de déploiement, nous avons besoin de quelque chose à déployer. Pour une application web statique, le composant le plus simple est une page d'accueil. Nous allons créer un fichier HTML minimaliste qui servira de contenu pour notre site.

Sur votre noeud de contrôle Ansible (là où vous exécutez les commandes ansible-playbook), créez un répertoire pour cet exercice, par exemple ansible_static_deploy. A l'intérieur de ce répertoire, créez un sous-répertoire nommé files. C'est une convention souvent utilisée avec Ansible : le module copy recherche par défaut les fichiers sources dans un répertoire files relatif au playbook, mais il est plus explicite de spécifier le chemin complet.

Dans le répertoire ansible_static_deploy/files/, créez un fichier nommé index.html avec le contenu suivant :

    
    
    


    

        
Bienvenue sur mon site déployé avec Ansible !
        
L'automatisation, c'est fantastique.
        
Page servie par Nginx.
    

Ce fichier HTML simple sera la page d'accueil de notre site web. Vous pouvez bien sûr le personnaliser si vous le souhaitez. L'important est d'avoir un fichier à copier sur le serveur web.

Etape 2 : Ecrire le Playbook de déploiement

Maintenant que notre contenu est prêt, nous pouvons écrire le playbook Ansible. Créez un fichier nommé deploy_static_website.yml dans le répertoire ansible_static_deploy (au même niveau que le répertoire files). Ce playbook effectuera les actions suivantes sur un noeud géré (nous choisirons un seul serveur de notre inventaire pour cet exercice, par exemple node1) :

1. Installer le serveur web Nginx.
2. S'assurer que le service Nginx est démarré et activé pour se lancer au démarrage du système.
3. Copier notre fichier index.html dans le répertoire racine web par défaut de Nginx.

Voici le contenu du playbook deploy_static_website.yml :

---
- name: Déployer un site web statique simple avec Nginx
  hosts: node1  # Cible un hôte spécifique de votre inventaire
  become: true  # La plupart des actions nécessitent des privilèges root

  tasks:
    - name: Installer Nginx
      ansible.builtin.package:
        name: nginx
        state: present
        update_cache: yes # S'assure que le cache est à jour avant l'installation (surtout pour apt)
      when: ansible_os_family == "Debian" or ansible_os_family == "Ubuntu" # Adapter si autre OS
      # Pour RedHat/CentOS, utiliser ansible.builtin.yum ou dnf et ajuster update_cache si besoin

    # Tâche alternative pour RedHat/CentOS (à décommenter et adapter si besoin)
    # - name: Installer Nginx (pour RedHat/CentOS)
    #   ansible.builtin.yum: # ou dnf
    #     name: nginx
    #     state: present
    #   when: ansible_os_family == "RedHat"

    - name: S'assurer que Nginx est démarré et activé
      ansible.builtin.service:
        name: nginx
        state: started
        enabled: yes

    - name: Copier le fichier index.html vers la racine web de Nginx
      ansible.builtin.copy:
        src: files/index.html  # Chemin relatif au playbook
        dest: /var/www/html/index.html # Chemin de destination standard pour Nginx
        owner: www-data # Utilisateur propriétaire typique pour Nginx sur Debian/Ubuntu
        group: www-data # Groupe propriétaire typique
        mode: '0644'      # Permissions du fichier
      notify:
        - Restart Nginx # Nom du handler à notifier

  handlers:
    - name: Restart Nginx
      ansible.builtin.service:
        name: nginx
        state: restarted

Analysons les points clés de ce playbook :

• hosts: node1 : Nous ciblons un seul hôte pour ce déploiement. Remplacez node1 par le nom d'un serveur de votre inventaire (par exemple, srv-web-01).
• Installation de Nginx : Utilise le module package (ou yum/dnf/apt spécifiquement). La condition when permet d'adapter à la famille d'OS.
• Gestion du service Nginx : Le module service assure que Nginx est started (démarré) et enabled (s'active au boot).
• Copie du fichier index.html :
  • Le module copy est utilisé.
  • src: files/index.html : Ansible cherchera ce fichier dans un sous-répertoire files par rapport à l'emplacement du playbook, ou si vous spécifiez un chemin absolu, il le prendra. Ici, nous avons placé index.html dans ansible_static_deploy/files/index.html, donc le chemin relatif files/index.html fonctionnera si le playbook est dans ansible_static_deploy.
  • dest: /var/www/html/index.html : C'est le chemin par défaut où Nginx sert les fichiers sur de nombreuses distributions (Debian/Ubuntu). Sur CentOS/RHEL, ce pourrait être /usr/share/nginx/html/index.html. Adaptez si nécessaire.
  • owner, group, mode : Définissent les permissions et la propriété du fichier copié. www-data est l'utilisateur/groupe sous lequel Nginx tourne souvent sur Debian/Ubuntu. Sur CentOS/RHEL, c'est souvent nginx.
• Handlers :
  • notify: Restart Nginx : Si la tâche de copie du fichier index.html entraîne un changement (c'est-à-dire que le fichier est copié ou mis à jour), Ansible notifiera un "handler" nommé "Restart Nginx".
  • La section handlers: définit ce que fait ce handler. Ici, il redémarre le service Nginx. Les handlers ne sont exécutés qu'une seule fois à la fin du jeu, même s'ils sont notifiés par plusieurs tâches. C'est utile pour éviter des redémarrages de service multiples.

Adaptez les chemins (dest pour copy) et les utilisateurs/groupes (owner, group) en fonction de la configuration Nginx de votre noeud géré et de sa distribution.

Etape 3 : Exécuter le Playbook et vérifier le déploiement

Avant d'exécuter, assurez-vous que votre fichier d'inventaire (par exemple my_inventory.ini) est correct et que le noeud cible (node1 ou celui que vous avez choisi) y est bien défini et accessible.

Depuis le répertoire ansible_static_deploy, exécutez le playbook :

ansible-playbook -i ../my_inventory.ini deploy_static_website.yml

(Adaptez ../my_inventory.ini si votre inventaire est ailleurs par rapport à votre répertoire de travail actuel).

Ansible va maintenant exécuter les tâches : installer Nginx (s'il n'est pas déjà là), démarrer et activer le service, puis copier le fichier index.html. Si le fichier index.html est copié ou modifié, le handler pour redémarrer Nginx sera exécuté à la fin.

Une fois le playbook terminé avec succès, la dernière étape est de vérifier que votre site web est accessible. Ouvrez un navigateur web sur votre machine (ou utilisez curl en ligne de commande) et accédez à l'adresse IP de votre noeud géré (par exemple, http://10.0.0.5 si c'est l'IP de node1). Vous devriez voir la page HTML que nous avons créée : "Bienvenue sur mon site déployé avec Ansible !".

# Depuis une machine ayant accès au noeud géré
curl http://

Félicitations ! Vous avez déployé une application web statique simple en utilisant Ansible. Cet exercice illustre un flux de travail de déploiement basique mais complet, de l'installation des dépendances à la mise en place du contenu applicatif et à la gestion des services. Vous pouvez maintenant imaginer comment étendre ce playbook pour des déploiements plus complexes, par exemple en utilisant des templates pour les fichiers de configuration Nginx, ou en déployant des applications dynamiques.