Autoscaler vos charges de travail de consommateur Kafka

Ce tutoriel vous explique comment configurer et déployer un autoscaler Kafka en tant que service Cloud Run. Cet autoscaler effectue une logique de scaling pour une charge de travail de consommateur Kafka, telle qu'un déploiement de pool de nœuds de calcul Cloud Run. L'autoscaler Kafka lit les métriques de votre cluster Kafka et utilise le scaling manuel pour un pool de workers ou un service Cloud Run afin de faire évoluer une charge de travail de consommateur Kafka en fonction de la métrique de décalage du consommateur Kafka.

Le schéma suivant montre comment un service d'autoscaler Kafka lit les métriques d'un cluster Kafka pour effectuer l'autoscaling d'un pool de nœuds de calcul consommateur Kafka.

Un service d'autoscaling Kafka extrait les métriques de Kafka et autoscale un consommateur Kafka.

Rôles requis

Pour obtenir les autorisations nécessaires pour déployer et exécuter ce service, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Avant de commencer

Pour configurer et utiliser l'autoscaler Kafka, vous devez disposer des ressources suivantes.

  • Cluster Kafka
  • Consommateur déployé

Cluster Kafka

Consommateur Cloud Run déployé

  • Une charge de travail de consommateur Kafka doit être déployée sur Cloud Run en tant que service ou pool de nœuds de calcul. Il doit être configuré pour se connecter à votre cluster, sujet et groupe de consommateurs Kafka. Pour obtenir un exemple de consommateur Kafka, consultez Exemple de consommateur de l'autoscaler Kafka Cloud Run.
  • Votre charge de travail consommateur doit se trouver dans le même Google Cloud projet que votre cluster Kafka.

Bonnes pratiques

  • Connectez vos consommateurs Kafka à votre réseau VPC à l'aide de Direct VPC. Le VPC direct vous permet de vous connecter à votre cluster Kafka à l'aide d'adresses IP privées et de conserver le trafic sur votre réseau VPC.
  • Configurez une vérification de l'état d'activité pour vos consommateurs Kafka afin de vérifier si le consommateur extrait des événements. La vérification de l'état permet de s'assurer que les instances non opérationnelles redémarrent automatiquement si elles cessent de traiter les événements, même si le conteneur ne plante pas.

Créer l'autoscaler Kafka

Vous pouvez utiliser Cloud Build pour créer une image de conteneur de l'autoscaler Kafka à partir de son code source.

  1. Clonez le dépôt :

    git clone https://github.com/GoogleCloudPlatform/cloud-run-kafka-scaler.git

  2. Accédez au dossier du dépôt :

    cd cloud-run-kafka-scaler

Pour spécifier le nom de l'image de sortie, mettez à jour %ARTIFACT_REGISTRY_IMAGE% dans le fichier cloudbuild.yaml inclus, par exemple : us-central1-docker.pkg.dev/my-project/my-repo/my_kafka_autoscaler.

gcloud builds submit --tag us-central1-docker.pkg.dev/my-project/my-repo/my_kafka_autoscaler

Cette commande crée l'image de conteneur et la transfère vers Artifact Registry. Notez le chemin d'accès complet à l'image (SCALER_IMAGE_PATH), car vous en aurez besoin plus tard.

Notez que l'image obtenue ne s'exécutera pas en local. Il est conçu pour être superposé à une image de base Java. Pour en savoir plus, y compris sur la façon de réassembler l'image de conteneur pour l'exécuter en local, consultez Configurer les mises à jour automatiques des images de base.

Définir la configuration de l'autoscaler Kafka

Vous pouvez configurer l'autoscaler Kafka à l'aide de secrets. L'autoscaler actualise sa configuration régulièrement. Vous pouvez donc envoyer de nouvelles versions secrètes pour modifier la configuration sans avoir à redéployer l'autoscaler.

Configurer les propriétés du client Kafka

Vous pouvez configurer la connexion à l'API Kafka Admin en installant un secret en tant que volume lorsque vous déployez l'autoscaler Kafka.

Créez un fichier nommé kafka_client_config.txt et incluez les propriétés de configuration du client Admin Kafka que vous souhaitez ajouter. La propriété bootstrap.servers est obligatoire :

bootstrap.servers=BOOTSTRAP_SERVER_LIST

Remplacez BOOTSTRAP_SERVER_LIST par la liste HOST:PORT pour le cluster Kafka.

Configurer l'authentification Kafka

