Mongodb - Commandes et scripts d'administration de bases de données

mongosh

Lance le shell interactif MongoDB (Mongosh)

mongosh "mongodb://localhost:27017"

Se connecte via URI MongoDB

mongosh -u admin -p --authenticationDatabase admin

Connexion avec authentification

mongosh --quiet

Lance le shell sans messages de démarrage

mongosh --eval "db.stats()"

Exécute une commande JavaScript et quitte

mongosh --file script.js

Exécute un fichier JavaScript

mongod

Démarre le serveur MongoDB (démon)

mongod --dbpath /data/db

Démarre le serveur avec un chemin de données personnalisé

mongod --port 27018 --dbpath /data/db

Démarre sur un port personnalisé

mongod --bind_ip localhost,192.168.1.100

Écoute sur des IP spécifiques

mongod --bind_ip_all

Écoute sur toutes les interfaces réseau

mongod --replSet rs0

Démarre en tant que membre d'un Replica Set

mongod --config /etc/mongod.conf

Démarre avec un fichier de configuration

mongod --fork --logpath /var/log/mongodb/mongod.log

Démarre en arrière-plan avec logs

mongod --auth

Active l'authentification

mongod --storageEngine wiredTiger --wiredTigerCacheSizeGB 2

Définit le cache WiredTiger à 2 Go

mongod --directoryperdb

Stocke chaque base dans son propre dossier

mongod --profile 1 --slowms 100

Active le profiling des requêtes > 100ms

mongod --setParameter failIndexKeyTooLong=false

Désactive l'erreur sur index trop long

mongos

Démarre le routeur MongoDB (pour sharding)

mongos --configdb configReplSet/localhost:27019

Démarre mongos avec Config Servers

mongo

Ancien shell MongoDB (déprécié, utiliser mongosh)

mongodump

Sauvegarde une base de données MongoDB

mongodump --db ma_base --out /backup/

Sauvegarde une base spécifique

mongodump --collection users --db ma_base --out /backup/

Sauvegarde une collection spécifique

mongodump --archive=backup.archive

Sauvegarde au format archive

mongodump --gzip --archive=backup.gz

Sauvegarde compressée au format archive

mongodump --query='{"age": {"$gt": 18}}' --db ma_base --collection users

Sauvegarde avec filtre de requête

mongodump --oplog

Inclut l'oplog pour une restauration point-in-time

mongodump --excludeCollection logs --db ma_base

Exclut une collection de la sauvegarde

mongodump --numParallelCollections 4

Sauvegarde avec 4 threads parallèles

mongorestore

Restaure une sauvegarde MongoDB

mongorestore /backup/ma_base

Restaure une base depuis un dossier

mongorestore --db ma_base --collection users /backup/ma_base/users.bson

Restaure une collection spécifique

mongorestore --drop /backup/ma_base

Supprime les collections existantes avant restauration

mongorestore --archive=backup.archive

Restaure depuis une archive

mongorestore --gzip --archive=backup.gz

Restaure depuis une archive compressée

mongorestore --oplogReplay

Rejoue l'oplog pour restauration point-in-time

mongorestore --numInsertionWorkersPerCollection 4

Restaure avec 4 workers par collection

mongorestore --dryRun /backup/ma_base

Simule la restauration sans écrire

mongoexport

Exporte des données au format JSON ou CSV

mongoexport --db ma_base --collection users --out users.json

Exporte une collection en JSON

mongoexport --db ma_base --collection users --type=csv --fields name,email,age --out users.csv

Exporte en CSV avec champs spécifiques

mongoexport --db ma_base --collection users --query '{"age": {"$gt": 18}}' --out adults.json

Exporte avec filtre de requête

mongoexport --db ma_base --collection users --limit 100 --out sample.json

Exporte les 100 premiers documents

mongoexport --db ma_base --collection users --sort '{"created_at": -1}' --limit 10 --out latest.json

Exporte les 10 derniers documents

mongoexport --db ma_base --collection users --jsonFormat canonical

