Vaultwarden : héberger son gestionnaire de mots de passe avec Docker et Traefik

Le gestionnaire de mots de passe est la fondation absolue de toute stratégie de sécurité informatique sérieuse. Sans lui, la réutilisation de mots de passe entre services est inévitable, et une seule fuite de données suffit à compromettre l'ensemble de vos comptes. Les solutions cloud comme 1Password, Dashlane ou Bitwarden cloud sont pratiques, mais elles impliquent de confier vos secrets à un tiers — une décision que beaucoup d'organisations ne peuvent pas se permettre, notamment pour des raisons réglementaires (RGPD, NIS 2, ISO 27001) ou de souveraineté. Vaultwarden, implémentation open source non officielle mais compatible avec le protocole Bitwarden, offre la meilleure des deux mondes : toute la puissance de l'écosystème Bitwarden (extensions navigateur, applications mobiles, partage d'équipe) avec un contrôle total sur vos données hébergées sur votre propre infrastructure. Ce guide complet vous explique comment déployer Vaultwarden avec Docker Compose et Traefik sur un VPS, avec HTTPS automatique Let's Encrypt, sécurisation de l'interface d'administration, gestion des sauvegardes et accès depuis vos appareils mobiles et navigateurs. Une solution robuste et souveraine pour individus exigeants et équipes soucieuses de leur sécurité.

Vaultwarden vs Bitwarden officiel — différences et compatibilité

Bitwarden est le gestionnaire de mots de passe open source le plus populaire du marché. Sa version self-hosted officielle existe mais nécessite Docker avec une dizaine de conteneurs (base de données MSSQL, services multiples) et consomme 2 à 4 Go de RAM minimum — surdimensionné pour un usage personnel ou une petite équipe.

Vaultwarden (anciennement Bitwarden_RS) est une réimplémentation en Rust du serveur Bitwarden, développée par la communauté. Il implémente l'intégralité de l'API Bitwarden officielle et est donc 100% compatible avec tous les clients Bitwarden officiels : extension Chrome/Firefox, application Windows/Mac/Linux, application iOS/Android. La différence fondamentale est la légèreté : Vaultwarden tient dans un seul conteneur Docker et nécessite moins de 100 Mo de RAM.

Points de compatibilité importants :

• Clients officiels : toutes les extensions et applications Bitwarden fonctionnent sans modification
• Chiffrement : identique au Bitwarden officiel (AES-256, PBKDF2/Argon2)
• Organisations : support complet des partages de coffre entre membres d'équipe
• 2FA : TOTP, YubiKey, Duo, email OTP
• Sends : partage temporaire de texte ou fichiers

La seule différence notable est que certaines fonctionnalités "premium" de Bitwarden (rapports de sécurité avancés, support SSO enterprise) nécessitent un abonnement dans la version officielle mais sont disponibles gratuitement dans Vaultwarden. En contrepartie, Vaultwarden n'est pas soutenu par Bitwarden Inc. et sa maintenance dépend de la communauté open source.

Pour les organisations soumises à des audits de conformité, il est important de noter que Vaultwarden n'est pas certifié SOC 2 contrairement au Bitwarden officiel. Si la certification tierce est requise, optez pour Bitwarden officiel self-hosted ou la version cloud.

Prérequis (VPS, domaine, Docker + Docker Compose, Traefik)

Avant de commencer, assurez-vous de disposer de tous les éléments nécessaires :

• Un VPS : Ubuntu 22.04 LTS ou Debian 12, minimum 1 vCPU / 512 Mo RAM (1 Go recommandé)
• Un nom de domaine : avec accès à la gestion DNS (ex : vault.votre-domaine.fr)
• Docker et Docker Compose v2 installés
• Ports 80 et 443 ouverts dans le firewall du VPS

Installez Docker et Docker Compose sur Ubuntu/Debian :

curl -fsSL https://get.docker.com | bash
sudo usermod -aG docker $USER
docker --version && docker compose version

Créez la structure de répertoires pour votre déploiement :

mkdir -p ~/docker/{traefik,vaultwarden}/data
cd ~/docker

Pointez votre enregistrement DNS A vers l'IP de votre VPS. Vérifiez la propagation :

dig +short vault.votre-domaine.fr

Installer Traefik comme reverse proxy (docker-compose.yml)

