Coffre-fort numérique lumineux avec cadenas, style cyberpunk sombre
Arnaud Wallon6 min read

Comment héberger ton gestionnaire de mots de passe avec Vaultwarden

Déploie Vaultwarden, le gestionnaire de mots de passe open source compatible Bitwarden, sur ton serveur avec Docker, HTTPS et sauvegardes automatiques.

Tu en as marre de confier tous tes mots de passe à un service en ligne dont tu ne contrôles rien ? Vaultwarden est un gestionnaire de mots de passe open source, léger et compatible avec les applications Bitwarden, que tu peux héberger sur ton propre serveur. Dans ce tuto, tu vas le déployer avec Docker en une vingtaine de minutes, le sécuriser avec le HTTPS et la double authentification, et mettre en place une sauvegarde automatique.

De quoi tu as besoin

Un gestionnaire de mots de passe, c'est le logiciel qui stocke tous tes identifiants dans un coffre chiffré, protégé par un seul mot de passe maître. Vaultwarden est une réimplémentation légère du serveur Bitwarden, écrite en Rust, qui consomme moins de 100 Mo de RAM : elle tourne sur le plus petit des serveurs.

  • Un serveur Linux (Ubuntu 24.04 ou Debian 12) avec Docker et Docker Compose installés.
  • Un nom de domaine dont tu contrôles le DNS, par exemple vault.tondomaine.fr.
  • Les ports 80 et 443 ouverts sur ton pare-feu, pour le certificat HTTPS.
  • Quelques minutes et un peu de rigueur : c'est un service critique, on ne bâcle pas.

Étape 1 : installer Docker et Docker Compose

Si Docker n'est pas encore là, installe-le depuis le dépôt officiel, pas depuis les paquets Ubuntu qui sont souvent en retard :

sudo apt update
sudo apt install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Ajoute ton utilisateur au groupe docker, puis vérifie l'installation :

sudo usermod -aG docker $USER
# déconnecte-toi et reconnecte-toi pour appliquer
docker --version && docker compose version

Étape 2 : configurer le DNS

Le serveur a besoin que ton domaine pointe vers son adresse IP pour obtenir le certificat HTTPS. Chez ton fournisseur DNS, crée un enregistrement A (et AAAA si tu as l'IPv6) qui relie vault.tondomaine.fr à l'IP de ton serveur.

Attends la propagation, puis vérifie depuis ta machine :

dig +short vault.tondomaine.fr

La commande doit renvoyer l'IP de ton serveur. Tant que ce n'est pas le cas, le certificat ne pourra pas être émis.

Étape 3 : générer le mot de passe d'administration

Vaultwarden expose un panneau d'administration sous /admin, protégé par un jeton. Ce jeton doit être un hash Argon2, pas une chaîne en clair. Générez-le directement avec l'image Vaultwarden :

docker run --rm -it vaultwarden/server:latest /vaultwarden hash

Saisis un mot de passe administrateur long et unique quand l'outil le demande. Il affiche une chaîne qui commence par $argon2id$... Copie-la précieusement : c'est elle qu'on placera dans la configuration. Note aussi le mot de passe en clair dans ton coffre-fort : c'est celui que tu taperas pour accéder à /admin.

Génération du jeton d'administration Argon2 dans un terminal. Source : IT-Connect.

Étape 4 : créer le réseau Docker partagé

Pour que le reverse proxy Caddy joigne le conteneur Vaultwarden par son nom, les deux partagent un réseau Docker dédié. Crée-le une seule fois :

docker network create web

Si le réseau existe déjà, la commande renvoie une erreur sans gravité, ignore-la.

Étape 5 : le fichier docker-compose de Vaultwarden

Crée un dossier de travail et le fichier de composition :

mkdir -p ~/vaultwarden && cd ~/vaultwarden
nano docker-compose.yml
services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      # Désactive l'inscription publique : personne ne peut créer de compte
      SIGNUPS_ALLOWED: "false"
      # Autorise l'invitation manuelle d'utilisateurs depuis /admin
      INVITATIONS_ALLOWED: "true"
      # URL publique du service (HTTPS obligatoire)
      DOMAIN: "https://vault.tondomaine.fr"
      # Hash Argon2 du token admin (noter le $$ à la place de $)
      ADMIN_TOKEN: "${ADMIN_TOKEN}"
      # WebSockets pour la synchro temps réel des clients
      ENABLE_WEBSOCKET: "true"
    volumes:
      - ./vw-data:/data
    networks:
      - web

networks:
  web:
    external: true

Crée ensuite le fichier .env qui contient le jeton, en doublant chaque $ du hash Argon2 :

nano .env
ADMIN_TOKEN='$$argon2id$$v=19$$m=65540,t=3,p=4$$VOTRE_HASH_ICI'

Remplace par le hash généré à l'étape 3, en remplaçant chaque $ par $$. Les apostrophes simples protègent la chaîne. Note l'absence de section ports : Vaultwarden n'est jamais exposé directement sur Internet, il n'est accessible qu'à travers Caddy.

Étape 6 : le Caddyfile pour le HTTPS automatique

Caddy est un reverse proxy qui obtient et renouvelle tout seul les certificats HTTPS. Crée un dossier Caddy et son fichier de configuration :

mkdir -p ~/caddy && cd ~/caddy
nano Caddyfile
{
    # Email pour les notifications Let's Encrypt
    email admin@tondomaine.fr
}

vault.tondomaine.fr {
    # Certificat Let's Encrypt et redirection HTTP -> HTTPS automatiques
    encode gzip zstd
    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
        X-Content-Type-Options "nosniff"
        X-Frame-Options "SAMEORIGIN"
        Referrer-Policy "strict-origin-when-cross-origin"
        -Server
    }
    # On envoie tout le trafic vers le conteneur Vaultwarden
    reverse_proxy vaultwarden:80
}

