Automatisation de la configuration VPS avec Ansible : Inventaire et premier playbook

Introduction

Ansible est un outil d'automatisation open source utilisé pour la gestion de configuration, le déploiement d'applications et la provision d'infrastructure. Il se connecte aux serveurs via SSH et ne nécessite aucune installation d'agent sur les machines distantes, ce qui le rend simple et sûr à utiliser. Les cas d'utilisation courants incluent l'automatisation de la configuration des serveurs, le maintien de configurations cohérentes et le déploiement d'applications sur plusieurs systèmes à la fois.

Dans ce tutoriel, vous configurez Ansible sur votre machine locale et l'utilisez pour automatiser la configuration de plusieurs instances VPS. Au lieu de configurer chaque serveur manuellement, vous définissez les tâches une fois et les appliquez partout. Vous créez un inventaire, écrivez votre premier playbook et déployez une pile d'applications web fonctionnelle.

Comprendre les concepts de base d'Ansible

Vous n'écrivez pas un script qui exécute des commandes une par une. Vous décrivez à quoi vos serveurs devraient ressembler après l'exécution du playbook.

Dans ce tutoriel, vous utilisez seulement quelques composants de base. Le fichier d'inventaire définit vos serveurs VPS et comment Ansible s'y connecte. Le playbook est l'endroit où vous décrivez l'état souhaité de vos serveurs. À l'intérieur du playbook, les tâches définissent les éléments individuels de cet état souhaité, tels que les paquets installés, les services en cours d'exécution ou les fichiers de configuration.

Le concept le plus important ici est la déclarativité. Au lieu d'écrire des commandes exactes comme vous le feriez dans un script shell, vous décrivez le résultat que vous souhaitez. Par exemple, vous ne dites pas à Ansible d'exécuter une commande pour installer Nginx. Vous définissez que Nginx doit être installé. Vous ne lui dites pas de démarrer un service manuellement. Vous définissez que le service doit être en cours d'exécution et activé. Ansible décide ensuite des actions nécessaires pour atteindre cet état.

Cela diffère d'une approche traditionnelle où vous exécuteriez manuellement des commandes dans un ordre spécifique. Dans de tels scripts, vous devez gérer chaque situation possible vous-même. Avec Ansible, la logique est intégrée dans les modules que vous utilisez, tels que la gestion des paquets, le contrôle des services, la gestion des fichiers et les vérifications HTTP.

Un autre concept clé est l'idempotence. Cela signifie que l'exécution du même playbook plusieurs fois ne provoque pas de changements inutiles. Si le système correspond déjà à l'état souhaité, Ansible le laisse inchangé. Par exemple, si Nginx est déjà installé, il ne le réinstallera pas. Si un fichier de configuration correspond déjà à ce que vous avez défini, il ne sera pas réécrit.

En raison de la déclarativité et de l'idempotence, vous pouvez exécuter le playbook en toute sécurité plusieurs fois. Lors de la première exécution, Ansible installe et configure tout. Lors des lancements suivants, il ne vérifie que l'état du système et le modifie si nécessaire.

Prérequis

• Public cible : Administrateurs système débutants
• Temps estimé : ~40–60 minutes
• Système d'exploitation : Debian 13 sur PC local et tous les nœuds VPS
• Nœuds VPS :
  • ans0 : 192.168.10.10
  • ans1 : 192.168.10.11
  • ans2 : 192.168.10.12
• Accès :
  • Accès SSH à toutes les instances VPS
  • Un utilisateur avec des privilèges sudo sur chaque VPS
• Réseau :
  • Port 22 ouvert pour SSH
  • Port 80 ouvert pour HTTP
• Machine locale :
  • Python 3 installé
  • Accès Internet
• Objectif final : À la fin de ce tutoriel, vous configurerez automatiquement plusieurs serveurs VPS, installerez Nginx, déploierez PocketBase et le rendrez accessible via un serveur web.

Étape 1 : Installer Ansible sur la machine locale

Ansible s'exécute sur votre machine locale et se connecte aux serveurs distants. Vous ne l'installez qu'une seule fois.

Mettez à jour les listes de paquets :

sudo apt update

Installez Ansible :

sudo apt install ansible -y

Vérifiez l'installation :

ansible --version

Résultat attendu : Vous voyez les informations de version. Cela confirme qu'Ansible est installé et prêt.

Étape 2 : Préparer l'accès SSH

Ansible utilise SSH pour se connecter aux serveurs. Pour éviter de taper des mots de passe à chaque fois, vous utilisez des clés SSH.

Générez une clé SSH :

ssh-keygen

Appuyez sur Entrée pour accepter les valeurs par défaut. Cela crée une paire de clés :

• La clé privée reste sur votre PC
• La clé publique est copiée sur les serveurs

Copiez la clé sur le VPS :

ssh-copy-id <YOUR_USERNAME>@192.168.10.10

ssh-copy-id <YOUR_USERNAME>@192.168.10.11

ssh-copy-id <YOUR_USERNAME>@192.168.10.12

Testez l'accès :

ssh <YOUR_USERNAME>@192.168.10.10

Résultat attendu : Vous vous connectez sans entrer de mot de passe.

Étape 3 : Créer un projet Ansible et un inventaire

Ansible utilise un fichier d'inventaire pour savoir quels serveurs gérer.

