Maîtriser
Docker & Ansible

# 1. Supprimer les anciens packages
sudo apt remove docker docker-engine docker.io containerd runc

# 2. Installer les dépendances
sudo apt update
sudo apt install ca-certificates curl gnupg

# 3. Ajouter la clé GPG officielle Docker
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 4. Ajouter le dépôt Docker
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 5. Installer Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 6. Vérifier l'installation
docker --version
# → Docker version 26.x.x

# Lancer le conteneur de test officiel Docker
docker run hello-world

# Si tu vois "Hello from Docker!" → tout fonctionne !

# Vérifier la version
docker version

# Infos système
docker info

# Ajouter l'utilisateur courant au groupe docker
sudo usermod -aG docker $USER

# Déconnecter/reconnecter pour appliquer, puis tester sans sudo :
docker ps

=== LANCER ===
docker run nginx                         # Lance et s'attache (foreground)
docker run -d nginx                      # Lance en arrière-plan (detached)
docker run -it ubuntu bash               # Mode interactif (-i) avec terminal (-t)
docker run --name mon-app -d nginx       # Avec un nom personnalisé
docker run -p 8080:80 -d nginx           # Avec mapping de port
docker run -e MA_VAR=valeur -d nginx     # Avec variable d'environnement

=== VOIR ===
docker ps                                # Conteneurs en cours d'exécution
docker ps -a                             # Tous les conteneurs (même arrêtés)
docker logs mon-app                      # Voir les logs
docker logs -f mon-app                   # Logs en temps réel (follow)
docker inspect mon-app                   # Infos détaillées (JSON)
docker stats                             # Utilisation CPU/RAM en temps réel

=== INTERAGIR ===
docker exec -it mon-app bash             # Ouvrir un shell dans un conteneur actif
docker exec mon-app ls /app              # Lancer une commande sans entrer
docker cp fichier.txt mon-app:/tmp/      # Copier un fichier dans le conteneur

=== GÉRER ===
docker stop mon-app                      # Arrêt propre (SIGTERM)
docker kill mon-app                      # Arrêt forcé (SIGKILL)
docker restart mon-app                   # Redémarrer
docker rm mon-app                        # Supprimer (doit être arrêté)
docker rm -f mon-app                     # Supprimer de force
docker system prune                      # Nettoyer tout ce qui n'est pas utilisé

# 1. Image de base (depuis Docker Hub)
FROM node:20-alpine

# 2. Métadonnées (optionnel mais bonne pratique)
LABEL maintainer="toi@exemple.com"

# 3. Répertoire de travail dans le conteneur
WORKDIR /app

# 4. Copier les fichiers de dépendances en premier (optimisation cache)
COPY package*.json ./

# 5. Installer les dépendances
RUN npm install

# 6. Copier le reste du code source
COPY . .

# 7. Exposer le port (documentation)
EXPOSE 3000

# 8. Variable d'environnement
ENV NODE_ENV=production

# 9. Commande de démarrage
CMD ["node", "server.js"]

# Construire l'image depuis le répertoire courant (.)
docker build -t mon-app:1.0 .

# -t = tag (nom:version)
# . = contexte de build (répertoire courant)

# Lancer le conteneur
docker run -d -p 3000:3000 mon-app:1.0

# Voir les images disponibles
docker images

# Pousser sur Docker Hub
docker tag mon-app:1.0 tonusername/mon-app:1.0
docker push tonusername/mon-app:1.0

# Étape 1 : Builder (image lourde avec les outils)
FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN go build -o main .

# Étape 2 : Image finale (ultra-légère)
FROM alpine:3.18
WORKDIR /app
COPY --from=builder /app/main .  # Copie uniquement le binaire compilé
CMD ["./main"]

# Résultat : image finale ~10 Mo au lieu de ~900 Mo !

# Créer un volume nommé
docker volume create mes-donnees

# Lancer MySQL avec un volume persistant
docker run -d \
  --name ma-bdd \
  -e MYSQL_ROOT_PASSWORD=secret \
  -e MYSQL_DATABASE=mabase \
  -v mes-donnees:/var/lib/mysql \
  mysql:8

# Même si tu fais "docker rm -f ma-bdd"...
# ...les données dans "mes-donnees" survivent !

# Lister les volumes
docker volume ls

# Inspecter un volume
docker volume inspect mes-donnees

# Supprimer un volume
docker volume rm mes-donnees

