Ansible Avancé : Vault, inventaires dynamiques et production

# Créer un nouveau fichier chiffré
ansible-vault create vars/secrets.yml

# Modifier un fichier chiffré existant
ansible-vault edit vars/secrets.yml

# Chiffrer un fichier existant en clair
ansible-vault encrypt vars/secrets.yml

# Déchiffrer un fichier (attention : le résultat sera en clair)
ansible-vault decrypt vars/secrets.yml

# Voir le contenu sans le déchiffrer définitivement
ansible-vault view vars/secrets.yml

# Changer le mot de passe du vault
ansible-vault rekey vars/secrets.yml

ansible-vault encrypt_string 'MonMotDePasse123' --name 'db_password'

db_password: !vault |
  $ANSIBLE_VAULT;1.1;AES256
  61616265353733623264343264333063...
  (suite du chiffrement)

---
- name: Déployer la base de données
  hosts: databases
  become: true
  vars_files:
    - vars/all.yml
    - vars/secrets.yml    # Fichier chiffré avec Vault

  tasks:
    - name: Créer l'utilisateur PostgreSQL
      community.postgresql.postgresql_user:
        name: "{{ db_user }}"
        password: "{{ db_password }}"    # Vient du fichier chiffré
        state: present

# Lancer le playbook en fournissant le mot de passe vault
ansible-playbook playbook.yml --ask-vault-pass

# Ou via un fichier contenant le mot de passe (à ne pas versionner !)
ansible-playbook playbook.yml --vault-password-file ~/.vault_pass

# Créer le fichier (ne jamais le committer dans Git !)
echo "MonMotDePasseVault" > ~/.vault_pass
chmod 600 ~/.vault_pass

# Ajouter dans .gitignore
echo ".vault_pass" >> .gitignore

# Installer la collection AWS
ansible-galaxy collection install amazon.aws
pip install boto3

# inventaire_aws.yml
plugin: amazon.aws.aws_ec2
regions:
  - eu-west-1
filters:
  instance-state-name: running
  "tag:Environment": production
keyed_groups:
  - key: tags.Role        # Créer des groupes basés sur le tag "Role"
    prefix: role
hostnames:
  - private-ip-address

# Tester l'inventaire dynamique
ansible-inventory -i inventaire_aws.yml --list

# Lancer un playbook avec cet inventaire
ansible-playbook -i inventaire_aws.yml playbook.yml

#!/usr/bin/env python3
# inventaire.py
import json
import subprocess

def get_docker_containers():
    # Récupère les conteneurs Docker en cours d'exécution
    result = subprocess.run(
        ['docker', 'ps', '--format', '{{.Names}}\t{{.ID}}'],
        capture_output=True, text=True
    )
    hosts = {}
    for line in result.stdout.strip().split('\n'):
        if line:
            name, container_id = line.split('\t')
            hosts[name] = {'ansible_connection': 'docker'}
    return hosts

inventory = {
    'docker_containers': {
        'hosts': list(get_docker_containers().keys())
    },
    '_meta': {
        'hostvars': get_docker_containers()
    }
}

print(json.dumps(inventory))

chmod +x inventaire.py
ansible-playbook -i inventaire.py playbook.yml

tasks:
  - name: Installer les paquets sur Debian/Ubuntu
    ansible.builtin.apt:
      name: nginx
      state: present
    when: ansible_os_family == "Debian"

  - name: Installer les paquets sur Red Hat/CentOS
    ansible.builtin.dnf:
      name: nginx
      state: present
    when: ansible_os_family == "RedHat"

  - name: Tâche uniquement en production
    ansible.builtin.debug:
      msg: "Déploiement en production !"
    when:
      - env == "production"
      - ansible_hostname.startswith("prod-")

  - name: Passer si déjà fait
    ansible.builtin.command: /opt/init.sh
    when: not init_done.stat.exists

- name: Créer plusieurs utilisateurs
  ansible.builtin.user:
    name: "{{ item.name }}"
    groups: "{{ item.groups }}"
    state: present
  loop:
    - { name: alice, groups: sudo }
    - { name: bob, groups: www-data }
    - { name: charlie, groups: docker }

- name: Installer une liste de paquets
  ansible.builtin.apt:
    name: "{{ item }}"
    state: present
  loop:
    - git
    - curl
    - htop
    - vim

- name: Déployer plusieurs fichiers de configuration
  ansible.builtin.template:
    src: "{{ item.src }}"
    dest: "{{ item.dest }}"
  loop:
    - { src: nginx.conf.j2, dest: /etc/nginx/nginx.conf }
    - { src: app.conf.j2, dest: /etc/nginx/sites-available/app }

