Guide étape par étape : Déploiement d'un cluster MongoDB fragmenté de base

MongoDB, une base de données de documents NoSQL populaire, excelle dans la gestion de grands volumes de données avec des performances et une flexibilité élevées. Cependant, à mesure que les données augmentent, un serveur unique ou un jeu de répliques peut atteindre ses limites d'évolutivité. C'est là que le partitionnement (sharding) entre en jeu, permettant une évolutivité horizontale en distribuant les données sur plusieurs serveurs, ou fragments (shards).

Ce guide complet vous accompagnera tout au long du processus de configuration d'un cluster MongoDB fragmenté fonctionnel. Vous apprendrez à configurer les composants essentiels : les serveurs de configuration (config servers), les routeurs mongos et les jeux de répliques de fragments. À la fin de ce tutoriel, vous aurez une compréhension fondamentale et une expérience pratique du déploiement d'un cluster fragmenté conçu pour une évolutivité horizontale et une disponibilité élevées.

Comprendre les clusters MongoDB fragmentés

Un cluster MongoDB fragmenté se compose de trois composants principaux qui fonctionnent ensemble pour distribuer et acheminer les données :

• Jeux de répliques de fragments (Shard Replica Sets) : Ce sont les nœuds réels contenant les données. Chaque fragment est un jeu de répliques pour assurer une haute disponibilité et une redondance des données. Les données sont partitionnées sur ces fragments.
• Serveurs de configuration (Config Servers) : Ceux-ci stockent les métadonnées du cluster, y compris le mappage des morceaux de données aux fragments. À partir de MongoDB 3.2, les serveurs de configuration doivent être déployés sous forme de jeu de répliques (CSRS - Config Server Replica Set) pour une haute disponibilité et une cohérence.
• Routeurs mongos : Ceux-ci agissent comme des routeurs de requêtes, fournissant une interface pour les applications clientes. Une instance mongos dirige les opérations clientes vers le ou les fragments appropriés en fonction des métadonnées du cluster. Les applications se connectent à mongos, et non directement aux fragments.

Diagramme conceptuel d'un cluster MongoDB fragmenté (crédit image : documentation officielle MongoDB)

Prérequis

Avant de commencer, assurez-vous d'avoir les éléments suivants :

1. Plusieurs machines/VMs : Pour un cluster fragmenté véritablement distribué, vous aurez besoin d'au moins 6 à 9 machines/VMs/conteneurs Docker. Pour ce tutoriel de base, nous pouvons simuler cela sur une seule machine en utilisant différents ports, mais rappelez-vous qu'une configuration de production nécessite des ressources dédiées.
   • 3 pour les serveurs de configuration (configSrv01, configSrv02, configSrv03)
   • Minimum 2-3 pour chaque fragment (par exemple, Shard01-RS01, Shard01-RS02, Shard01-RS03 ; Shard02-RS01, ...)
   • 1+ pour les routeurs mongos
2. Installation de MongoDB : MongoDB 4.2+ installé sur toutes les machines qui hébergeront les instances mongod ou mongos. Vous pouvez trouver les instructions d'installation sur la documentation MongoDB.
3. Mise en réseau : Assurez-vous que toutes les machines peuvent communiquer entre elles sur les ports nécessaires (par défaut 27017, 27018, 27019, 27020 respectivement pour les serveurs de configuration, les fragments et mongos, ou des ports personnalisés).
4. Structure des répertoires : Créez des répertoires de données et de journaux dédiés pour chaque instance mongod et mongos.

Pour simplifier ce guide, nous utiliserons localhost avec différents ports et répertoires. Dans un environnement de production, vous utiliseriez de vrais noms d'hôtes ou adresses IP.

Structure de répertoires recommandée (Exemple pour une configuration localhost)

mkdir -p /data/db/configdb01 /data/db/configdb02 /data/db/configdb03
mkdir -p /data/db/shard01-rs01 /data/db/shard01-rs02 /data/db/shard01-rs03
mkdir -p /data/db/shard02-rs01 /data/db/shard02-rs02 /data/db/shard02-rs03
mkdir -p /data/log/config /data/log/shard01 /data/log/shard02 /data/log/mongos

Étapes de déploiement

Étape 1 : Configurer les serveurs de configuration (jeu de répliques de configuration)

Les serveurs de configuration stockent les métadonnées du cluster fragmenté. Ils doivent fonctionner comme un jeu de répliques.

1. Démarrer les instances mongod pour les serveurs de configuration : Chaque instance nécessite les options --configsvr et --replSet.

   ```bash

   Serveur de configuration 1

   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb01 --port 27019 --bind_ip localhost --logpath /data/log/config/configdb01.log --fork

   Serveur de configuration 2

   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb02 --port 27020 --bind_ip localhost --logpath /data/log/config/configdb02.log --fork

   Serveur de configuration 3

   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb03 --port 27021 --bind_ip localhost --logpath /data/log/config/configdb03.log --fork
   ```

   Conseil : Pour la production, remplacez localhost par de véritables adresses IP ou noms d'hôte.

