Vous souhaitez héberger votre propre gestionnaire de mots de passe plutôt que de confier vos données sensibles à un service tiers ? Bitwarden est la solution open source la plus populaire et la plus sécurisée du marché. Dans ce tutoriel complet, nous allons vous montrer comment installer Bitwarden sur votre serveur Linux en utilisant Docker. Que vous soyez un administrateur système, un passionné de self-hosting ou une entreprise togolaise soucieuse de la souveraineté de ses données, ce guide vous accompagnera étape par étape vers une installation fonctionnelle et sécurisée

Pourquoi auto-héberger Bitwarden ?

Avant de plonger dans l’installation, comprenons pourquoi de plus en plus d’utilisateurs et d’entreprises choisissent d’héberger leur propre instance Bitwarden.

Les avantages de l’auto-hébergement

Contrôle total de vos données : Vos mots de passe restent sur votre serveur, dans votre infrastructure. Aucun tiers n’a accès à vos données chiffrées. Pour les entreprises au Togo et en Afrique, c’est une garantie de souveraineté numérique.

Confidentialité maximale : Même si Bitwarden utilise un chiffrement de bout en bout, certains préfèrent ne faire confiance à personne d’autre qu’eux-mêmes pour stocker leurs secrets.

Aucune limite d’utilisateurs : Contrairement aux offres cloud payantes, votre instance auto-hébergée peut accueillir autant d’utilisateurs que vous le souhaitez sans frais supplémentaires.

Personnalisation avancée : Vous pouvez configurer les politiques de sécurité, les sauvegardes et l’intégration avec vos systèmes existants exactement comme vous le souhaitez.

Indépendance : Votre gestionnaire de mots de passe fonctionne même si les serveurs Bitwarden officiels sont indisponibles ou si l’entreprise change sa politique.

Bitwarden officiel vs Vaultwarden

Il existe deux options pour auto-héberger Bitwarden :

Bitwarden officiel : L’image Docker officielle fournie par Bitwarden Inc. Elle est complète mais gourmande en ressources (minimum 2 Go de RAM, plusieurs conteneurs). Recommandée pour les grandes entreprises.

Vaultwarden (anciennement Bitwarden_RS) : Une implémentation alternative et légère du serveur Bitwarden, écrite en Rust. Elle est compatible avec toutes les applications clientes officielles Bitwarden mais consomme beaucoup moins de ressources (fonctionne avec 256 Mo de RAM). C’est la solution idéale pour les particuliers, les petites entreprises et les serveurs modestes.

Dans ce tutoriel, nous utiliserons Vaultwarden pour sa légèreté et sa facilité d’installation. Les applications clientes Bitwarden (mobile, desktop, extension navigateur) fonctionnent parfaitement avec Vaultwarden.

Prérequis pour l’installation

Avant de commencer, assurez-vous de disposer des éléments suivants :

Matériel et système

• Un serveur Linux (Ubuntu 20.04/22.04, Debian 11/12, ou toute distribution compatible Docker)
• Minimum 512 Mo de RAM (1 Go recommandé)
• 1 Go d’espace disque disponible
• Accès root ou sudo au serveur
• Connexion internet stable

Logiciels requis

• Docker installé et fonctionnel
• Docker Compose (version 2.x recommandée)
• Un nom de domaine pointant vers votre serveur (optionnel mais fortement recommandé pour HTTPS)
• Un reverse proxy avec SSL (Nginx, Traefik, ou Caddy) pour la production

Connaissances recommandées

• Bases de la ligne de commande Linux
• Compréhension basique de Docker
• Notions de réseau (ports, DNS, certificats SSL)

Étape 1 : Installation de Docker et Docker Compose

Si Docker n’est pas encore installé sur votre serveur, voici comment procéder sur Ubuntu/Debian.

Installer Docker

Commencez par mettre à jour votre système et installer les dépendances nécessaires :

sudo apt update
sudo apt upgrade -y
sudo apt install -y ca-certificates curl gnupg lsb-release

Ajoutez la clé GPG officielle de Docker :

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Configurez 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

Installez Docker Engine et Docker Compose :

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

Vérifiez que Docker fonctionne correctement :

sudo docker --version
sudo docker compose version

Ajoutez votre utilisateur au groupe docker pour éviter d’utiliser sudo à chaque commande :

sudo usermod -aG docker $USER

Déconnectez-vous et reconnectez-vous pour que les changements prennent effet.