Puis le docker-compose de Caddy dans le même dossier :

nano docker-compose.yml
services:
  caddy:
    image: caddy:2-alpine
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - web

volumes:
  caddy_data:
  caddy_config:

networks:
  web:
    external: true

Le volume caddy_data est critique : il conserve tes certificats. Sans lui, tu redemanderais un certificat à chaque redémarrage et atteindrais vite les limites de Let's Encrypt.

Étape 7 : lancer les services

Démarre d'abord Vaultwarden, puis Caddy :

cd ~/vaultwarden && docker compose up -d
cd ~/caddy && docker compose up -d

Suis les logs de Caddy pour voir l'émission du certificat en direct :

docker compose logs -f caddy

Tu devrais voir une ligne du type certificate obtained successfully pour vault.tondomaine.fr. Visite ensuite https://vault.tondomaine.fr : la page d'accueil de Vaultwarden s'affiche avec un cadenas valide.

Étape 8 : créer ton compte et inviter les autres

Comme SIGNUPS_ALLOWED est à false, personne ne peut s'inscrire librement. Pour créer ton premier compte, rends-toi sur https://vault.tondomaine.fr/admin, saisis le mot de passe administrateur, puis utilise Invite User pour t'inviter, ainsi que ta famille ou ton équipe. Chacun reçoit un lien d'inscription.

Une fois ton compte créé, installe l'extension navigateur Bitwarden ou l'application mobile, et dans les paramètres, configure l'URL du serveur sur https://vault.tondomaine.fr avant de te connecter. Tout le reste fonctionne exactement comme Bitwarden.

Étape 9 : activer la double authentification