Exporte au format JSON canonique (types étendus)

mongoexport --db ma_base --collection users --pretty --out users.json

Exporte en JSON formaté (pretty)

mongoexport --forceTableScan

Force un scan de table (si index non utilisable)

mongoimport

Importe des données JSON, CSV ou TSV

mongoimport --db ma_base --collection users --file users.json

Importe un fichier JSON

mongoimport --db ma_base --collection users --type csv --headerline --file users.csv

Importe un CSV avec en-têtes

mongoimport --db ma_base --collection users --type csv --fields name,email,age --file users.csv

Importe un CSV sans en-têtes

mongoimport --db ma_base --collection users --jsonArray --file users.json

Importe un tableau JSON

mongoimport --db ma_base --collection users --drop --file users.json

Supprime la collection avant import

mongoimport --db ma_base --collection users --mode upsert --upsertFields email --file users.json

Met à jour les documents existants (upsert)

mongoimport --db ma_base --collection users --mode merge --file users.json

Fusionne avec les documents existants

mongoimport --numInsertionWorkers 4 --file users.json

Importe avec 4 workers parallèles

mongoimport --stopOnError --file users.json

Arrête l'import à la première erreur

mongostat

Affiche les statistiques en temps réel du serveur

mongostat --rowcount 10

Affiche 10 lignes de statistiques

mongostat --json

Affiche les statistiques au format JSON

mongostat --all

Affiche toutes les colonnes disponibles

mongostat --humanReadable

Affiche les tailles en format lisible (KB, MB)

mongostat --discover

Découvre tous les nœuds d'un Replica Set

mongotop

Affiche le temps passé par collection

mongotop --rowcount 10

Affiche 10 lignes

mongotop --json

Affiche au format JSON

mongotop --locks

Affiche les statistiques de verrous

mongofiles

Gère les fichiers dans GridFS

mongofiles --db ma_base put monfichier.txt

Upload un fichier dans GridFS

mongofiles --db ma_base get monfichier.txt

Télécharge un fichier depuis GridFS

mongofiles --db ma_base list

Liste les fichiers dans GridFS

mongofiles --db ma_base delete monfichier.txt

Supprime un fichier de GridFS

mongofiles --db ma_base search monfichier

Recherche des fichiers par nom

mongofiles --db ma_base put_id '{ "$oid": "..." }' monfichier.txt

Upload avec un ID personnalisé

show dbs

[Shell] Affiche toutes les bases de données

show databases

[Shell] Alias de show dbs

use ma_base

[Shell] Change ou crée une base de données

db

[Shell] Affiche la base de données courante

show collections

[Shell] Affiche les collections de la base courante

show tables

[Shell] Alias de show collections

db.createCollection("users")

[Shell] Crée une collection explicitement

db.createCollection("logs", { capped: true, size: 10485760, max: 5000 })

[Shell] Crée une collection capped (taille fixe)

db.users.drop()

[Shell] Supprime une collection

db.dropDatabase()

[Shell] Supprime la base de données courante

db.users.insertOne({ name: "John", age: 30 })

[Shell] Insère un document

db.users.insertMany([{ name: "John" }, { name: "Jane" }])

[Shell] Insère plusieurs documents

db.users.insertMany([...], { ordered: false })

[Shell] Continue l'insertion même après une erreur

db.users.find()

[Shell] Trouve tous les documents

db.users.find({ age: 30 })

[Shell] Filtre par égalité

db.users.find({ age: { $gt: 18 } })

[Shell] Opérateur $gt (greater than)

db.users.find({ age: { $in: [20, 30, 40] } })

[Shell] Opérateur $in

db.users.find({ $and: [{ age: { $gt: 18 } }, { city: "Paris" }] })

[Shell] Opérateur logique $and

db.users.find({ "address.city": "Paris" })

[Shell] Requête sur champ imbriqué

db.users.find({ tags: "mongodb" })

[Shell] Recherche dans un tableau

db.users.find({ tags: { $all: ["mongodb", "database"] } })

