Skip to content

Conteneurs Docker

Introduction

Kolla-Ansible déploie tous les services OpenStack dans des conteneurs Docker. Comprendre Docker est essentiel pour le déploiement, le troubleshooting et les opérations day-2.

Cette section couvre les concepts Docker nécessaires pour administrer un déploiement Kolla-Ansible.

Prérequis

Points à apprendre

Installation Docker

# Ubuntu
apt update
apt install -y ca-certificates curl gnupg

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  tee /etc/apt/sources.list.d/docker.list > /dev/null

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Ajouter utilisateur au groupe docker
usermod -aG docker $USER

# Démarrer et activer
systemctl enable --now docker

Architecture Docker

graph TB
    subgraph Client["Docker Client"]
        cli["docker CLI"]
    end

    subgraph Daemon["Docker Daemon (dockerd)"]
        images["Images"]
        containers["Containers"]
        networks["Networks"]
        volumes["Volumes"]
        plugins["Plugins"]
    end

    subgraph Containerd["containerd"]
        cd[" "]
    end

    subgraph Runtime["runc (OCI runtime)"]
        runc[" "]
    end

    cli -->|REST API| Daemon
    images --> cd
    containers --> cd
    networks --> cd
    volumes --> cd
    cd --> runc

Gestion des conteneurs

Commandes de base

# Lancer conteneur
docker run -d --name nginx nginx:latest
docker run -it --rm ubuntu:24.04 bash  # Interactif, supprimé à la sortie

# Lister conteneurs
docker ps           # En cours
docker ps -a        # Tous
docker ps -q        # IDs seulement

# Gestion lifecycle
docker start|stop|restart nom-conteneur
docker pause|unpause nom-conteneur
docker kill nom-conteneur

# Logs
docker logs nom-conteneur
docker logs -f nom-conteneur        # Follow
docker logs --tail 100 nom-conteneur
docker logs --since 1h nom-conteneur

# Exécuter commande dans conteneur
docker exec -it nom-conteneur bash
docker exec nom-conteneur ls -la

# Informations
docker inspect nom-conteneur
docker stats                        # Ressources temps réel
docker top nom-conteneur            # Processus

# Suppression
docker rm nom-conteneur
docker rm -f nom-conteneur          # Force (si running)
docker container prune              # Supprimer tous les arrêtés

Options importantes

docker run \
  -d                                 # Detached (background)
  --name mon-conteneur               # Nom
  --hostname mon-host                # Hostname dans conteneur
  -p 8080:80                         # Port mapping host:container
  -p 192.168.1.10:8080:80            # Bind IP spécifique
  -v /host/path:/container/path      # Bind mount
  -v vol-name:/container/path        # Named volume
  --mount type=bind,src=/host,dst=/container  # Syntaxe mount
  -e VAR=value                       # Variable environnement
  --env-file .env                    # Fichier de variables
  --network mon-network              # Réseau
  --restart unless-stopped           # Politique restart
  --memory 512m                      # Limite RAM
  --cpus 0.5                         # Limite CPU
  --privileged                       # Mode privilégié (éviter)
  --user 1000:1000                   # UID:GID
  nginx:latest                       # Image

Gestion des images

# Télécharger image
docker pull ubuntu:24.04
docker pull quay.io/kolla/nova-api:2025.2

# Lister images
docker images
docker image ls

# Informations
docker image inspect nginx:latest
docker history nginx:latest

# Supprimer
docker rmi nginx:latest
docker image prune              # Supprimer images non utilisées
docker image prune -a           # Supprimer toutes les non utilisées

# Sauvegarder/Charger
docker save nginx:latest -o nginx.tar
docker load -i nginx.tar

# Tag et push
docker tag nginx:latest registry.local/nginx:v1
docker push registry.local/nginx:v1

Construction d'images

Dockerfile basique

# Exemple Dockerfile
FROM ubuntu:24.04

# Métadonnées
LABEL maintainer="admin@example.com"
LABEL version="1.0"

# Variables d'environnement
ENV APP_HOME=/app
ENV DEBIAN_FRONTEND=noninteractive