Traefik est le reverse proxy recommandé pour les environnements Docker car il génère automatiquement les certificats Let's Encrypt et détecte dynamiquement les nouveaux conteneurs via les labels Docker. Contrairement à nginx, aucune configuration manuelle n'est nécessaire lors de l'ajout d'un nouveau service.

Créez le réseau Docker partagé :

docker network create traefik-public

Créez le fichier de configuration statique de Traefik :

cat > ~/docker/traefik/traefik.yml << 'EOF'
api:
  dashboard: true
  insecure: false

entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
  websecure:
    address: ":443"

certificatesResolvers:
  letsencrypt:
    acme:
      email: [email protected]
      storage: /data/acme.json
      httpChallenge:
        entryPoint: web

providers:
  docker:
    exposedByDefault: false
    network: traefik-public
EOF

Créez le fichier ~/docker/traefik/docker-compose.yml :

version: '3.8'
services:
  traefik:
    image: traefik:v3.0
    container_name: traefik
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - traefik-public
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik.yml:/traefik.yml:ro
      - ./data:/data
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.traefik.rule=Host(`traefik.votre-domaine.fr`)"
      - "traefik.http.routers.traefik.entrypoints=websecure"
      - "traefik.http.routers.traefik.tls.certresolver=letsencrypt"
      - "traefik.http.routers.traefik.service=api@internal"

networks:
  traefik-public:
    external: true

Créez le fichier acme.json avec les bonnes permissions :

touch ~/docker/traefik/data/acme.json
chmod 600 ~/docker/traefik/data/acme.json

Démarrez Traefik :

cd ~/docker/traefik && docker compose up -d
docker logs traefik --tail 20

Déployer Vaultwarden avec Docker Compose (configuration complète)

Créez le fichier ~/docker/vaultwarden/docker-compose.yml :

version: '3.8'
services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - traefik-public
    volumes:
      - ./data:/data
    environment:
      DOMAIN: "https://vault.votre-domaine.fr"
      SIGNUPS_ALLOWED: "false"
      ADMIN_TOKEN: "VOTRE_TOKEN_ADMIN_SECURISE"
      WEBSOCKET_ENABLED: "true"
      LOG_FILE: "/data/vaultwarden.log"
      LOG_LEVEL: "warn"
      EXTENDED_LOGGING: "true"
      TZ: "Europe/Paris"
    labels:
      - "traefik.enable=true"
      # Route principale
      - "traefik.http.routers.vaultwarden.rule=Host(`vault.votre-domaine.fr`)"
      - "traefik.http.routers.vaultwarden.entrypoints=websecure"
      - "traefik.http.routers.vaultwarden.tls.certresolver=letsencrypt"
      - "traefik.http.routers.vaultwarden.service=vaultwarden"
      - "traefik.http.services.vaultwarden.loadbalancer.server.port=80"
      # WebSocket pour les notifications temps réel
      - "traefik.http.routers.vaultwarden-ws.rule=Host(`vault.votre-domaine.fr`) && Path(`/notifications/hub`)"
      - "traefik.http.routers.vaultwarden-ws.entrypoints=websecure"
      - "traefik.http.routers.vaultwarden-ws.tls.certresolver=letsencrypt"
      - "traefik.http.routers.vaultwarden-ws.service=vaultwarden-ws"
      - "traefik.http.services.vaultwarden-ws.loadbalancer.server.port=3012"

networks:
  traefik-public:
    external: true

Générez un token admin sécurisé :

openssl rand -base64 48

Démarrez Vaultwarden :

cd ~/docker/vaultwarden && docker compose up -d
docker logs vaultwarden --tail 30

Configurer HTTPS automatique avec Let's Encrypt via Traefik

Traefik gère automatiquement la demande et le renouvellement des certificats Let's Encrypt via le challenge HTTP-01. Lors du premier démarrage, Traefik écoute sur le port 80 pour répondre au challenge ACME de Let's Encrypt, valide la propriété du domaine, et stocke le certificat dans acme.json.

Vérifiez que le certificat a bien été émis :

cat ~/docker/traefik/data/acme.json | python3 -m json.tool | grep '"domain"'

Vous devriez voir votre domaine listé. Testez l'accès HTTPS depuis un navigateur ou via curl :

