Docker pour les bases NoSQL : MongoDB, Cassandra et Neo4j en local

MySQL, c’est parfait pour 90% des projets. Mais parfois tu tombes sur un cas qui ne rentre pas dans le moule relationnel : des données très imbriquées, un volume colossal à écrire, ou des relations complexes entre entités. C’est là qu’entrent en jeu les bases NoSQL.

Ce guide montre comment lancer trois types de bases NoSQL en local avec Docker Compose : MongoDB (documents), Cassandra (colonnes), Neo4j (graphes). Si tu n’es pas encore à l’aise avec les concepts Docker (image, conteneur, volume), commence par l’article Environnement LAMP avec Docker avant de revenir ici.

Quand sortir du SQL relationnel ?

Le SQL relationnel gère très bien les données structurées avec des relations claires. Il commence à montrer ses limites dans ces situations :

• Données semi-structurées : chaque enregistrement a des champs différents (catalogue produit avec attributs variables, CMS flexible)
• Écriture à très haute fréquence : millions d’événements par seconde (logs, IoT, métriques)
• Relations complexes : recommandations, réseaux sociaux, détection de fraude où les liens entre données sont aussi importants que les données elles-mêmes

Les 3 types et leurs cas d’usage

MongoDB: base orientée documents

MongoDB stocke des documents JSON avec une structure flexible. Chaque document peut avoir des champs différents, ce qui le rend idéal pour les données hétérogènes.

Entreprises qui l’utilisent :

SNCF Connect & Tech a migré 130 millions de commandes depuis Oracle vers MongoDB pour moderniser leur plateforme. La flexibilité du schéma permet de gérer des billets simples, des abonnements et des réservations complexes dans la même collection sans jongler avec des dizaines de tables jointes.

Criteo traite plus d’un milliard de transactions publicitaires par jour avec MongoDB. Le schéma de chaque campagne peut varier d’un annonceur à l’autre : exactement le genre de cas où une base relationnelle avec ALTER TABLE à répétition devient ingérable.

Bouygues Telecom et AXA Banque l’utilisent pour construire une vue client unique, en agrégeant des données issues de systèmes legacy hétérogènes.

Cas d’usage typiques : catalogues e-commerce (attributs variables selon les catégories), CMS, profils utilisateurs, agrégation de données multi-sources.

Cassandra: base orientée colonnes

Cassandra est conçue pour écrire des millions d’événements par seconde de façon distribuée, sans point de défaillance unique. Son modèle de données est optimisé pour les requêtes en lecture avec des patterns d’accès prévisibles.

Entreprises qui l’utilisent :

Apple gère plus de 160 000 instances Cassandra réparties sur des milliers de clusters, pour un total de plus de 100 pétaoctets. Chaque service Apple qui doit stocker des données utilisateur à grande échelle finit souvent sur Cassandra.

Netflix dépasse un trillion de requêtes par jour sur 10 000 instances et 6 pétaoctets de données. Ils l’utilisent notamment pour stocker les états de lecture (à quelle seconde tu t’es arrêté sur chaque série), les métadonnées d’assets et les logs de recommandations.

Instagram s’en sert pour les feeds utilisateurs et les logs d’activité. Quand quelqu’un publie une photo, le système pousse l’information vers les followers en écriture massive. Cassandra absorbe ça avec une latence stable, même à 1 million d’écritures par seconde.

Uber l’utilise pour les paiements et l’état des commandes, avec des dizaines de millions de requêtes par seconde sur des centaines de clusters.

Cas d’usage typiques : métriques IoT, logs applicatifs, historique d’événements, time series, tout ce qui grossit vite et doit rester disponible.

Neo4j: base orientée graphes

Neo4j stocke des nœuds et des relations entre eux. La puissance, c’est de traverser ces relations de façon très efficace, là où une requête SQL avec plusieurs jointures récursives deviendrait ingérable.

Entreprises qui l’utilisent :

