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

ScaledJob vs. ScaledObject

Use ScaledJob quando cada evento corresponder a uma tarefa discreta e de longa duração executada até a conclusão em seu próprio pod. O ack-keda agenda um Job por evento: ele inicializa, processa o evento e encerra. Esse isolamento impede que tarefas lentas bloqueiem outras e permite controle preciso de concorrência via maxReplicaCount.

Prefira ScaledObject quando os eventos gerarem throughput contínuo e sua carga de trabalho for melhor atendida por um pool de réplicas de Deployment de longa duração.

O tutorial abaixo usa ScaledJob para transcodificação de vídeo. Quando um registro com "state":"waiting" é inserido no MongoDB, o ack-keda cria um Job para processar a tarefa e define o registro como "state":"finished" após a conclusão. Os Jobs finalizados são limpos automaticamente.

Criar namespaces de exemplo

Este exemplo usa o namespace mongodb para o banco de dados e mongodb-test para as configurações de dimensionamento automático.

kubectl create ns mongodb
kubectl create ns mongodb-test

Implantar o MongoDB

Se você já tem um serviço MongoDB, pule esta etapa.

1. Crie o arquivo mongoDB.yaml.

   Importante

   Este serviço MongoDB destina-se apenas a demonstrações e não possui alta disponibilidade. Não o use em produção.

   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. Implante o MongoDB.

   kubectl apply -f mongoDB.yaml

Inicializar o banco de dados MongoDB

1. Obtenha o nome do pod do 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. No banco de dados test, crie o usuário test_user e a coleção 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")'

Configurar TriggerAuthentication e ScaledJob

O ack-keda usa TriggerAuthentication para gerenciar credenciais de fontes de eventos com segurança. O ScaledJob define regras de dimensionamento, intervalos de verificação e o modelo de Job.

O arquivo a seguir combina três recursos: Secret, TriggerAuthentication e ScaledJob.

1. Crie o arquivo keda-mongodb.yaml. O campo secretTargetRef em TriggerAuthentication lê a string de conexão do Secret para autenticação no MongoDB. A query no ScaledJob aciona a criação de Jobs quando documentos na test_collection correspondem a {"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. Implante a configuração.

   kubectl apply -f keda-mongodb.yaml