Qu’est-ce que MongoDB ?

MongoDB est une base de données NoSQL orientée documents, multiplateforme et

open-source, utilisée pour stocker des données semi-structurées écrites en C . Au lieu
de tableaux et de lignes, MongoDB stocke les données sous forme de paires clé-
valeur. Pour faciliter l’apprentissage des développeurs et des administrateurs, voici
quelques-unes des commandes MongoDB les plus fréquemment utilisées.

Commençons par le commencement.

Commandes de base
1. Vérification de la version

La commande la plus importante permet de vérifier la version installée du serveur

MongoDB et de Mongo Shell. Exécutez cette commande dans le terminal sous Linux
ou dans l’invite CMD sous Windows.

mongod --version

C:\NWindows\NSystem32>mongod --version
version de la base de données : v4.2.7
version git : 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
allocateur : tcmalloc
modules : aucun
environnement de construction :
distmod : 2012plus
distarch : x86_64
target_arch : x86_64

Nous pouvons également utiliser la commande mongod pour vérifier la version,

comme suit.

mongo -version

C:\NWindows\NSystem32>mongo --version
MongoDB shell version v4.2.7
version git : 51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
allocateur : tcmalloc
modules : aucun
environnement de construction :
distmod : 2012plus
distarch : x86_64
 architecture_cible : x86_64

2. Liste des commandes MongoDB

Cette commande aidera les utilisateurs à trouver toutes les commandes qui peuvent
être utilisées dans MongoDB. Exécutez la commande sur Mongo Shell.

help()

