🍃 MongoDB – NoSQL, Réplication, Sécurité & Tuning

La BDD NoSQL de type Document

MongoDB est la BDD NoSQL la plus populaire. Elle stocke les données non pas en lignes, mais en Documents.

Un Document est un objet BSON (Binary JSON). C'est du JSON binaire, qui supporte plus de types de données (ex: Date, ObjectId, Int64).

Exemple de Document (JSON)

{
  "_id": ObjectId("67f51..."), // Clé primaire (gérée auto)
  "titre": "Mon Article",
  "contenu": "Texte de l'article...",
  "status": "publie",
  "tags": ["mongo", "nosql", "guide"], // Array (natif)
  "auteur": { // Objet imbriqué (dénormalisation)
    "nom": "Alice",
    "email": "alice@mail.com"
  },
  "date_pub": ISODate("2025-11-01T10:00:00Z"),
  "vues": 1500
}

mongosh (CLI)

Le shell interactif (JS) moderne de Mongo. (Remplace l'ancien mongo).

# Lancer le shell (connexion à localhost:27017)
$ mongosh

Current Mongosh Log ID: ...
Connecting to:    mongodb://127.0.0.1:27017/
Using MongoDB:    7.0.x
...
test> 

# (Le prompt 'test' indique la BDD actuelle)

# Changer de BDD
test> use ideo_lab_db
switched to db ideo_lab_db

ideo_lab_db> 

# Lister les BDD
ideo_lab_db> show dbs
admin   ...
config  ...
local   ...

# Lister les Collections
ideo_lab_db> show collections

MongoDB Compass (UI Officielle)

Compass est l'IDE/UI graphique officiel (gratuit) pour MongoDB. C'est l'équivalent de PhpMyAdmin ou DBeaver.

Fonctionnalités :

• Visualisation (CRUD) des documents (BSON/JSON).
• Création/Gestion des Index.
• Analyse (explain()) visuelle des requêtes.
• Analyse du schéma (Schema Validation).
• Outil d'Aggregation Pipeline.

Hiérarchie

BDD (Database) : Un conteneur pour les collections.
Collection : Un conteneur pour les documents (équivalent d'une "table" SQL).
Document : Un objet BSON (équivalent d'une "ligne" SQL).

Création Implicite

Dans Mongo, tout est créé à la volée. Pas besoin de CREATE DATABASE ou CREATE TABLE.

# 1. Changer vers une BDD (même si elle n'existe pas)
test> use nouvelle_db
switched to db nouvelle_db

# 2. 'nouvelle_db' n'est PAS encore créée.
#    (Elle ne sera créée que lors de la 1ère insertion)

# 3. Insérer dans une 'collection' (même si elle n'existe pas)
nouvelle_db> db.articles.insertOne({ titre: "Test" })

# 4. MAINTENANT, 'nouvelle_db' et 'articles' existent.

Création Explicite

Vous pouvez (rarement) avoir besoin de créer une collection avec des options (ex: timeseries, validation).

ideo_lab_db> db.createCollection("logs", {
  timeseries: {
    timeField: "timestamp"
  }
})

insertOne()

db.articles.insertOne({
  titre: "Mon Article 1",
  tags: ["mongo", "guide"],
  auteur: { nom: "Alice" }
})
// Réponse:
{
  "acknowledged" : true,
  "insertedId" : ObjectId("67f51...")
}

insertMany()

db.articles.insertMany([
  { _id: 10, titre: "Article 2" }, // On peut forcer l'_id
  { titre: "Article 3", status: "brouillon" }
])
// Réponse:
{
  "acknowledged" : true,
  "insertedIds" : [ 10, ObjectId("67f52...") ]
}

Opérateurs de Comparaison

// WHERE vues > 1000
db.articles.find({ vues: { $gt: 1000 } })

// (Autres: $gte (>=), $lt (<), $lte (<=), $ne (!=))

// WHERE status IN ('publie', 'archive')
db.articles.find({ status: { $in: ["publie", "archive"] } })

// WHERE tags CONTAINS 'mongo' AND 'python'
db.articles.find({ tags: { $all: ["mongo", "python"] } })

// WHERE 'description' exists
db.articles.find({ description: { $exists: true } })

Opérateurs Logiques

// WHERE (status = 'publie' OR vues > 5000)
db.articles.find({
  $or: [
    { status: "publie" },
    { vues: { $gt: 5000 } }
  ]
})

// WHERE (status = 'publie' AND vues > 1000)
db.articles.find({
  $and: [
    { status: "publie" },
    { vues: { $gt: 1000 } }
  ]
})
// (Note: { status: "publie", vues: { $gt: 1000 } } est plus simple)

// Regex (WHERE titre LIKE 'Mon%')
db.articles.find({ titre: { $regex: '^Mon', $options: 'i' } })

updateOne() / updateMany()

⚠️ Attention : L'update nécessite des "opérateurs d'update" (ex: $set).

// (MAUVAIS: Écrase tout le document)
// db.articles.updateOne({_id: 1}, { status: "archive" })

// 1. $set (Mettre à jour/Ajouter un champ)
db.articles.updateOne(
  { _id: 1 }, // Filtre
  { $set: { status: "archive", "auteur.nom": "Alice V2" } }
)

// 2. $unset (Supprimer un champ)
db.articles.updateOne(
  { _id: 1 },
  { $unset: { description: "" } }
)

Opérateurs (Atomiques)

// 3. $inc (Incrémenter)
db.articles.updateOne(
  { _id: 1 },
  { $inc: { vues: 1 } } // (Atomique)
)

// 4. $push (Ajouter à un Array)
db.articles.updateOne(
  { _id: 1 },
  { $push: { tags: "news" } }
)

// 5. $pull (Retirer d'un Array)
db.articles.updateOne(
  { _id: 1 },
  { $pull: { tags: "mongo" } }
)

Supprimer des Documents

// Supprime UN seul document (le 1er trouvé)
db.articles.deleteOne({ status: "brouillon" })

// Supprime TOUS les documents (selon filtre)
db.articles.deleteMany({ status: "archive" })

// Supprime TOUS les documents (filtre vide)
db.articles.deleteMany({ })

Supprimer (Drop)

// Supprime la collection (et les index)
db.articles.drop()

// Se positionner sur la BDD
use ideo_lab_db

// Supprime la BDD actuelle
db.dropDatabase()

L'index _id (Défaut)

Par défaut, MongoDB crée un index unique sur le champ _id. Une recherche par _id est donc instantanée.

COLLSCAN (Scan de Collection)

Si vous cherchez sur un champ non-indexé (ex: titre), Mongo doit faire un COLLSCAN : il doit lire **chaque document** de la collection (lent).

IXSCAN (Scan d'Index)

Si vous créez un index sur titre, Mongo crée une structure (Arbre B+) triée. Une recherche sur titre utilise l'index (IXSCAN) et trouve le document instantanément, sans lire toute la collection.

Index Composé (Compound)

Un index sur plusieurs champs (pour les requêtes find+sort).

// Pour la requête:
// db.users.find({ age: { $gt: 30 } }).sort({ nom: 1 })

// On crée l'index (l'ordre compte !)
db.users.createIndex({ age: 1, nom: 1 })

Index TTL (Time-To-Live)

Supprime automatiquement les documents après X secondes. Parfait pour les logs, sessions, cache.

// Supprime les docs 1h (3600s) après 'date_creation'
db.logs.createIndex(
  { "date_creation": 1 },
  { expireAfterSeconds: 3600 }
)

Index Texte (Full-Text Search)

Permet la recherche "Google" (stop-words, stemming...).

// 1. Créer l'index (sur 'titre' et 'contenu')
db.articles.createIndex({
  titre: "text",
  contenu: "text"
})

// 2. Utiliser l'opérateur $text
db.articles.find({
  $text: {
    $search: "python guide" // (Cherche 'python' ET 'guide')
  }
})

Haute Disponibilité (HA)

Un "Replica Set" est un groupe (minimum 3) de serveurs mongod qui se copient les uns les autres. Le but est la **Haute Disponibilité** (failover).

Composition (P-S-A)

• 1 Primaire (Primary) : Le seul nœud qui accepte les écritures.
• 2+ Secondaires (Secondary) : Reçoivent les données (oplog) du Primaire. Acceptent les lectures (optionnel).
• (Optionnel) 1 Arbiter : Un nœud "juge" léger, qui ne stocke pas de données, mais vote en cas d'élection.

Scénario de "Failover"

(App) -> [Primaire (N1)] -> (Copie) -> [Secondaire (N2)]
   |          |                          |
   |          +---- (Copie) ------------>+
   |                                     |
   +<----------- (Heartbeat) ----------->+

--- (N1 CRASHE) ---

(App) X [Primaire (N1)]   (Timeout)   [Secondaire (N2)]
   |                                     |
   | (Élection: N2 devient Primaire)     |
   |                                     |
(App) ---------------------------------> [Nouveau Primaire (N2)]

1. explain("executionStats")

L'outil n°1. Montre si une requête utilise un index (IXSCAN) ou un scan de collection (COLLSCAN). (Voir 3.2).

2. Outils CLI

# (Similaire à 'top')
# Moniteur en temps réel (Read/Write, ms)
mongotop

# (Similaire à 'vmstat')
# Stats globales (connexions, requêtes/sec, faults)
mongostat

3. Tuning (mongod.conf)

WiredTiger (Moteur de stockage) :
Par défaut, WiredTiger utilise 50% de la RAM ((RAM - 1GB) / 2) pour son cache interne.

# /etc/mongod.conf
storage:
  wiredTiger:
    engineConfig:
      # Augmenter le cache (ex: 8GB)
      cacheSizeGB: 8

Tuning (Linux) :
Désactiver THP (Transparent Huge Pages) et augmenter ulimit (fichiers ouverts) sont des optimisations courantes.

Djongo (Traducteur SQL -> Mongo)

Problème : Django est un ORM SQL. MongoDB est NoSQL. Ils sont incompatibles.

Solution : djongo. Un "fork" de Django qui traduit les requêtes de l'ORM Django (SQL-like) en requêtes MongoDB (JSON).

⚠️ Attention : djongo peut être instable et n'est pas toujours à jour avec les dernières versions de Django. (django-mongoengine est l'alternative, mais n'est *pas* l'ORM Django).

Installation

(venv) $ pip install djongo

settings.py (DATABASES)

Remplacez la configuration DATABASES.

DATABASES = {
    'default': {
        'ENGINE': 'djongo',
        'NAME': 'ideo_lab_django', // Nom de la BDD Mongo
        'CLIENT': {
            'host': '127.0.0.1',
            'port': 27017,
            'username': 'djongo_user', // (Si auth activée)
            'password': 'password',
            'authSource': 'ideo_lab_django',
        }
    }
}

# (Désactiver les 'related_field' non-supportés)
SILENCED_SYSTEM_CHECKS = ["fields.E300", "fields.E307"]

Vous pouvez ensuite utiliser makemigrations, migrate, et l'Admin Django (presque) normalement.

Navigation

mongosh
show dbs
use ideo_lab_db
show collections
db.stats()
db.collection.stats()

CRUD (Create, Read)

db.articles.insertOne({ ... })
db.articles.insertMany([ ... ])

db.articles.find().pretty()
db.articles.findOne({ _id: 1 })
db.articles.find({ status: "publie" })
db.articles.find({ vues: { $gt: 100 } })
db.articles.find({ $or: [ ... ] })
db.articles.find().sort({ date: -1 }).limit(5)

CRUD (Update, Delete)

db.articles.updateOne(
  { _id: 1 },
  { $set: { status: "archive" } }
)
db.articles.updateMany(
  { status: "draft" },
  { $set: { status: "archive" } }
)
db.articles.updateOne(
  { _id: 1 },
  { $inc: { vues: 1 } }
)

db.articles.deleteOne({ _id: 1 })
db.articles.deleteMany({ status: "archive" })

db.articles.drop() # Supprime la collection
db.dropDatabase() # Supprime la BDD