Skip to content

Latest commit

 

History

History
252 lines (168 loc) · 9.29 KB

README.fr.md

File metadata and controls

252 lines (168 loc) · 9.29 KB

Cluster MongoDB Shardé sur Kubernetes

English Français

Ce dépôt contient la configuration complète pour déployer un cluster MongoDB shardé dans un environnement Kubernetes en utilisant kind (Kubernetes in Docker). La configuration inclut plusieurs ensembles de réplicas, des données fragmentées et un routage, tous conçus pour garantir une haute disponibilité, évolutivité et tolérance aux pannes.

Table des Matières

Introduction

Ce projet montre comment déployer un cluster MongoDB shardé entièrement fonctionnel sur Kubernetes en utilisant des StatefulSets pour les composants MongoDB, y compris les serveurs de configuration, les serveurs shard, et les services de routage mongos.

L'architecture du cluster comprend :

  • 4 Shards avec 2 ou 3 ensembles de réplicas chacun
  • 3 Serveurs de configuration (ensemble de réplicas)
  • 1 Serveur de routage MongoS

Ce projet est idéal pour quiconque cherche à implémenter une base de données distribuée et évolutive dans Kubernetes pour des applications réelles ou à des fins de test.

Prérequis

Pour installer et déployer ce cluster MongoDB shardé, assurez-vous d'avoir les outils suivants installés :

Architecture

Le cluster est déployé comme suit :

  • Shard 1 : Ensemble de réplicas avec des instances sur les ports 27301, 27302, 27303
  • Shard 2 : Ensemble de réplicas avec des instances sur les ports 27401, 27402, 27403
  • Shard 3 : Ensemble de réplicas avec des instances sur les ports 27501, 27502, 27503
  • Shard 4 : Ensemble de réplicas avec des instances sur les ports 27601, 27602, 27603
  • Serveurs de configuration : 3 instances formant un ensemble de réplicas sur les ports 27201, 27202, 27203
  • Routeur MongoS : Instance sur le port 27100

Guide d'Installation

1. Cloner le Dépôt

git clone https://github.com/Mx-Bx/k8smongodb-shardedcluster.git
cd k8smongodb-shardedcluster

2. Déployer le Cluster Kubernetes

Déployez les shards MongoDB et les serveurs de configuration en utilisant les manifests Kubernetes fournis :

kubectl apply -R -f manifests/.
## OU
./start-all.sh

Vérifiez si tout fonctionne correctement :

./check-status.sh

3. Configurer les Shards MongoDB

Déployez les shards MongoDB et les serveurs de configuration en utilisant les manifests Kubernetes fournis :

./init-sharding.sh

4. Configurer le Sharding

Activez le sharding pour une base de données :

sh.enableSharding("dbTest")

5. Vérifier l'Installation

Pour vérifier que le sharding fonctionne correctement, vérifiez le statut :

kubectl exec -it $(kubectl get pods -l app=mongos -o jsonpath="{.items[0].metadata.name}") -- mongosh --eval "sh.status()"

Mise à l'Échelle et Test de Charge

Vous pouvez mettre à l'échelle les ensembles de réplicas ou les shards en modifiant les fichiers de configuration StatefulSet.

Pour tester la charge, envisagez d'utiliser un jeu de données comme les exemples de MongoDB ou de générer des données personnalisées en utilisant l'outil mongoimport de MongoDB.

Cas d'Usage: Fragmenter une Collection d'Utilisateurs par userId

1. Activer le Sharding sur une Base de Données

Commencez par créer une base de données appelée testdb et activer le sharding sur celle-ci.

  1. Connectez-vous à l'instance mongos :

    kubectl exec -it $(kubectl get pods -l app=mongos -o jsonpath="{.items[0].metadata.name}") -- mongosh --port 27100

  2. Activez le sharding sur la base de données testdb :

    use testdb
sh.enableSharding("testdb")

2. Créer une Collection avec une Clé de Sharding

Ensuite, créez une collection appelée users et fragmentez-la en fonction du champ userId, qui servira de clé de fragmentation.