mongo> db.help()
Méthodes de la base de données :
db.adminCommand(nameOrDocument) - bascule dans la base de données "admin" et exécute la
commande [appelle simplement db.runCommand(...)]
db.aggregate([pipeline], {options}) - effectue une agrégation sans collection sur cette base de données
; renvoie un curseur
db.auth(nom d'utilisateur, mot de passe)
db.cloneDatabase(fromhost) - ne fonctionne qu'avec MongoDB 4.0 et moins
db.commandHelp(name) renvoie l'aide de la commande
db.copyDatabase(fromdb, todb, fromhost) - ne fonctionne qu'avec MongoDB 4.0 et moins
db.createCollection(name, {size : ..., capped : ..., max : ...})
db.createUser(userDocument)
db.createView(name, viewOn, [{$operator : {...}}, ...], {viewOptions})
db.currentOp() affiche les opérations en cours d'exécution dans la base de données
db.dropDatabase(writeConcern)
db.dropUser(nomd'utilisateur)
db.eval() - obsolète
db.fsyncLock() envoie les données sur le disque et verrouille le serveur pour les sauvegardes
db.fsyncUnlock() déverrouille le serveur après un db.fsyncLock()
db.getCollection(cname) identique à db['cname'] ou db.cname
db.getCollectionInfos([filter]) - renvoie une liste contenant les noms et les options des collections de
la base de données
db.getCollectionNames()
db.getLastError() - renvoie la chaîne de caractères du message d'erreur
db.getLastErrorObj() - renvoie l'objet d'état complet
db.getLogComponents()
db.getMongo() récupère l'objet de connexion au serveur
db.getMongo().setSlaveOk() autorise les requêtes sur un serveur esclave de réplication
db.getName()
db.getProfilingLevel() - obsolète
db.getProfilingStatus() - renvoie si le profilage est activé et si le seuil de lenteur est atteint
db.getReplicationInfo()
db.getSiblingDB(name) récupère la base de données sur le même serveur que celle-ci
 db.getWriteConcern() - renvoie le souci d'écriture utilisé pour toutes les opérations sur cette base de
données, hérité de l'objet serveur s'il est défini
db.hostInfo() obtient des détails sur l'hôte du serveur
db.isMaster() vérifie le statut primaire du réplica
db.killOp(opid) tue l'opération en cours dans la base de données
db.listCommands() liste toutes les commandes de la base de données
db.loadServerScripts() charge tous les scripts dans db.system.js
db.logout()
db.printCollectionStats()
db.printReplicationInfo()
db.printShardingStatus()
db.printSlaveReplicationInfo()
db.resetError()
db.runCommand(cmdObj) exécute une commande de base de données. si cmdObj est une chaîne, elle
est transformée en {cmdObj : 1}
db.serverStatus()
db.setLogLevel(level,<component>)
db.setProfilingLevel(level,slowms) 0=off 1=slow 2=all
db.setVerboseShell(flag) affiche des informations supplémentaires dans la sortie de l'interpréteur de
commandes
db.setWriteConcern(<préoccupation d'écriture doc>) - définit la préoccupation d'écriture pour les
écritures dans la base de données
db.shutdownServer()
db.stats()
db.unsetWriteConcern(<préoccupation d'écriture doc>) - désactive la préoccupation d'écriture pour
les écritures dans la base de données
db.version() version actuelle du serveur
db.watch() - ouvre un curseur de flux de changement pour une base de données afin de signaler toutes
les modifications apportées à ses collections hors système.

3. Statistiques de la base de données

La commande ci-dessous vous donnera des détails sur les bases de données ainsi
que sur plusieurs collections et paramètres connexes de cette base de données.

db.stats()

> db.stats()
{
"db" : "test",
"collections" : 0,
"vues" : 0,
"objets" : 0,
"avgObjSize" : 0,
"dataSize" : 0,
"storageSize" : 0,
 "numExtents" : 0,
"index" : 0,
"indexSize" : 0,
"scaleFactor" : 1,
"fileSize" : 0,
"fsUsedSize" : 0,
"fsTotalSize" : 0,
"ok" : 1
}

4. Créez une nouvelle base de données ou passez à une base de

données existante

Cette commande simple permet de créer une nouvelle base de données si elle
n’existe pas ou de basculer vers la base de données existante. Dans MongoDB, “test”
est la base de données par défaut et les utilisateurs utilisent donc la base de données
“test” une fois que Mongo Shell est connecté.

use DB_Name

mongos> use geekFlareDB

basculé vers la base de données geekFlareDB

Copy

5. Liste de toutes les bases de données

La commande mentionnée est utilisée pour lister toutes les bases de données.

show dbs

mongo> show dbs

admin 0.000GB
config 0.002GB
geekFlareDB 0.000GB
test 0.000GB

Copy

6. Vérifiez la base de données en cours d’utilisation

Exécutez la commande suivante sur Mongo Shell pour voir la base de données
actuellement utilisée.

db
> db
GeekFlare

7. Abandonner la base de données

La commande donnée permet à l’utilisateur de supprimer la base de données requise.

Exécutez la commande sur le client MongoDB. Veillez à sélectionner la base de
données avant d’exécuter la commande Drop. Dans le cas contraire, la base de
données par défaut “test” sera supprimée.

db.dropDatabase()

Commençons par lister toutes les bases de données, basculons sur l’une d’entre elles
et abandonnons-la

> show dbs

admin 0.000GB
config 0.001GB
local 0.000GB
test 0.000GB
training 0.000GB
>
> utiliser l'entraînement
basculé sur l'entraînement de la base de données
>
> db.dropDatabase()
{ "dropped" : "training", "ok" : 1 }

8. Créer une collection

Les collections sont similaires aux tables dans les SGBDR.

La commande de création d’une collection se compose de deux paramètres. La

collection se compose de zéro document ou plus. Ainsi, pour créer une collection, le
paramètre obligatoire à utiliser dans la commande est son nom et les paramètres
facultatifs peuvent inclure le nom des documents, leur taille et leur index.

• Création d’une collection simple.

Syntaxe: db.createCollection(Name,Options)

Exemple: > use geekFlare

> utiliser geekFlare

basculé vers db geekFlare
>
> db.createCollection("geekFlareCollection")
{ "ok" : 1 }
>
> afficher les collections
geekFlareCollection

Copy

• Création d’une collection plafonnée

Dans cette collection, vous limitez la taille et le nombre des documents à insérer dans
la collection. La collection plafonnée possède une propriété qui permet de supprimer
les documents les plus anciens pour faire de la place aux nouveaux documents.

Syntaxe:

db.createCollection(Name,{capped : true, size : sizeLimit , max : documentLimit })

Exemple : Créons une collection plafonnée, insérons un enregistrement et

récupérons-le

> db.createCollection("Login",{capped:true,max:1,size:200})
{ "ok" : 1 }
>
> > db.Login.insertMany([{"id":1,status : "Active"},{"id":2,status : "Hold"},{"id":3,status : "Pending"}])
{
"acknowledged" : vrai,
"insertedIds" : [
ObjectId("5edc5f4f411247725e75e52e"),
ObjectId("5edc5f4f411247725e75e52f"),
ObjectId("5edc5f4f411247725e75e530")
]
}
>
> db.Login.find()
{ "_id" : ObjectId("5edc5f4f411247725e75e530"), "id" : 3, "status" : "Pending" }

Copy

9. Drop Collection
La commande Drop Collection est similaire à DDL dans un SGBDR. Elle acquiert des
verrous sur la collection requise jusqu’à l’exécution de la commande. La commande
Drop Collection supprime la collection de la base de données ainsi que tous les index
associés à cette collection. La méthode drop() est nécessaire pour supprimer la
collection.

Elle renvoie un message vrai si l’abandon est réussi et un message faux en cas
d’erreur ou si la base de données n’existe pas.

Syntaxe: collectionName.drop()

Exemple:

> utiliser geekFlare

basculé vers db geekFlare
>
> afficher les collections
geekFlareCollection
>
> db.geekFlareCollection.drop()
vrai
>
> db.geekFlareCollection.drop()
faux

Copy

Opérations CRUD
10. Insérer un document dans une collection

Dans MongoDB, un document est similaire à un tuple dans un SGBDR.

Pour créer un document, la méthode insert() est utilisée. La méthode insert() crée un
ou plusieurs documents dans la collection existante. Elle crée également une
collection si elle n’est pas présente dans la base de données. Dans MongoDB, le
document est sans schéma, ce qui signifie qu’il n’y a aucune restriction quant à
l’insertion d’un nombre quelconque de clés dans un document.

• Insertion d’un seul enregistrement

Pour insérer un enregistrement, vous pouvez utiliser la méthode insert() ou insertOne().

Syntaxe: collectionName.insertOne({document})
Exemple:

> db.geekFlareCollection.insertOne( {
code : "P123", Qty : 200, status : "Active"
}) ;
{
"acknowledged" : vrai,
"insertedId" : ObjectId("5ed309725429283aee2e134d")
}

Copy

• Insertion de plusieurs enregistrements

Pour insérer plusieurs enregistrements, une liste d’enregistrements sera transmise à la

méthode insert() ou insertMany().

Syntaxe:

collectionName.insertMany([{document1},{document2},{document3}....{ documentn}])

Exemple:

db.geekFlareCollection.insertMany([
... { code : "P1", Qty : 100, statut : "Active"},
... { code : "P2", Qté : 200, statut : "Actif"},
... { code : "P3", Qté : 0, statut : "Déctif"}
... ]) ;
{
"acknowledged" : vrai,
"insertedIds" : [
ObjectId("5edf7b4e18b2c26b9dfe8cac"),
ObjectId("5edf7b4e18b2c26b9dfe8cad"),
ObjectId("5edf7b4e18b2c26b9dfe8cae")
]
}
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b8"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75b9"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf546fdfa12b33b7cb75ba"), "produit" : "yaourt", "Qté" : 30 }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cac"), "code" : "P1", "Qté" : 100, "status" : "Active" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cad"), "code" : "P2", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5edf7b4e18b2c26b9dfe8cae"), "code" : "P3", "Qté" : 0, "status" : "Dective" }
>

Copy

• Insertion d’un enregistrement en masse

Un grand nombre de documents peut également être inséré de manière ordonnée et

non ordonnée en exécutant les
méthodes initializeOrderedBulkOp() et initializeUnorderedBulkOp().

Syntaxe: var bulk = db.collectionNom

var bulk = db.collectionName.initializeUnorderedBulkOp() ;

bulk.insert({document1} ) ;

bulk.insert({document2} ) ;

bulk.insert({documentn} ) ;

bulk.execute() ;

Copy

Exemple :

> var bulk = db.geekFlareCollection.initializeUnorderedBulkOp() ;

> bulk.insert({ code : "P1", Qty : 100, status : "Active"}) ;
> bulk.insert({ code : "P2", Qty : 200, status : "Active"}) ;
> bulk.insert({ code : "P3", Qty : 0, status : "Dective"}) ;
> bulk.execute() ;
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 3,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8caf"), "code" : "P1", "Qty" : 100, "status" : "Active" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb0"), "code" : "P2", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5edf7be318b2c26b9dfe8cb1"), "code" : "P3", "Qté" : 0, "status" : "Dective" }
>

Copy

11. Récupérer un document dans une collection

Pour rechercher un document stocké dans une collection, vous pouvez utiliser la
méthode find(). La commande ci-dessous sera utilisée pour récupérer tous les
documents de la collection.

• la méthodefind()peut être utilisée pour récupérer tous les documents stockés

dans une collection.

Syntaxe: collectionNom.find()

