MongoDB : débuter avec les documents, les collections, les requêtes et l'agrégation

MongoDB est une base de données NoSQL orientée documents : au lieu de ranger les données dans des tables avec des colonnes fixes, elle stocke des documents au format proche du JSON, regroupés dans des collections, chaque document pouvant contenir des sous-documents et des listes. C’est l’une des bases NoSQL les plus utilisées pour les applications web, les API et les données à structure variable.

Ce guide s’adresse aux développeurs, analystes et étudiants qui découvrent MongoDB, avec ou sans expérience du SQL. Vous y apprendrez à installer l’environnement, à comprendre le modèle documents, à insérer, lire, modifier et supprimer des données, à écrire des requêtes précises avec les opérateurs, à créer des index et à construire vos premiers pipelines d’agrégation.

Qu’est-ce que MongoDB ?

MongoDB est un système de gestion de base de données NoSQL qui stocke les informations sous forme de documents BSON, une représentation binaire du JSON. Les documents sont regroupés en collections, elles-mêmes rangées dans des bases de données. Aucun schéma n’est imposé : la structure des documents peut évoluer librement avec l’application.

Voici un document typique d’une collection produits :

{
  _id: ObjectId("..."),
  nom: "Casque audio sans fil",
  categorie: "Audio",
  prix: 89.9,
  stock: 42,
  tags: ["bluetooth", "promo"],
  fournisseur: { nom: "SonoPlus", pays: "France" },
  avis: [
    { note: 5, commentaire: "Très bon son" },
    { note: 4, commentaire: "Confortable" }
  ]
}

Quelques notions de base :

• Document : l’équivalent d’une ligne, mais qui peut contenir des objets imbriqués (fournisseur) et des tableaux (tags, avis).
• Collection : l’équivalent d’une table, qui regroupe des documents de même nature.
• Base de données : un ensemble de collections.
• _id : l’identifiant unique de chaque document, généré automatiquement (un ObjectId) si vous ne le fournissez pas.

Pourquoi utiliser une base de données NoSQL comme MongoDB ?

Le modèle documents répond à plusieurs besoins concrets :

• Une structure flexible : un catalogue où les téléviseurs, les livres et les vêtements n’ont pas les mêmes caractéristiques se modélise naturellement, sans colonnes vides ni tables multiples.
• Une correspondance directe avec le code : les documents ressemblent aux objets manipulés en JavaScript, Python ou Java, ce qui simplifie le développement.
• Moins de jointures : les données lues ensemble sont stockées ensemble (une commande et ses lignes), ce qui accélère les lectures.
• La montée en charge : MongoDB prend en charge la réplication (copies des données sur plusieurs serveurs) et le partitionnement (sharding) pour répartir de gros volumes.
• Un format adapté aux API : les données JSON reçues d’un service web ou d’un script de collecte s’enregistrent presque telles quelles.

Usages fréquents : back-end d’applications web et mobiles, catalogues produits, gestion de contenus, profils utilisateurs, journaux d’événements, données d’objets connectés, stockage de données collectées par web scraping en Python.

MongoDB vs SQL : les différences à connaître

Si vous connaissez déjà les bases relationnelles, ce tableau vous donne les correspondances :

Notion	SQL (MySQL, PostgreSQL…)	MongoDB
Stockage	Table	Collection
Enregistrement	Ligne	Document
Champ	Colonne	Champ (clé du document)
Schéma	Défini à l’avance, strict	Flexible, validation optionnelle
Données liées	Tables séparées et jointures	Imbrication ou références, $lookup
Langage de requête	SQL (SELECT, WHERE, GROUP BY)	Méthodes et opérateurs (find, $match, $group)
Clé primaire	Définie par le concepteur	_id, créé automatiquement
Filtrer	WHERE prix > 50	{ prix: { $gt: 50 } }
Agréger	GROUP BY categorie	{ $group: { _id: "$categorie" } }

Les deux mondes ne s’opposent pas : de nombreux projets utilisent une base relationnelle pour les données transactionnelles et MongoDB pour les contenus flexibles. Si vous voulez aussi maîtriser le SQL, notre guide pour apprendre SQL vous accompagne.

Comment débuter avec MongoDB : les étapes

Prenons un exemple concret : la base d’une petite boutique en ligne, avec une collection produits et une collection commandes.

Étape 1 — Installer MongoDB et Compass

Sur le site officiel de MongoDB, téléchargez MongoDB Community Server pour votre système. Sous Windows, l’installateur propose d’installer MongoDB comme service, qui démarre automatiquement avec l’ordinateur, ainsi que MongoDB Compass, l’interface graphique. Installez aussi mongosh, le shell en ligne de commande, et si besoin les Database Tools (qui contiennent mongoimport).