C'est non négociable pour un coffre-fort de mots de passe. Une fois connecté à l'interface web :

  • Va dans Paramètres, Sécurité, Connexion en deux étapes.
  • Active TOTP (application d'authentification) au minimum, ou idéalement une clé matérielle WebAuthn ou FIDO2 (YubiKey).
  • Note ton code de récupération dans un endroit sûr, hors du coffre-fort.

Sans double authentification, ton seul rempart est le mot de passe maître. Avec, même un mot de passe compromis ne suffit pas à un attaquant.

Étape 10 : sauvegardes chiffrées automatiques

Un coffre-fort sans sauvegarde, c'est tous tes accès qui disparaissent à la première panne disque. Vaultwarden stocke tout dans ~/vaultwarden/vw-data (base SQLite, pièces jointes, clés). Voici un script de sauvegarde quotidien :

nano ~/vaultwarden/backup.sh
#!/bin/bash
set -euo pipefail
DATA_DIR="$HOME/vaultwarden/vw-data"
BACKUP_DIR="$HOME/vaultwarden/backups"
STAMP=$(date +%Y%m%d-%H%M%S)
mkdir -p "$BACKUP_DIR"
# Sauvegarde cohérente de la base SQLite
docker compose -f "$HOME/vaultwarden/docker-compose.yml" exec -T vaultwarden \
  /bin/sh -c "sqlite3 /data/db.sqlite3 '.backup /data/db-backup.sqlite3'"
# Archive l'ensemble des données
tar -czf "$BACKUP_DIR/vaultwarden-$STAMP.tar.gz" -C "$DATA_DIR" .
# Conserve les 14 derniers jours
find "$BACKUP_DIR" -name 'vaultwarden-*.tar.gz' -mtime +14 -delete

Rends-le exécutable et planifie-le via cron (tous les jours à 3h) :

chmod +x ~/vaultwarden/backup.sh
(crontab -l 2>/dev/null; echo "0 3 * * * $HOME/vaultwarden/backup.sh") | crontab -

Une sauvegarde sur le même serveur ne protège pas d'un incendie, d'un vol ou d'un rançongiciel. Envoie ces archives hors-site et chiffrées, par exemple avec restic, comme on le voyait dans notre tuto sur la sauvegarde chiffrée.

Vérifier que ça fonctionne

Contrôle que tout est en place avec ces commandes :

# Les conteneurs tournent
docker ps --filter "name=vaultwarden" --filter "name=caddy"
# Le HTTP redirige bien vers HTTPS (code 308)
curl -sI http://vault.tondomaine.fr | head -1
# Le HTTPS répond et le certificat est valide
curl -sI https://vault.tondomaine.fr | head -1
# Le panneau admin n'est PAS accessible sans jeton (doit demander une auth)
curl -sI https://vault.tondomaine.fr/admin | head -1

Pour un audit TLS complet, teste ton domaine sur SSL Labs : tu devrais viser A ou A+ grâce aux en-têtes HSTS et aux protocoles modernes de Caddy.

Limites et pièges

  • Le jeton admin doit être un hash Argon2, pas une chaîne en clair. Si tu colles le hash dans un fichier .env, double chaque $ ($$) car Docker Compose l'interprète comme une variable.
  • Vaultwarden n'est pas associé à Bitwarden : c'est un projet indépendant, mais compatible avec ses applications. Ne confonds pas les deux.
  • Le HTTPS est obligatoire : sans lui, les applications Bitwarden refusent de se connecter à ton instance.
  • Ne laisse jamais SIGNUPS_ALLOWED à true : n'importe qui pourrait créer un compte sur ton serveur.
  • Une sauvegarde locale ne suffit pas : réplique-la hors-site, chiffrée, pour te protéger d'un vol ou d'un incendie.
  • Tu peux héberger Vaultwarden sur un NAS (Synology, QNAP, TrueNAS) : la logique est identique, conteneur derrière un reverse proxy HTTPS.

Conclusion

Tu as maintenant un gestionnaire de mots de passe souverain, en HTTPS, sauvegardé et durci, qui tourne sur moins de 100 Mo de RAM. C'est l'un des services les plus utiles qu'un serveur maison puisse offrir : tes secrets restent chez toi, et plus personne d'autre n'y a accès.

Sources

Vaultwarden sur GitHub — le dépôt officiel du projet, avec la documentation et les notes de version.

IT-Connect — le tutoriel d'installation de Vaultwarden avec Docker et Traefik.

Selfhostr — le tutoriel 2026 de déploiement de Vaultwarden avec Docker, Caddy et les sauvegardes.

—

Recherche, relecture et illustration assistées par IA. Le contenu reflète le travail éditorial de la rédaction.

No comments yet

À lire aussi