Exemple: > db.geekFlareCollection.find()

> db.geekFlareCollection.find()
{"_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"), "code" : "P1", "Qty" : 200, "status" : "Active" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86cf"), "code" : "P2", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5ed31186b6f2c2bb1edb86d0"), "code" : "P3", "Qté" : 200, "statut" : "Actif" }
{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qté" : 100, "status" : "Inactive" }

Copy

• la méthodefind({condition}) peut être utilisée pour extraire de la collection

uniquement les documents requis en fonction de certaines conditions.
MongoDB fournit une liste d’opérateurs de projection et de requête pour
récupérer des valeurs de type BSON.

Syntaxe: collectionName.find({ condition })

Exemple:

> db.geekFlareCollection.find({ Qty : { $eq : 100 }}) ;

{ "_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"), "code" : "P4", "Qté" : 100, "status" : "Inactive" }

Copy

• Pour récupérer un seul document, MongoDB propose la méthode findOne(). Elle

fournit une sortie formatée.

Syntaxe: collectionName.findOne()

Exemple: > db.geekFlareCollection.findOne()

> db.geekFlareCollection.findOne() ;
{
"_id" : ObjectId("5ed31186b6f2c2bb1edb86ce"),
"code" : "P1",
"Qté" : 200,
"status" : "Inactive"
}

Copy

12. Sortie de l’extraction de l’embellissement

La méthode find() produit un résultat désorganisé. MongoDB fournit des

commandes pretty() pour obtenir une sortie formatée.

Syntaxe: collectionName.find().pretty()

Exemple:

> db.geekFlareCollection.find({ Qty : { $eq : 100 }}).pretty() ;

{
"_id" : ObjectId("5ed3159eb6f2c2bb1edb86d1"),
"code" : "P4",
"Qté" : 100,
"status" : "Inactive"
}

Copy

13. Mise à jour d’un document dans une collection

MongoDB propose la méthode update() pour définir de nouvelles valeurs pour les clés
existantes dans les documents. La commande de mise à jour donne des détails sur les
documents modifiés et correspondants. La syntaxe de la commande de mise à jour
est la suivante :

Syntaxe: collectionName.update({KeyToUpdate},{Set Command})

Exemple:

> db.geekFlareCollection.find()
{"_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "produit" : "yaourt", "Qté" : 30 }
>
> db.geekFlareCollection.update({"product" : "bottles"},{$set : {"Qty" : 10}} )
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "product" : "bottles", "Qty" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "produit" : "yaourt", "Qté" : 30 }
>
> db.geekFlareCollection.find()
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfb"), "produit" : "bouteilles", "Qté" : 10 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfc"), "produit" : "pain", "Qté" : 20 }
{ "_id" : ObjectId("5edf3f67d6bfbd8125f58cfd"), "produit" : "yaourt", "Qté" : 30 }

Copy

• updateOne():
Pour mettre à jour un seul document, il existe la méthode
updateOne (). updateOne() donne le nombre de documents correspondants et
modifiés.

Syntaxe: collectionName.updateOne({SingleKeyToUpdate},{Set Command})

Exemple:

> db.geekFlareCollection.updateOne({"product" : "bottles"},{$set : {"Qty" : 40}} )

{"acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Copy

• ) : Pour mettre à jour plusieurs documents selon

<strong>updateMany(</strong>
certaines conditions, MongoDB dispose de la méthode updateMany().

Syntaxe: collectionName.updateMany({filtre},{Set Command})

Exemple:

> db.geekFlareCollection.updateMany( { "Qty" : { $lt : 30 } },{ $set : { "Qty" : "Inactive"} } )

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

Copy

14. Supprimer un document d’une collection

Pour supprimer un document, MongoDB propose les

méthodes deleteOne() et deleteMany(). La syntaxe des méthodes de suppression est la
suivante :
 • <strong>deleteOne({condition}) </strong>supprime le document unique répondant
aux critères de suppression.

Syntaxe: collectionName.deleteOne({Condition de suppression})

Exemple:

> db.geekFlareCollection.deleteOne({"product" : "bread"})

{ "acknowledged" : true, "deletedCount" : 1 }

Copy

• <strong>deleteMany() </strong>supprime tous les documents correspondant aux

critères de suppression. Sans les critères de
suppression, deleteMany({condition}) supprime tous les documents.

Syntaxe : collectionName.deleteMany({Condition de suppression})

Exemple:

> db.geekFlareCollection.deleteMany({"product" : "bottles"})

{ "acknowledged" : true, "deletedCount" : 2 }

Copy

• <strong>remove </strong>()
Il existe une autre méthode pour supprimer tous les
documents correspondant aux critères de suppression. La méthode remove()
prend deux arguments, l’un étant la condition de suppression et l’autre un
simple drapeau.

Remarque: la méthode Remove est obsolète dans les versions à venir.

Syntaxe: collectionName.remove({DeletionCondition},1)

Exemple:

> db.geekFlareCollection.remove({"product" : "bottles"})

WriteResult({ "nRemoved" : 1 })

Copy

15. Récupérer des éléments distincts

La méthode distinct() est utilisée pour obtenir des enregistrements uniques.

• Pour obtenir des enregistrements distincts à partir d’un champ.

Syntaxe: collectionName.distinct(field)
Exemple:

> db.geekFlareCollection.distinct("produit")
[ "Cheese", "Snacks2", "Snacks3", "bread", "ketchup" ]

Copy

• Pour obtenir des enregistrements distincts à partir d’un champ tout en

spécifiant la requête.

Syntaxe: collectionName.distinct(field,query)

Exemple:

> db.geekFlareCollection.distinct('product',{"Qty":20})
["Snacks3", "pain" ]

Copy

16. Renommer la collection

MongoDB propose la méthode renameCollection () pour renommer une collection.

Syntaxe: collectionName.renameCollection(newCollectionName)

Exemple:

>db.geekFlareCollection.renameCollection('geekFlareCol')
{ "ok" : 1 }
> afficher les collections
geekFlareCol

Copy

Indexation
17. Créer un index sur le document

Les index sont une structure de données spéciale qui stocke une petite partie de
l’ensemble des données de la collection sous une forme facile à parcourir. Les index
permettent de classer les valeurs des champs par ordre croissant ou décroissant, ce
qui améliore les performances lors de la recherche.

MongoDB fournit l’index default_id. MongoDB prend également en charge la création

d’index définis par l’utilisateur. Les index MongoDB sont définis au niveau des
collections et prennent en charge les champs ou sous-champs d’un document. La
syntaxe de création d’un index est la suivante : :

• Créez un index sur un seul champ.

Syntaxe: collectionName.createIndex({Key:1})

La clé indique le champ sur lequel l’index est créé et 1 signifie l’ordre croissant. Pour
créer un index dans l’ordre décroissant, vous pouvez utiliser -1.

Exemple:

> db.geekFlareCollection.createIndex({"product" : 1})

{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}

Copy

• Créez un index sur plusieurs champs.

Syntaxe: collectionName.createIndex({Key1:1,key2:1...keyn:1})

Exemple:

> db.geekFlareCollection.createIndex({"product" : 1, "Qty":-1})

{
"createdCollectionAutomatically" : false,
"numIndexesBefore" : 1,
"numIndexesAfter" : 2,
"ok" : 1
}

Copy

18. Afficher l’index sur le document

MongoDB propose la méthode getIndexes() pour répertorier tous les index créés sur un
document.

Syntaxe: collectionName.getIndexes()
Exemple: > db.geekFlareCollection.getIndexes()

> db.geekFlareCollection.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "geekFlareCollection.geekFlareCollection"
}
]