# Volume en lecture seule
docker run -v mon-config:/etc/config:ro mon-app

# Monter ton code source dans le conteneur
# Toute modification de fichier est immédiatement visible dans le conteneur
docker run -d \
  -p 3000:3000 \
  -v $(pwd):/app \               # $(pwd) = répertoire courant
  -v /app/node_modules \         # Exclure node_modules (trick !)
  mon-app:dev

# Maintenant, édite tes fichiers localement
# → le conteneur voit les changements en temps réel

# Créer un réseau bridge personnalisé
docker network create mon-reseau

# Lancer une base de données dans ce réseau
docker run -d \
  --name ma-bdd \
  --network mon-reseau \
  -e POSTGRES_PASSWORD=secret \
  postgres:15

# Lancer une app qui doit parler à la BDD
docker run -d \
  --name mon-app \
  --network mon-reseau \
  -e DATABASE_URL=postgres://postgres:secret@ma-bdd:5432/db \
  mon-app:1.0

# ✅ mon-app peut accéder à ma-bdd en utilisant son nom "ma-bdd"
# Docker DNS résout automatiquement les noms des conteneurs

# Voir les réseaux
docker network ls

# Inspecter un réseau
docker network inspect mon-reseau

# Connecter un conteneur existant à un réseau
docker network connect mon-reseau autre-conteneur

version: '3.9'

services:

  # Service 1 : Notre application web
  webapp:
    build: .                   # Build depuis le Dockerfile local
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mabase
      - REDIS_URL=redis://redis:6379
    depends_on:           # Attend que db et redis soient prêts
      - db
      - redis
    volumes:
      - ./:/app             # Bind mount pour le dev
    restart: unless-stopped

  # Service 2 : Base de données PostgreSQL
  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mabase
    volumes:
      - postgres-data:/var/lib/postgresql/data
    ports:
      - "5432:5432"          # Exposer pour debug local

  # Service 3 : Cache Redis
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres-data:          # Volume nommé géré par Docker

# Démarrer tous les services (build si nécessaire)
docker compose up

# Démarrer en arrière-plan
docker compose up -d

# Rebuild les images et démarrer
docker compose up --build

# Voir l'état des services
docker compose ps

# Voir les logs de tous les services
docker compose logs

# Logs d'un service en particulier, en temps réel
docker compose logs -f webapp

# Entrer dans un conteneur d'un service
docker compose exec webapp bash

# Lancer une commande dans un service
docker compose exec db psql -U user -d mabase

# Arrêter les services (sans supprimer les volumes)
docker compose stop

# Arrêter ET supprimer conteneurs + réseau
docker compose down

# Arrêter + supprimer volumes (⚠️ perte de données !)
docker compose down -v

# Scaler un service (ex: 3 instances de webapp)
docker compose up --scale webapp=3

# Sur Ubuntu/Debian
sudo apt update
sudo apt install python3-pip
pip3 install ansible

# Vérifier la version
ansible --version
# → ansible [core 2.18.x]

# Premier test : ping sur ta propre machine
ansible localhost -m ping
# → localhost | SUCCESS => { "ping": "pong" }

# Hôtes standalone
192.168.1.10
mon-serveur.exemple.com

# Groupe "webservers"
[webservers]
web1.exemple.com
web2.exemple.com  ansible_port=2222   # Port SSH custom
web3              ansible_host=192.168.1.20

# Groupe "databases"
[databases]
db1.exemple.com
db2.exemple.com

# Groupe contenant d'autres groupes
[production:children]
webservers
databases

# Variables pour un groupe
[webservers:vars]
ansible_user=ubuntu
ansible_ssh_private_key_file=~/.ssh/ma-cle

all:
  children:
    webservers:
      hosts:
        web1:
          ansible_host: 192.168.1.10
          ansible_user: ubuntu
        web2:
          ansible_host: 192.168.1.11
          ansible_user: ubuntu
      vars:
        http_port: 80
        max_clients: 200
    databases:
      hosts:
        db1:
          ansible_host: 192.168.1.20
          ansible_user: admin

# Lister tous les hôtes de l'inventaire
ansible all -i inventaire/hosts --list-hosts

# Lister uniquement le groupe webservers
ansible webservers -i inventaire/hosts --list-hosts

# Ping tous les serveurs
ansible all -i inventaire/hosts -m ping