Alternative sans installation : créez un compte sur MongoDB Atlas, le service cloud, et déployez un cluster gratuit pour apprendre.

Étape 2 — Se connecter

Ouvrez Compass et connectez-vous avec la chaîne de connexion locale par défaut :

mongodb://localhost:27017

Ou, dans un terminal, lancez mongosh, qui se connecte à la même adresse par défaut. Pour Atlas, copiez la chaîne de connexion fournie par l’interface Atlas.

Étape 3 — Créer une base et une collection

Dans mongosh :

use boutique                        // sélectionne (et créera) la base
db.createCollection("produits")     // crée la collection
show collections

MongoDB crée réellement la base au premier enregistrement. Dans Compass, le bouton Create database fait la même chose en une étape.

Étape 4 — Insérer et importer des documents

db.produits.insertOne({
  nom: "Casque audio sans fil", categorie: "Audio",
  prix: 89.9, stock: 42, tags: ["bluetooth", "promo"]
})

db.produits.insertMany([
  { nom: "Enceinte portable", categorie: "Audio", prix: 59, stock: 15, tags: ["bluetooth"] },
  { nom: "Clavier mécanique", categorie: "Informatique", prix: 120, stock: 0 },
  { nom: "Souris ergonomique", categorie: "Informatique", prix: 45, stock: 30, tags: ["promo"] }
])

Pour générer des données de test, une boucle suffit dans mongosh :

for (let i = 1; i <= 100; i++) {
  db.test.insertOne({ numero: i, pair: i % 2 === 0 })
}

Pour importer un fichier existant, utilisez dans Compass Add data > Import JSON or CSV file, ou en ligne de commande :

mongoimport --db boutique --collection produits --file produits.json --jsonArray

Étape 5 — Lire les données avec find

db.produits.find()                                  // tous les documents
db.produits.find({ categorie: "Audio" })            // filtre d'égalité
db.produits.findOne({ nom: "Clavier mécanique" })   // premier document trouvé

// Projection : n'afficher que le nom et le prix
db.produits.find({ categorie: "Audio" }, { nom: 1, prix: 1, _id: 0 })

// Rechercher une valeur dans un tableau
db.produits.find({ tags: "promo" })

// Champ d'un sous-document
db.produits.find({ "fournisseur.pays": "France" })

db.produits.countDocuments({ stock: 0 })

La projection est un bon réflexe : ne ramener que les champs utiles réduit le volume transféré et rend les résultats lisibles.

Étape 6 — Filtrer avec les opérateurs de requêtes MongoDB

Les opérateurs commencent par $ :

// Comparaison : $gt, $gte, $lt, $lte, $ne
db.produits.find({ prix: { $gte: 50, $lte: 100 } })

// Appartenance : $in, $nin
db.produits.find({ categorie: { $in: ["Audio", "Informatique"] } })

// Tableau contenant toutes les valeurs : $all
db.produits.find({ tags: { $all: ["bluetooth", "promo"] } })

// Logique : $or, $and
db.produits.find({ $or: [{ stock: 0 }, { prix: { $gt: 100 } }] })

// Présence d'un champ : $exists
db.produits.find({ tags: { $exists: false } })

// Expression régulière : noms commençant par "Cla", insensible à la casse
db.produits.find({ nom: { $regex: "^cla", $options: "i" } })

Plusieurs conditions séparées par des virgules dans un même filtre sont combinées par un ET implicite : $and n’est nécessaire que pour combiner plusieurs conditions sur le même champ avec des opérateurs identiques, ou pour plus de lisibilité.

Étape 7 — Trier et paginer

db.produits.find().sort({ prix: -1 })                    // prix décroissant
db.produits.find().sort({ categorie: 1, prix: -1 })      // tri sur deux champs
db.produits.find().sort({ prix: -1 }).limit(5)           // top 5
db.produits.find().sort({ nom: 1 }).skip(10).limit(10)   // page 2 de 10 résultats

Pour une pagination stable, triez toujours sur un champ déterministe (au besoin, ajoutez _id au tri).

Étape 8 — Mettre à jour et supprimer

// Modifier un champ
db.produits.updateOne({ nom: "Clavier mécanique" }, { $set: { stock: 25 } })

// Incrémenter
db.produits.updateMany({ categorie: "Audio" }, { $inc: { stock: 10 } })

// Ajouter à un tableau : $push (accepte les doublons), $addToSet (sans doublon)
db.produits.updateOne({ nom: "Enceinte portable" }, { $addToSet: { tags: "promo" } })
db.produits.updateOne(
  { nom: "Casque audio sans fil" },
  { $addToSet: { tags: { $each: ["nouveau", "garantie-2-ans"] } } }
)

