Docker Volumes

---

Chapter objectives

• Understand data persistence in Docker
• Master the different volume types
• Manage volumes effectively
• Share data between containers

---

1 - Why volumes?

The ephemerality problem

By default, a container's data is lost when it is deleted:

# Créer un fichier dans un conteneur
docker run -it --name test ubuntu bash
echo "Hello" > /data.txt
exit

# Redémarrer le conteneur - fichier présent
docker start -i test
cat /data.txt  # Hello

# Supprimer le conteneur - fichier perdu !
docker rm test
docker run -it ubuntu cat /data.txt  # Erreur !

The solutions

┌─────────────────────────────────────────────────────────────┐
│                   Options de stockage                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
│  │   Volumes   │  │ Bind Mounts │  │       tmpfs         │  │
│  │  (Géré par  │  │  (Dossier   │  │  (Mémoire RAM)      │  │
│  │   Docker)   │  │   hôte)     │  │                     │  │
│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

---

2 - Storage types

Comparison

Type	Location	Management	Usage
Volume	/var/lib/docker/volumes/	Docker	Production, persistent data
Bind mount	Anywhere on the host	User	Development, configs
tmpfs	RAM memory	Docker	Sensitive temporary data

Diagram

┌─────────────────────────────────────────────────────────────┐
│                      Conteneur                               │
│  ┌─────────────────────────────────────────────────────┐    │
│  │                 /app/data                            │    │
│  └────────────────────────┬────────────────────────────┘    │
└───────────────────────────┼─────────────────────────────────┘
                            │
        ┌───────────────────┼───────────────────┐
        │                   │                   │
        ▼                   ▼                   ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│    Volume     │   │  Bind Mount   │   │    tmpfs      │
│ /var/lib/     │   │ /home/user/   │   │   (RAM)       │
│ docker/vol/   │   │ project/data  │   │               │
└───────────────┘   └───────────────┘   └───────────────┘

---

3 - Docker Volumes

Create a volume

# Créer un volume
docker volume create mon-volume

# Créer avec options
docker volume create --driver local \
  --opt type=none \
  --opt device=/path/to/data \
  --opt o=bind \
  mon-volume

List the volumes

# Lister tous les volumes
docker volume ls

# Filtrer
docker volume ls --filter "dangling=true"
docker volume ls --filter "driver=local"

# Format personnalisé
docker volume ls --format "{{.Name}}: {{.Driver}}"

Inspect a volume

# Détails d'un volume
docker volume inspect mon-volume

# Sortie JSON
{
  "Name": "mon-volume",
  "Driver": "local",
  "Mountpoint": "/var/lib/docker/volumes/mon-volume/_data",
  "Labels": {},
  "Scope": "local"
}

Delete volumes

# Supprimer un volume
docker volume rm mon-volume

# Supprimer plusieurs volumes
docker volume rm vol1 vol2 vol3

# Supprimer les volumes non utilisés
docker volume prune

# Forcer la suppression
docker volume prune -f

---

4 - Use volumes

Syntax with -v

# Volume nommé
docker run -v mon-volume:/app/data nginx

# Volume anonyme
docker run -v /app/data nginx

# Mode lecture seule
docker run -v mon-volume:/app/data:ro nginx

Syntax with --mount (recommended)

# Volume nommé
docker run --mount source=mon-volume,target=/app/data nginx

# Avec options
docker run --mount type=volume,source=mon-volume,target=/app/data,readonly nginx

# Volume anonyme
docker run --mount type=volume,target=/app/data nginx

Practical examples

# Base de données PostgreSQL avec volume
docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=secret \
  --mount source=pg-data,target=/var/lib/postgresql/data \
  postgres:15

# Les données survivent à la suppression du conteneur
docker rm -f postgres
docker run -d \
  --name postgres-new \
  -e POSTGRES_PASSWORD=secret \
  --mount source=pg-data,target=/var/lib/postgresql/data \
  postgres:15
# Les données sont préservées !

---

5 - Bind Mounts

Syntax

# Avec -v
docker run -v /chemin/hote:/chemin/conteneur nginx
docker run -v $(pwd)/html:/usr/share/nginx/html nginx

# Avec --mount
docker run --mount type=bind,source=/chemin/hote,target=/chemin/conteneur nginx

# Lecture seule
docker run --mount type=bind,source=$(pwd)/config,target=/etc/nginx,readonly nginx

Use case: development

# Monter le code source pour le hot-reload
docker run -d \
  --name dev-app \
  -p 3000:3000 \
  -v $(pwd)/src:/app/src \
  -v $(pwd)/package.json:/app/package.json \
  node:18 npm run dev

# Les modifications du code sont reflétées immédiatement

Differences with volumes