curl -I https://vault.votre-domaine.fr

Le renouvellement est automatique : Traefik vérifie l'expiration toutes les 24 heures et renouvelle les certificats 30 jours avant expiration. Aucune intervention manuelle n'est nécessaire.

Pour renforcer la configuration TLS, ajoutez un fichier de configuration dynamique pour imposer TLS 1.2+ et les cipher suites modernes. Consultez notre article sur la configuration TLS sécurisée pour les détails des paramètres de durcissement.

Sécuriser l'admin panel Vaultwarden (désactiver les inscriptions, accès restreint)

Par défaut, si SIGNUPS_ALLOWED=false est configuré, les nouveaux utilisateurs ne peuvent pas s'inscrire eux-mêmes. Les invitations restent possibles depuis l'admin panel. C'est la configuration recommandée pour un usage personnel ou d'équipe.

L'admin panel est accessible à https://vault.votre-domaine.fr/admin avec le token défini dans ADMIN_TOKEN. Il permet de gérer les utilisateurs, les organisations, les invitations et la configuration générale.

Pour renforcer la sécurité de l'admin panel, ajoutez une restriction IP via un middleware Traefik :

labels:
  # Middleware de restriction IP pour l'admin
  - "traefik.http.middlewares.vaultwarden-admin-ip.ipwhitelist.sourcerange=VOTRE_IP_BUREAU/32,VPN_IP/32"
  - "traefik.http.routers.vaultwarden-admin.rule=Host(`vault.votre-domaine.fr`) && PathPrefix(`/admin`)"
  - "traefik.http.routers.vaultwarden-admin.middlewares=vaultwarden-admin-ip"
  - "traefik.http.routers.vaultwarden-admin.entrypoints=websecure"
  - "traefik.http.routers.vaultwarden-admin.tls.certresolver=letsencrypt"

Générez un token admin robuste avec Argon2 (recommandé depuis Vaultwarden 1.28) :

echo -n "VOTRE_MOT_DE_PASSE_ADMIN" | argon2 "$(openssl rand -base64 32)" -id -t 3 -m 16 -p 4 -l 64 -e

Utilisez la sortie comme valeur de ADMIN_TOKEN. Vaultwarden vérifie automatiquement si le token est un hash Argon2 et l'utilise comme tel.

Configurer les invitations et organisations (pour les équipes)

Vaultwarden supporte le modèle d'organisation Bitwarden, qui permet de partager des secrets entre plusieurs utilisateurs avec des niveaux d'accès différenciés (lecture seule, écriture, gestionnaire, admin).

Pour inviter un utilisateur, accédez à l'admin panel et utilisez "Invite User". Un email d'invitation est envoyé si vous avez configuré un serveur SMTP :

environment:
  SMTP_HOST: "smtp.votre-fournisseur.fr"
  SMTP_PORT: "587"
  SMTP_SECURITY: "starttls"
  SMTP_USERNAME: "[email protected]"
  SMTP_PASSWORD: "MOT_DE_PASSE_SMTP"
  SMTP_FROM: "[email protected]"
  SMTP_FROM_NAME: "Vaultwarden"

Sans SMTP, activez les invitations par lien direct :

SIGNUPS_ALLOWED: "false"
INVITATIONS_ALLOWED: "true"

Dans l'application Bitwarden client, créez une organisation depuis "Paramètres > Organisations > Créer". Ajoutez des membres via leur email, définissez les collections partagées et les droits d'accès. C'est particulièrement utile pour partager des credentials d'infrastructure au sein d'une équipe DevOps ou sécurité. Vous pouvez également consulter notre guide sur la gestion des secrets avec HashiCorp Vault pour les cas d'usage plus avancés nécessitant une intégration CI/CD.

Activer le 2FA (TOTP, YubiKey)

L'authentification à deux facteurs est indispensable sur un gestionnaire de mots de passe. Vaultwarden supporte plusieurs méthodes de second facteur :

• TOTP : compatible avec Google Authenticator, Aegis, Authy, Bitwarden Authenticator
• YubiKey OTP : nécessite une clé API YubiCloud
• FIDO2/WebAuthn : passkeys et clés de sécurité hardware (YubiKey 5, etc.)
• Email OTP : code envoyé par email (nécessite SMTP)
• Duo : intégration avec Duo Security

