Container Service for Kubernetes:Use event-driven scaling with a MongoDB event source

ScaledJob vs. ScaledObject

Utilisez ScaledJob lorsque chaque événement correspond à une tâche discrète et de longue durée qui s'exécute jusqu'à son terme dans son propre pod. ack-keda planifie un Job par événement : celui-ci s'initialise, traite l'événement, puis se termine. Cette isolation empêche les tâches lentes de bloquer les autres et permet un contrôle précis de la concurrence grâce à maxReplicaCount.

Utilisez ScaledObject lorsque les événements alimentent un débit continu et que votre charge de travail est mieux gérée par un pool de réplicas de Deployment fonctionnant en continu.

Le tutoriel ci-dessous utilise ScaledJob pour le transcodage vidéo. Lorsqu'un enregistrement avec "state":"waiting" est inséré dans MongoDB, ack-keda crée un Job pour traiter la tâche et définit l'enregistrement sur "state":"finished" à la fin du traitement. Les Jobs terminés sont nettoyés automatiquement.

Créer les namespaces d'exemple

Cet exemple utilise le namespace mongodb pour la base de données et mongodb-test pour les configurations de mise à l'échelle automatique.

kubectl create ns mongodb
kubectl create ns mongodb-test

Déployer MongoDB

Si vous disposez déjà d'un service MongoDB, ignorez cette étape.

1. Créez le fichier mongoDB.yaml.

   Important

   Ce service MongoDB est destiné uniquement à la démonstration et n'offre pas de haute disponibilité. Ne l'utilisez pas en production.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: mongodb
     namespace: mongodb
   spec:
     replicas: 1
     selector:
       matchLabels:
         name: mongodb
     template:
       metadata:
         labels:
           name: mongodb
       spec:
         containers:
         - name: mongodb
           image: registry-cn-shanghai.ack.aliyuncs.com/acs/mongo:v5.0.0
           imagePullPolicy: IfNotPresent
           ports:
           - containerPort: 27017
             name: mongodb
             protocol: TCP
   ---
   kind: Service
   apiVersion: v1
   metadata:
     name: mongodb-svc
     namespace: mongodb
   spec:
     type: ClusterIP
     ports:
     - name: mongodb
       port: 27017
       targetPort: 27017
       protocol: TCP
     selector:
       name: mongodb

2. Déployez MongoDB.

   kubectl apply -f mongoDB.yaml

Initialiser la base de données MongoDB

1. Récupérez le nom du pod MongoDB.

   MONGO_POD_NAME=$(kubectl get pods -n mongodb -l name=mongodb -o jsonpath='{.items[0].metadata.name}')
   echo "MongoDB pod name: $MONGO_POD_NAME"

2. Dans la base de données test, créez l'utilisateur test_user et la collection test_collection.

   # Create user
   kubectl exec -n mongodb ${MONGO_POD_NAME} -- mongo --eval 'db.createUser({ user:"test_user",pwd:"test_password",roles:[{ role:"readWrite", db: "test"}]})'
   
   # Authenticate user
   kubectl exec -n mongodb ${MONGO_POD_NAME} -- mongo --eval 'db.auth("test_user","test_password")'
   
   # Create collection
   kubectl exec -n mongodb ${MONGO_POD_NAME} -- mongo test --eval 'db.createCollection("test_collection")'

Configurer TriggerAuthentication et ScaledJob

ack-keda utilise TriggerAuthentication pour gérer de manière sécurisée les identifiants de la source d'événements. ScaledJob définit les règles de mise à l'échelle, les intervalles d'interrogation et le modèle de Job.

Le fichier suivant combine les trois ressources : Secret, TriggerAuthentication et ScaledJob.

1. Créez le fichier keda-mongodb.yaml. Le champ secretTargetRef dans TriggerAuthentication lit la chaîne de connexion depuis le Secret pour l'authentification MongoDB. La requête query dans ScaledJob déclenche la création d'un Job lorsque les documents de test_collection correspondent à {"type":"mp4","state":"waiting"}.

   apiVersion: v1
   kind: Secret
   metadata:
     name: mongodb-secret
     namespace: mongodb-test
   type: Opaque
   data:
     # Base64-encoded value of:
     # mongodb://test_user:test_password@mongodb-svc.mongodb.svc.cluster.local:27017/test
     connect: bW9uZ29kYjovL3Rlc3RfdXNlcjp0ZXN0X3Bhc3N3b3JkQG1vbmdvZGItc3ZjLm1vbmdvZGIuc3ZjLmNsdXN0ZXIubG9jYWw6MjcwMTcvdGVzdA==
   ---
   apiVersion: keda.sh/v1alpha1
   kind: TriggerAuthentication
   metadata:
     name: mongodb-trigger
     namespace: mongodb-test
   spec:
     secretTargetRef:
       - parameter: connectionString
         name: mongodb-secret
         key: connect
   ---
   apiVersion: keda.sh/v1alpha1
   kind: ScaledJob
   metadata:
     name: mongodb-job
     namespace: mongodb-test
   spec:
     jobTargetRef:
       template:
         spec:
           containers:
             - name: mongo-update
               image: registry-cn-shanghai.ack.aliyuncs.com/acs/mongo-update:v6
               args:
                 - --dataBase=test
                 - --collection=test_collection
                 - --operation=updateMany
                 - --update={"$set":{"state":"finished"}}
               env:
                 - name: MONGODB_CONNECTION_STRING
                   value: mongodb://test_user:test_password@mongodb-svc.mongodb.svc.cluster.local:27017/test
               imagePullPolicy: IfNotPresent
           restartPolicy: Never
       backoffLimit: 1
     pollingInterval: 15         # Check MongoDB every 15 seconds
     maxReplicaCount: 5          # Run at most 5 concurrent Jobs
     successfulJobsHistoryLimit: 0  # Delete completed Jobs immediately
     failedJobsHistoryLimit: 10     # Keep the last 10 failed Jobs for debugging
     triggers:
       - type: mongodb
         metadata:
           dbName: test
           collection: test_collection
           query: '{"type":"mp4","state":"waiting"}'  # Launch a Job for each matching document
           queryValue: "1"
         authenticationRef:
           name: mongodb-trigger

2. Déployez la configuration.

   kubectl apply -f keda-mongodb.yaml