Si votre serveur Kafka nécessite une authentification, incluez les propriétés de configuration nécessaires dans le fichier kafka_client_config.txt. Par exemple, pour se connecter à un cluster Managed Service pour Apache Kafka à l'aide des identifiants par défaut de l'application avec Google OAuth, ce secret doit inclure les propriétés suivantes :

bootstrap.servers=BOOTSTRAP_SERVER_LIST
security.protocol=SASL_SSL
sasl.mechanism=OAUTHBEARER
sasl.login.callback.handler.class=com.google.cloud.hosted.kafka.auth.GcpLoginCallbackHandler
sasl.jaas.config=org.apache.kafka.common.security.oauthbearer.OAuthBearerLoginModule required;

Remplacez BOOTSTRAP_SERVER_LIST par la liste HOST:PORT pour le cluster Kafka.

L'utilisation des identifiants par défaut de l'application avec un cluster Managed Service pour Apache Kafka nécessite également d'attribuer le rôle Client Kafka géré (roles/managedkafka.client) au compte de service de l'autoscaler Kafka :

gcloud projects add-iam-policy-binding PROJECT_ID \
--member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
--role="roles/managedkafka.client"

Remplacez les éléments suivants :

  • SCALER_SERVICE_ACCOUNT : nom du compte de service de l'autoscaler Kafka.
  • PROJECT_ID : ID de projet du service Kafka Autoscaler.

Pour créer le secret qui sera installé en tant que volume lors du déploiement, utilisez le fichier kafka_client_config.txt :

gcloud secrets create ADMIN_CLIENT_SECRET_NAME --data-file=kafka_client_config.txt

Remplacez ADMIN_CLIENT_SECRET_NAME par le nom du secret d'authentification Kafka.

Configurer le scaling

L'autoscaler Kafka lit sa configuration de scaling à partir du volume /scaler-config/scaling. Le contenu de ce volume doit être au format YAML. Nous vous recommandons de monter un volume secret pour cette configuration.

Créez un fichier nommé scaling_config.yaml avec la configuration suivante :

spec:
  scaleTargetRef:
    name: projects/PROJECT_ID/locations/REGION/workerpools/CONSUMER_SERVICE_NAME
 metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: TARGET_CPU_UTILIZATION
        activationThreshold: CPU_ACTIVATION_THRESHOLD
        tolerance: CPU_TOLERANCE
        windowSeconds: CPU_METRIC_WINDOW
  - type: External
    external:
      metric:
        name: consumer_lag
      target:
        type: AverageValue
        averageValue: LAG_THRESHOLD
        activationThreshold: LAG_ACTIVATION_THRESHOLD
        tolerance: LAG_TOLERANCE

Remplacez les éléments suivants :

  • PROJECT_ID : ID de projet de la charge de travail du consommateur Kafka à mettre à l'échelle automatiquement.
  • REGION : région de la charge de travail du consommateur Kafka à autoscaler.
  • CONSUMER_SERVICE_NAME : nom de la charge de travail du consommateur Kafka à mettre à l'échelle automatiquement.
  • TARGET_CPU_UTILIZATION : utilisation cible du processeur pour les calculs d'autoscaling, par exemple : 60.
  • LAG_THRESHOLD : seuil de la métrique consumer_lag pour déclencher l'autoscaling (par exemple, 1000).
  • (Facultatif) CPU_ACTIVATION_THRESHOLD : seuil d'activation du processeur. Lorsque toutes les métriques sont inactives, le consommateur cible est mis à l'échelle zéro. La valeur par défaut est 0.
  • (Facultatif) CPU_TOLERANCE : seuil qui empêche les changements d'échelle s'il se trouve dans la plage spécifiée. Exprimé en pourcentage de l'utilisation cible du processeur. La valeur par défaut est 0.1.
  • (Facultatif) CPU_METRIC_WINDOW : période (en secondes) sur laquelle l'utilisation moyenne du processeur est calculée. La valeur par défaut est 120.
  • (Facultatif) LAG_ACTIVATION_THRESHOLD : seuil d'activation de la métrique consumer_lag. Lorsque toutes les métriques sont inactives, le consommateur cible est mis à l'échelle zéro. La valeur par défaut est 0.
  • (Facultatif) LAG_TOLERANCE : seuil qui empêche les changements d'échelle s'il se trouve dans la plage spécifiée. Exprimé en pourcentage du décalage cible du consommateur. La valeur par défaut est 0.1.