# Commande ad-hoc : voir l'uptime de tous les webservers
ansible webservers -i inventaire/hosts -m command -a "uptime"

# Commande shell (avec pipes, redirections...)
ansible all -i inventaire/hosts -m shell -a "df -h | grep /dev/sda"

---
# Un playbook = liste de "plays"

- name: Configurer les serveurs web     # Nom du play
  hosts: webservers                     # Sur quel groupe agir
  become: true                          # Devenir root (sudo)
  vars:                                 # Variables locales
    nginx_port: 80
    app_name: monapp

  tasks:                               # Liste des tâches

    - name: Mettre à jour les packages
      apt:
        update_cache: true
        upgrade: dist

    - name: Installer Nginx
      apt:
        name: nginx
        state: present         # present = installé, absent = désinstallé

    - name: Copier la config Nginx
      copy:
        src: files/nginx.conf
        dest: /etc/nginx/nginx.conf
        owner: root
        group: root
        mode: '0644'
      notify: Redémarrer Nginx   # Déclenche le handler si modifié

    - name: Démarrer et activer Nginx
      service:
        name: nginx
        state: started
        enabled: true           # Démarrer au boot

    - name: Créer un utilisateur app
      user:
        name: "{{ app_name }}"    # Utiliser une variable
        shell: /bin/bash
        create_home: true

    - name: Tâche conditionnelle
      debug:
        msg: "Nous sommes sur Ubuntu"
      when: ansible_distribution == "Ubuntu"

  handlers:                           # Tâches déclenchées par notify
    - name: Redémarrer Nginx
      service:
        name: nginx
        state: restarted

# Lancer le playbook
ansible-playbook -i inventaire/hosts playbook.yml

# Mode dry-run (voir ce qui serait fait sans rien changer)
ansible-playbook -i hosts playbook.yml --check

# Mode verbose (voir le détail des actions)
ansible-playbook -i hosts playbook.yml -v
ansible-playbook -i hosts playbook.yml -vvv    # Très verbeux

# Cibler un sous-ensemble
ansible-playbook -i hosts playbook.yml --limit web1

# Demander le mot de passe sudo
ansible-playbook -i hosts playbook.yml --ask-become-pass

# Démarrer depuis une tâche précise
ansible-playbook -i hosts playbook.yml --start-at-task "Installer Nginx"

=== CRÉER / CHIFFRER ===
# Créer un fichier de secrets chiffré
ansible-vault create secrets.yml
# → Demande un mot de passe maître, ouvre un éditeur

# Chiffrer un fichier existant
ansible-vault encrypt vars/passwords.yml

# Chiffrer une seule valeur (inline)
ansible-vault encrypt_string 'mon-super-mdp' --name 'db_password'
# → Génère une valeur chiffrée à coller dans ton YAML

=== VOIR / MODIFIER ===
# Voir le contenu chiffré
ansible-vault view secrets.yml

# Éditer le contenu
ansible-vault edit secrets.yml

# Déchiffrer (attention !)
ansible-vault decrypt secrets.yml

=== UTILISER DANS UN PLAYBOOK ===
# Lancer un playbook avec les secrets
ansible-playbook -i hosts playbook.yml --ask-vault-pass

# Ou avec un fichier mot de passe (pratique en CI/CD)
echo "mon-mot-de-passe" > .vault_pass
chmod 600 .vault_pass
ansible-playbook -i hosts playbook.yml --vault-password-file .vault_pass

# Ce fichier sera chiffré par ansible-vault
db_password: MonMotDePasse123!
api_key: sk-abc123def456
jwt_secret: supersecretkey

---
- name: Déployer l'application
  hosts: all
  vars_files:
    - vars/secrets.yml      # Fichier chiffré — déchiffré automatiquement

  tasks:
    - name: Configurer la BDD
      template:
        src: templates/db.conf.j2
        dest: /etc/app/db.conf
      # Dans le template : {{ db_password }}

# Installer la collection Ansible pour Docker
ansible-galaxy collection install community.docker

# Vérifier l'installation
ansible-galaxy collection list | grep docker