Pour activer le support YubiKey, ajoutez vos clés API YubiCloud dans les variables d'environnement :

YUBICO_CLIENT_ID: "VOTRE_CLIENT_ID"
YUBICO_SECRET_KEY: "VOTRE_CLE_SECRETE"

Obtenez ces clés gratuitement sur yubico.com. Le TOTP et le FIDO2/WebAuthn fonctionnent sans configuration supplémentaire côté serveur — l'utilisateur les active directement dans les paramètres de son compte Bitwarden.

La configuration du 2FA se fait depuis l'application cliente : Paramètres > Sécurité > Authentification à deux facteurs. Recommandez à tous vos utilisateurs d'activer au minimum TOTP et de sauvegarder leurs codes de récupération dans un endroit sûr (hors Vaultwarden).

Sauvegarder Vaultwarden (base SQLite, volume Docker)

Vaultwarden utilise par défaut SQLite comme base de données, stockée dans ./data/db.sqlite3. C'est à la fois un avantage (légèreté, pas de service supplémentaire) et un risque si la sauvegarde n'est pas correctement configurée.

Script de sauvegarde automatique :

#!/bin/bash
BACKUP_DIR="/opt/backups/vaultwarden"
DATE=$(date +%Y%m%d_%H%M%S)
mkdir -p $BACKUP_DIR

# Copie à chaud de SQLite (safe avec WAL mode)
sqlite3 ~/docker/vaultwarden/data/db.sqlite3 ".backup '$BACKUP_DIR/db-$DATE.sqlite3'"

# Archive des attachments et configs
tar -czf $BACKUP_DIR/data-$DATE.tar.gz \
  ~/docker/vaultwarden/data/attachments/ \
  ~/docker/vaultwarden/data/sends/

# Rotation : garder 30 jours
find $BACKUP_DIR -name "*.sqlite3" -mtime +30 -delete
find $BACKUP_DIR -name "*.tar.gz" -mtime +30 -delete

echo "Sauvegarde $DATE terminée"

Automatisez via cron (sauvegarde quotidienne à 2h du matin) :

crontab -e
# Ajouter :
0 2 * * * /opt/scripts/backup-vaultwarden.sh >> /var/log/backup-vaultwarden.log 2>&1

Pour une sauvegarde externe (S3, rclone vers un bucket cloud), ajoutez après la sauvegarde locale :

rclone copy $BACKUP_DIR remote:backups/vaultwarden/ --max-age 30d

Consultez également la documentation officielle de Vaultwarden sur GitHub pour les détails sur la configuration de PostgreSQL comme backend de base de données si vous préférez une solution plus robuste pour des équipes importantes.

Mettre à jour Vaultwarden sans perte de données

Vaultwarden publie régulièrement des nouvelles versions. La procédure de mise à jour est simple grâce à Docker :

# 1. Sauvegarder AVANT toute mise à jour
/opt/scripts/backup-vaultwarden.sh

# 2. Télécharger la nouvelle image
cd ~/docker/vaultwarden
docker compose pull

# 3. Redémarrer avec la nouvelle image
docker compose up -d

# 4. Vérifier le bon démarrage
docker logs vaultwarden --tail 20

Vaultwarden gère automatiquement les migrations de base de données au démarrage. Aucun script manuel n'est nécessaire. Cependant, il est recommandé de lire les release notes avant chaque mise à jour majeure pour identifier d'éventuels changements de configuration ou de comportement.

Pour automatiser les mises à jour, vous pouvez utiliser Watchtower (en conjonction avec le Docker Socket Proxy pour la sécurité — voir notre article dédié à ce sujet) :

docker run -d \
  --name watchtower \
  -v /var/run/docker.sock:/var/run/docker.sock \
  containrrr/watchtower \
  --schedule "0 0 3 * * *" \
  --cleanup \
  vaultwarden

Attention : l'auto-update est pratique mais risqué sur un gestionnaire de mots de passe critique. Préférez les mises à jour manuelles avec vérification, ou configurez Watchtower pour envoyer une notification avant de procéder.

Accès mobile et extensions navigateur

L'un des avantages majeurs de Vaultwarden est sa compatibilité totale avec les clients officiels Bitwarden, disponibles sur toutes les plateformes.