Étape 2 : Préparation de l’environnement

Créez un répertoire dédié pour Bitwarden/Vaultwarden :

mkdir -p ~/bitwarden
cd ~/bitwarden

Créez les sous-répertoires pour les données persistantes :

mkdir -p data

Étape 3 : Configuration de Docker Compose

Créez le fichier docker-compose.yml qui définira notre conteneur Vaultwarden :

nano docker-compose.yml

Copiez et collez la configuration suivante :

version: '3.8'

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    environment:
      # Domaine de votre instance (IMPORTANT pour les notifications push)
      - DOMAIN=https://vault.votre-domaine.tg
      
      # Fuseau horaire
      - TZ=Africa/Lome
      
      # Désactiver les inscriptions publiques après avoir créé votre compte
      - SIGNUPS_ALLOWED=true
      
      # Activer l'interface d'administration (générez un token sécurisé)
      - ADMIN_TOKEN=VOTRE_TOKEN_ADMIN_SECURISE
      
      # Activer les WebSocket pour les notifications en temps réel
      - WEBSOCKET_ENABLED=true
      
      # Limiter les tentatives de connexion (protection brute force)
      - LOGIN_RATELIMIT_MAX_BURST=5
      - LOGIN_RATELIMIT_SECONDS=60
      
      # Journalisation
      - LOG_FILE=/data/vaultwarden.log
      - LOG_LEVEL=info
      
    volumes:
      - ./data:/data
    ports:
      - "8080:80"
      - "3012:3012"

Explication des paramètres importants

DOMAIN : L’URL complète de votre instance. Indispensable pour le bon fonctionnement des applications mobiles et des notifications push.

SIGNUPS_ALLOWED : Définissez sur true pour créer votre premier compte, puis passez à false pour empêcher les inscriptions non autorisées.

ADMIN_TOKEN : Un token secret pour accéder à l’interface d’administration. Générez-en un sécurisé avec cette commande :

openssl rand -base64 48

Copiez le résultat et remplacez VOTRE_TOKEN_ADMIN_SECURISE dans le fichier.

WEBSOCKET_ENABLED : Active les notifications en temps réel lorsqu’un mot de passe est modifié sur un autre appareil.

Étape 4 : Lancement de Vaultwarden

Démarrez le conteneur avec Docker Compose :

docker compose up -d

Vérifiez que le conteneur fonctionne correctement :

docker compose ps
docker compose logs -f vaultwarden

Vous devriez voir des logs indiquant que Vaultwarden a démarré avec succès. Appuyez sur Ctrl+C pour quitter les logs.

À ce stade, Vaultwarden est accessible sur http://IP_DE_VOTRE_SERVEUR:8080. Cependant, n’utilisez jamais Bitwarden sans HTTPS en production ! Passons à la configuration du reverse proxy.

Étape 5 : Configuration du reverse proxy avec Nginx (Optionnel si vous utilisez un tunnel cloudfare)

Pour sécuriser votre installation avec HTTPS, nous allons configurer Nginx comme reverse proxy avec un certificat SSL Let’s Encrypt.

Installer Nginx et Certbot

sudo apt install -y nginx certbot python3-certbot-nginx

Créer la configuration Nginx

Créez un fichier de configuration pour votre domaine :

sudo nano /etc/nginx/sites-available/vaultwarden

Copiez cette configuration (remplacez vault.votre-domaine.tg par votre domaine réel) :