# Installation paquets
RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    && rm -rf /var/lib/apt/lists/*

# Créer utilisateur non-root
RUN useradd -m -s /bin/bash appuser

# Répertoire de travail
WORKDIR $APP_HOME

# Copier fichiers
COPY requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt

COPY app/ .

# Changer propriétaire
RUN chown -R appuser:appuser $APP_HOME

# Utilisateur non-root
USER appuser

# Port exposé (documentation)
EXPOSE 8000

# Commande par défaut
CMD ["python3", "app.py"]

Build et bonnes pratiques

# Build image
docker build -t mon-app:v1 .
docker build -t mon-app:v1 -f Dockerfile.prod .

# Build avec arguments
docker build --build-arg VERSION=1.0 -t mon-app:v1 .

# Multi-stage build (réduire taille)

# Multi-stage Dockerfile
FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp

FROM alpine:3.19
COPY --from=builder /app/myapp /usr/local/bin/
CMD ["myapp"]

Volumes et persistance

# Types de stockage
# 1. Volumes (géré par Docker)
docker volume create mon-volume
docker volume ls
docker volume inspect mon-volume
docker run -v mon-volume:/data nginx

# 2. Bind mounts (répertoire hôte)
docker run -v /host/data:/container/data nginx

# 3. tmpfs (en mémoire)
docker run --tmpfs /tmp nginx

# Backup volume
docker run --rm -v mon-volume:/data -v $(pwd):/backup \
  ubuntu tar cvf /backup/backup.tar /data

Réseaux Docker

Types de réseaux

Driver Description Cas d'usage
bridge Réseau isolé par défaut Conteneurs sur même hôte
host Partage stack réseau hôte Performance max
none Pas de réseau Isolation totale
overlay Multi-hôtes (Swarm) Cluster
macvlan MAC unique par conteneur Intégration LAN

Commandes réseau

# Créer réseau
docker network create mon-reseau
docker network create --driver bridge --subnet 172.20.0.0/16 mon-reseau

# Lister
docker network ls
docker network inspect mon-reseau

# Connecter conteneur
docker network connect mon-reseau mon-conteneur
docker network disconnect mon-reseau mon-conteneur

# Lancer conteneur sur réseau
docker run --network mon-reseau nginx

Réseau dans Kolla

# Kolla utilise des réseaux spécifiques
docker network ls | grep kolla

# Typiquement:
# - kolla_bridge (management)
# - kolla_network (provider)

Docker Compose

Docker Compose orchestre plusieurs conteneurs. Kolla n'utilise pas Compose directement mais le concept est similaire.

docker-compose.yml

version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./html:/usr/share/nginx/html:ro
    networks:
      - frontend
    depends_on:
      - api
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3

  api:
    build:
      context: ./api
      dockerfile: Dockerfile
    environment:
      - DATABASE_URL=postgres://db:5432/app
    networks:
      - frontend
      - backend
    restart: unless-stopped

  db:
    image: postgres:16
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: secret
    networks:
      - backend
    restart: unless-stopped

networks:
  frontend:
  backend:

volumes:
  db-data:

Commandes Compose

# Démarrer
docker compose up -d
docker compose up -d --build  # Rebuild images

# Arrêter
docker compose down
docker compose down -v  # + supprimer volumes

# Logs
docker compose logs -f
docker compose logs api

# Scale
docker compose up -d --scale api=3

# Exécuter commande
docker compose exec api bash

Registries privés

# Lancer registry local
docker run -d -p 5000:5000 --name registry \
  -v registry-data:/var/lib/registry \
  registry:2

# Taguer et pousser
docker tag nginx:latest localhost:5000/nginx:latest
docker push localhost:5000/nginx:latest

# Pour Kolla, configurer dans globals.yml:
# docker_registry: "registry.local:5000"
# docker_namespace: "kolla"

Troubleshooting conteneurs

# Logs détaillés
docker logs --details mon-conteneur

# Événements Docker
docker events

# Utilisation ressources
docker stats --no-stream

# Système
docker system df              # Espace disque
docker system prune -a        # Nettoyage complet

# Debug conteneur qui crash
docker run -it --entrypoint /bin/sh image:tag
docker logs $(docker ps -lq)  # Logs dernier conteneur
docker inspect --format='{{.State.ExitCode}}' mon-conteneur

Sécurité Docker

# Limiter capabilities
docker run --cap-drop ALL --cap-add NET_BIND_SERVICE nginx

# Read-only filesystem
docker run --read-only nginx

# User non-root
docker run --user 1000:1000 nginx

# Seccomp profile
docker run --security-opt seccomp=profile.json nginx

# Pas de nouveaux privilèges
docker run --security-opt no-new-privileges nginx

Exemples pratiques

Lab 1 : Stack web complète

mkdir -p ~/docker-lab && cd ~/docker-lab

# Créer docker-compose.yml
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  nginx:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    networks:
      - web
    depends_on:
      - app

  app:
    image: python:3.12-slim
    working_dir: /app
    volumes:
      - ./app:/app
    command: python -m http.server 5000
    networks:
      - web
    expose:
      - "5000"

networks:
  web:
EOF

# Config nginx
cat > nginx.conf << 'EOF'
upstream app {
    server app:5000;
}

server {
    listen 80;
    location / {
        proxy_pass http://app;
    }
}
EOF

# App simple
mkdir -p app
echo "<h1>Hello from Docker!</h1>" > app/index.html

# Lancer
docker compose up -d
curl http://localhost:8080

Lab 2 : Simuler conteneurs Kolla

# Simuler l'exécution de conteneurs style Kolla

# Créer répertoires config style Kolla
mkdir -p /tmp/kolla/{nova,keystone}

# Lancer conteneur avec config montée
docker run -d \
  --name test-nova \
  --hostname nova \
  --network host \
  -v /tmp/kolla/nova:/etc/nova:ro \
  -v /var/log/kolla/nova:/var/log/nova \
  --restart unless-stopped \
  ubuntu:24.04 \
  tail -f /dev/null

# Vérifier
docker ps
docker logs test-nova

# Cleanup
docker rm -f test-nova

Ressources

Checkpoint

  • Je sais installer et configurer Docker
  • Je maîtrise les commandes de gestion des conteneurs
  • Je comprends la différence entre volumes et bind mounts
  • Je peux construire des images avec Dockerfile
  • Je sais utiliser Docker Compose
  • Je comprends les réseaux Docker
  • Je peux diagnostiquer les problèmes de conteneurs