Extensions navigateur : installez l'extension Bitwarden depuis le Chrome Web Store, Firefox Add-ons, ou le Microsoft Edge Add-ons Store. Au premier lancement, cliquez sur "Se connecter" et avant de saisir vos identifiants, cliquez sur "URL personnalisée du serveur" et entrez https://vault.votre-domaine.fr.

Applications mobiles : disponibles sur App Store (iOS) et Google Play (Android). La configuration est identique : dans les paramètres, section "Serveur auto-hébergé", entrez votre URL Vaultwarden. L'application utilise alors votre serveur personnel pour toutes les opérations.

Application desktop : Bitwarden Desktop est disponible pour Windows, macOS et Linux. Même procédure de configuration du serveur personnalisé.

Pour les équipes en entreprise, Bitwarden propose également une intégration avec les annuaires LDAP/Active Directory via le Directory Connector. Ce connecteur permet de synchroniser automatiquement les utilisateurs et groupes depuis votre AD vers les organisations Vaultwarden. Configurez l'accès LDAP depuis l'outil Bitwarden Directory Connector et pointez-le vers votre Vaultwarden. Consultez notre guide sur la sécurisation Active Directory pour les meilleures pratiques de gestion des accès.

Enfin, notez que Vaultwarden supporte le protocole WebSocket pour les notifications en temps réel — lorsqu'un membre de l'équipe modifie un mot de passe partagé, votre coffre est automatiquement synchronisé sans délai. Cette fonctionnalité est configurée via les labels Traefik décrits plus haut, qui routent les connexions WebSocket vers le port 3012 de Vaultwarden. Pour en apprendre davantage sur la documentation officielle de Traefik, consultez doc.traefik.io/traefik.

Intégration avec les outils DevOps et CI/CD

Vaultwarden ne se limite pas à un usage personnel ou d'équipe via l'interface graphique. Les API Bitwarden permettent d'intégrer le gestionnaire de mots de passe dans des pipelines CI/CD, des scripts d'automatisation et des outils DevOps.

Bitwarden propose un outil CLI officiel (bw) qui communique avec n'importe quel serveur Bitwarden compatible, y compris Vaultwarden :

npm install -g @bitwarden/cli

# Configurer le serveur (pointer vers Vaultwarden)
bw config server https://vault.votre-domaine.fr

# S'authentifier
bw login [email protected]

# Récupérer un secret depuis un script
export MOTDEPASSE_BDD=$(bw get password "Production Database" --session $BW_SESSION)

Dans un pipeline GitLab CI ou GitHub Actions, vous pouvez utiliser les secrets Vaultwarden pour injecter des credentials dynamiquement, sans jamais les écrire en dur dans les fichiers de configuration ou les variables d'environnement du CI/CD. La commande bw get récupère un secret par son nom ou son ID unique :

# Dans .gitlab-ci.yml
before_script:
  - bw config server $VAULT_URL
  - export BW_SESSION=$(bw unlock $VAULT_MASTER_PASSWORD --raw)
  - export DB_PASSWORD=$(bw get password "Prod DB" --session $BW_SESSION)
  - bw lock

Cette approche est plus sécurisée que de stocker des secrets dans les variables CI/CD du serveur, qui sont souvent accessibles à tous les membres du projet. Elle centralise la gestion des secrets dans un seul endroit auditable.

Pour les déploiements Kubernetes, vous pouvez combiner Vaultwarden avec l'opérateur External Secrets, qui synchronise automatiquement les secrets depuis Vaultwarden vers les Kubernetes Secrets natifs. Chaque secret est défini dans un manifest ExternalSecret qui pointe vers l'élément Bitwarden correspondant par son ID.

Pensez également à activer les logs d'audit dans Vaultwarden. Chaque accès à un secret, chaque modification de mot de passe et chaque connexion est loggée. Ces logs sont précieux en cas d'incident de sécurité pour déterminer quel secret a été accédé et à quel moment.

Monitoring et alertes de sécurité

Un gestionnaire de mots de passe auto-hébergé doit faire l'objet d'une surveillance active. Vaultwarden génère des logs structurés qu'il est possible d'intégrer dans une stack de monitoring centralisée.

Activez les logs détaillés dans les variables d'environnement :