Vous pouvez éventuellement configurer des propriétés de scaling avancées à l'aide d'un bloc behavior:. Ce bloc est compatible avec la plupart des propriétés des règles de scaling HPA de Kubernetes.

Si vous ne spécifiez pas de bloc behavior, la configuration par défaut suivante est utilisée : 

behavior:
  scaleDown:
    stabilizationWindowSeconds: 300
    policies:
    - type: Percent
      value: 50
      periodSeconds: 30
    selectPolicy: Min
  scaleUp:
    stabilizationWindowSeconds: 0
    policies:
    - type: Percent
      value: 100
      periodSeconds: 15
    - type: Instances
      value: 4
      periodSeconds: 15
    selectPolicy: Max

Pour créer le volume secret, qui sera installé sur deployment, copiez la configuration dans un fichier nommé scaling_config.yaml, puis exécutez la commande suivante :

gcloud secrets create SCALING_CONFIG_SECRET_NAME --data-file=scaling_config.yaml

Remplacez SCALING_CONFIG_SECRET_NAME par le nom du secret de scaling.

Déployer l'autoscaler Kafka

Une fois les conditions préalables remplies, vous pouvez déployer le service d'autoscaler Kafka et son infrastructure associée. Un module Terraform et un script shell sont fournis pour simplifier ce processus.

gcloud

Cette section présente chaque commande gcloud requise pour déployer manuellement l'autoscaler. Dans la plupart des cas, nous vous recommandons d'utiliser plutôt le script shell ou le module Terraform.

Créer un compte de service

Les exigences liées au compte de service dépendent de l'intervalle de vérification de l'autoscaling que vous avez configuré. Vous pouvez configurer l'autoscaler Kafka pour qu'il effectue des vérifications d'autoscaling à des intervalles flexibles :

  • Une minute ou plus : Cloud Scheduler déclenche la vérification de l'autoscaling avec une requête POST à l'intervalle sélectionné.

  • Moins d'une minute : Cloud Scheduler déclenche la création de plusieurs tâches Cloud Tasks chaque minute, en fonction de la fréquence configurée.

Une ou plusieurs minutes

Compte de service de l'autoscaler Kafka

Créez un compte de service pour le scaler automatique Kafka :

gcloud iam service-accounts create SCALER_SERVICE_ACCOUNT

Remplacez SCALER_SERVICE_ACCOUNT par le nom du compte de service de l'autoscaler Kafka.

L'autoscaler Kafka a besoin des autorisations suivantes pour mettre à jour le nombre d'instances de consommateur Kafka :

  • iam.serviceaccounts.actAs pour le compte de service du consommateur Kafka.
  • roles/artifactregistry.reader pour le dépôt contenant l'image du consommateur Kafka.
  • run.workerpools.get et run.workerpools.update. Ces autorisations sont incluses dans le rôle Administrateur Cloud Run (roles/run.admin).
  • roles/secretmanager.secretAccessor pour les secrets d'authentification de scaling et Kafka.
  • roles/monitoring.viewer pour le projet client Kafka. Ce rôle est nécessaire pour lire les métriques d'utilisation du processeur.
  • roles/monitoring.metricWriter pour le projet client Kafka. Ce rôle est facultatif, mais il permet à l'autoscaler d'émettre des métriques personnalisées pour une meilleure observabilité.
gcloud iam service-accounts add-iam-policy-binding CONSUMER_SERVICE_ACCOUNT_EMAIL \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

gcloud iam service-accounts add-iam-policy-binding CONSUMER_IMAGE_REPO \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.reader" \
    --location=REPO_REGION

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/run.admin"

gcloud secrets add-iam-policy-binding ADMIN_CLIENT_SECRET_NAME \
  --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

gcloud secrets add-iam-policy-binding SCALING_CONFIG_SECRET_NAME \
  --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/monitoring.viewer" \
    --condition=None

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/monitoring.metricWriter" \
    --condition=None

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet dans lequel se trouve le service Kafka Autoscaler.
  • CONSUMER_SERVICE_ACCOUNT_EMAIL : adresse e-mail du compte de service pour le consommateur Kafka. (par exemple, example@PROJECT-ID.iam.gserviceaccount.com).
  • SCALER_SERVICE_ACCOUNT : compte de service pour le scaling automatique de Kafka.
  • ADMIN_CLIENT_SECRET_NAME : nom du secret d'authentification Kafka.
  • SCALING_CONFIG_SECRET_NAME : nom du secret de scaling.
  • CONSUMER_IMAGE_REPO : ID ou identifiant complet du dépôt avec l'image de conteneur pour le consommateur Kafka.
  • REPO_REGION : emplacement du dépôt d'images du consommateur.