[Shell] Tableau contenant tous les éléments

db.users.find({ tags: { $size: 2 } })

[Shell] Tableau de taille exacte

db.users.find({ tags: { $elemMatch: { $eq: "mongodb" } } })

[Shell] Filtre sur éléments de tableau

db.users.find({ name: /^J/i })

[Shell] Expression régulière

db.users.find({ name: { $regex: /^J/, $options: 'i' } })

[Shell] Regex avec options ($regex)

db.users.find({ age: { $exists: true } })

[Shell] Champ existant

db.users.find({ age: { $type: "int" } })

[Shell] Filtre par type BSON

db.users.find({ $expr: { $gt: ["$age", "$minAge"] } })

[Shell] Compare deux champs du document

db.users.find({ $text: { $search: "john developer" } })

[Shell] Recherche textuelle

db.users.find().limit(10)

[Shell] Limite le nombre de résultats

db.users.find().skip(20).limit(10)

[Shell] Pagination (documents 21-30)

db.users.find().sort({ age: 1 })

[Shell] Trie par âge croissant (1 = asc, -1 = desc)

db.users.find().sort({ age: -1, name: 1 })

[Shell] Trie sur plusieurs champs

db.users.find({}, { name: 1, email: 1, _id: 0 })

[Shell] Projection (inclut/exclut des champs)

db.users.find({}, { "address.city": 1 })

[Shell] Projection sur champ imbriqué

db.users.find({ tags: { $slice: 2 } })

[Shell] Limite le nombre d'éléments d'un tableau

db.users.find({ tags: { $slice: [2, 3] } })

[Shell] Slice avec skip et limit

db.users.findOne({ _id: ObjectId("...") })

[Shell] Trouve un seul document

db.users.countDocuments({ age: { $gt: 18 } })

[Shell] Compte les documents

db.users.estimatedDocumentCount()

[Shell] Estimation rapide du nombre de documents

db.users.distinct("city")

[Shell] Valeurs distinctes d'un champ

db.users.distinct("city", { age: { $gt: 18 } })

[Shell] Valeurs distinctes avec filtre

db.users.updateOne({ name: "John" }, { $set: { age: 31 } })

[Shell] Met à jour un document

db.users.updateMany({}, { $inc: { age: 1 } })

[Shell] Met à jour plusieurs documents

db.users.replaceOne({ name: "John" }, { name: "John", age: 31, city: "Paris" })

[Shell] Remplace un document entier

db.users.updateOne({ name: "John" }, { $set: { age: 31 } }, { upsert: true })

[Shell] Met à jour ou insère si non trouvé

db.users.updateOne({ name: "John" }, { $set: { "address.city": "Lyon" } })

[Shell] Met à jour un champ imbriqué (dot notation)

db.users.updateOne({ name: "John" }, { $unset: { age: "" } })

[Shell] Supprime un champ ($unset)

db.users.updateOne({ name: "John" }, { $rename: { "name": "fullName" } })

[Shell] Renomme un champ ($rename)

db.users.updateOne({ name: "John" }, { $currentDate: { lastModified: true } })

[Shell] Définit la date courante ($currentDate)

db.users.updateOne({ name: "John" }, { $inc: { age: 1, "stats.visits": 1 } })

[Shell] Incrémente des champs ($inc)

db.users.updateOne({ name: "John" }, { $mul: { price: 1.2 } })

[Shell] Multiplie un champ ($mul)

db.users.updateOne({ name: "John" }, { $min: { age: 25 } })

[Shell] Met à jour si valeur < existante ($min)

db.users.updateOne({ name: "John" }, { $addToSet: { tags: "mongodb" } })

[Shell] Ajoute à un tableau si non présent ($addToSet)

db.users.updateOne({ name: "John" }, { $push: { tags: "mongodb" } })

[Shell] Ajoute à un tableau ($push)

db.users.updateOne({ name: "John" }, { $push: { scores: { $each: [90, 85], $sort: -1, $slice: 5 } } })