Aspect	Volume	Bind Mount
Location	Managed by Docker	Specified by the user
Portability	Excellent	Depends on the host path
Performance	Optimized	Variable
Backup	Via Docker	Manual
Security	Better isolation	Access to the host system

---

6 - tmpfs Mounts

Usage

tmpfs stores data in RAM memory:

# Créer un tmpfs mount
docker run --mount type=tmpfs,target=/app/temp nginx

# Avec options
docker run --mount type=tmpfs,target=/app/temp,tmpfs-size=100m,tmpfs-mode=1777 nginx

Use cases

• Sensitive data (secrets, tokens)
• Temporary cache
• Session files
• Data that should not persist

# Stocker des secrets temporairement
docker run -d \
  --name secure-app \
  --mount type=tmpfs,target=/run/secrets \
  mon-app

---

7 - Share data between containers

Shared volumes

# Conteneur 1 : écrit des données
docker run -d \
  --name writer \
  --mount source=shared-data,target=/data \
  alpine sh -c "while true; do date >> /data/log.txt; sleep 1; done"

# Conteneur 2 : lit les données
docker run -it \
  --name reader \
  --mount source=shared-data,target=/data,readonly \
  alpine tail -f /data/log.txt

Volumes-from (legacy)

# Créer un conteneur avec des volumes
docker run -d --name data-container -v /data alpine sleep infinity

# Utiliser les volumes d'un autre conteneur
docker run --volumes-from data-container alpine ls /data

---

8 - Backup and restore

Back up a volume

# Méthode 1 : tar dans un conteneur temporaire
docker run --rm \
  -v mon-volume:/source:ro \
  -v $(pwd):/backup \
  alpine tar cvf /backup/mon-volume-backup.tar -C /source .

# Méthode 2 : docker cp (depuis un conteneur)
docker cp mon-conteneur:/app/data ./backup/

Restore a volume

# Créer le volume
docker volume create mon-volume-restored

# Restaurer depuis le backup
docker run --rm \
  -v mon-volume-restored:/target \
  -v $(pwd):/backup \
  alpine tar xvf /backup/mon-volume-backup.tar -C /target

Automated backup script

#!/bin/bash
# backup-volumes.sh

BACKUP_DIR="/backups/docker"
DATE=$(date +%Y%m%d_%H%M%S)

for volume in $(docker volume ls -q); do
  echo "Backing up $volume..."
  docker run --rm \
    -v $volume:/source:ro \
    -v $BACKUP_DIR:/backup \
    alpine tar cvf /backup/${volume}_${DATE}.tar -C /source .
done

# Nettoyer les backups de plus de 7 jours
find $BACKUP_DIR -name "*.tar" -mtime +7 -delete

---

9 - Volumes in a Dockerfile

The VOLUME instruction

FROM node:18

WORKDIR /app

# Déclarer un volume
VOLUME /app/data
VOLUME ["/app/logs", "/app/uploads"]

COPY . .

CMD ["node", "server.js"]

Behavior

# Un volume anonyme est créé automatiquement
docker run mon-app

# Lister les volumes anonymes
docker volume ls
# DRIVER    VOLUME NAME
# local     abc123def456...

Warning

VOLUME instructions in the Dockerfile create anonymous volumes that are hard to manage. Prefer named volumes at runtime.

---

10 - Best practices

Naming

# ✅ Bon : noms descriptifs
docker volume create postgres-data
docker volume create app-uploads
docker volume create nginx-logs

# ❌ Mauvais : noms génériques
docker volume create data
docker volume create vol1

Security

# Lecture seule quand possible
docker run --mount source=config,target=/etc/app,readonly mon-app

# Utilisateur non-root
docker run -u 1000:1000 --mount source=data,target=/app/data mon-app

Performance

# Utiliser des volumes pour les données fréquemment accédées
# (meilleure performance que bind mounts sur macOS/Windows)

# Pour le développement sur macOS
docker run -v mycode:/app:cached node:18 npm run dev

Regular cleanup

# Identifier les volumes orphelins
docker volume ls -f dangling=true

# Nettoyer
docker volume prune

# Vérifier l'espace utilisé
docker system df -v | grep VOLUME -A 100

---

Summary

Command	Description
docker volume create	Create a volume
docker volume ls	List the volumes
docker volume inspect	Volume details
docker volume rm	Delete a volume
docker volume prune	Clean up unused volumes
-v or --mount	Mount a volume

Type	Recommended usage
Volume	Production data
Bind mount	Development
tmpfs	Temporary/sensitive data

Key points

• Volumes persist after containers are deleted
• Use --mount for a clear syntax
• Name your volumes descriptively
• Regularly back up your critical volumes

---

Hands-on exercises

1. Create a volume and use it with a MySQL container
2. Mount a local folder for developing a Node.js app
3. Share a volume between two containers
4. Perform a backup and restore of a volume

---

← Dockerfile | Docker Networks →