db.createCollection("users")

sh.shardCollection("testdb.users", { "userId": 1 })
## ou
db.users.createIndex({ 'userId': "hashed" })
sh.shardCollection("testdb.users", { 'userId': "hashed" })

## Pour vérifier si les index ont été créés
db.users.getIndexes()

3. Générer un Large Jeu de Données

Ensuite, générez un grand jeu de données d'utilisateurs pour observer le comportement du sharding. Utilisez une boucle simple pour insérer un grand nombre de documents avec des valeurs userId qui seront distribuées uniformément entre les shards.

Dans le shell mongos, exécutez le script suivant pour insérer 100 000 documents utilisateur :

let batch = [];
for (let i = 1; i <= 100000; i++) {
    batch.push({ userId: i, name: "User " + i, age: Math.floor(Math.random() * 50) + 18 });
    if (batch.length === 1000) {  // Insère tous les 1000 documents
        db.users.insertMany(batch);
        batch = [];
    }
}
if (batch.length > 0) {
    db.users.insertMany(batch);  // Insère les documents restants
}

Cela insérera 100 000 utilisateurs dans la collection users avec des âges aléatoires. Le champ userId est utilisé comme clé de sharding, ce qui permet de distribuer les documents entre vos shards.

4. Vérifier la Distribution des Shards

Une fois le jeu de données inséré, vous pouvez vérifier comment les chunks ont été distribués entre les shards. Utilisez la commande suivante dans le shell mongos :

db.adminCommand({ balancerStatus: 1 })

Cela affichera si le balancer distribue activement des chunks entre les shards.

Ensuite, vous pouvez vérifier la distribution des chunks pour la collection users :

db.printShardingStatus()
db.users.getShardDistribution()

Recherchez la section testdb.users dans la sortie, qui affichera la distribution des chunks entre vos shards. Chaque chunk représentera une plage de valeurs userId, et vous verrez combien de chunks sont attribués à chaque shard.

5. Tester les Requêtes pour Vérifier le Sharding

Vous pouvez effectuer quelques requêtes de test pour vérifier comment le sharding affecte les résultats des requêtes.

Par exemple, pour interroger les utilisateurs avec des plages spécifiques de userId et voir comment MongoDB les traite à travers les shards :

db.users.find({ userId: { $gte: 1000, $lt: 2000 } }).explain("executionStats")

La sortie montrera combien de shards ont été impliqués dans la requête.

Résumé des Étapes

  1. Activer le sharding sur la base de données testdb.
  2. Fragmenter la collection users par userId.
  3. Insérer 100 000 utilisateurs avec des valeurs userId.
  4. Vérifier la distribution des chunks avec db.printShardingStatus().
  5. Exécuter des requêtes pour observer comment les données sont réparties entre les shards.

Dépannage

Si vous rencontrez des problèmes, vous pouvez inspecter les journaux des composants MongoDB :

kubectl logs <nom-du-pod>

Étape 1 : Déployer un Pod de Test avec des Outils Réseau

Vous pouvez exécuter un pod simple busybox ou alpine incluant telnet ou curl. Voici comment créer un pod de test :

kubectl run test-network-a --image=busybox --restart=Never -- sh -c "sleep 3600"

Étape 2 : Exec dans le Pod de Test et Tester la Connectivité

Une fois que le pod est en cours d'exécution, connectez-vous dedans et testez la connectivité :

kubectl exec -it test-network-a -- sh

Dans le pod, exécutez la commande suivante pour tester la connectivité vers config-server-2 :

telnet config-server-2.config-server.default.svc.cluster.local 27201

ou

nc -zv config-server-2.config-server.default.svc.cluster.local 27201

Pour les problèmes courants liés au réseau, au stockage persistant ou à la planification des pods, consultez la documentation Kubernetes ou la documentation MongoDB sur le sharding.

Contribuer

Si vous souhaitez contribuer, n'hésitez pas à soumettre une pull request. Pour les changements majeurs, veuillez ouvrir un ticket pour discuter des modifications avant de les proposer.

Licence

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.