PayPal l’utilise pour la détection de fraude. En SQL, détecter un réseau organisé qui partage des appareils, des adresses et des comptes bancaires nécessite des jointures complexes difficiles à maintenir. Avec un graphe, la requête devient naturelle : “trouve-moi tous les comptes reliés à cet appareil, qui sont aussi reliés à cette adresse.” Résultat : doublement du taux de détection à taux de faux positifs équivalent.

BNP Paribas (via WeLoveCinema) et Konbini s’en servent pour des moteurs de recommandations : “les utilisateurs qui ont aimé ça ont aussi apprécié ça”, modélisé comme un graphe de relations entre personnes et contenus.

La SNCF modélise son réseau ferroviaire avec Neo4j pour cartographier les dépendances entre infrastructure et circulation, ce qui aide à la maintenance prédictive.

Cas d’usage typiques : détection de fraude, recommandations, réseaux sociaux, gestion de droits d’accès hiérarchiques, cartographie de dépendances (supply chain, infrastructure IT).

Si une de ces trois bases t’a donné envie de tester, Docker te permet de l’avoir en local en quelques minutes, sans rien installer directement sur ta machine. Voici comment s’y prendre.

Ce qui est commun aux trois

Avant de rentrer dans chaque configuration, trois concepts communs aux trois :

Les volumes nommés persistant les données entre redémarrages. Supprimer un conteneur ne supprime pas les données, sauf si tu supprimes aussi le volume.

L’accès shell se fait via docker exec -it <nom-conteneur> <shell>. Chaque base a son shell dédié (mongosh, cqlsh, cypher-shell).

Le healthcheck est optionnel mais pratique pour les bases qui démarrent lentement (Cassandra notamment). Il permet à depends_on d’attendre que la base soit réellement prête.

MongoDB : base de données orientée documents

MongoDB stocke des documents JSON (techniquement BSON). Idéal quand tes données ont une structure variable ou très imbriquée.

Structure du projet

mon-projet-mongodb/
  └── docker-compose.yml

docker-compose.yml (sans authentification)

Configuration minimale pour du développement local. L’article utilise mongo:7 (LTS, supportée jusqu’en 2027). mongo:8 est la version stable courante si tu veux les dernières fonctionnalités.

services:
  mongodb:
    image: mongo:7
    container_name: MongoDB-Server
    volumes:
      - mongodb_data:/data/db
      - mongodb_config:/data/configdb
    ports:
      - "27017:27017"
    restart: "no"

volumes:
  mongodb_data:
  mongodb_config:

docker-compose.yml (avec authentification)

Pour simuler un environnement proche de la production :

services:
  mongodb:
    image: mongo:7
    container_name: MongoDB-Server
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: example_pass
    volumes:
      - mongodb_data:/data/db
      - mongodb_config:/data/configdb
    ports:
      - "27017:27017"
    restart: "no"

volumes:
  mongodb_data:
  mongodb_config:

Démarrer le conteneur

docker compose up -d

docker compose ps

Accéder à MongoDB via mongosh

Sans authentification :

docker exec -it MongoDB-Server mongosh

Avec authentification :

docker exec -it MongoDB-Server mongosh -u root -p example_pass

Quelques commandes rapides dans le shell :

show dbs
use ma_base
db.utilisateurs.insertOne({ nom: "Alice", age: 30 })
db.utilisateurs.find()

Accéder via MongoDB Compass

MongoDB Compass est le client graphique officiel. Connecte-toi sur localhost:27017 (sans auth) ou avec mongodb://root:example_pass@localhost:27017 (avec auth).

Arrêter et nettoyer

docker compose down

Pour supprimer les données aussi :

docker volume rm mongodb_data mongodb_config

MongoDB, c’est bouclé. Si ton cas d’usage tourne plutôt autour de l’écriture à haute fréquence que de la flexibilité du schéma, Cassandra est l’étape suivante.

Cassandra : base de données orientée colonnes

Conçue pour absorber des volumes d’écriture massifs sur plusieurs nœuds, Cassandra est la plus exigeante des trois à démarrer. En local, on travaille avec un nœud unique.

