MongoDB en production : installation, sécurisation et sauvegarde

Pourquoi MongoDB avec Docker ?

Installer MongoDB directement sur le serveur fonctionne mais crée des dépendances système difficiles à gérer. Avec Docker, MongoDB tourne dans un container isolé, facile à mettre à jour, à sauvegarder et à migrer.

1. Lancer MongoDB avec Docker

docker run -d \
  --name mongodb \
  -p 127.0.0.1:27017:27017 \
  --restart always \
  -v /home/app/mongo-data:/data/db \
  mongo:7

Explications :

• -p 127.0.0.1:27017:27017 : MongoDB n'est accessible que depuis le serveur lui-même, pas depuis internet
• --restart always : MongoDB redémarre automatiquement si le serveur reboot ou si le container plante
• -v /home/app/mongo-data:/data/db : les données sont stockées sur le serveur hôte et non dans le container. Si le container est supprimé, les données sont préservées

Vérifier que MongoDB tourne :

docker ps | grep mongodb

2. Le problème de sécurité par défaut

Par défaut, MongoDB démarre sans authentification. N'importe qui ayant accès au serveur peut lire, modifier ou supprimer toutes les données sans mot de passe.

En 2017, des centaines de milliers de bases MongoDB exposées sur internet ont été effacées par des attaquants qui demandaient une rançon pour les restaurer. La plupart n'avaient aucune authentification.

Il faut activer l'authentification avant de mettre quoi que ce soit en production.

3. Créer les utilisateurs

Se connecter à MongoDB :

docker exec -it mongodb mongosh

Créer un utilisateur administrateur :

use admin
db.createUser({
  user: "adminUser",
  pwd: "MotDePasseFort",
  roles: ["root"]
})

Créer un utilisateur dédié à l'application avec des droits limités :

use mabase
db.createUser({
  user: "appUser",
  pwd: "AutreMotDePasse",
  roles: [{ role: "readWrite", db: "mabase" }]
})
exit

Il est important de créer deux utilisateurs distincts :

• L'administrateur a tous les droits mais ne doit être utilisé que pour les opérations de maintenance
• L'utilisateur applicatif a uniquement les droits de lecture et écriture sur sa base de données

4. Activer l'authentification

Recrée le container avec l'option --auth :

docker stop mongodb
docker rm mongodb
docker run -d \
  --name mongodb \
  -p 127.0.0.1:27017:27017 \
  --restart always \
  -v /home/app/mongo-data:/data/db \
  mongo:7 --auth

Les données sont préservées grâce au volume. Seul le container est recréé.

Vérifier que l'authentification fonctionne :

docker exec -it mongodb mongosh -u adminUser -p "MotDePasseFort" --authenticationDatabase admin

5. Connecter l'application à MongoDB

Dans le fichier .env de l'application, mets à jour l'URI de connexion :

MONGO_URI=mongodb://appUser:AutreMotDePasse@MONGO_IP:27017/mabase?authSource=mabase

Pour trouver l'IP du container MongoDB :

docker inspect mongodb | grep IPAddress

Note : cette IP peut changer si le container est recréé. Pour une configuration plus stable, utilise un réseau Docker dédié.

6. Créer un réseau Docker dédié

Plutôt que d'utiliser l'IP du container qui peut changer, crée un réseau Docker pour que les containers communiquent par leur nom :

docker network create app-network

Recrée les containers en les attachant à ce réseau :

docker run -d \
  --name mongodb \
  --network app-network \
  -p 127.0.0.1:27017:27017 \
  --restart always \
  -v /home/app/mongo-data:/data/db \
  mongo:7 --auth

docker run -d \
  --name mon-backend \
  --network app-network \
  --env-file /home/app/.env \
  -p 8000:8000 \
  --restart always \
  mon-backend-image

Maintenant dans le .env du backend, utilise le nom du container MongoDB au lieu de son IP :

MONGO_URI=mongodb://appUser:AutreMotDePasse@mongodb:27017/mabase?authSource=mabase

7. Sauvegarder MongoDB automatiquement

Une base de données non sauvegardée est une base de données perdue. Voici un script de sauvegarde automatique.

Créer le dossier de sauvegarde :

mkdir -p /home/app/backups/mongodb

Créer le script :

sudo nano /home/app/backup-mongo.sh

#!/bin/bash
DATE=$(date +%Y-%m-%d_%H-%M)
BACKUP_DIR="/home/app/backups/mongodb"

docker exec mongodb mongodump \
  -u appUser \
  -p AutreMotDePasse \
  --authenticationDatabase mabase \
  --db mabase \
  --out /tmp/backup-$DATE

docker cp mongodb:/tmp/backup-$DATE $BACKUP_DIR/

find $BACKUP_DIR -type d -mtime +7 -exec rm -rf {} +

echo "Sauvegarde terminee : $DATE"

sudo chmod +x /home/app/backup-mongo.sh

Tester le script :

sudo /home/app/backup-mongo.sh

Automatiser avec cron, chaque nuit à 2h :

sudo crontab -e

0 2 * * * /home/app/backup-mongo.sh >> /var/log/backup-mongo.log 2>&1

8. Restaurer une sauvegarde

En cas de problème, voici comment restaurer une sauvegarde :

docker cp /home/app/backups/mongodb/backup-2026-05-13_02-00 mongodb:/tmp/restore
docker exec mongodb mongorestore \
  -u adminUser \
  -p MotDePasseFort \
  --authenticationDatabase admin \
  --db mabase \
  /tmp/restore/mabase

9. Migrer des données depuis une autre machine

Pour transférer une base de données d'une machine locale vers le serveur de production :

Sur la machine locale, exporte la base :

mongodump --uri="mongodb://localhost:27017" --db=mabase --out=./backup

Transfère le backup sur le serveur :

scp -r ./backup user@IP_SERVEUR:/home/app/

Sur le serveur, importe dans le container MongoDB :

docker cp /home/app/backup/mabase mongodb:/tmp/restore
docker exec mongodb mongorestore \
  -u adminUser \
  -p MotDePasseFort \
  --authenticationDatabase admin \
  --db mabase \
  /tmp/restore

Conclusion

MongoDB bien configuré est une base solide pour n'importe quelle application en production. Les trois points essentiels sont l'authentification obligatoire, l'accès restreint au localhost et les sauvegardes automatiques régulières.

Ne jamais exposer MongoDB directement sur internet et ne jamais laisser l'authentification désactivée en production.