Copy

19. Supprimer l’index du document

la méthodedropIndex() est utilisée pour supprimer un seul index et la méthode

dropIndexes() est utilisée pour supprimer plusieurs index.

• Suppression d’un seul index

Syntaxe: collectionName.dropIndex({key})

Exemple:

> db.geekFlareCollection.dropIndex({"product" : 1})

{ "nIndexesWas" : 3, "ok" : 1 }

Copy

• Suppression d’index multiples.

Syntaxe: collectionName.dropIndexes({key1,key2...,keyN})

Exemple:

> db.geekFlareCollection.dropIndexes({"product" : 1, "Qty":-1})

{ "nIndexesWas" : 3, "ok" : 1 }

Copy

Récupération liée
20. Limiter la recherche de documents
la méthode limit( ) permet de limiter le nombre de documents retournés. La méthode
limit() accepte des arguments numériques.

Syntaxe: collectionName.find().limit(number)

Exemple: > db.geekFlareCollection.find().limit(number)

> db.geekFlareCollection.find().limit(2)
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8702"), "product" : "bottles", "Qty" : 100 }
{ "_id" : ObjectId("5ed3c9e7b6f2c2bb1edb8703"), "produit" : "pain", "Qté" : 20 }

Copy

21. Sauter l’extraction des documents

MongoDB prend en charge la méthode skip(). Cette méthode permet d’ignorer le

nombre requis de documents. Elle accepte un argument numérique.

Syntaxe: collectionName.find().skip(number)

Exemple: > db.geekFlareCollection.find().skip(number)

> db.geekFlareCollection.find().skip(2)
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
> db.geekFlareCollection.find().skip(3)

Copy

22. Récupération triée des documents

La méthode MongoDB sort () permet de trier les documents de sortie dans l’ordre
croissant ou décroissant. Cette méthode accepte le nom des clés et le nombre pour
spécifier l’ordre de tri. 1 est utilisé pour l’ordre croissant tandis que -1 est utilisé pour
spécifier l’ordre décroissant.

Syntaxe: collectionName.find().sort({key:1})

Exemple:

> db.geekFlareCollection.find().sort({"Qty":1})
{ "_id" : 2, "product" : "bread", "Qty" : 20 }
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
{ "_id" : 1, "product" : "bottles", "Qty" : 100 }

Copy
Validation liée
23. Validation des documents

Les validateurs permettent de limiter le type de données insérées dans les

documents. Les validateurs sont définis sur la collection. Pour créer un validateur, il
faut utiliser le mot-clé validator et, en option, le niveau de validation et l’action de
validation pour spécifier le mode de validation. La validation de document ne limite
pas l’insertion d’un nouveau champ dans le document.

Syntaxe: createCollection("collectionName",{validator:{ fields condition }})

Exemple :

> db.createCollection("Login",
... { validator : { $and :
... [
... { phone : { $type : "string" } },
... { email : { $regex : /@flares\.com$/ } },
... { status : { $in : [ "Registered", "Unknown" ] } } }
... ]
... }
... } )
{ "ok" : 1 }
>
> db.Login.insert({phone:1234})
WriteResult({
"nInserted" : 0,
"writeError" : {
"code" : 121,
"errmsg" : "La validation du document a échoué"
}
})
>
> db.Login.insert({phone : "1234",email : "[email protected]",status : "Unknown",mode : "limited"})
WriteResult({ "nInserted" : 1 })

Copy

24. Validateurs de schéma sur une nouvelle collection

Le mot-clé supplémentaire $jsonSchema ainsi que la valeur False des propriétés
supplémentaires sont nécessaires pour imposer une restriction au niveau du schéma.
Cela empêche l’ajout de nouveaux champs dans le document.

Syntaxe: createCollection("collectionName",{validator : { $jsonSchema { schema condition } }})

Exemple:

> db.createCollection("Login", {
... validator : { $jsonSchema : {
... bsonType : "object",
... "additionalProperties" : false,
... required : ["email" ],
... propriétés : {
... email : {
... bsonType : "string",
... pattern : "@flares\c.com$",
... description : "string meets the given expression"
... },
... statut : {
... enum : [ "registered", "Invalid" ],
... description : "Le statut doit être compris dans les valeurs de l'enum"
... }
... }
... } },
... } )
{ "ok" : 1 }
>
> db.Login.insert({email : "[email protected]"})
WriteResult({
"nInserted" : 0,
"writeError" : {
"code" : 121,
"errmsg" : "La validation du document a échoué"
}
})

Copy

25. Mettre à jour ou créer des validateurs de schéma sur une collection
existante
Un validateur peut être créé sur une collection existante en utilisant collMod

Syntaxe: runCommand({collMod : "nomCollection",validateur:{conditionSchéma}})

Exemple :

> db.runCommand( {
collMod : "Login",
validator : { $jsonSchema : {
bsonType : "object",
"additionalProperties" : false,
required : ["email", "status" ],
properties : {
email : {
bsonType : "string",
pattern : "@flares\c.com$",
description : "string meets the given expression"
},
status : {
enum : [ "registered", "Invalid" ],
description : "le statut doit être compris dans les valeurs de l'énumération"
}
}
} },
validationAction : "error",
validationLevel : "strict"
})
{ "ok" : 1 }

Copy

26. Supprimer les validateurs de schéma sur une collection existante

Pour supprimer les validateurs de schéma, il est nécessaire de désactiver

le <strong>niveau de validation (validationLevel</strong> ).

Syntaxe: runCommand({collMod : "nomcollection",validator:{ },validationLevel:off})

Exemple:

> db.runCommand({
collMod : "Login",
validator:{},
 validationLevel : "off"
})
{ "ok" : 1 }
>
> db.Login.insert({"email" : "abc"})
WriteResult({ "nInserted" : 1 })

Copy

27. Vérifier la présence de validateurs sur une collection existante

Pour vérifier si la collection existante possède des validateurs de schéma, exécutez la

commande suivante. Sans spécifier le nom de la collection, la
méthode db.getCollectionInfos() donne des détails sur les validateurs de toutes les
collections résidant dans une base de données.

Syntaxe: getCollectionInfos({nom : "nomcollection"})

Exemple:

> db.getCollectionInfos({nom : "Login"})

[
{
"name" : "Login",
"type" : "collection",
"options" : {
"validator" : {
"email" : {
"$regex" : /@flares\c.com$/
}
}
},
"info" : {
"readOnly" : faux,
"uuid" : UUID("646674f6-4b06-466d-93b0-393b5f5cb4ff")
},
"idIndex" : {
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
 "ns" : "geekFlareDB.Login"
}
}
]

Copy

Curseurs liés
28. Curseur dans MongoDB

Le curseur est un pointeur qui permet d’itérer sur l’ensemble des résultats. MongoDB
utilise les méthodes <strong>hasNext()</strong> et <strong>forEach()</strong> pour
l’itération. Une liste des méthodes de curseur a été fournie.

Exemples:

> var newCursor=db.geekFlareCollection.find()

> newCursor.forEach(printjson)
{ "_id" : 1, "product" : "bottles", "Qty" : 100 }
{ "_id" : 2, "product" : "bread", "Qty" : 20 }
{ "_id" : 3, "product" : "yogurt", "Qty" : 30 }
>
> var newCursor1=db.geekFlareCollection.find()
> while(newCursor1.hasNext()){ printjson(newCursor1.next())}
{ "_id" : 1, "product" : "bottles", "Qty" : 100 }
{ "_id" : 2, "product" : "bread", "Qty" : 20 }
{ "_id" : 3, "product" : "yogurt", "Qty" : 30

Copy

Utilité
29. Sauvegarde d’une base de données

l’utilitairemongodump est utilisé pour exporter le contenu de la base de données

MongoDB en tant que sauvegarde. Cette commande s’exécute à partir de la console
système et non à partir du shell MongoDB. Elle génère une sauvegarde binaire
accompagnée d’informations sur les métadonnées.

Syntaxe de la commande :

mongodump --db dbName --out outFile --host "IP:PORT" --username <user> --password <pass>
Exemple :

C:\Nmongodb\dump>mongodump --db geekFlareDB --out "C:\Nmongodb\dump" --host

"127.0.0.1:27017"
2020-06-02T12:26:34.428 0530 écriture de geekFlareDB.myTable dans
2020-06-02T12:26:34.430 0530 écriture de geekFlareDB.geekFlareCollection vers
2020-06-02T12:26:34.430 0530 écriture de geekFlareDB.mCollection vers
2020-06-02T12:26:34.433 0530 écriture de geekFlareDB.users vers
2020-06-02T12:26:34.434 0530 dumping de geekFlareDB.myTable terminé (2 documents)
2020-06-02T12:26:34.434 0530 done dumping geekFlareDB.geekFlareCollection (4 documents)
2020-06-02T12:26:34.435 0530 écriture de geekFlareDB.contacts2 dans
2020-06-02T12:26:34.435 0530 écriture de geekFlareDB.login à
2020-06-02T12:26:34.436 0530 dumping de geekFlareDB.mCollection terminé (2 documents)
2020-06-02T12:26:34.437 0530 done dumping geekFlareDB.users (1 document)
2020-06-02T12:26:34.437 0530 done dumping geekFlareDB.Login (0 documents)
2020-06-02T12:26:34.438 0530 done dumping geekFlareDB.contacts2 (0 documents)

Copy

30. Restauration de la base de données à partir de la sauvegarde

L’utilitaire <strong>mongorestore</strong> est utilisé pour restaurer les données binaires

générées par mongodump.

Syntaxe: mongorestore --db newDB "pathOfOldBackup"

Exemple:

C:\Users\asad.ali>mongorestore --db geekFlareNew "C:\Nmongodb\dump\geekFlare" --host

"127.0.0.1:27017"
2020-06-09T15:49:35.147 0530 Les arguments --db et --collection ne doivent être utilisés que lors de la
restauration à partir d'un fichier BSON. Les autres utilisations sont dépréciées et n'existeront plus dans le
futur ; utilisez --nsInclude à la place
2020-06-09T15:49:35.148 0530 construction d'une liste de collections à restaurer à partir du répertoire
C:\Nmongodb\Ndump\NgeekFlare
2020-06-09T15:49:35.152 0530 lecture des métadonnées pour geekFlareNew.geekFlareCollection depuis
C:\mongodb\dump\geekFlare\geekFlareCollection.metadata.json
2020-06-09T15:49:35.321 0530 Restauration de geekFlareNew.geekFlareCollection à partir de
C:\Nmongodb\dump\NgeekFlare\NgeekFlareCollection.bson
2020-06-09T15:49:35.461 0530 aucun index à restaurer
2020-06-09T15:49:35.462 0530 restauration terminée de geekFlareNew.geekFlareCollection (3
documents, 0 échecs)
2020-06-09T15:49:35.467 0530 3 document(s) restauré(s) avec succès. 0 document(s) n'a pas été
restauré.

Copy
31. Exportation des collections

Pour exporter le contenu d’une collection vers un fichier (JSON ou CSV),

l’utilitaire Mongoexport a été fourni. Pour exécuter cette commande, utilisez le terminal
système.

• Exportez une seule collection vers un fichier.

Syntaxe: mongoexport --db dbName --collection collectionName --out outputFile

Exemple:

C:\NMongodb\NNNouveau dossier>mongoexport --db geekFlareDB --collection geekFlareCol --out

outFile.json
2020-06-06T19:02:29.994 0530 connecté à : mongodb://localhost/
2020-06-06T19:02:30.004 0530 exporté 6 enregistrements

Copy

• Exportez un champ spécifique de la collection vers un fichier.

Syntaxe: mongoexport --db dbName --collection collectionName --out outputFile --fields fieldname

Exemple:

C:\NMongodb\NNNouveau dossier>mongoexport --db geekFlareDB --collection geekFlareCol --out

outFile.json --fields product
2020-06-06T19:05:22.994 0530 connecté à : mongodb://localhost/
2020-06-06T19:05:23.004 0530 a exporté 6 enregistrements

Copy

32. Importation de collections

Pour importer des données à partir d’un fichier (CSV ou JSON), vous pouvez utiliser
l’outil de ligne de commande mongoimport.

Syntaxe: mongoimport --db dbName --collection collectionName --file inputFile

C:\Users\asad.ali>mongoimport --db geekFlareDB --collection geekFlareNew --file outFile.json

2020-06-09T14:52:53.655 0530 connecté à : mongodb://localhost/
2020-06-09T14:52:53.924 0530 6 document(s) importé(s) avec succès. 0 document(s) n'a pas été
importé.

Copy

Relatif à la réplique
La réplication est différente du sharding, consultez ce guide pour implémenter le
sharding.

33. Réplication MongoDB

La réplication est le processus de synchronisation des données sur plusieurs serveurs.

Elle permet d’éviter les pertes de données dues à des dysfonctionnements matériels
ou logiciels. MongoDB réalise la réplication à l’aide d’ensembles de répliques.
L’ensemble de répliques se compose d’ensembles de données Mongo primaires et
secondaires dans le cluster.

L’ensemble de données primaire accepte toutes les opérations d’écriture et

l’ensemble de données secondaire lit les données de l’ensemble primaire. Un
minimum de 3 ensembles de données est requis dans l’ensemble de répliques
Mongo. Le processus suivant est nécessaire pour configurer un ensemble de
répliques :

• Démarrez le serveur Mongo avec l’option replset sur un minimum de 3 nœuds.

mongod --port 27017 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128

mongod --port 27018 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128

mongod --port 27019 --dbpath C:\data\data1 --replSet rs0 --oplogSize 128

• Initialisez l’ensemble de répliques.

rs.initiate( { _id : "rs0", members : [ { _id : 0, host : "IP:27017" }, { _id : 1, host : "IP:27018" }, { _id : 2, host :
"IP:27019" } ] })

> rs.initiate( {
... _id : "rs0",
... membres : [
... { _id : 0, host : "localhost:27017" },
... { _id : 1, host : "localhost:27018" },
... { _id : 2, host : "localhost:27019" }
... ]
... })
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591089166, 1),
"signature" : {
"hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
 }
},
"operationTime" : Timestamp(1591089166, 1)
}