Moins d'une minute

Configurer Cloud Tasks

Cloud Scheduler ne peut se déclencher qu'à des intervalles d'une minute ou plus. Pour les intervalles inférieurs à une minute, utilisez Cloud Tasks pour déclencher l'autoscaler Kafka. Pour configurer Cloud Tasks, vous devez disposer des éléments suivants :

  • Créez la file d'attente Cloud Tasks pour les tâches de vérification de l'autoscaling.
  • Créez le compte de service que Cloud Tasks utilise pour appeler le scaler automatique Kafka avec le rôle Appelant Cloud Run.
gcloud tasks queues create CLOUD_TASKS_QUEUE_NAME \
--location=REGION

gcloud iam service-accounts create TASKS_SERVICE_ACCOUNT

gcloud run services add-iam-policy-binding SCALER_SERVICE_NAME \
    --member="serviceAccount:TASKS_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/run.invoker"

Remplacez les éléments suivants :

  • CLOUD_TASKS_QUEUE_NAME : file d'attente Cloud Tasks configurée pour déclencher les vérifications de l'autoscaling.
  • TASKS_SERVICE_ACCOUNT : compte de service que Cloud Tasks doit utiliser pour déclencher les vérifications de l'autoscaling.
  • SCALER_SERVICE_NAME : nom de votre service Kafka Autoscaler.
  • PROJECT_ID : ID de projet du service Kafka Autoscaler.
  • REGION : emplacement du service de scaling automatique Kafka.

Configurer le compte de service de l'autoscaler Kafka

Créez un compte de service pour le scaler automatique Kafka :

gcloud iam service-accounts create SCALER_SERVICE_ACCOUNT

Remplacez SCALER_SERVICE_ACCOUNT par le nom du compte de service de l'autoscaler Kafka.

Pour mettre à jour le nombre d'instances de consommateur Kafka et créer des tâches pour les vérifications de l'autoscaling, le scaler Kafka a besoin des autorisations suivantes :

  • iam.serviceaccounts.actAs pour le compte de service du consommateur Kafka.
  • roles/artifactregistry.reader pour le dépôt contenant l'image du consommateur Kafka
  • run.workerpools.get et run.workerpools.update. Ces autorisations sont incluses dans le rôle Administrateur Cloud Run (roles/run.admin).
  • roles/secretmanager.secretAccessor pour les secrets d'authentification Kafka et de scaling.
  • roles/monitoring.viewer pour le projet client Kafka. Ce rôle est nécessaire pour lire les métriques d'utilisation du processeur.
  • roles/monitoring.metricWriter pour le projet client Kafka. Ce rôle est facultatif, mais il permet à l'autoscaler d'émettre des métriques personnalisées pour une meilleure observabilité.
  • Rôle Empileur de tâches Cloud (roles/cloudtasks.enqueuer).
gcloud iam service-accounts add-iam-policy-binding CONSUMER_SERVICE_ACCOUNT_EMAIL \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/iam.serviceAccountUser"

gcloud iam service-accounts add-iam-policy-binding CONSUMER_IMAGE_REPO \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.reader" \
    --location=REPO_REGION

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/run.admin"

gcloud secrets add-iam-policy-binding ADMIN_CLIENT_SECRET_NAME \
  --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

gcloud secrets add-iam-policy-binding SCALING_CONFIG_SECRET_NAME \
  --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/secretmanager.secretAccessor"

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/monitoring.viewer" \
    --condition=None

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/monitoring.metricWriter" \
    --condition=None

gcloud tasks queues add-iam-policy-binding CLOUD_TASKS_QUEUE_NAME \
    --member="serviceAccount:SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/cloudtasks.enqueuer" \
    --location=REGION

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet dans lequel se trouve le service Kafka Autoscaler.
  • CONSUMER_SERVICE_ACCOUNT_EMAIL : adresse e-mail du compte de service pour le consommateur Kafka. (par exemple, example@PROJECT_ID.iam.gserviceaccount.com).
  • SCALER_SERVICE_ACCOUNT : compte de service pour le scaling automatique de Kafka.
  • CONSUMER_IMAGE_REPO : ID ou identifiant complet du dépôt avec l'image de conteneur pour le consommateur Kafka.
  • ADMIN_CLIENT_SECRET_NAME : nom du secret d'authentification Kafka.
  • SCALING_CONFIG_SECRET_NAME : nom du secret de scaling.
  • REPO_REGION : emplacement du dépôt d'images du consommateur.
  • CLOUD_TASKS_QUEUE_NAME : file d'attente Cloud Tasks configurée pour déclencher les vérifications de l'autoscaling.
  • REGION : emplacement du service de scaling automatique Kafka.