2. Initialiser le jeu de répliques de configuration : Connectez-vous à l'une des instances du serveur de configuration et initialisez le jeu de répliques.

   bash mongo --port 27019

   Dans le shell mongo :

   javascript rs.initiate({ _id: "cfgReplSet", configsvr: true, members: [ { _id : 0, host : "localhost:27019" }, { _id : 1, host : "localhost:27020" }, { _id : 2, host : "localhost:27021" } ] });

   Vérifier le statut :

   javascript rs.status();

Étape 2 : Configurer les jeux de répliques de fragments

Chaque fragment du cluster est un jeu de répliques. Nous allons configurer deux fragments (shard01 et shard02), chacun avec trois membres.

1. Démarrer les instances mongod pour les membres du fragment 1 : Chaque instance nécessite les options --shardsvr et --replSet.

   ```bash

   Membre 1 du fragment 1

   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs01 --port 27030 --bind_ip localhost --logpath /data/log/shard01/shard01-rs01.log --fork

   Membre 2 du fragment 1

   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs02 --port 27031 --bind_ip localhost --logpath /data/log/shard01/shard01-rs02.log --fork

   Membre 3 du fragment 1

   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs03 --port 27032 --bind_ip localhost --logpath /data/log/shard01/shard01-rs03.log --fork
   ```

2. Initialiser le jeu de répliques du fragment 1 : Connectez-vous à l'une des instances du fragment 1.

   bash mongo --port 27030

   Dans le shell mongo :

   javascript rs.initiate({ _id : "shard01", members: [ { _id : 0, host : "localhost:27030" }, { _id : 1, host : "localhost:27031" }, { _id : 2, host : "localhost:27032" } ] });

3. Démarrer les instances mongod pour les membres du fragment 2 (répéter pour les fragments supplémentaires) :

   ```bash

   Membre 1 du fragment 2

   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs01 --port 27040 --bind_ip localhost --logpath /data/log/shard02/shard02-rs01.log --fork

   Membre 2 du fragment 2

   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs02 --port 27041 --bind_ip localhost --logpath /data/log/shard02/shard02-rs02.log --fork

   Membre 3 du fragment 2

   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs03 --port 27042 --bind_ip localhost --logpath /data/log/shard02/shard02-rs03.log --fork
   ```

4. Initialiser le jeu de répliques du fragment 2 : Connectez-vous à l'une des instances du fragment 2.

   bash mongo --port 27040

   Dans le shell mongo :

   javascript rs.initiate({ _id : "shard02", members: [ { _id : 0, host : "localhost:27040" }, { _id : 1, host : "localhost:27041" }, { _id : 2, host : "localhost:27042" } ] });

Étape 3 : Configurer les routeurs mongos

Les instances mongos sont les points d'entrée pour les applications clientes. Elles doivent savoir où se trouvent les serveurs de configuration.

1. Démarrer les instances mongos : Fournissez l'option --configdb, en listant les membres du jeu de répliques de configuration.

   ```bash

   Routeur Mongos 1

   mongos --configdb cfgReplSet/localhost:27019,localhost:27020,localhost:27021 --port 27017 --bind_ip localhost --logpath /data/log/mongos/mongos01.log --fork
   ```

   Remarque : Vous pouvez démarrer plusieurs instances mongos pour l'équilibrage de charge et la haute disponibilité. Elles se connectent toutes aux mêmes serveurs de configuration.

Étape 4 : Se connecter à mongos et ajouter des fragments

Maintenant, connectez-vous à une instance mongos et ajoutez les jeux de répliques de fragments au cluster.

1. Se connecter à mongos : Utilisez le port MongoDB par défaut 27017 ou le port personnalisé que vous avez spécifié pour mongos.

   bash mongo --port 27017

2. Ajouter des fragments : Utilisez la commande sh.addShard(), en spécifiant le nom du jeu de répliques et l'un de ses membres.

   javascript sh.addShard("shard01/localhost:27030"); sh.addShard("shard02/localhost:27040");

Étape 5 : Activer le partitionnement pour une base de données et une collection

Une fois les fragments ajoutés, vous devez activer le partitionnement pour des bases de données spécifiques, puis pour des collections spécifiques au sein de ces bases de données. Cela nécessite de choisir une clé de fragment (shard key).

1. Activer le partitionnement pour une base de données : Basculez vers la base de données que vous souhaitez partitionner et exécutez sh.enableSharding().

   javascript use mydatabase; sh.enableSharding("mydatabase");

2. Partitionner une collection : Choisissez une clé de fragment (shard key) et utilisez sh.shardCollection().

   Avertissement : Le choix d'une clé de fragment efficace est crucial pour les performances et une distribution équitable. Une mauvaise clé de fragment peut entraîner des points chauds (hot spots) ou des requêtes inefficaces. Les stratégies courantes incluent les clés hachées, les clés de plage ou les clés composées.

   Pour cet exemple, supposons une collection mycollection avec un champ _id.

   ```javascript
   sh.shardCollection("mydatabase.mycollection"