---
- name: Installer Docker sur les serveurs
  hosts: all
  become: true

  tasks:
    - name: Installer les dépendances
      apt:
        name: [ca-certificates, curl, gnupg]
        state: present
        update_cache: true

    - name: Ajouter la clé GPG Docker
      apt_key:
        url: https://download.docker.com/linux/ubuntu/gpg
        state: present

    - name: Ajouter le dépôt Docker
      apt_repository:
        repo: "deb https://download.docker.com/linux/ubuntu {{ ansible_lsb.codename }} stable"
        state: present

    - name: Installer Docker
      apt:
        name: [docker-ce, docker-ce-cli, containerd.io, docker-compose-plugin]
        state: present

    - name: Démarrer Docker
      service:
        name: docker
        state: started
        enabled: true

    - name: Ajouter l'utilisateur au groupe docker
      user:
        name: "{{ ansible_user }}"
        groups: docker
        append: true

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

  tasks:
    - name: Créer le réseau Docker
      community.docker.docker_network:
        name: app-network
        state: present

    - name: Lancer le conteneur PostgreSQL
      community.docker.docker_container:
        name: postgres
        image: postgres:15-alpine
        state: started
        restart_policy: unless-stopped
        networks:
          - name: app-network
        env:
          POSTGRES_PASSWORD: "{{ db_password }}"  # depuis Vault !
          POSTGRES_DB: mabase
        volumes:
          - postgres-data:/var/lib/postgresql/data

    - name: Lancer le conteneur de l'application
      community.docker.docker_container:
        name: webapp
        image: monusername/webapp:latest
        state: started
        restart_policy: unless-stopped
        ports:
          - "80:3000"
        networks:
          - name: app-network
        env:
          DATABASE_URL: "postgres://postgres:{{ db_password }}@postgres:5432/mabase"

    - name: Vérifier que les conteneurs tournent
      community.docker.docker_container_info:
        name: webapp
      register: container_info

    - name: Afficher le statut
      debug:
        msg: "Conteneur webapp : {{ container_info.container.State.Status }}"

=== CONTENEURS ===
docker run -d -p 8080:80 --name app nginx   # Lancer
docker ps                                    # Lister actifs
docker ps -a                                 # Lister tous
docker stop/start/restart app               # Contrôle
docker rm -f app                             # Supprimer
docker exec -it app bash                     # Shell interactif
docker logs -f app                           # Logs en direct
docker stats                                 # Monitoring
docker inspect app                           # Détails JSON

=== IMAGES ===
docker build -t app:1.0 .                   # Construire
docker images                                # Lister
docker pull nginx:alpine                     # Télécharger
docker push user/app:1.0                     # Pousser vers registry
docker rmi app:1.0                           # Supprimer
docker image prune                           # Nettoyer inutilisées

=== VOLUMES ===
docker volume create monvol                 # Créer
docker volume ls                             # Lister
docker volume rm monvol                      # Supprimer
docker run -v monvol:/data app              # Named volume
docker run -v $(pwd):/app app               # Bind mount

=== RÉSEAUX ===
docker network create mon-net               # Créer
docker network ls                            # Lister
docker run --network mon-net app            # Connecter
docker network inspect mon-net              # Inspecter

=== COMPOSE ===
docker compose up -d                        # Démarrer tout
docker compose down                          # Arrêter tout
docker compose ps                            # État des services
docker compose logs -f service              # Logs d'un service
docker compose exec service bash           # Shell dans service
docker compose pull                          # Mettre à jour images

=== NETTOYAGE ===
docker system prune                          # Tout nettoyer
docker system prune -a --volumes            # Nettoyage complet

=== AD-HOC ===
ansible all -i hosts -m ping                # Test connectivité
ansible webservers -m command -a "uptime"  # Commande rapide
ansible all -m setup                         # Collecter facts

=== PLAYBOOKS ===
ansible-playbook -i hosts playbook.yml      # Lancer
ansible-playbook ... --check                # Dry-run
ansible-playbook ... -v / -vvv              # Verbosité
ansible-playbook ... --limit web1           # Cibler hôte
ansible-playbook ... --tags deploy          # Lancer par tag
ansible-playbook ... --ask-become-pass     # Demander sudo

=== VAULT ===
ansible-vault create secrets.yml            # Créer chiffré
ansible-vault edit secrets.yml              # Éditer
ansible-vault encrypt fichier.yml           # Chiffrer existant
ansible-vault decrypt fichier.yml           # Déchiffrer
ansible-vault encrypt_string 'mdp' --name x # Valeur inline

=== GALAXY ===
ansible-galaxy collection install community.docker
ansible-galaxy role install geerlingguy.docker