// Upsert : met à jour ou crée si absent
db.produits.updateOne(
  { nom: "Webcam HD" },
  { $set: { categorie: "Informatique", prix: 69, stock: 12 } },
  { upsert: true }
)

// Supprimer
db.produits.deleteOne({ nom: "Webcam HD" })
db.produits.deleteMany({ stock: 0 })
db.test.drop()            // supprime la collection entière

Attention : un updateOne sans opérateur comme $set est refusé par les versions récentes, mais replaceOne remplace le document entier. Et un deleteMany({}) avec un filtre vide supprime tous les documents de la collection.

L’agrégation MongoDB : analyser et joindre les données

Le pipeline d’agrégation traite les documents en plusieurs étapes successives, chacune transformant le résultat de la précédente. C’est l’équivalent MongoDB des requêtes SQL avec GROUP BY et JOIN.

// Valeur du stock par catégorie, pour les produits en stock
db.produits.aggregate([
  { $match: { stock: { $gt: 0 } } },
  { $group: {
      _id: "$categorie",
      nbProduits: { $sum: 1 },
      valeurStock: { $sum: { $multiply: ["$prix", "$stock"] } },
      prixMoyen: { $avg: "$prix" }
  } },
  { $sort: { valeurStock: -1 } }
])

Les étapes les plus utilisées :

Étape	Rôle	Équivalent SQL
$match	Filtrer les documents	WHERE
$group	Regrouper et calculer ($sum, $avg, $min, $max)	GROUP BY
$sort	Trier	ORDER BY
$project	Choisir, renommer ou calculer des champs	SELECT
$unwind	Déplier un tableau en plusieurs documents	—
$lookup	Joindre une autre collection	LEFT JOIN
$limit / $skip	Limiter, paginer	LIMIT / OFFSET

Pour une jointure, $lookup ajoute à chaque commande les informations du produit correspondant :

db.commandes.aggregate([
  { $lookup: {
      from: "produits",
      localField: "idProduit",
      foreignField: "_id",
      as: "produit"
  } },
  { $unwind: "$produit" },
  { $project: { date: 1, quantite: 1, "produit.nom": 1, "produit.prix": 1 } }
])

Pour obtenir simplement la liste des valeurs distinctes d’un champ : db.produits.distinct("categorie"). Dans Compass, l’onglet Aggregations permet de construire le pipeline étape par étape en visualisant le résultat intermédiaire de chacune, ce qui est idéal pour apprendre.

Les index : accélérer vos requêtes MongoDB

Sans index, MongoDB doit parcourir toute la collection pour trouver les documents correspondant à un filtre (collection scan). Un index sur les champs souvent filtrés ou triés évite ce parcours.

db.produits.createIndex({ categorie: 1 })               // index simple, croissant
db.produits.createIndex({ categorie: 1, prix: -1 })     // index composé
db.clients.createIndex({ email: 1 }, { unique: true })  // interdit les doublons
db.produits.getIndexes()

// Vérifier qu'une requête utilise un index
db.produits.find({ categorie: "Audio" }).explain("executionStats")

Dans le résultat d’explain, une étape IXSCAN indique l’utilisation d’un index, une étape COLLSCAN un parcours complet. Dans Compass, l’onglet Indexes permet de créer un index en quelques clics, et l’onglet Explain Plan affiche le plan d’exécution.

Notre conseil : n’indexez pas tout. Chaque index accélère la lecture mais ralentit légèrement les écritures et consomme de la mémoire. Indexez les champs réellement utilisés dans vos filtres et tris fréquents.

Modéliser vos données et les utiliser dans une application

Imbriquer ou référencer ?

C’est la question de conception la plus importante sur MongoDB, et celle qui déroute le plus les personnes venant du SQL. Il existe deux façons de représenter des données liées.

L’imbrication consiste à placer les données liées directement dans le document parent : les lignes d’une commande dans la commande, l’adresse dans le client, les avis dans le produit. Une seule lecture ramène tout, sans jointure, et la mise à jour de l’ensemble est atomique, c’est-à-dire qu’elle réussit ou échoue d’un bloc.

La référence consiste à stocker l’identifiant d’un document d’une autre collection, comme une clé étrangère : la commande contient idClient, et les informations du client restent dans la collection clients. On les réunit au besoin avec $lookup ou par deux requêtes successives dans l’application.

Situation	Choix conseillé	Exemple
Données toujours lues ensemble	Imbriquer	Lignes d’une commande
Relation « un à quelques-uns » stable	Imbriquer	Adresses d’un client
Relation « un à très nombreux », sans limite	Référencer	Commandes d’un client sur plusieurs années
Données partagées par de nombreux documents	Référencer	Fiche fournisseur utilisée par des centaines de produits
Données modifiées très souvent et indépendamment	Référencer	Stock en temps réel

