Déclencher des jobs Cloud Run avec Cloud Scheduler

1. Présentation

La fonctionnalité des tâches Cloud Run est couverte par les Conditions des offres avant disponibilité générale des conditions d'utilisation de Google Cloud. Les fonctionnalités pré-DG (avant disponibilité générale) sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités peuvent ne pas être compatibles avec d'autres versions avant disponibilité générale. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Dans cet atelier, vous allez créer une tâche Cloud Run et configurer une tâche Cloud Scheduler. Vous allez déployer le service de menu Cymbal Eats à l'aide du script de configuration. Vous allez créer un job Cloud Run qui effectue des appels d'API au service de menu Cymbal Eats. Vous exécuterez le job à l'aide de Google Cloud CLI et configurerez une planification pour le job. Vous allez vérifier l'exécution en examinant les journaux et en effectuant des appels d'API au service de menu pour confirmer que les éléments de menu ont été supprimés.

Que sont les tâches Cloud Run ?

Un job Cloud Run exécute un conteneur qui ne traite pas les requêtes Web, mais exécute plutôt des tâches opérationnelles ou de traitement des données. Le conteneur exécute la tâche et se ferme une fois celle-ci terminée.

Tâche de nettoyage du service

Le job du service de nettoyage récupère les éléments de menu dont l'état est "Échec" et les supprime. Lorsque de nouveaux éléments de menu sont créés, les images sont analysées à l'aide de l'API Vision pour déterminer s'il s'agit d'un plat ou non. Pour les images qui échouent à cette validation, l'état des éléments de menu est défini sur "Échec", puis ils sont supprimés par le job de nettoyage.

Objectifs de l'atelier

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Créer des jobs Cloud Run
• Exécuter des jobs Cloud Run
• Créer des tâches Cloud Scheduler
• Vérifier l'exécution des jobs

Prérequis

• Dans cet atelier, nous considérons que vous connaissez la console Cloud et les environnements de shell.
• Une expérience préalable avec Cloud Run et Cloud Scheduler est utile, mais pas obligatoire.

2. Préparation

Configuration du projet Cloud

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pouvez le modifier à tout moment.
• L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID du projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
• Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet est unique au niveau mondial. Une fois que vous l'avez choisi, personne d'autre ne peut l'employer. Vous en êtes le seul utilisateur. Même si un projet est supprimé, son ID ne peut pas être réutilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement pertinent pour votre organisation.

2. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300$.

Configuration de l'environnement

Activez Cloud Shell en cliquant sur l'icône à droite de la barre de recherche.

Dans Cloud Shell, exécutez la commande suivante pour cloner le code de l'application à partir de ce dépôt et accédez au répertoire contenant le service de menu :

git clone https://github.com/GoogleCloudPlatform/cymbal-eats.git && cd cymbal-eats/menu-service

Déployez le service Menu sur Cloud Run à l'aide du script de configuration. Le service de menu est un microservice basé sur Java et conçu avec le framework Quarkus. Il utilise une base de données Cloud SQL Postgres pour son backend. Le service Menu est une dépendance d'exécution pour le job Cloud Run que vous allez créer dans les étapes suivantes.

./setup.sh

Le déploiement prendra environ 10 minutes pour créer tous les composants requis.

Après avoir exécuté la commande ci-dessus, passez aux étapes suivantes.

3. Explorer le code Cloud Run Jobs

Ouvrez un nouvel onglet dans Cloud Shell en cliquant sur l'icône Plus.

Accédez au répertoire contenant le service de nettoyage et examinez les fichiers qui composent le job :

cd ~/cymbal-eats/cleanup-service

Le cleanup-service de ce répertoire contient un fichier Dockerfile qui définit l'image de conteneur pour le job de service de nettoyage avec les dépendances requises(httpie, jq).

Dockerfile

FROM ubuntu:latest 
RUN apt-get update && apt-get install -y httpie jq && apt-get clean
COPY script.sh /
RUN chmod +x /script.sh
CMD ["/script.sh"]
ENTRYPOINT ["/bin/bash"]

Le script de nettoyage proprement dit, listé ci-dessous, contient des commandes permettant d'obtenir la liste des éléments de menu dont l'état est "Échec" et de les supprimer en effectuant des appels d'API au service Menu.

script.sh

echo "FAILED_ITEM_AGE=$FAILED_ITEM_AGE"
echo "MENU_SERVICE_URL=$MENU_SERVICE_URL"
# Failed items older than FAILED_ITEM_AGE in minutes
for id in $(http GET $MENU_SERVICE_URL/menu/failed | jq '[.[] | select(.updateDateTime < ((now - 60 * (env.FAILED_ITEM_AGE | tonumber) )| strftime("%Y-%m-%dT%H:%M:%S.%f")))]'| jq '.[].id'); do
  echo "Deleting Menu Item : $MENU_SERVICE_URL/menu/$id"
  http GET $MENU_SERVICE_URL/menu/$id
  http DELETE $MENU_SERVICE_URL/menu/$id
done