[Shell] $push avec modificateurs

db.users.updateOne({ name: "John" }, { $pull: { tags: "mongodb" } })

[Shell] Retire d'un tableau ($pull)

db.users.updateOne({ name: "John" }, { $pull: { scores: { $lt: 60 } } })

[Shell] Retire avec condition ($pull)

db.users.updateOne({ name: "John" }, { $pop: { tags: 1 } })

[Shell] Retire le dernier élément (-1 pour premier)

db.users.updateOne({ name: "John" }, [ { $set: { fullName: { $concat: ["$firstName", " ", "$lastName"] } } } ])

[Shell] Pipeline d'agrégation dans update

db.users.deleteOne({ name: "John" })

[Shell] Supprime un document

db.users.deleteMany({ age: { $lt: 18 } })

[Shell] Supprime plusieurs documents

db.users.findOneAndUpdate({ name: "John" }, { $set: { age: 31 } }, { returnDocument: "after" })

[Shell] Met à jour et retourne le document

db.users.findOneAndReplace({ name: "John" }, { name: "John", age: 31 }, { returnDocument: "after" })

[Shell] Remplace et retourne le document

db.users.findOneAndDelete({ name: "John" })

[Shell] Supprime et retourne le document

db.users.bulkWrite([{ insertOne: { document: { name: "John" } } }, { updateOne: { filter: { name: "Jane" }, update: { $set: { age: 25 } } } }, { deleteOne: { filter: { name: "Bob" } } }])

[Shell] Opérations en masse

db.users.aggregate([{ $match: { age: { $gt: 18 } } }, { $group: { _id: "$city", total: { $sum: 1 } } }])

[Shell] Pipeline d'agrégation

db.users.aggregate([{ $match: { status: "active" } }])

[Shell] $match - filtre les documents

db.users.aggregate([{ $project: { fullName: { $concat: ["$firstName", " ", "$lastName"] }, age: 1 } }])

[Shell] $project - transforme les documents

db.users.aggregate([{ $group: { _id: "$city", count: { $sum: 1 }, avgAge: { $avg: "$age" } } }])

[Shell] $group - regroupe les documents

db.users.aggregate([{ $sort: { age: -1 } }])

[Shell] $sort - trie les documents

db.users.aggregate([{ $limit: 10 }])

[Shell] $limit - limite le nombre de documents

db.users.aggregate([{ $skip: 10 }])

[Shell] $skip - ignore des documents

db.users.aggregate([{ $unwind: "$tags" }])

[Shell] $unwind - décompose un tableau

db.orders.aggregate([{ $lookup: { from: "users", localField: "userId", foreignField: "_id", as: "user" } }])

[Shell] $lookup - jointure avec une autre collection

db.orders.aggregate([{ $lookup: { from: "users", let: { userId: "$userId" }, pipeline: [{ $match: { $expr: { $eq: ["$_id", "$$userId"] } } }], as: "user" } }])

[Shell] $lookup avec pipeline

db.users.aggregate([{ $addFields: { fullName: { $concat: ["$firstName", " ", "$lastName"] } } }])

[Shell] $addFields - ajoute des champs

db.users.aggregate([{ $replaceRoot: { newRoot: "$profile" } }])

[Shell] $replaceRoot - remplace la racine du document

db.users.aggregate([{ $merge: { into: "active_users", on: "_id", whenMatched: "merge", whenNotMatched: "insert" } }])

[Shell] $merge - écrit dans une collection

db.users.aggregate([{ $out: "new_collection" }])

[Shell] $out - écrit dans une nouvelle collection

db.users.aggregate([{ $bucket: { groupBy: "$age", boundaries: [0, 18, 30, 50, 100], default: "Other", output: { count: { $sum: 1 } } } }])

[Shell] $bucket - répartit en intervalles

db.users.aggregate([{ $facet: { ageStats: [{ $group: { _id: null, avgAge: { $avg: "$age" } } }], cityStats: [{ $group: { _id: "$city", count: { $sum: 1 } } }] } }])