La règle pratique est de partir des requêtes de l’application : quelles informations sont affichées ensemble sur un même écran ? Ce sont elles qu’il faut stocker ensemble. Notre conseil : dessinez vos principaux écrans ou appels d’API avant de créer la moindre collection.

Même sans schéma imposé, MongoDB permet d’ajouter une validation à une collection (règles au format JSON Schema) pour exiger certains champs ou certains types. C’est une bonne pratique dès qu’une application passe en production : la flexibilité reste disponible, mais les erreurs de saisie sont bloquées à l’écriture.

Utiliser MongoDB depuis une application ou un script

Le shell et Compass servent à apprendre, explorer et administrer. En pratique, les données sont le plus souvent lues et écrites par une application, au moyen d’un pilote (driver) officiel. MongoDB en propose pour la plupart des langages : JavaScript avec Node.js, Python avec PyMongo, Java, C#, PHP, Go, entre autres.

La bonne nouvelle, c’est que la syntaxe reste très proche de celle du shell : les mêmes méthodes (find, insertOne, updateOne, aggregate) et les mêmes opérateurs se retrouvent dans chaque langage. Ce que vous apprenez dans mongosh se transpose donc directement dans votre code.

Deux bonnes pratiques à adopter dès le départ : ne jamais écrire la chaîne de connexion et le mot de passe en dur dans le code (utilisez des variables d’environnement), et créer un utilisateur de base de données avec les seuls droits nécessaires à l’application plutôt que d’utiliser un compte administrateur.

Les erreurs fréquentes avec MongoDB (et comment les éviter)

En formation, ces erreurs reviennent chez presque tous les débutants :

Erreur	Conséquence	Solution
Nom de collection ou de champ mal orthographié	Requête vide, ou nouvelle collection créée par erreur	Vérifier avec show collections et un findOne()
Nombre stocké en texte ("89.9")	Comparaisons et tris faux	Stocker les nombres et dates avec les bons types
deleteMany({}) ou updateMany({}) avec un filtre vide	Tous les documents sont touchés	Tester le filtre avec find() avant de modifier
$push utilisé à la place de $addToSet	Doublons dans les tableaux	Utiliser $addToSet pour des valeurs uniques
Aucun index sur les champs filtrés	Requêtes lentes à mesure que la collection grossit	Créer les index adaptés et vérifier avec explain
Tableaux imbriqués qui grossissent sans limite	Documents trop volumineux (16 Mo maximum)	Placer les données illimitées dans une collection séparée
Reproduire un modèle relationnel à l’identique	Jointures $lookup partout, performances médiocres	Imbriquer les données lues ensemble

Comment apprendre MongoDB et progresser ?

MongoDB s’apprend vite par la pratique, en tapant les commandes vous-même. Voici le parcours que nous recommandons :

1. Première heure : installer MongoDB, Compass et mongosh, comprendre documents, collections et _id, créer une base et importer un jeu de données.
2. Deuxième heure : lire avec find, projections, opérateurs de comparaison et logiques, recherche dans les tableaux, tri et pagination.
3. Ensuite : insertions multiples, mises à jour avec $set, $inc, $push, $addToSet, upsert et suppressions contrôlées.
4. Enfin : pipelines d’agrégation, jointures avec $lookup et index, puis un petit projet complet relié à une application ou à un script Python.

Pour être guidé, la formation vidéo pour débuter sur MongoDB d’EspritAcadémique dure deux heures, sans prérequis. Elle couvre notamment :

• l’installation de MongoDB sous Windows, la connexion et la création d’une base et d’une collection ;
• l’import de données et la lecture avec find, limit et la recherche dans les tableaux ;
• les opérateurs de comparaison, logiques et d’appartenance ($gt, $or, $in, $all…) ;
• les mises à jour avec $set, $push, $addToSet, $each et l’upsert ;
• le tri, la pagination, $group, distinct et les jointures avec $lookup ;
• la création d’index en ligne de commande et dans Compass.

Pour comparer avec la syntaxe relationnelle, nos exemples de requêtes SQL montrent l’équivalent des principales opérations. Et si vos données doivent ensuite alimenter une plateforme analytique, Microsoft Fabric fait partie des solutions capables de les centraliser.

En résumé

MongoDB stocke les données sous forme de documents flexibles regroupés en collections, ce qui le rend bien adapté aux applications web et aux données à structure variable. Maîtrisez d’abord les opérations de base (insertOne, find, updateOne, deleteOne), puis les opérateurs de filtre, le tri et la pagination. Ajoutez des index sur les champs les plus interrogés et utilisez le pipeline d’agrégation pour vos analyses et vos jointures. Testez toujours un filtre avec find avant de modifier ou de supprimer.