Configurer les variables d'environnement

Une ou plusieurs minutes

L'autoscaler Kafka utilise des variables d'environnement pour spécifier le consommateur Kafka et d'autres aspects de la charge de travail cible. Pour des raisons de sécurité, nous vous recommandons de configurer les informations sensibles en tant que secrets.

Créez un fichier YAML nommé scaler_env_vars.yaml avec les variables suivantes :

KAFKA_TOPIC_ID: KAFKA_TOPIC_ID
CONSUMER_GROUP_ID: CONSUMER_GROUP_ID
CYCLE_SECONDS: CYCLE_SECONDS
OUTPUT_SCALER_METRICS: OUTPUT_SCALER_METRICS

Remplacez les éléments suivants :

  • KAFKA_TOPIC_ID : ID du sujet auquel les consommateurs Kafka sont abonnés.
  • CONSUMER_GROUP_ID : ID du groupe de consommateurs utilisé par le consommateur Kafka cible. Ces valeurs doivent correspondre, sinon l'autoscaling échouera.
  • CYCLE_SECONDS : période du cycle de l'autoscaler, en secondes.
  • OUTPUT_SCALER_METRICS : paramètre permettant d'activer les métriques. Définissez la valeur sur true pour activer la sortie des métriques personnalisées, ou sur false dans le cas contraire.

Moins d'une minute

L'autoscaler Kafka utilise des variables d'environnement pour spécifier le consommateur Kafka et d'autres aspects de la charge de travail cible. Pour des raisons de sécurité, nous vous recommandons de configurer les informations sensibles en tant que secrets.

Créez un fichier YAML nommé scaler_env_vars.yaml avec les variables suivantes :

KAFKA_TOPIC_ID: KAFKA_TOPIC_ID
CONSUMER_GROUP_ID: CONSUMER_GROUP_ID
CYCLE_SECONDS: CYCLE_SECONDS
OUTPUT_SCALER_METRICS: OUTPUT_SCALER_METRICS
FULLY_QUALIFIED_CLOUD_TASKS_QUEUE_NAME: CLOUD_TASKS_QUEUE_NAME
INVOKER_SERVICE_ACCOUNT_EMAIL: TASKS_SERVICE_ACCOUNT_EMAIL

Remplacez les éléments suivants :

  • KAFKA_TOPIC_ID : ID du sujet auquel les consommateurs Kafka sont abonnés.
  • CONSUMER_GROUP_ID : ID du groupe de consommateurs utilisé par le consommateur Kafka cible. Ces valeurs doivent correspondre, sinon l'autoscaling échouera.
  • CYCLE_SECONDS : période du cycle de l'autoscaler, en secondes.
  • OUTPUT_SCALER_METRICS : paramètre permettant d'activer les métriques. Définissez la valeur sur true pour activer la sortie des métriques personnalisées, ou sur false dans le cas contraire.
  • CLOUD_TASKS_QUEUE_NAME : nom complet de la file d'attente Cloud Tasks pour déclencher les vérifications de l'autoscaling. Il se présente sous la forme suivante : projects/$PROJECT_ID/locations/$REGION/queues/$CLOUD_TASKS_QUEUE_NAME.
  • TASKS_SERVICE_ACCOUNT_EMAIL : compte de service que Cloud Tasks doit utiliser pour déclencher les vérifications de l'autoscaling. (par exemple, example@PROJECT_ID.iam.gserviceaccount.com).

Déployez le scaler automatique Kafka à l'aide de l'image fournie, puis connectez-vous au VPC Kafka avec le fichier scaler_env_vars.yaml et les montages de volume secret :

gcloud run deploy SCALER_SERVICE_NAME \
    --image=SCALER_IMAGE_URI \
    --env-vars-file=scaler_env_vars.yaml \
    --service-account=SCALER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com \
    --no-allow-unauthenticated \
    --network=KAFKA_VPC_NETWORK \
    --subnet=KAFKA_VPC_SUBNET \
    --update-secrets=/kafka-config/kafka-client-properties=ADMIN_CLIENT_SECRET_NAME:latest \
    --update-secrets=/scaler-config/scaling=SCALING_CONFIG_SECRET_NAME:latest
    --labels=created-by=kafka-autoscaler

