Comment utiliser MongoDB Shell

MongoDB Shell est un environnement REPL (Read-Eval-Print Loop) flexible basé sur JavaScript et Node.js pour travailler avec des déploiements MongoDB. C’est un outil essentiel pour interroger les données, administrer les bases de données et exécuter diverses opérations. Il offre une interface pratique pour gérer les bases de données, que vous les utilisiez sur un serveur distant ou localement avec MongoDB.

Cet article présente étape par étape comment utiliser MongoDB Shell.

Étape 1 : Installation de MongoDB Shell

Avant de commencer, assurez-vous que MongoDB Shell est installé sur le système. Sinon, téléchargez la version appropriée depuis le site officiel et suivez les instructions d’installation correspondantes.

Windows

Visitez la page officielle, sélectionnez la version Windows et lancez le téléchargement.

macOS

Sur la page officielle, choisissez la version macOS et démarrez le téléchargement. Vous pouvez également utiliser Homebrew en exécutant les commandes suivantes :

brew tap mongodb/brew
brew install mongosh

Linux

Consultez les instructions fournies sur le site Web pour le système d’exploitation Linux. Par exemple, sur un système basé sur Debian, suivez ces étapes :

Ajoutez la clé GPG du dépôt MongoDB :

curl -fsSL https://pgp.mongodb.com/server-7.0.asc |  sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg --dearmor

Ajoutez le dépôt MongoDB à votre système :

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

Mettez à jour la liste des paquets :

sudo apt update

Installez MongoDB :

sudo apt install mongodb-org -y

Une fois l’installation terminée, vérifiez la version installée :

mongod --version

Après l’installation, activez, démarrez et vérifiez le service :

sudo systemctl enable mongod
sudo systemctl start mongod
sudo systemctl status mongod

Si vous recherchez une solution fiable, performante et économique pour vos flux de travail, Hostman propose des options d’hébergement VPS Linux, notamment Debian VPS, Ubuntu VPS et VPS CentOS.

Étape 2 : Connexion à une instance

Une fois l’installation terminée, vous pouvez établir une connexion à une instance. Si elle est locale, entrez mongosh. Par défaut, cela se connecte à l’instance exécutée sur le port 27017 de localhost :

mongosh

La syntaxe suivante est utilisée pour se connecter à un serveur distant :

mongodb+srv://<nom_utilisateur>:<mot_de_passe>@<adresse_du_cluster>/<base_de_données>?retryWrites=true&w=majority

Remplacez <nom_utilisateur>, <mot_de_passe>, <adresse_du_cluster> et <base_de_données> par les identifiants et les détails de connexion réels.

Étape 3 : Navigation dans le terminal

Une fois connecté, vous pouvez travailler avec les bases de données. Avant cela, l’interface affiche un message de bienvenue :

La base de données attribuée à une nouvelle instance Shell s’appelle test. Elle peut être utilisée sans risque pour des expérimentations.

Voici quelques opérations utiles :

Afficher toutes les bases de données

Exécutez show dbs pour obtenir une vue de toutes les bases de données disponibles :

show dbs

Afficher la base de données actuelle

La plupart des commandes fonctionnent sur une base de données ou une collection qui s’y trouve. L’objet db représente la base de données actuellement sélectionnée :

db

Changer de base de données

Utilisez la commande use suivie du nom de la base de données, par exemple new_db, pour la créer ou y basculer :

use new_db

Remplacez new_db par le nom réel de la base de données.

Insérer un objet

Insérez d’abord un objet nommé dans student_data de la base new_db existante :

db.student_data.insertOne({name: 'School has 500 students'})

Vous pouvez également insérer plusieurs documents dans student_data, chacun contenant un champ name avec des valeurs spécifiques. Cela permet une insertion en lot :

db.student_data.insertMany([
{name: 'School has 500 students'},
{name: 'School has 600 students'}
])

Afficher les collections

Une fois les données insérées, affichez les collections existantes :

show collections

Si vous ne souhaitez pas effectuer d’autres tâches, quittez l’interface avec la commande :

exit

Vous avez désormais compris les opérations de base de la Shell.

Étape 4 : Opérations CRUD

Lors de l’utilisation de la Shell, les opérations CRUD (Créer, Lire, Mettre à jour, Supprimer) sont essentielles. Réalisons quelques opérations de base :

Créer/Insérer des données

Pour insérer de nouvelles informations dans une collection, utilisez la fonction insertOne. Créons une nouvelle collection et remplissons-la avec les informations requises, y compris name (le nom), age (l’âge) et city (la ville) :

db.collection.insertOne({ name: "Harry", age: 45, city: "Sydney" })

Rechercher/Lire des données

Vous pouvez interroger les documents associés à la collection à l’aide de la fonction find. Par exemple, toutes les entrées dont l’âge est supérieur à 25 sont récupérées :

db.collection.find({ age: { $gt: 25 } }) //  Condition où l’âge est supérieur à 25

Modifier des données

Utilisez les fonctions updateOne ou updateMany pour modifier des documents existants. Par exemple, l’âge de Harry est mis à jour à 50 :

db.collection.updateOne({ name: "Harry" }, { $set: { age: 50 } })

Supprimer des données

