Déploiement d'un générateur de collection MongoDB sur Kubernetes

Créer un utilitaire pour générer 100 collections MongoDB, chacune remplie de 1 million de documents aléatoires, et le déployer sur Kubernetes implique plusieurs étapes. Ce guide décrit le processus, depuis la configuration d'un environnement Kubernetes jusqu'à la génération des collections et le déploiement de la tâche dans un espace de noms dédié.

1. Configuration de votre environnement Kubernetes

Assurez-vous d'avoir un cluster Kubernetes (tel que GKE, EKS, AKS ou Minikube) et configurez kubectl pour s'y connecter.

2. Créez un espace de noms dédié

Pour garder ce déploiement isolé, créez un espace de noms appelé my-lab :

kubectl create namespace my-lab
kubectl get ns my-lab

3. Déployez MongoDB sur Kubernetes

Créer un volume persistant (PV)

Créez un fichier mongo-pv.yaml pour définir un volume persistant pour les données MongoDB :

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mongo-pv
  namespace: my-lab
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /data/mongo

Appliquer le PV :

kubectl apply -f mongo-pv.yaml

Créer une réclamation de volume persistant (PVC)

Définissez une réclamation de volume persistante dans mongo-pvc.yaml :

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mongo-pvc
  namespace: my-lab
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

Appliquer le PVC :

kubectl apply -f mongo-pvc.yaml

Créer un déploiement MongoDB

Définissez le déploiement et le service MongoDB dans mongo-deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongo
  namespace: my-lab
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mongo
  template:
    metadata:
      labels:
        app: mongo
    spec:
      containers:
        - name: mongo
          image: mongo:latest
          ports:
            - containerPort: 27017
          env:
            - name: MONGO_INITDB_ROOT_USERNAME
              value: "root"
            - name: MONGO_INITDB_ROOT_PASSWORD
              value: "password"
          volumeMounts:
            - name: mongo-storage
              mountPath: /data/db
      volumes:
        - name: mongo-storage
          persistentVolumeClaim:
            claimName: mongo-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: mongo
  namespace: my-lab
spec:
  type: ClusterIP
  ports:
    - port: 27017
      targetPort: 27017
  selector:
    app: mongo

Appliquer le déploiement :

kubectl apply -f mongo-deployment.yaml

4. Connectez-vous à MongoDB

Vérifiez le déploiement de MongoDB en vous y connectant :

kubectl exec -it <mongo-pod-name> -n my-lab -- mongosh -u root -p password
</mongo-pod-name>

5. Vérifier la persistance

Réduisez puis sauvegardez le déploiement de MongoDB pour garantir la persistance des données :

kubectl scale deployment mongo --replicas=0 -n my-lab
kubectl scale deployment mongo --replicas=1 -n my-lab

6. Créez un utilitaire Python pour la génération de collections

À l'aide de Python, définissez un script pour créer des collections et les remplir avec des documents aléatoires :

import random
import string
import pymongo
from pymongo import MongoClient

def random_string(length=10):
    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))

def create_collections_and_populate(db_name='mydatabase', collections_count=100, documents_per_collection=1_000_000):
    client = MongoClient('mongodb://root:password@mongo:27017/')
    db = client[db_name]

    for i in range(collections_count):
        collection_name = f'collection_{i+1}'
        collection = db[collection_name]
        print(f'Creating collection: {collection_name}')

        bulk_data = [{'name': random_string(), 'value': random.randint(1, 100)} for _ in range(documents_per_collection)]
        collection.insert_many(bulk_data)
        print(f'Inserted {documents_per_collection} documents into {collection_name}')

if __name__ == "__main__":
    create_collections_and_populate()

7. Dockeriser l'utilitaire Python

Créez un Dockerfile pour conteneuriser le script Python :

FROM python:3.9-slim

WORKDIR /app
COPY mongo_populator.py .
RUN pip install pymongo

CMD ["python", "mongo_populator.py"]

Créez et transférez l'image vers un registre de conteneurs :

docker build -t <your-docker-repo>/mongo-populator:latest .
docker push <your-docker-repo>/mongo-populator:latest
</your-docker-repo></your-docker-repo>

8. Créer une tâche Kubernetes

Définissez un travail dans mongo-populator-job.yaml pour exécuter le script de génération de collection :

apiVersion: batch/v1
kind: Job
metadata:
  name: mongo-populator
  namespace: my-lab
spec:
  template:
    spec:
      containers:
        - name: mongo-populator
          image: <your-docker-repo>/mongo-populator:latest
          env:
            - name: MONGO_URI
              value: "mongodb://root:password@mongo:27017/"
      restartPolicy: Never
  backoffLimit: 4
</your-docker-repo>

Postuler le poste :

kubectl apply -f mongo-populator-job.yaml

9. Vérifier la génération de la collection

Une fois le travail terminé, connectez-vous à MongoDB pour examiner les données :

kubectl exec -it <mongo-pod-name> -n my-lab -- mongosh -u root -p password
</mongo-pod-name>

Dans MongoDB :

use mydatabase
show collections
db.collection_9.find().limit(5).pretty()

db.getCollectionNames().forEach(function(collection) {
     var count = db[collection].countDocuments();
     print(collection + ": " + count + " documents");
 });

Chaque collection doit contenir 1 million de documents, confirmant que le travail de génération de données a réussi.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!