Structure du projet

mon-projet-cassandra/
  └── docker-compose.yml

docker-compose.yml

services:
  cassandra:
    image: cassandra:5
    container_name: Cassandra-Server-Container
    volumes:
      - cassandra_data:/var/lib/cassandra
    ports:
      - "9042:9042"
    restart: "no"

volumes:
  cassandra_data:

Démarrer le conteneur

docker compose up -d

Attends 30 secondes, puis vérifie que Cassandra est prête :

docker compose ps

Tu peux aussi surveiller les logs pour voir quand le nœud est opérationnel :

docker compose logs -f cassandra

Cassandra est prête quand tu vois Starting listening for CQL clients on /0.0.0.0:9042 dans les logs (Ctrl + C pour quitter).

Accéder à Cassandra via cqlsh

docker exec -it Cassandra-Server-Container cqlsh

Quelques commandes rapides :

DESCRIBE keyspaces;
CREATE KEYSPACE mon_keyspace WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1};
USE mon_keyspace;
CREATE TABLE evenements (id UUID PRIMARY KEY, type TEXT, ts TIMESTAMP);

Cassandra n’a pas d’interface web native. Pour une interface graphique, DBeaver supporte Cassandra via le driver JDBC.

Arrêter et nettoyer

docker compose down

docker volume rm cassandra_data

Cassandra, c’est en place. Dernier de la série, Neo4j change complètement de logique : oublie les tables et les colonnes, ici tout est nœuds et relations.

Neo4j : base de données orientée graphes

Neo4j stocke des nœuds et des relations. Le langage de requête est Cypher, conçu pour traverser ces relations de façon intuitive.

Structure du projet

mon-projet-neo4j/
  └── docker-compose.yml

docker-compose.yml

services:
  neo4j:
    image: neo4j:5
    container_name: Neo4j-Server-Container
    environment:
      NEO4J_AUTH: neo4j/password123
    volumes:
      - neo4j_data:/data
      - neo4j_logs:/logs
    ports:
      - "7474:7474"
      - "7687:7687"
    restart: "no"

volumes:
  neo4j_data:
  neo4j_logs:

Les deux ports ont des rôles distincts :

• 7474 : interface web Neo4j Browser (HTTP)
• 7687 : protocole Bolt (utilisé par les drivers applicatifs)

Démarrer le conteneur

docker compose up -d

docker compose ps

Accéder via l’interface web

Ouvre http://localhost:7474 dans ton navigateur. Connecte-toi avec neo4j / password123 (les valeurs définies dans NEO4J_AUTH).

L’interface permet d’écrire des requêtes Cypher et de visualiser le graphe directement dans le navigateur.

Accéder via cypher-shell

docker exec -it Neo4j-Server-Container cypher-shell -u neo4j -p password123

Quelques commandes rapides :

CREATE (p:Personne {nom: 'Alice'})-[:CONNAIT]->(p2:Personne {nom: 'Bob'})
MATCH (n) RETURN n

Arrêter et nettoyer

docker compose down

docker volume rm neo4j_data neo4j_logs

Tableau récapitulatif

Pour aller plus loin

Ces configurations sont suffisantes pour développer et tester en local. Pour aller plus loin :

• Réplication : MongoDB Replica Set, Cassandra multi-nœuds, à aborder quand tu valides l’architecture en local
• Connexion depuis une app : chaque base a ses drivers (Mongoose pour MongoDB, cassandra-driver, neo4j-driver), les ports exposés sont les mêmes que ci-dessus
• Bases Docker : si tu veux approfondir les volumes, les réseaux ou le multi-conteneur, l’article Environnement LAMP avec Docker couvre tout ça en détail

Sources et références

• Documentation officielle MongoDB
• Documentation officielle Cassandra
• Documentation officielle Neo4j
• Images Docker Hub : mongo
• Images Docker Hub : cassandra
• Images Docker Hub : neo4j