server {
    listen 80;
    listen [::]:80;
    server_name vault.votre-domaine.tg;

    <em># Redirection vers HTTPS</em>
    location / {
        return 301 https://$server_name$request_uri;
    }
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name vault.votre-domaine.tg;

    <em># Les certificats SSL seront ajoutés par Certbot</em>
    
    <em># Taille maximale des uploads (pour les pièces jointes)</em>
    client_max_body_size 128M;

    <em># Proxy vers Vaultwarden</em>
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    <em># WebSocket pour les notifications</em>
    location /notifications/hub {
        proxy_pass http://127.0.0.1:3012;
        proxy_set_header Host $host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /notifications/hub/negotiate {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Activez le site et testez la configuration :

sudo ln -s /etc/nginx/sites-available/vaultwarden /etc/nginx/sites-enabled/
sudo nginx -t

Obtenir le certificat SSL

Utilisez Certbot pour obtenir un certificat Let’s Encrypt gratuit :

sudo certbot --nginx -d vault.votre-domaine.tg

Suivez les instructions à l’écran. Certbot configurera automatiquement le renouvellement du certificat.

Redémarrez Nginx :

sudo systemctl restart nginx

Votre instance Vaultwarden est maintenant accessible via HTTPS à l’adresse https://vault.votre-domaine.tg.

Étape 6 : Création de votre compte administrateur

Ouvrez votre navigateur et accédez à https://vault.votre-domaine.tg.

Créer votre premier compte

1. Cliquez sur Créer un compte
2. Entrez votre adresse email
3. Choisissez un mot de passe maître très sécurisé (minimum 16 caractères, utilisez la méthode de la phrase secrète)
4. Confirmez le mot de passe
5. Cliquez sur Soumettre

Désactiver les inscriptions publiques

Une fois votre compte créé, désactivez immédiatement les inscriptions pour empêcher les inconnus de créer des comptes sur votre serveur.

Modifiez le fichier docker-compose.yml :

cd ~/bitwarden
nano docker-compose.yml

Changez la ligne :

- SIGNUPS_ALLOWED=false

Redémarrez le conteneur :

docker compose down
docker compose up -d

Accéder à l’interface d’administration

L’interface d’administration vous permet de gérer les utilisateurs, voir les statistiques et configurer des paramètres avancés.

Accédez à https://vault.votre-domaine.tg/admin et entrez le token que vous avez configuré dans ADMIN_TOKEN.

Étape 7 : Configuration des clients Bitwarden

Maintenant que votre serveur est opérationnel, configurez les applications clientes pour se connecter à votre instance.

Extension navigateur

1. Installez l’extension Bitwarden pour Chrome, Firefox, Edge ou Safari
2. Cliquez sur l’icône Bitwarden
3. Cliquez sur la roue dentée (Paramètres)
4. Dans URL du serveur auto-hébergé, entrez https://vault.votre-domaine.tg
5. Connectez-vous avec votre email et mot de passe maître

Application mobile (Android/iOS)

1. Téléchargez Bitwarden depuis Google Play ou l’App Store
2. Avant de vous connecter, appuyez sur la roue dentée
3. Entrez l’URL de votre serveur : https://vault.votre-domaine.tg
4. Connectez-vous

Application desktop (Windows/Mac/Linux)

1. Téléchargez l’application desktop depuis le site officiel Bitwarden
2. Dans les paramètres, configurez l’URL du serveur auto-hébergé
3. Connectez-vous

Étape 8 : Sauvegardes automatiques

Les sauvegardes sont cruciales. Si vous perdez vos données Vaultwarden, vous perdez tous vos mots de passe.

Sauvegarde manuelle

Les données de Vaultwarden sont stockées dans le répertoire ~/bitwarden/data. Pour sauvegarder :

cd ~/bitwarden
tar -czvf backup-vaultwarden-$(date +%Y%m%d).tar.gz data/

Sauvegarde automatique avec cron

Créez un script de sauvegarde :

nano ~/bitwarden/backup.sh

Contenu du script :

#!/bin/bash

<em># Configuration</em>
BACKUP_DIR="/home/$USER/bitwarden-backups"
DATA_DIR="/home/$USER/bitwarden/data"
RETENTION_DAYS=30

<em># Créer le répertoire de sauvegarde s'il n'existe pas</em>
mkdir -p $BACKUP_DIR

<em># Nom du fichier de sauvegarde avec date</em>
BACKUP_FILE="$BACKUP_DIR/vaultwarden-backup-$(date +%Y%m%d-%H%M%S).tar.gz"

<em># Créer la sauvegarde</em>
tar -czvf $BACKUP_FILE $DATA_DIR

<em># Supprimer les sauvegardes plus anciennes que RETENTION_DAYS jours</em>
find $BACKUP_DIR -name "vaultwarden-backup-*.tar.gz" -mtime +$RETENTION_DAYS -delete

echo "Sauvegarde créée : $BACKUP_FILE"

Rendez le script exécutable et programmez-le avec cron :

bash

chmod +x ~/bitwarden/backup.sh
crontab -e

Ajoutez cette ligne pour une sauvegarde quotidienne à 3h du matin :

0 3 * * * /home/$USER/bitwarden/backup.sh >> /home/$USER/bitwarden/backup.log 2>&1

Stockage des sauvegardes hors site

Pour une sécurité optimale, copiez régulièrement vos sauvegardes vers un autre serveur ou un service cloud chiffré :

<em># Exemple avec rsync vers un serveur distant</em>
rsync -avz ~/bitwarden-backups/ user@serveur-backup:/backups/vaultwarden/

<em># Exemple avec rclone vers un cloud (Google Drive, S3, etc.)</em>
rclone copy ~/bitwarden-backups/ remote:vaultwarden-backups/

Étape 9 : Sécurisation avancée

Fail2ban pour bloquer les attaques brute force

Installez fail2ban pour bloquer les IP qui tentent trop de connexions échouées :

sudo apt install -y fail2ban

Créez un filtre pour Vaultwarden :

sudo nano /etc/fail2ban/filter.d/vaultwarden.conf

Contenu :

[Definition]
failregex = ^.*Username or password is incorrect\. Try again\. IP: <HOST>\. Username:.*$
ignoreregex =

Créez la configuration jail :

sudo nano /etc/fail2ban/jail.d/vaultwarden.local

Contenu :

[vaultwarden]
enabled = true
port = 80,443
filter = vaultwarden
logpath = /home/VOTRE_USER/bitwarden/data/vaultwarden.log
maxretry = 5
bantime = 3600
findtime = 600

Redémarrez fail2ban :

sudo systemctl restart fail2ban

Firewall avec UFW

Configurez le pare-feu pour n’autoriser que les ports nécessaires :

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow ssh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable

Mises à jour automatiques de Vaultwarden

Créez un script pour mettre à jour Vaultwarden automatiquement :

nano ~/bitwarden/update.sh

Contenu :

#!/bin/bash
cd /home/$USER/bitwarden
docker compose pull
docker compose up -d
docker image prune -f
echo "Vaultwarden mis à jour le $(date)"

chmod +x ~/bitwarden/update.sh

Programmez une mise à jour hebdomadaire :

crontab -e

Ajoutez :

0 4 * * 0 /home/$USER/bitwarden/update.sh >> /home/$USER/bitwarden/update.log 2>&1

Dépannage des problèmes courants

Le conteneur ne démarre pas

Vérifiez les logs :

docker compose logs vaultwarden

Causes fréquentes :

• Port 8080 déjà utilisé : changez le port dans docker-compose.yml
• Permissions incorrectes sur le dossier data : sudo chown -R $USER:$USER ~/bitwarden/data

Impossible de se connecter depuis l’application mobile

Vérifiez que :

• Le certificat SSL est valide (pas auto-signé)
• Le domaine est correctement configuré dans DOMAIN
• Les ports 80 et 443 sont ouverts dans le firewall

Les notifications push ne fonctionnent pas

Les notifications push nécessitent :

• WEBSOCKET_ENABLED=true
• La configuration correcte du WebSocket dans Nginx
• Un domaine valide configuré

Erreur « Invalid TOTP code »

Si l’authentification 2FA échoue, vérifiez que le fuseau horaire de votre serveur est correct :

timedatectl set-timezone Africa/Lome

LIRE AUSSI:Installer Graylog sous PROXMOX

Commandes utiles au quotidien

Voici un récapitulatif des commandes les plus utilisées :

<em># Démarrer Vaultwarden</em>
cd ~/bitwarden && docker compose up -d

<em># Arrêter Vaultwarden</em>
cd ~/bitwarden && docker compose down

<em># Voir les logs en temps réel</em>
cd ~/bitwarden && docker compose logs -f

<em># Redémarrer après modification de la config</em>
cd ~/bitwarden && docker compose down && docker compose up -d

<em># Mettre à jour Vaultwarden</em>
cd ~/bitwarden && docker compose pull && docker compose up -d

<em># Vérifier l'état du conteneur</em>
docker ps | grep vaultwarden

<em># Sauvegarder manuellement</em>
cd ~/bitwarden && tar -czvf backup-$(date +%Y%m%d).tar.gz data/

Félicitations ! Vous disposez maintenant de votre propre instance Bitwarden/Vaultwarden, entièrement sous votre contrôle. Vos mots de passe sont stockés sur votre infrastructure, chiffrés avec les meilleurs algorithmes disponibles, et accessibles depuis tous vos appareils.N’oubliez pas de tester régulièrement vos sauvegardes en les restaurant sur un environnement de test. Une sauvegarde qui n’a jamais été testée n’est pas une vraie sauvegarde !