Bereitstellung eines MongoDB-Sammlungsgenerators auf Kubernetes

Das Erstellen eines Dienstprogramms zum Generieren von 100 MongoDB-Sammlungen, die jeweils mit 1 Million zufälligen Dokumenten gefüllt sind, und die Bereitstellung auf Kubernetes umfasst mehrere Schritte. Dieser Leitfaden führt Sie durch den Prozess, von der Einrichtung einer Kubernetes-Umgebung über die Generierung der Sammlungen bis hin zur Bereitstellung des Jobs in einem dedizierten Namespace.

1. Einrichten Ihrer Kubernetes-Umgebung

Stellen Sie sicher, dass Sie über einen Kubernetes-Cluster verfügen (z. B. GKE, EKS, AKS oder Minikube) und konfigurieren Sie kubectl für die Verbindung damit.

2. Erstellen Sie einen dedizierten Namespace

Um diese Bereitstellung isoliert zu halten, erstellen Sie einen Namespace namens my-lab:

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

3. Stellen Sie MongoDB auf Kubernetes bereit

Erstellen Sie ein persistentes Volume (PV)

Erstellen Sie eine mongo-pv.yaml-Datei, um ein persistentes Volume für MongoDB-Daten zu definieren:

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

PV anwenden:

kubectl apply -f mongo-pv.yaml

Erstellen Sie einen Persistent Volume Claim (PVC)

Definieren Sie einen dauerhaften Volumenanspruch in mongo-pvc.yaml:

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

PVC auftragen:

kubectl apply -f mongo-pvc.yaml

Erstellen Sie eine MongoDB-Bereitstellung

Definieren Sie die MongoDB-Bereitstellung und den MongoDB-Dienst in 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

Wenden Sie die Bereitstellung an:

kubectl apply -f mongo-deployment.yaml

4. Stellen Sie eine Verbindung zu MongoDB her

Überprüfen Sie die MongoDB-Bereitstellung, indem Sie eine Verbindung herstellen:

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

5. Überprüfen Sie die Persistenz

Skalieren Sie die MongoDB-Bereitstellung herunter und sichern Sie sie dann, um sicherzustellen, dass die Daten bestehen bleiben:

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

6. Erstellen Sie ein Python-Dienstprogramm zur Sammlungsgenerierung

Definieren Sie mit Python ein Skript, um Sammlungen zu erstellen und diese mit zufälligen Dokumenten zu füllen:

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. Dockerisieren Sie das Python-Dienstprogramm

Erstellen Sie eine Docker-Datei, um das Python-Skript zu containerisieren:

FROM python:3.9-slim

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

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

Erstellen Sie das Image und übertragen Sie es in eine Containerregistrierung:

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

8. Erstellen Sie einen Kubernetes-Job

Definieren Sie einen Job in mongo-populator-job.yaml, um das Skript zur Sammlungsgenerierung auszuführen:

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

Bewerben Sie sich:

kubectl apply -f mongo-populator-job.yaml

9. Überprüfen Sie die Sammlungsgenerierung

Nach Abschluss des Auftrags stellen Sie eine Verbindung zu MongoDB her, um die Daten zu untersuchen:

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

In 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");
 });

Jede Sammlung sollte 1 Million Dokumente enthalten, was bestätigt, dass der Datengenerierungsauftrag erfolgreich war.

Das obige ist der detaillierte Inhalt vonBereitstellung eines MongoDB-Sammlungsgenerators auf Kubernetes. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!