Utilisez les méthodes deleteOne ou deleteMany pour supprimer des entrées de la collection. Cette commande supprime un document ayant la valeur John dans le champ name :

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

Étape 5 : Utilisation avancée

Dans cette étape, effectuez des opérations complexes à l’aide de fonctionnalités avancées. Grâce aux outils de débogage, de profilage et d’optimisation des performances, la Shell vous aide à identifier les goulots d’étranglement et à optimiser votre configuration.

Pipeline d’agrégation

Grâce aux pipelines, vous pouvez calculer des enregistrements et obtenir des résultats agrégés. Les pipelines permettent de créer des analyses et des transformations complexes pour extraire des informations précieuses à partir de données brutes. Pour exécuter un pipeline d’étapes, utilisez la fonction aggregate. Exemple de code :

db.collection.aggregate([
    { $match: { status: "A" } },
    { $group: { _id: "$city", total: { $sum: "$amount" } } },
    { $sort: { total: -1 } }
])

Dans ce script, le pipeline filtre les documents avec le statut A, les regroupe par city, additionne les montants et trie les résultats par ordre décroissant.

Le pipeline d’agrégation est un outil puissant pour l’analyse et la transformation des données. Il est composé de plusieurs étapes, chacune transformant le flux de documents. Ces étapes comprennent :

$project : sélectionne ou exclut certains champs.

$match : applique une condition de requête pour filtrer les documents.

$group : regroupe les entrées selon un champ et calcule des agrégations.

$sort : trie les enregistrements selon un champ donné.

$limit : limite le nombre d’enregistrements.

$skip : ignore un nombre défini d’enregistrements.

MapReduce

Un paradigme efficace pour traiter de grands ensembles de données. Pour exécuter des tâches MapReduce, utilisez la commande mapReduce :

// Données d’exemple
db.collection.insertMany([
    { name: "Harry", age: 25, salary: 5000 },
    { name: "Buttler", age: 30, salary: 6000 },
    { name: "Morgan", age: 35, salary: 7000 }
]);

// Fonction Map
var mapFunction = function() {
    emit(this.age, this.salary);
};

// Fonction Reduce
var reduceFunction = function(keyAge, valuesSalaries) {
    return Array.sum(valuesSalaries);
};

// Exécution de MapReduce
db.runCommand({
    mapreduce: "collection",
    map: mapFunction,
    reduce: reduceFunction,
    out: "results"
});

db.results.find().forEach(printjson); // Afficher les résultats

• Dans cet exemple, la fonction mapFunction émet l’âge comme clé et le salaire comme valeur.

• La fonction reduceFunction additionne les salaires pour chaque groupe d’âge.

• Les résultats sont stockés dans une nouvelle collection appelée results, et la sortie finale est affichée avec db.results.find().forEach(printjson).

Le résultat est montré ci-dessous :

Projection

Utilisez l’opérateur de projection pour définir quels champs doivent être inclus ou exclus du jeu de résultats. Il récupère toutes les informations associées à une requête, par exemple en n’affichant que les champs name et age. Cela vous permet de visualiser des résultats spécifiques tout en excluant d’autres. Projétons uniquement les champs name et age :

db.collection.find({}, { name: 1, age: 1 }) 

Tri

Triez les résultats en utilisant la fonction sort. Elle récupère tous les documents de l’ensemble, puis les trie par âge décroissant. Cela affiche d’abord les valeurs d’âge les plus élevées. Trions par âge décroissant :

db.collection.find().sort({ age: -1 }) 

Limitation

Les utilisateurs peuvent limiter le nombre de résultats avec la fonction limit. Par exemple, récupérez les trois premiers documents de la collection. Cela est utile pour afficher un sous-ensemble restreint sans charger toute la liste. Limitons à 3 résultats :

db.collection.find().limit(3) 

Ignorer

Les entrées peuvent être ignorées avec la fonction skip. Par exemple, ignorer les deux premiers documents de la collection. C’est utile pour la pagination ou pour ignorer certains enregistrements initiaux. Ignorons les 2 premiers résultats :

db.collection.find().skip(2) 

Étape 6 : Script avec Shell

Les utilisateurs peuvent écrire des scripts pour automatiser des tâches dans la Shell. Pour ce faire, enregistrez le script dans un fichier .js et exécutez-le avec mongosh. C’est utile pour exécuter efficacement des tâches répétitives comme le remplissage de données ou les mises à jour en lot :

mongosh script.js

En maîtrisant les commandes MongoDB, vous obtiendrez des informations précieuses sur vos données.

Conclusion

Grâce à l’interface interactive de MongoDB Shell, vous pouvez effectuer des tâches d’administration répétitives comme l’écriture, la lecture et la modification. De plus, interroger des collections existantes, ajouter de nouveaux objets à la base de données et exécuter des tâches d’administration. Des opérations CRUD simples aux agrégations et scripts complexes, les utilisateurs peuvent utiliser l’interface pour accomplir efficacement une grande variété de tâches.

En exécutant des scripts, les utilisateurs peuvent automatiser efficacement des tâches répétitives. Ce tutoriel a couvert l’installation, la configuration et les tâches de gestion des bases de données, de leurs collections et de leurs utilisateurs.