LOG_FILE: "/data/vaultwarden.log"
LOG_LEVEL: "info"
EXTENDED_LOGGING: "true"

Surveillez les événements critiques avec un script simple qui alerte via email ou webhook Slack lorsque certains patterns sont détectés :

#!/bin/bash
# Détecter les tentatives d'authentification échouées
FAILED=$(grep -c "Username or password is incorrect" /var/lib/docker/volumes/vaultwarden/_data/vaultwarden.log)
if [ $FAILED -gt 10 ]; then
  curl -X POST -H 'Content-type: application/json' \
    --data "{\"text\":\"⚠️ Vaultwarden: $FAILED tentatives d'authentification échouées détectées\"}" \
    $SLACK_WEBHOOK
fi

Intégrez également Vaultwarden dans votre monitoring d'infrastructure avec un check HTTP simple qui vérifie que l'interface est accessible et retourne un code 200. Utilisez Uptime Kuma, Checkmk ou Zabbix pour cette surveillance de disponibilité.

Configurez des alertes sur les métriques système du conteneur Docker. Une utilisation mémoire anormalement élevée ou des pics CPU inexpliqués peuvent indiquer une activité suspecte. La commande docker stats vaultwarden donne une vue en temps réel de la consommation de ressources.

Enfin, surveillez les mises à jour de sécurité de Vaultwarden via le flux RSS de leur dépôt GitHub. Abonnez-vous aux notifications de releases pour être informé dès qu'une version corrective est publiée. La réactivité sur les patches de sécurité est cruciale sur un composant aussi sensible qu'un gestionnaire de mots de passe.

Questions fréquentes sur Vaultwarden

Vaultwarden est-il aussi sécurisé que Bitwarden cloud officiel ?

Le chiffrement de bout en bout est identique : vos données sont chiffrées localement avec AES-256 avant d'être envoyées au serveur, qu'il soit Bitwarden cloud ou Vaultwarden auto-hébergé. La sécurité dépend donc principalement de votre infrastructure serveur. Un Vaultwarden bien configuré (HTTPS, 2FA, sauvegardes, mises à jour régulières) peut être plus sûr que le cloud si vous avez les compétences pour maintenir votre VPS. En revanche, Bitwarden cloud bénéficie d'audits SOC 2 tiers et d'une équipe dédiée à la sécurité.

Quelle base de données est recommandée pour Vaultwarden en équipe ?

Pour un usage personnel ou une équipe de moins de 20 personnes, SQLite est parfaitement adapté. Au-delà, ou si vous souhaitez une meilleure résistance aux corruptions et des sauvegardes en ligne plus simples, Vaultwarden supporte MySQL/MariaDB et PostgreSQL. Configurez via DATABASE_URL=mysql://user:pass@host/vaultwarden ou DATABASE_URL=postgresql://user:pass@host/vaultwarden.

Comment migrer depuis Bitwarden cloud vers Vaultwarden ?

La migration est simple : depuis l'application Bitwarden, exportez votre coffre en JSON chiffré (Paramètres > Coffre > Exporter). Configurez l'application pour pointer vers votre serveur Vaultwarden. Importez le fichier JSON exporté (Outils > Importer des données). Les mots de passe, notes sécurisées et identités sont tous importés. Les pièces jointes doivent être téléchargées et réimportées manuellement.

Vaultwarden peut-il être utilisé sans nom de domaine (en IP) ?

Techniquement oui, mais non recommandé. Les applications clients Bitwarden exigent une connexion HTTPS sécurisée pour accepter les credentials. Vous pouvez générer un certificat auto-signé, mais devrez l'installer manuellement sur chaque appareil. Pour un usage professionnel, un nom de domaine avec Let's Encrypt est indispensable et rend la configuration bien plus simple.

Comment gérer la haute disponibilité de Vaultwarden ?

Vaultwarden ne supporte pas nativement le clustering. Pour la haute disponibilité, la solution recommandée est de faire de la réplication de base de données (PostgreSQL avec streaming replication) et d'utiliser un volume NFS partagé pour les attachments. En cas de panne du nœud principal, un basculement manuel vers un nœud secondaire avec les données répliquées restaure le service en quelques minutes. Pour des besoins enterprise critiques, considérez Bitwarden officiel self-hosted qui supporte des architectures HA natives.