- name: Créer des répertoires avec un label clair
  ansible.builtin.file:
    path: "{{ item }}"
    state: directory
  loop:
    - /var/www/app1
    - /var/www/app2
    - /var/log/app1
  loop_control:
    label: "Répertoire : {{ item }}"    # Personnalise l'affichage dans les logs

- name: Vérifier si le fichier existe
  ansible.builtin.stat:
    path: /etc/app/config.yml
  register: config_file            # Stocker le résultat dans une variable

- name: Créer la config si elle n'existe pas
  ansible.builtin.copy:
    src: files/config.yml
    dest: /etc/app/config.yml
  when: not config_file.stat.exists  # Utiliser le résultat

- name: Afficher la version déployée
  ansible.builtin.command: cat /etc/app/version
  register: app_version
  changed_when: false              # Cette commande ne "change" rien

- name: Afficher la version
  ansible.builtin.debug:
    msg: "Version actuelle : {{ app_version.stdout }}"

---
- name: Déployer l'application
  hosts: webservers
  become: true

  tasks:
    - name: Installer les dépendances système
      ansible.builtin.apt:
        name: "{{ item }}"
        state: present
      loop: "{{ system_packages }}"
      tags:
        - install
        - setup

    - name: Déployer le code applicatif
      ansible.builtin.git:
        repo: "{{ app_repo }}"
        dest: "{{ app_dir }}"
        version: "{{ app_version }}"
      tags:
        - deploy
        - code

    - name: Recharger la configuration
      ansible.builtin.service:
        name: nginx
        state: reloaded
      tags:
        - reload
        - deploy

# Exécuter uniquement les tâches taguées "deploy"
ansible-playbook playbook.yml --tags deploy

# Exécuter tout SAUF les tâches taguées "install"
ansible-playbook playbook.yml --skip-tags install

# Lister tous les tags disponibles
ansible-playbook playbook.yml --list-tags

# En ligne de commande
ansible-playbook playbook.yml -f 20

# Dans ansible.cfg
[defaults]
forks = 20

[defaults]
inventory     = inventaire.ini
remote_user   = ubuntu
private_key_file = ~/.ssh/id_ed25519
forks         = 10
host_key_checking = False    # Utile en dev, à activer en prod
vault_password_file = ~/.vault_pass
retry_files_enabled = False

[privilege_escalation]
become        = True
become_method = sudo

- name: Enregistrer l'hôte dans le load balancer
  ansible.builtin.uri:
    url: "http://lb.example.com/api/add"
    method: POST
    body_format: json
    body:
      host: "{{ ansible_hostname }}"
  delegate_to: localhost    # Cette tâche s'exécute sur ton control node

- name: Générer un rapport en local
  ansible.builtin.template:
    src: rapport.j2
    dest: /tmp/rapport_{{ inventory_hostname }}.txt
  delegate_to: localhost

# 1. Toujours nommer tes tâches
- name: Installer Nginx version {{ nginx_version }}    # ✅
  ansible.builtin.apt:
    name: "nginx={{ nginx_version }}"

# 2. Utiliser changed_when pour les commandes
- name: Vérifier la configuration Nginx
  ansible.builtin.command: nginx -t
  changed_when: false    # Cette commande ne modifie rien

# 3. Utiliser failed_when pour contrôler les erreurs
- name: Vérifier si le service existe
  ansible.builtin.command: systemctl status monservice
  register: service_status
  failed_when: service_status.rc > 1   # rc=0 OK, rc=1 inactif (acceptable)

# 4. Préférer les modules aux commandes shell
- name: Créer un utilisateur          # ✅ Idempotent
  ansible.builtin.user:
    name: deploy
    state: present

- name: Créer un utilisateur          # ❌ Pas idempotent
  ansible.builtin.command: useradd deploy

# Installation
pip install molecule molecule-docker

# Initialiser les tests pour un rôle
cd roles/nginx
molecule init scenario

# Lancer les tests
molecule test

# Tester uniquement le lint
molecule lint

# Converger (appliquer le rôle) sans détruire
molecule converge

# molecule/default/converge.yml
---
- name: Converge
  hosts: all
  tasks:
    - name: Inclure le rôle nginx
      ansible.builtin.include_role:
        name: nginx
      vars:
        nginx_port: 80

- name: Créer l'utilisateur avec son mot de passe
  ansible.builtin.user:
    name: deploy
    password: "{{ user_password | password_hash('sha512') }}"
  no_log: true    # Masque les paramètres dans les logs