Remplacez les éléments suivants :

  • SCALER_IMAGE_URI : URI de l'image de l'autoscaler Kafka.
  • SCALER_SERVICE_NAME : nom de votre service Kafka Autoscaler.
  • SCALER_SERVICE_ACCOUNT : nom du compte de service de l'autoscaler Kafka.
  • PROJECT_ID : ID de projet du service Kafka Autoscaler.
  • KAFKA_VPC_NETWORK : réseau VPC connecté au cluster Kafka.
  • KAFKA_VPC_SUBNET : sous-réseau VPC connecté au cluster Kafka.
  • ADMIN_CLIENT_SECRET_NAME : nom du secret d'authentification Kafka.
  • SCALING_CONFIG_SECRET_NAME : nom du secret de scaling.

Configurer des vérifications périodiques de l'autoscaling

Dans cette section, vous allez utiliser Cloud Scheduler pour déclencher des vérifications périodiques de l'autoscaling :

  • Une minute ou plus : configurez Cloud Scheduler pour qu'il se déclenche à l'intervalle sélectionné.
  • Moins d'une minute : configurez Cloud Scheduler pour qu'il se déclenche toutes les minutes.
Créer un compte de service d'appelant

Pour permettre à Cloud Scheduler d'appeler le scaler automatique Kafka, vous devez créer un compte de service avec le rôle "Demandeur" (roles/run.invoker) sur le service de scaler automatique Kafka :

gcloud iam service-accounts create SCALER_INVOKER_SERVICE_ACCOUNT

gcloud run services add-iam-policy-binding SCALER_SERVICE_NAME \
  --member="serviceAccount:SCALER_INVOKER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/run.invoker"

Remplacez les éléments suivants :

  • SCALER_SERVICE_NAME : nom de votre service Kafka Autoscaler.
  • SCALER_INVOKER_SERVICE_ACCOUNT : nom du compte de service de l'appelant.
  • PROJECT_ID : ID de projet du service Kafka Autoscaler.
Créer une tâche Cloud Scheduler

Une ou plusieurs minutes

Créez une tâche Cloud Scheduler avec l'intervalle de vérification de l'autoscaling sélectionné :

gcloud scheduler jobs create http kafka-scaling-check \
    --location=REGION \
    --schedule="CRON_SCHEDULE" \
    --time-zone="TIMEZONE" \
    --uri=https://SCALER_SERVICE_NAME-PROJECT_NUMBER.REGION.run.app \
    --oidc-service-account-email=SCALER_INVOKER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com \
    --http-method=POST

Remplacez les éléments suivants :

  • SCALER_SERVICE_NAME : nom de votre service Kafka Autoscaler.
  • SCALER_INVOKER_SERVICE_ACCOUNT : nom du compte de service de l'appelant.
  • PROJECT_ID : ID du projet ou du service Kafka Autoscaler.
  • PROJECT_NUMBER : numéro de projet du service d'autoscaler Kafka.
  • REGION : emplacement du service de scaling automatique Kafka.
  • TIMEZONE : fuseau horaire, par exemple America/Los_Angeles.
  • CRON_SCHEDULE : planification sélectionnée au format Crontab. Par exemple, pour chaque minute : "* * * * *".

Moins d'une minute

Créez une tâche Cloud Scheduler qui s'exécute toutes les minutes :

gcloud scheduler jobs create http kafka-scaling-check \
    --location=REGION \
    --schedule="* * * * *" \
    --time-zone="TIMEZONE" \
    --uri=https://SCALER_SERVICE_NAME-PROJECT_NUMBER.REGION.run.app \
    --oidc-service-account-email=SCALER_INVOKER_SERVICE_ACCOUNT@PROJECT_ID.iam.gserviceaccount.com \
    --http-method=POST

Remplacez les éléments suivants :

  • SCALER_SERVICE_NAME : nom de votre service Kafka Autoscaler.
  • SCALER_INVOKER_SERVICE_ACCOUNT : nom du compte de service de l'appelant.
  • PROJECT_ID : ID de projet du service d'autoscaler Kafka.
  • PROJECT_NUMBER : numéro de projet du service d'autoscaler Kafka.
  • REGION : emplacement du service de scaling automatique Kafka.
  • TIMEZONE : fuseau horaire, par exemple America/Los_Angeles.