# Processing items older than FAILED_ITEM_AGE in minutes
for id in $(http GET $MENU_SERVICE_URL/menu/processing | jq '[.[] | select(.updateDateTime < ((now - 60 * (env.FAILED_ITEM_AGE | tonumber))| strftime("%Y-%m-%dT%H:%M:%S.%f")))]'| jq '.[].id'); do
  echo "Deleting Menu Item : $MENU_SERVICE_URL/menu/$id"
  http GET $MENU_SERVICE_URL/menu/$id
  http DELETE $MENU_SERVICE_URL/menu/$id
done

Remarques concernant le script :

• Les variables d'environnement FAILED_ITEM_AGE et MENU_SERVICE_URL seront définies lors du déploiement et transmises par la tâche Cloud Run.
• FAILED_ITEM_AGE : nombre de minutes avant la suppression de l'élément ayant échoué.
• MENU_SERVICE_URL : URL du service de menu Cymbal Eats.

4. Créer un job Cloud Run

Vous allez ensuite créer une image de conteneur et la publier dans Artifact Registry.

Cette image de conteneur sera utilisée pour créer un job Cloud Run.

Activez les API de service :

gcloud services enable \
    run.googleapis.com \
    artifactregistry.googleapis.com \
    cloudscheduler.googleapis.com \
    --quiet

Définissez les variables d'environnement :

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')
export PROJECT_NAME=$(gcloud projects describe $PROJECT_ID --format='value(name)')
export REGION=us-east1
export MENU_SERVICE_NAME=menu-service

Créez un dépôt Artifact Registry pour stocker les images Docker pour le job de nettoyage :

gcloud artifacts repositories create cymbal-eats --repository-format=docker --location=$REGION

Créez une image de conteneur à l'aide de Cloud Build et transférez-la vers Artifact Registry en une seule commande :

gcloud builds submit -t $REGION-docker.pkg.dev/$PROJECT_NAME/cymbal-eats/cleanup-service:latest

Exemple de résultat :

DURATION: 35S
SOURCE: gs://cymbal-eats-14906-569_cloudbuild/source/1657126400.933586-dc3e91ec85934a55bb6d2f7012611365.tgz
IMAGES: us-east1-docker.pkg.dev/cymbal-eats-14906-569/cymbal-eats/cleanup-service (+1 more)
STATUS: SUCCESS

Une fois la publication terminée, accédez à Artifact Registry et examinez l'image publiée :

Passez au premier onglet Cloud Shell pour vérifier si le déploiement du service de menu est toujours en cours. Attendez qu'il soit terminé avant de passer à l'étape suivante.

Revenez au deuxième onglet Cloud Shell. Exécutez la commande suivante pour décrire le service de menu et enregistrer l'URL dans une variable d'environnement. Cette variable d'environnement sera utilisée pour configurer le job Cloud Run.

MENU_SERVICE_URL=$(gcloud run services describe $MENU_SERVICE_NAME \
 --region=$REGION \
 --format=json | jq \
 --raw-output ".status.url")

Créez un job Cloud Run pour nettoyer les éléments de menu ayant échoué et datant de plus d'une minute [défini par FAILED_ITEM_AGE].

gcloud beta run jobs create cleanup-service \
  --image=$REGION-docker.pkg.dev/$PROJECT_NAME/cymbal-eats/cleanup-service:latest \
  --set-env-vars MENU_SERVICE_URL=$MENU_SERVICE_URL \
  --set-env-vars FAILED_ITEM_AGE=1 \
  --region $REGION

Exemple de résultat :

Creating Cloud Run job [cleanup-service] in project [cymbal-eats] region [us-east1]
OK Creating job... Done.
Done.
Job [cleanup-service] has successfully been created.

Accédez à la section JOBS de Cloud Run dans la console et examinez le job créé.

Cliquez sur le job et explorez les onglets disponibles : "HISTORIQUE", "JOURNAUX", "CONFIGURATION" et "YAML".

Vérifiez que les variables d'environnement ont été définies en examinant la section CONFIGURATION du job dans la console :

(Facultatif) Si vous souhaitez modifier les variables "Âge de l'élément ayant échoué" ou "URL du service de menu" après la création du job Cloud Run, vous pouvez utiliser la commande update :

gcloud beta run jobs update cleanup-service \
  --image=$REGION-docker.pkg.dev/$PROJECT_NAME/cymbal-eats/cleanup-service:latest \
  --set-env-vars MENU_SERVICE_URL=$MENU_SERVICE_URL \
  --set-env-vars FAILED_ITEM_AGE=1 \
  --region $REGION

Pour valider le job, exécutez le job Cloud Run en exécutant la commande suivante :

gcloud beta run jobs execute cleanup-service --region=$REGION

Exemple de résultat :

OK Creating execution... Done.                                   
  OK Provisioning resources...
Done.
Execution [cleanup-service-rlxs4] has successfully started running.

View details about this execution by running:
gcloud beta run jobs executions describe cleanup-service-rlxs4
 