[Shell] $facet - traitements parallèles

db.users.createIndex({ email: 1 })

[Shell] Crée un index ascendant

db.users.createIndex({ email: 1 }, { unique: true })

[Shell] Crée un index unique

db.users.createIndex({ email: 1 }, { background: true })

[Shell] Crée un index en arrière-plan

db.users.createIndex({ name: "text", description: "text" })

[Shell] Crée un index textuel

db.users.createIndex({ location: "2dsphere" })

[Shell] Crée un index géospatial 2dsphere

db.users.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })

[Shell] Crée un index TTL (expire après 1h)

db.users.createIndex({ email: 1 }, { partialFilterExpression: { email: { $exists: true } } })

[Shell] Crée un index partiel

db.users.createIndex({ email: 1, age: -1 })

[Shell] Crée un index composé

db.users.createIndex({ email: 1 }, { sparse: true })

[Shell] Crée un index sparse (ignore les documents sans le champ)

db.users.createIndex({ "$**": "text" })

[Shell] Crée un index textuel sur tous les champs texte

db.users.getIndexes()

[Shell] Liste les index d'une collection

db.users.dropIndex("email_1")

[Shell] Supprime un index par nom

db.users.dropIndex({ email: 1 })

[Shell] Supprime un index par spécification

db.users.dropIndexes()

[Shell] Supprime tous les index (sauf _id)

db.users.hideIndex("email_1")

[Shell] Masque un index (ne sera plus utilisé)

db.users.unhideIndex("email_1")

[Shell] Réactive un index masqué

db.users.totalIndexSize()

[Shell] Taille totale des index

db.users.stats()

[Shell] Statistiques d'une collection

db.stats()

[Shell] Statistiques de la base de données

db.serverStatus()

[Shell] Statistiques du serveur

db.currentOp()

[Shell] Opérations en cours

db.killOp(opid)

[Shell] Tue une opération

db.setProfilingLevel(1, { slowms: 100 })

[Shell] Active le profiling

db.getProfilingLevel()

[Shell] Affiche le niveau de profiling

db.system.profile.find().sort({ ts: -1 }).limit(5)

[Shell] Consulte les requêtes profilées

db.users.explain().find({ email: "test@example.com" })

[Shell] Explique le plan d'exécution

db.users.explain("executionStats").find({ email: "test@example.com" })

[Shell] Explique avec statistiques d'exécution

db.users.aggregate([{ $indexStats: {} }])

[Shell] Statistiques d'utilisation des index

db.createRole({ role: "readAnyDatabase", privileges: [{ resource: { db: "", collection: "" }, actions: ["find"] }], roles: [] })

[Shell] Crée un rôle personnalisé

db.updateRole("readAnyDatabase", { privileges: [...] })

[Shell] Met à jour un rôle

db.dropRole("readAnyDatabase")

[Shell] Supprime un rôle

show roles

[Shell] Affiche les rôles disponibles

db.createUser({ user: "appUser", pwd: "password", roles: ["readWrite"] })

[Shell] Crée un utilisateur

db.updateUser("appUser", { roles: ["read"] })

[Shell] Met à jour un utilisateur

db.changeUserPassword("appUser", "newPassword")

[Shell] Change le mot de passe

db.dropUser("appUser")

[Shell] Supprime un utilisateur

show users

[Shell] Affiche les utilisateurs de la base

db.grantRolesToUser("appUser", ["readWrite"])

[Shell] Ajoute des rôles à un utilisateur

db.revokeRolesFromUser("appUser", ["readWrite"])

[Shell] Retire des rôles

db.getUser("appUser")

[Shell] Affiche les détails d'un utilisateur

rs.initiate()

[Shell] Initialise un Replica Set

rs.initiate({ _id: "rs0", members: [{ _id: 0, host: "localhost:27017" }] })

[Shell] Initialise avec configuration

rs.status()

[Shell] Statut du Replica Set

rs.conf()

[Shell] Configuration du Replica Set