Copy

34. Vérifiez l’état de la réplication

Exécutez la commande ci-dessous à partir du nœud de réplique primaire pour

obtenir des informations complètes sur l’ensemble de répliques.

rs.conf()

rs.status()

rs0:PRIMARY> rs.conf()
{
"_id" : "rs0",
"version" : 2,
"protocolVersion" : NumberLong(1),
"writeConcernMajorityJournalDefault" : true,
"members" : [
{
"_id" : 0,
"host" : "localhost:27017",
"arbiterOnly" : false,
"buildIndexes" : true,
"hidden" : faux,
"priority" : 1,
"tags" : {

},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 1,
"host" : "localhost:27018",
"arbiterOnly" : faux,
"buildIndexes" : true,
"hidden" : faux,
 "priority" : 1,
"tags" : {

},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 2,
"host" : "localhost:27019",
"arbiterOnly" : faux,
"buildIndexes" : true,
"hidden" : faux,
"priority" : 1,
"tags" : {

},
"slaveDelay" : NumberLong(0),
"votes" : 1
},
{
"_id" : 3,
"host" : "localhost:27016",
"arbiterOnly" : faux,
"buildIndexes" : true,
"hidden" : faux,
"priority" : 1,
"tags" : {

},
"slaveDelay" : NumberLong(0),
"votes" : 1
}
],
"settings" : {
"chainingAllowed" : true,
"heartbeatIntervalMillis" : 2000,
"heartbeatTimeoutSecs" : 10,
"electionTimeoutMillis" : 10000,
 "catchUpTimeoutMillis" : -1,
"catchUpTakeoverDelayMillis" : 30000,
"getLastErrorModes" : {

},
"getLastErrorDefaults" : {
"w" : 1,
"wtimeout" : 0
},
"replicaSetId" : ObjectId("5ed6180d01a39f2162335de5")
}
}

Copy

35. Ajouter une nouvelle instance MongoDB à un ensemble de

répliques

Démarrez le client MongoDB primaire et exécutez la commande suivante

Syntaxe: rs.add("hostname:port")

Exemple: rs0:PRIMAIRE> rs.add(“nom d’hôte:port”)

rs0:PRIMARY> rs.add("localhost:27016")
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591094195, 1),
"signature" : {
"hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1591094195, 1)
}

Copy

36. Supprimez l’instance MongoDB existante de l’ensemble de

répliques
La commande ci-dessous supprimera l’hôte secondaire requis de l’ensemble de
réplicas.

Syntaxe: rs.remove("localhost:27017")

Exemple:

rs0:PRIMARY> rs.remove("localhost:27016")
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591095681, 1),
"signature" : {
"hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
"operationTime" : Timestamp(1591095681, 1)
}
rs0:PRIMARY>

Copy

37. Faire de l’ensemble de réplicas primaire un ensemble de réplicas

secondaire

MongoDB fournit une commande pour demander à un réplica primaire de devenir un

ensemble de répliques secondaire.

Syntaxe: rs.stepDown( stepDownSecs , secondaryCatchupSecs )

Exemple:

rs0:PRIMARY> rs.stepDown(12)
{
"ok" : 1,
"$clusterTime" : {
"clusterTime" : Timestamp(1591096055, 1),
"signature" : {
"hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
},
 "operationTime" : Timestamp(1591096055, 1)
}
rs0:SECONDARY>

Copy

38. Vérifiez le décalage de réplique entre le primaire et le secondaire

La commande ci-dessous sera utilisée pour vérifier le délai de réplication entre tous
les ensembles de répliques du primaire.

Syntaxe: rs.printSlaveReplicationInfo()

Exemple:

rs0:PRIMARY> rs.printSlaveReplicationInfo()
source : localhost:27018
syncedTo : Tue Jun 02 2020 16:14:04 GMT 0530 (India Standard Time)
0 sec (0 hrs) derrière le primaire
source : localhost:27019
syncedTo : Thu Jan 01 1970 05:30:00 GMT 0530 (India Standard Time)
1591094644 secs (441970.73 hrs) derrière la source primaire
source : localhost:27016
syncedTo : Tue Jun 02 2020 16:14:04 GMT 0530 (India Standard Time)
0 sec (0 hrs) derrière le primaire
rs0:PRIMARY>

Copy

Transactions liées
39. Transactions dans MongoDB

MongoDB prend en charge les propriétés ACID pour les transactions sur les
documents.

Pour lancer une transaction, une session est nécessaire pour démarrer, et la validation
est nécessaire pour enregistrer les modifications dans la base de données. Les
transactions sont prises en charge sur les ensembles de répliques ou les mangos. Une
fois que la session a été validée avec succès, les opérations effectuées à l’intérieur de
la session seront visibles à l’extérieur.

• Démarrer une session

Syntaxe: session =db.getMongo().startSession()

• Démarrer la transaction,

Syntaxe: session.startTransaction()

• Validation de la transaction

Syntaxe: session.commitTransaction()

Exemple:

Créons une session, démarrons la transaction, effectuons quelques insertions/mises à

jour puis validons la transaction.

rs0:PRIMARY> session = db.getMongo().startSession()

session { "id" : UUID("f255a40d-81bd-49e7-b96c-9f1083cb4a29") }
rs0:PRIMARY> session.startTransaction()
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.insert([
... {_id : 4 , product : "ketchup"},
... {_id : 5, produit : "Cheese"}
... ]) ;
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 2,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "produit" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMAIRE> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "produit" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "bottles", "Qty" : 100 }
{ "_id" : 3, "product" : "bread", "Qty" : 20 }
{ "_id" : 4, "produit" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }

Copy

40. Document unique Transactions Conflit

Si deux transactions tentent de mettre à jour le même document, MongoDB génère

une erreur de conflit d’écriture.

• session1.startTransaction()
• session2.startTransaction()

Effectuez des insertions/mises à jour sur Session1 puis sur Session2. Observez
maintenant l’erreur dans l’exemple ci-dessous

Exemple:

rs0:PRIMARY> session1.startTransaction()
rs0:PRIMAIRE> session2.startTransaction()
rs0:PRIMAIRE> session1.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product :
"Bread" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
rs0:PRIMARY> session2.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product :
"Snacks" }})
WriteCommandError({
"errorLabels" : [
"TransientTransactionError"
],
"operationTime" : Timestamp(1591174593, 1),
"ok" : 0,
"errmsg" : "WriteConflict",
 "code" : 112,
"codeName" : "WriteConflict",
"$clusterTime" : {
"clusterTime" : Timestamp(1591174593, 1),
"signature" : {
"hash" : BinData(0, "AAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
})
rs0:PRIMARY>

Copy

41. Transactions multi-documents

MongoDB supporte les transactions multi-documents dans une même session.

• db.getMongo().startTransaction()

Effectuer des insertions/mises à jour sur plusieurs documents

• session.commitTransaction()

Exemple:

rs0:PRIMARY> var session = db.getMongo().startSession()

rs0:PRIMAIRE> session.startTransaction()
rs0:PRIMAIRE> session.getDatabase("geekFlareDB").geekFlareCollection.update({_id:3},{$set:{ product :
"Snacks3" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
rs0:PRIMARY> session.getDatabase("geekFlareDB").geekFlareCollection.update({_id:2},{$set:{ product :
"Snacks2" }})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
rs0:PRIMARY> session.commitTransaction()
rs0:PRIMAIRE> db.geekFlareCollection.find()
{ "_id" : 1, "product" : "bread", "Qty" : 20 }
{ "_id" : 2, "product" : "Snacks2", "Qty" : 100 }
{ "_id" : 3, "product" : "Snacks3", "Qty" : 20 }
{ "_id" : 4, "product" : "ketchup" }
{ "_id" : 5, "product" : "Cheese" }
rs0:PRIMARY>

Copy
42. Profilage dans MongoDB

Le profilage permet d’enregistrer les requêtes lentes dans la collection system.profile.

Le niveau de profilage et le taux d’échantillonnage définissent le pourcentage de
requêtes à enregistrer dans la collection system.profile.

• Définir/obtenir le niveau de profilage

Syntaxe:

db.setProfilingLevel(profilingLevel,{"slowms":time, "sampleRate":LoggingPercentage})

> db.setProfilingLevel(2,{"slowms":1, "sampleRate":1})

{ "was" : 1, "slowms" : 1, "sampleRate" : 0.5, "ok" : 1 }
>
> db.getProfilingLevel()
2

Copy

• Obtenir l’état du profilage

Syntaxe: db.getProfilingStatus()

> db.getProfilingStatus()
{ "was" : 2, "slowms" : 1, "sampleRate" : 1 }

Copy

• Pour activer le profilage au niveau de l’instance MongoDB, démarrez l’instance

avec des informations de profilage ou ajoutez des détails de profilage dans le
fichier de configuration.

Syntaxe:

mongod --profile <Niveau> --slowms <heure> --slowOpSampleRate <%Logging>

Exemple:

C:\NWindows\NSystem32>mongod --port 27017 --dbpath C:\Ndata\Ndata1 --profil 1 --slowms 25 --

slowOpSampleRate 0.5
2020-06-09T02:34:41.110-0700 I CONTROL [ <x>main]</x> Désactivation automatique de TLS 1.0, pour
forcer l'activation de TLS 1.0, spécifiez --sslDisabledProtocols 'none'
2020-06-09T02:34:41.113-0700 W ASIO [ <x>main]</x> No TransportLayer configured during
NetworkInterface startup
2020-06-09T02:34:41.113-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> MongoDB démarre
: pid=22604 port=27017 dbpath=C:\data\data1 64-bit host=MCGL-4499
2020-06-09T02:34:41.114-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> targetMinOS :
Windows 7/Windows Server 2008 R2
2020-06-09T02:34:41.116-0700 I CONTROL [ <x><x><x>initandlisten]</x></x></x> db version v4.2.7
2020-06-09T02:34:41.116-0700 I CONTROLE [ <x><x><x>initandlisten]</x></x></x> git version :
51d9fe12b5d19720e72dcd7db0f2f17dd9a19212
Copy

43. MongoDB Explain()

La méthode MongoDB explains() renvoie des statistiques et fournit des informations

permettant de sélectionner un plan gagnant et de l’exécuter jusqu’au bout. Elle
renvoie les résultats en fonction du plan de verbosité.

Syntaxe: collectionName.explain("verbosityName")

Pour exécuter la méthode/commande explain(), créons une verbosité puis exécutons

la méthode explain(). Regardez l’exemple ci-dessous, dans lequel ces étapes ont été
exécutées.

Regardez l’exemple ci-dessous, dans lequel ces étapes ont été exécutées :

> db.runCommand(
... {
... explain : { count : "product", query : { Qty : { $gt : 10 } } },
... verbosity : "executionStats"
... }
... )
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "test.product",
"indexFilterSet" : false,
"winningPlan" : {
"stage" : "COUNT",
"inputStage" : {
"stage" : "EOF"
}
},
"rejectedPlans" : [ ]
},
"executionStats" : {
"executionSuccess" : true,
"nReturned" : 0,
"executionTimeMillis" : 47,
"totalKeysExamined" : 0,
 "totalDocsExamined" : 0,
"executionStages" : {
"stage" : "COUNT",
"nReturned" : 0,
"executionTimeMillisEstimate" : 0,
"works" : 1,
"advanced" : 0,
"needTime" : 0,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"nCounted" : 0,
"nSkipped" : 0,
"inputStage" : {
"stage" : "EOF",
"nReturned" : 0,
"executionTimeMillisEstimate" : 0,
"works" : 0, "advanced" : 0, "executionTimeMillisEstimate" : 0
"advanced" : 0,
"needTime" : 0,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1
}
}
},
"serverInfo" : {
"host" : "MCGL-4499",
"port" : 27017,
"version" : "4.2.7",
"gitVersion" : "51d9fe12b5d19720e72dcd7db0f2f17dd9a19212"
},
"ok" : 1
}
>

Copy
> var expv = db.geekFlareCol.explain("executionStats")
> expv.find( { product : "bread"} )
{
"queryPlanner" : {
"plannerVersion" : 1,
"namespace" : "geekFlareDB.geekFlareCol",
"indexFilterSet" : false,
"parsedQuery" : {
"product" : {
"$eq" : "bread"
}
},
"winningPlan" : {
"stage" : "COLLSCAN",
"filter" : {
"product" : {
"$eq" : "pain"
}
},
"direction" : "forward"
},
"rejectedPlans" : [ ]
},
"executionStats" : {
"executionSuccess" : true,
"nReturned" : 2,
"executionTimeMillis" : 0,
"totalKeysExamined" : 0,
"totalDocsExamined" : 6,
"executionStages" : {
"stage" : "COLLSCAN",
"filter" : {
"product" : {
"$eq" : "bread"
}
},
"nReturned" : 2,
"executionTimeMillisEstimate" : 0,
"works" : 8,
"advanced" : 2,
 "needTime" : 5,
"needYield" : 0,
"saveState" : 0,
"restoreState" : 0,
"isEOF" : 1,
"direction" : "forward",
"docsExamined" : 6
}
},
"serverInfo" : {
"host" : "MCGL-4499",
"port" : 27017,
"version" : "4.2.7",
"gitVersion" : "51d9fe12b5d19720e72dcd7db0f2f17dd9a19212"
},
"ok" : 1
}
>

Copy

Contrôle d’accès
44. Contrôle d’accès dans MongoDB

Les fonctions de contrôle d’accès permettent d’authentifier l’accès aux utilisateurs

existants. Pour que le contrôle d’accès soit activé dans la base de données, vous
devez créer un rôle d’administrateur pour l’utilisateur dans la base de données
d’administration.

• Connectez-vous à la base de données sans authentification.

• Accédez à la base de données

utilisez admin

• Créez un utilisateur comme ci-dessous

db.createUser( {user : "UserAdmin", pwd : "password" ,role : [adminRole])

Exemple :

db.createUser(
... {
... utilisateur : "AdminUser",
... pwd : passwordPrompt(),
... roles : [ { role : "userAdminAnyDatabase", db : "admin" }, "readWriteAnyDatabase" ]
... }
... )
Entrez le mot de passe :
L'utilisateur a été ajouté avec succès : {
"user" : "AdminUser",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
},
"readWriteAnyDatabase"
]
}

Copy

• Redémarrez l’instance de mongod

• Accédez à nouveau avec l’utilisateur et le mot de passe créés.

C:\NUsers\>mongo --port 27017 --authenticationDatabase "admin" -u "AdminUser" -p

MongoDB shell version v4.2.7
Entrez votre mot de passe :
connexion à :
mongodb://127.0.0.1:27017/?authSource=admin&compressors=disabled&gssapiServiceName=mongodb

Copy

45. Récupérer et supprimer l’utilisateur du contrôle d’accès

La commande ci-dessous peut être utilisée pour vérifier les informations de

l’utilisateur et le supprimer.

• db.getUser("AdminUser")
• db.dropUser("AdminUser")

Exemple: > db.getUser(“AdminUser”)

> db.getUser("AdminUser")
{
"_id" : "admin.AdminUser",
"userId" : UUID("78d2d5bb-0464-405e-b27e-643908a411ce"),
 "user" : "AdminUser",
"db" : "admin",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
},
{
"role" : "readWriteAnyDatabase",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
> db.dropUser("AdminUser")
true
> db.getUser("AdminUser")
null
>

Copy

46. Octroi de rôles définis par l’utilisateur

MongoDB fournit la méthode db.createRole() pour spécifier les privilèges d’un

utilisateur et un tableau de rôles hérités.

• Connectez l’instance MongoDB avec l’utilisateur admin.

• Exécutez la commande ci-dessous pour créer un nouveau rôle.

Syntaxe:

db.createRole({role : "roleName",privileges :[{privilegeName}],roles :[InheritedArray]})

Exemple:

utilisez admin
> db.createRole(
... {
... rôle : "abc",
... privilèges : [ { resource : { db : "geekFlareDB", collection : "geekFlareCol" }, actions : [ "killop" , "inprog"]
} } ],
... rôles : []
... }
... )
{
"role" : "abc",
"privileges" : [
{
"resource" : {
"db" : "geekFlareDB",
"collection" : "geekFlareCol"
},
"actions" : [
"killop",
"inprog"
]
}
],
"roles" : [ ]
}

Copy

47. Révoquer les rôles définis par l’utilisateur

Pour modifier les rôles existants, utilisez la commande suivante.

Syntaxe: db.revokeRolesFromUser( userName, [{"role" : roleName , db:dbName} ] )

Exemple:

> db.getUser("AdminUser")
{
"_id" : "admin.AdminUser",
"userId" : UUID("fe716ed1-6771-459e-be13-0df869c91ab3"),
"user" : "AdminUser",
"db" : "admin",
"roles" : [
{
"role" : "userAdminAnyDatabase",
"db" : "admin"
 },
{
"role" : "readWriteAnyDatabase",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
> db.revokeRolesFromUser("AdminUser", [{"role" : "userAdminAnyDatabase" , db : "admin"} ] )
> db.getUser("AdminUser")
{
"_id" : "admin.AdminUser",
"userId" : UUID("fe716ed1-6771-459e-be13-0df869c91ab3"),
"user" : "AdminUser",
"db" : "admin",
"roles" : [
{
"role" : "readWriteAnyDatabase",
"db" : "admin"
}
],
"mechanisms" : [
"SCRAM-SHA-1",
"SCRAM-SHA-256"
]
}
>