Créez un répertoire de projet :

mkdir ~/ansible-vps

cd ~/ansible-vps

Créez un fichier d'inventaire :

nano inventory.ini

Insérez le contenu suivant dans le fichier d'inventaire :

[vps]
ans0 ansible_host=192.168.10.10
ans1 ansible_host=192.168.10.11
ans2 ansible_host=192.168.10.12
[vps:vars]
ansible_user=<YOUR_USERNAME>
ansible_python_interpreter=/usr/bin/python3

Explication :

• [vps] est un nom de groupe
• ans0, ans1, ans2 sont des noms logiques
• ansible_host définit les adresses IP réelles
• ansible_user indique à Ansible quel utilisateur utiliser pour se connecter

Testez la connectivité :

ansible -i inventory.ini vps -m ping

Résultat attendu : Chaque serveur renvoie "pong".

Étape 4 : Créer votre premier playbook

Un playbook est un fichier où vous décrivez les tâches que vous souhaitez exécuter sur les serveurs.

Créez un fichier :

nano playbook.yml

Insérez le contenu suivant dans le fichier playbook :

- name: Configure VPS nodes
  hosts: vps
  become: true
  tasks:
    - name: Test connectivity
      ping:
    - name: Update apt cache
      apt:
        update_cache: yes
    - name: Upgrade packages
      apt:
        upgrade: dist
    - name: Install Nginx
      apt:
        name: nginx
        state: present
    - name: Ensure Nginx is running
      service:
        name: nginx
        state: started
        enabled: true
    - name: Test HTTP connectivity
      uri:
        url: http://127.0.0.1/
        return_content: no
    - name: Create directory for PocketBase
      file:
        path: /opt/pocketbase/pb_public
        state: directory
    - name: Install unzip
      apt:
        name: unzip
        state: present
    - name: Download PocketBase
      get_url:
        url: https://github.com/pocketbase/pocketbase/releases/download/v0.36.7/pocketbase_0.36.7_linux_amd64.zip
        dest: /opt/pocketbase/pocketbase.zip
    - name: Unpack PocketBase
      unarchive:
        src: /opt/pocketbase/pocketbase.zip
        dest: /opt/pocketbase/
        remote_src: yes
    - name: Create Pocketbase index.html
      copy:
        dest: /opt/pocketbase/pb_public/index.html
        content: |
          <h1>Pocketbase</h1>
    - name: Create systemd service
      copy:
        dest: /etc/systemd/system/pocketbase.service
        content: |
          [Unit]
          Description=PocketBase Service
          After=network.target
          [Service]
          Type=simple
          ExecStart=/opt/pocketbase/pocketbase serve --http=127.0.0.1:8090
          Restart=always
          [Install]
          WantedBy=multi-user.target
    - name: Reload systemd
      command: systemctl daemon-reexec
    - name: Enable and start PocketBase
      service:
        name: pocketbase
        enabled: true
        state: started
    - name: Configure Nginx site
      copy:
        dest: /etc/nginx/sites-available/pocketbase
        content: |
          server {
              listen 80;
              server_name _;
              location / {
                  proxy_pass http://127.0.0.1:8090;
                  proxy_set_header Host $host;
                  proxy_set_header X-Real-IP $remote_addr;
              }
          }
    - name: Enable Nginx site
      file:
        src: /etc/nginx/sites-available/pocketbase
        dest: /etc/nginx/sites-enabled/pocketbase
        state: link
    - name: Remove default site
      file:
        path: /etc/nginx/sites-enabled/default
        state: absent
    - name: Restart Nginx
      service:
        name: nginx
        state: restarted
    - name: Check PocketBase availability
      uri:
        url: http://127.0.0.1:8090/_/
        return_content: no

Explication :

• hosts: vps signifie tous les serveurs du groupe
• become: true exécute les tâches avec des privilèges élevés
• Chaque tâche décrit une action
• Les modules comme apt, service, file sont intégrés dans Ansible

Étape 5 : Exécuter le playbook

ansible-playbook -i inventory.ini playbook.yml

Résultat attendu : Les tâches s'exécutent sur tous les nœuds sans erreurs.

Vérification

Vérifiez le serveur web :

curl http://192.168.10.10/

Résultat attendu : Une réponse HTTP est retournée.

Ouvrez dans le navigateur : http://192.168.10.10/_/

Résultat attendu : L'interface PocketBase se charge.

Répétez pour les autres nœuds.

Annulation des modifications

sudo systemctl stop pocketbase

sudo systemctl disable pocketbase

sudo rm /etc/systemd/system/pocketbase.service

sudo rm -rf /opt/pocketbase

sudo apt remove nginx unzip -y

Rechargez systemd :

sudo systemctl daemon-reload

Dépannage

• Échec SSH : vérifiez les clés et l'utilisateur
• Échec du ping Ansible : assurez-vous de la connexion réseau entre les hôtes
• Problèmes Nginx : systemctl status nginx
• Problèmes PocketBase : journalctl -u pocketbase

Conclusion

Vous avez installé l'outil d'automatisation Ansible, créé un inventaire et écrit votre premier playbook. Vous avez automatisé le déploiement de Nginx et PocketBase sur plusieurs serveurs.

Prochaines étapes :

• Utilisez des rôles pour une meilleure structure
• Ajoutez des variables et des modèles
• Configurez HTTPS