terraform

Le répertoire terraform/ contient un module Terraform réutilisable que vous pouvez utiliser pour provisionner l'autoscaler Kafka et ses ressources associées.

Ce module automatise la création des éléments suivants :

  • Service Cloud Run de l'autoscaler Kafka
  • Prise en charge des comptes de service et des liaisons IAM
  • File d'attente de tâches Cloud
  • Tâche Cloud Scheduler

Pour obtenir des instructions détaillées, des exemples d'utilisation et des descriptions de toutes les variables d'entrée/de sortie, consultez terraform readme.

Vous devez fournir les variables nécessaires au module Terraform, y compris les détails des prérequis, tels que l'ID du projet, la région, l'adresse e-mail du compte de service consommateur, les noms secrets, le chemin d'accès à l'image du scaler et l'ID du thème.

shell

Un script setup_kafka_scaler.sh est fourni avec l'autoscaler pour créer et configurer automatiquement toutes les ressources nécessaires.

Définir des variables d'environnement

Avant d'exécuter le script, assurez-vous d'avoir défini toutes les variables d'environnement requises :

# Details for already-deployed Kafka consumer
export PROJECT_ID=PROJECT_ID
export REGION=REGION
export CONSUMER_SERVICE_NAME=DEPLOYED_KAFKA_CONSUMER
export CONSUMER_SA_EMAIL=KAFKA_CONSUMER_ACCOUNT_EMAIL # For example, NAME@PROJECT_ID.iam.gserviceaccount.com
export TOPIC_ID=KAFKA_TOPIC_ID
export CONSUMER_GROUP_ID=KAFKA_CONSUMER_GROUP_ID
export NETWORK=VPC_NETWORK
export SUBNET=VPC_SUBNET

# Details for new items to be created during this setup
export CLOUD_TASKS_QUEUE_NAME=CLOUD_TASKS_QUEUE_FOR_SCALING_CHECKS
export TASKS_SERVICE_ACCOUNT=TASKS_SERVICE_ACCOUNT_NAME

export SCALER_SERVICE_NAME=KAFKA_AUTOSCALER_SERVICE_NAME
export SCALER_IMAGE_PATH=KAFKA_AUTOSCALER_IMAGE_URI
export SCALER_CONFIG_SECRET=KAFKA_AUTOSCALER_CONFIG_SECRET_NAME

export CYCLE_SECONDS=SCALER_CHECK_FREQUENCY # For example, 15; this value should be at least 5 seconds.

export OUTPUT_SCALER_METRICS=false # If you want scaling metrics to outputted to Cloud Monitoring set this to true and ensure your scaler service account has permission to write metrics (for example, via roles/monitoring.metricWriter).

Remplacez les éléments suivants :

  • PROJECT_ID : ID du projet dans lequel se trouve le service Kafka Autoscaler.
  • REGION : emplacement du service de scaling automatique Kafka.
  • DEPLOYED_KAFKA_CONSUMER : nom du consommateur Kafka.
  • KAFKA_CONSUMER_ACCOUNT_EMAIL : adresse e-mail du compte de service pour le consommateur Kafka.
  • KAFKA_TOPIC_ID : ID du sujet auquel les consommateurs Kafka sont abonnés.
  • KAFKA_CONSUMER_GROUP_ID : ID du groupe de consommateurs utilisé par le consommateur Kafka cible. Ces valeurs doivent correspondre, sinon l'autoscaling échouera.
  • VPC_NETWORK : réseau VPC connecté au cluster Kafka.
  • VPC_SUBNET : sous-réseau VPC connecté au cluster Kafka.
  • CLOUD_TASKS_QUEUE_FOR_SCALING_CHECKS : file d'attente Cloud Tasks configurée pour déclencher les vérifications de l'autoscaling.
  • TASKS_SERVICE_ACCOUNT_NAME : compte de service que Cloud Tasks doit utiliser pour déclencher les vérifications de l'autoscaling.
  • KAFKA_AUTOSCALER_SERVICE_NAME : nom de votre service Kafka Autoscaler.
  • KAFKA_AUTOSCALER_IMAGE_URI : URI de l'image de l'autoscaler Kafka.
  • KAFKA_AUTOSCALER_CONFIG_SECRET_NAME : nom du secret de scaling.
  • SCALER_CHECK_FREQUENCY : période du cycle de l'autoscaler, en secondes.