Passez à l'onglet "JOURNAUX" pour examiner les résultats du job. L'âge de l'élément ayant échoué et l'URL du service de menu doivent s'afficher dans les journaux.

5. Configurer une programmation pour un job Cloud Run

Cloud Scheduler est un planificateur de tâches Cron entièrement géré, spécialement conçu pour les entreprises. Il vous permet de planifier pratiquement n'importe quel job, y compris les jobs par lots et de big data, les opérations d'infrastructure cloud, etc.

Une bonne pratique de sécurité lorsque vous travaillez avec une tâche Cloud Scheduler consiste à exécuter chaque tâche avec des identifiants distincts. À cette étape, créez un compte de service à utiliser par le job du planificateur de nettoyage.

export SCHEDULER_SERVICE_ACCOUNT=cleanup-scheduler-job-sa

gcloud iam service-accounts create ${SCHEDULER_SERVICE_ACCOUNT}

Le job Cloud Scheduler aura besoin d'autorisations pour effectuer des appels à Cloud Run Jobs.

Attribuez le rôle Cloud Run Invoker au compte de service utilisé dans le job Cloud Scheduler :

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:${SCHEDULER_SERVICE_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role="roles/run.invoker"

Vous allez ensuite configurer une programmation pour exécuter le job du service de nettoyage.

Cloud Scheduler est compatible avec plusieurs types de cibles.

• HTTP
• Pub/Sub
• HTTP App Engine

Vous allez créer un job Scheduler à l'aide du type de cible HTTP.

Pour la démonstration, vous allez programmer son exécution toutes les cinq minutes.

gcloud scheduler jobs create http cleanup-schedule \
    --location $REGION \
    --schedule="*/5 * * * *" \
    --uri="https://$REGION-run.googleapis.com/apis/run.googleapis.com/v1/namespaces/$PROJECT_ID/jobs/cleanup-service:run" \
    --http-method POST \
    --oauth-service-account-email ${SCHEDULER_SERVICE_ACCOUNT}@${PROJECT_ID}.iam.gserviceaccount.com

Examinez le paramètre uri utilisé pour appeler le job Cloud Run :

• REGION et PROJECT_ID : région Cloud Run et ID du projet dans lequel la tâche du service de nettoyage est déployée
• cleanup-service : nom du job Cloud Run

Accédez à Cloud Scheduler dans la console pour examiner la tâche de planification créée :

Examinez les options disponibles dans le menu "Actions".

6. Tester un job Cloud Run

À l'aide des points de terminaison du service de menu, examinez les éléments de menu existants et leur état :

curl ${MENU_SERVICE_URL}/menu | jq

Résultat :

Trois éléments de menu sont à l'état Ready.

Modifiez l'état de l'élément de menu 1 sur Failed :

curl -X PUT "${MENU_SERVICE_URL}/menu/1" \
  -H 'Content-Type: application/json' \
  -d '{"status": "Failed"}' | jq

Patientez une minute. Pour que l'élément de menu soit supprimé, il doit avoir au moins une minute, comme défini par le paramètre FAILED_ITEM_AGE.

Vous pouvez attendre la prochaine exécution planifiée ou forcer l'exécution du job depuis la console.

Il existe plusieurs façons de déclencher un job, que ce soit via l'UI ou la ligne de commande.

Pour cet exemple, exécutez la commande dans Cloud Shell(option 3) pour déclencher le job.

1. Depuis Cloud Scheduler, en sélectionnant "Forcer l'exécution d'un job" dans le menu "Actions".

2. Depuis Cloud Run Job en cliquant sur le bouton "EXECUTE" (EXÉCUTER).

3. Depuis Cloud Shell, en exécutant la commande suivante :

gcloud beta run jobs execute cleanup-service --region=$REGION

Accédez à la section "JOBS" de Cloud Run, ouvrez l'onglet JOURNAUX et vérifiez que l'élément de menu a été supprimé.

Filtrez les journaux avec le mot clé "suppression" pour les trouver.

Utilisez les points de terminaison du service de menu pour vérifier les éléments de menu existants via le point de terminaison REST.

curl ${MENU_SERVICE_URL}/menu | jq

Résultat :

Deux éléments de menu sont à l'état Ready.

7. Félicitations !

Félicitations, vous avez terminé cet atelier de programmation.

Points abordés

• Créer des jobs Cloud Run
• Exécuter des jobs Cloud Run
• Créer des jobs Cloud Scheduler
• Vérifier l'exécution des jobs

Étapes suivantes :

Découvrez d'autres ateliers de programmation Cymbal Eats :

• Déclencher des workflows Cloud avec Eventarc
• Déclencher le traitement des événements à partir de Cloud Storage
• Se connecter à une instance CloudSQL privée depuis Cloud Run
• Se connecter à des bases de données entièrement gérées depuis Cloud Run
• Sécuriser une application serverless avec Identity-Aware Proxy (IAP)
• Déployer de manière sécurisée sur Cloud Run
• Sécuriser le trafic d'entrée Cloud Run
• Se connecter à une instance AlloyDB privée depuis GKE Autopilot

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez chaque ressource individuellement.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.