rs.reconfig(cfg)

[Shell] Reconfigure le Replica Set

rs.add("localhost:27018")

[Shell] Ajoute un membre au Replica Set

rs.remove("localhost:27018")

[Shell] Retire un membre

rs.stepDown()

[Shell] Le primary devient secondary

rs.freeze(60)

[Shell] Empêche l'élection pendant 60 secondes

rs.printReplicationInfo()

[Shell] Informations sur l'oplog

rs.printSecondaryReplicationInfo()

[Shell] Lag de réplication des secondaries

sh.status()

[Shell] Statut du sharding

sh.enableSharding("ma_base")

[Shell] Active le sharding sur une base

sh.shardCollection("ma_base.users", { _id: "hashed" })

[Shell] Sharde une collection (hashed)

sh.shardCollection("ma_base.users", { city: 1 })

[Shell] Sharde une collection (range)

sh.addShard("rs1/localhost:27018")

[Shell] Ajoute un shard

sh.addShardTag("shard0000", "europe")

[Shell] Ajoute un tag à un shard

sh.addTagRange("ma_base.users", { city: "Paris" }, { city: "Z" }, "europe")

[Shell] Associe une plage à un tag

sh.getBalancerState()

[Shell] État du balancer

sh.setBalancerState(true)

[Shell] Active/désactive le balancer

sh.startBalancer()

[Shell] Démarre le balancer

sh.stopBalancer()

[Shell] Arrête le balancer

sh.moveChunk("ma_base.users", { city: "Paris" }, "shard0001")

[Shell] Déplace un chunk manuellement

sh.splitAt("ma_base.users", { city: "M" })

[Shell] Divise un chunk

db.users.getShardDistribution()

[Shell] Distribution des données par shard

session = db.getMongo().startSession()

[Shell] Démarre une session

session.startTransaction()

[Shell] Démarre une transaction

session.commitTransaction()

[Shell] Valide une transaction

session.abortTransaction()

[Shell] Annule une transaction

session.endSession()

[Shell] Termine une session

db.getCollectionInfos()

[Shell] Informations sur les collections

db.getCollectionNames()

[Shell] Noms des collections

db.users.renameCollection("clients")

[Shell] Renomme une collection

db.cloneCollection("localhost:27018", "users", { active: true })

[Shell] Clone une collection depuis un autre serveur

db.users.mapReduce(mapFunction, reduceFunction, { out: "results" })

[Shell] Map-Reduce (déprécié, utiliser aggregation)

db.users.watch()

[Shell] Change Stream - surveille les changements

db.users.validate({ full: true })

[Shell] Valide une collection

db.users.compact()

[Shell] Compacte une collection (WiredTiger)

db.repairDatabase()

[Shell] Répare la base de données

db.runCommand({ ping: 1 })

[Shell] Exécute une commande administrateur

db.runCommand({ buildInfo: 1 })

[Shell] Informations sur le build

db.runCommand({ hostInfo: 1 })

[Shell] Informations sur l'hôte

db.runCommand({ listDatabases: 1 })

[Shell] Liste les bases (admin)

db.runCommand({ collStats: "users", scale: 1024 })

[Shell] Statistiques de collection

db.runCommand({ dbStats: 1, scale: 1024 })

[Shell] Statistiques de base

db.runCommand({ createIndexes: "users", indexes: [{ key: { email: 1 }, name: "email_1", unique: true }] })

[Shell] Crée des index via commande

db.runCommand({ listIndexes: "users" })

[Shell] Liste les index via commande

db.runCommand({ dropIndexes: "users", index: "email_1" })

[Shell] Supprime un index via commande

db.adminCommand({ setParameter: 1, logLevel: 1 })

[Shell] Change le niveau de log

db.adminCommand({ getLog: "global" })

[Shell] Récupère les logs récents

db.adminCommand({ rotateLogs: 1 })

[Shell] Rotation des logs

db.adminCommand({ shutdown: 1 })

[Shell] Arrête le serveur MongoDB