Exécuter le script d'installation

Exécutez le script setup_kafka_scaler.sh fourni :

./setup_kafka_scaler.sh

Le script effectue les actions suivantes :

  • Crée la file d'attente Cloud Tasks utilisée pour déclencher les vérifications de l'autoscaling.
  • Crée le compte de service de l'autoscaler Kafka et accorde les autorisations nécessaires.
  • Configure et déploie l'autoscaler Kafka.
  • Crée le job Cloud Scheduler qui déclenche périodiquement les vérifications de l'autoscaling.

Lorsque le script setup_kafka_scaler.sh s'exécute, il génère les variables d'environnement configurées. Vérifiez que les variables d'environnement sont correctes avant de continuer.

Accorder des autorisations supplémentaires

Pour modifier le nombre d'instances du consommateur Kafka, le compte de service de l'autoscaler Kafka doit disposer de l'autorisation d'affichage sur l'image de conteneur déployée. Par exemple, si l'image consommateur a été déployée à partir d'Artifact Registry, exécutez la commande suivante :

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$SCALER_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/artifactregistry.reader" # Or appropriate role for your registry

Vérifier que l'autoscaling Kafka fonctionne

Le scaling du service d'autoscaler Kafka est déclenché par une requête envoyée à l'URL du service (SCALER_SERVICE_NAME-PROJECT_NUMBER.REGION.run.app).

Vous pouvez envoyer une requête POST au service Kafka Autoscaler pour déclencher le calcul de l'autoscaling :

curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" https://SCALER_SERVICE_NAME-PROJECT_NUMBER.REGION.run.app

Remplacez les éléments suivants :

  • SCALER_SERVICE_NAME : nom de votre service Kafka Autoscaler.
  • PROJECT_NUMBER : numéro de projet du service d'autoscaler Kafka.
  • REGION : emplacement du service de scaling automatique Kafka.

Les requêtes POST déclenchent le calcul de l'autoscaling, qui est consigné dans les journaux et modifie le nombre d'instances en fonction de la recommandation.

Les journaux de votre service d'autoscaler Kafka doivent inclure des messages tels que [SCALING] Recommended instances X.

Si l'indicateur OUTPUT_SCALER_METRICS est activé, vous pouvez également trouver les métriques Cloud Monitoring du scaler sous custom.googleapis.com/cloud-run-kafkascaler.

Configuration avancée du scaling

spec:
  metrics:
  behavior:
    scaleDown:
      stabilizationWindowSeconds: [INT]
      policies:
      - type: [Percent, Instances]
        value: [INT]
        periodSeconds: [INT]
      selectPolicy: [Min, Max]
    scaleUp:
      stabilizationWindowSeconds: [INT]
      policies:
      - type: [Percent, Instances]
        value: [INT]
        periodSeconds: [INT]
      selectPolicy: [Min, Max]

La liste suivante décrit certains des éléments précédents :

  • scaleDown : comportement lors de la réduction du nombre d'instances (scaling à la baisse).
  • scaleUp : comportement lors de l'augmentation du nombre d'instances (scaling à la hausse).
  • stabilizationWindowSeconds : nombre d'instances calculé sur une période glissante, le plus élevé (scaleDown) ou le plus bas (scaleUp). Si vous définissez la valeur sur 0, la valeur calculée la plus récente est utilisée.
  • selectPolicy : résultat à appliquer lorsque plusieurs règles sont configurées.
  • Min : la plus petite modification
  • Max : la plus grande variation
  • Percent : les modifications par période sont limitées au pourcentage configuré du nombre total d'instances.
  • Instances : les modifications par période sont limitées au nombre d'instances configuré.
  • periodSeconds : durée pendant laquelle la règle est appliquée.

Par exemple, la spécification complète, avec la configuration par défaut, ressemble à ce qui suit : 

spec:
  scaleTargetRef:
    name: projects/PROJECT-ID/locations/us-central1/workerpools/kafka-consumer-worker
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60
          activationThreshold: 0
          tolerance: 0.1
          windowSeconds: 120
    - type: External
      external:
        metric:
          name: consumer_lag
        target:
          type: AverageValue
          averageValue: 1000
          activationThreshold: 0
          tolerance: 0.1
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Percent
          value: 50
          periodSeconds: 30
      selectPolicy: Min
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
        - type: Percent
          value: 100
          periodSeconds: 15
        - type: Instances
          value: 4
          periodSeconds: 15
      selectPolicy: Max