Utiliser des pipelines sans serveur avec Active Assist

Last reviewed 2021-06-09 UTC

Ce document est destiné aux architectes d'entreprise et aux développeurs de logiciels qui souhaitent créer un pipeline d'automatisation pour utiliser Active Assist dans leur organisation Google Cloud. Il fait partie d'une série qui traite des modèles architecturaux que les entreprises peuvent utiliser pour optimiser leur empreinte cloud à grande échelle à l'aide d'Active Assist. Cette série comprend les parties suivantes :

Ce tutoriel explique comment utiliser les technologies sans serveur Google Cloud pour créer un pipeline d'automatisation permettant de récupérer et de traiter les recommandations Active Assist. Vous basez les recommandations sur les règles commerciales définies par votre entreprise. Le pipeline d'automatisation que vous configurez dans ce tutoriel vous permet de travailler avec Active Assist à grande échelle tout en conservant un processus de vérification et d'activation mené par l'équipe. Cette approche est utile lorsque votre entreprise souhaite faire évoluer l'utilisation du portefeuille Active Assist tout en gardant le contrôle du processus de vérification et d'activation au sein des équipes. Il offre une alternative à l'utilisation d'un pipeline d'intégration et de livraison continue (CI/CD).

L'architecture présentée dans ce tutoriel est générique et vous pouvez l'étendre pour utiliser d'autres produits sans serveur. Dans ce tutoriel, nous partons du principe que vous connaissez les technologies Google Cloud suivantes :

Pour suivre ce tutoriel, vous devez disposer d'un compte Slack ou d'un outil de gestion de notifications ou de demandes similaire. L'outil doit être configuré sur votre machine et prêt à être utilisé.

Architecture

L'architecture présentée dans ce tutoriel étant modulaire, vous pouvez adapter le composant de notifications pour répondre aux exigences de votre entreprise. Ce tutoriel explique comment générer des notifications et les envoyer à Slack. Vous pouvez également choisir d'envoyer des notifications à Pub/Sub ou à tout autre outil de gestion de notifications ou de demandes.

Le schéma d'architecture suivant présente les composants que vous utilisez dans ce tutoriel :

Pipeline sans serveur.

L'architecture comprend les composants suivants :

  • Un service Cloud Run déclenché à intervalles fixes par un planificateur. Le service appelle les API de l'outil de recommandation en lisant les métadonnées (ID de projet et types d'outils de recommandation) définies et conservées dans une collection Firestore.
  • Sujet Pub/Sub dans lequel les recommandations Active Assist sont transmises et traitées.
  • Un deuxième service Cloud Run qui analyse les recommandations Active Assist. Ce service détermine la manière dont les recommandations sont traitées en fonction des règles métier définies par votre entreprise et stockées dans une collection Firestore.
  • Deux collections Firestore pour stocker les métadonnées métier et les règles d'entreprise. Les collections Firestore fonctionnent comme suit :
    • La première collection stocke les métadonnées métier pertinentes pour récupérer les recommandations Active Assist. Dans ce tutoriel, les attributs recommendation type, Google Cloud project IDs et locations sont utilisés comme métadonnées métier. Ces attributs sont utilisés par le service Cloud Run recommendation-collector pour déterminer les types de recommandations qui sont récupérés.
    • La deuxième collection stocke les règles métier qui sont appliquées lors du traitement des recommandations.

Objectifs

  • Créer un exemple de service Cloud Run pour récupérer les recommandations Active Assist d'un exemple de projet et les transférer vers un sujet Pub/Sub
  • Créer deux collections Firestore pour stocker les exemples de métadonnées et les règles d'entreprise, respectivement.
  • Créer un deuxième service Cloud Run pour traiter les recommandations conformément aux exemples de règles métier que vous définissez dans ce tutoriel.
  • Créer un canal Slack auquel le service Cloud Run envoie des exemples de recommandations Active Assist.
  • Tester le pipeline de bout en bout avec des exemples de recommandations Active Assist.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  1. In the Google Cloud console, go to the project selector page.

    Go to project selector

  2. Select or create a Google Cloud project.

  3. Notez l'ID de projet Google Cloud pour le projet de gestionnaire de recommandations. Vous en aurez besoin dans la section suivante pour configurer votre environnement.

  4. Enable the Cloud Build, Firestore, App Engine,Pub/Sub, Cloud Run, Cloud Scheduler, and Cloud Source Repositories APIs.

    Enable the APIs

    Pour ce tutoriel, vous utilisez les identifiants par défaut de l'application. Si vous êtes invité à créer des identifiants sur la page Ajouter des identifiants à votre projet, cliquez sur Annuler.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Créez les éléments suivants :
    • Un exemple de canal Slack.
    • Un exemple d'application Slack et de webhook entrant pour recevoir des notifications générées par un moteur nommé recommendation-rules-engine. Vous configurerez le moteur plus tard dans ce tutoriel.
    Pour en savoir plus, consultez les sections Créer un canal Slack et Envoyer des messages à l'aide de webhooks entrants.

    Une fois que vous avez créé une application Slack et une URL de webhook entrant, notez cette URL car vous en aurez besoin plus tard dans ce tutoriel.

Créer le pipeline sans serveur

Dans cette section, vous allez créer les composants dont vous avez besoin pour créer le pipeline sans serveur. La plate-forme génère des recommandations Active Assist basées sur les modèles d'utilisation et les métriques système. En fonction des recommandations générées, chaque catégorie de recommandation peut utiliser une période par défaut différente dans le passé pour analyser les données et les métriques d'utilisation.

Si vous disposez d'un exemple de projet Google Cloud contenant des ressources et des recommandations Active Assist existantes, vous pouvez exécuter le pipeline pour traiter ces recommandations après avoir apporté les modifications appropriées à l'exemple de code fourni.

Créer les collections Firestore

Dans cette section, vous allez créer deux collections Firestore. La première, la collection activeassist-metadata, stocke les métadonnées commerciales pertinentes pour la récupération des recommandations Active Assist. La deuxième, la collection activeassist-business-rules, stocke les règles d'entreprise appliquées lorsque le pipeline traite les recommandations.

Lorsque les recommandations Active Assist sont analysées, en fonction des règles métier de la collection Firestore, une notification est générée et envoyée, ou la recommandation est automatiquement appliquée à la ressource Google Cloud concernée.

Créer la collection activeassist-metadata

  1. Dans Google Cloud Console, accédez à la page Firestore.

    Ouvrir Firestore

  2. Créez une base de données Firestore si vous n'en avez pas déjà une. Si vous disposez déjà d'une base de données Firestore, passez à l'étape suivante.

    Créez la base de données :

    1. Cliquez sur Sélectionner le mode natif pour activer Firestore.
    2. Sélectionnez un emplacement de région proche de la région dans laquelle vos services Cloud Run s'exécutent.
    3. Cliquez sur Create Database (Créer une base de données). La configuration prend quelques instants.

  3. Sur la page Firestore, cliquez sur Démarrer la collection.

  4. Dans le champ ID de collection, saisissez les informations suivantes : activeassist-metadata.

  5. Remplissez les champs comme indiqué dans le tableau suivant. Pour ajouter le champ suivant, cliquez sur Ajouter un champ.

    Nom du champ Type de champ Valeur du champ Note
    project string Stub-Project-ID Ce tutoriel utilise un bouchon (stub) pour la valeur de champ. Si vous souhaitez utiliser les recommandations d'un projet Google Cloud existant, saisissez plutôt l'ID du projet.
    locations array global Certaines recommandations comme les recommandations de redimensionnement de VM peuvent être spécifiques à une région ou à une zone. Les autres recommandations sont globales, par exemple les recommandations IAM.
    recommenderType string google.iam.policy.Recommender Non applicable.

  6. Lorsque les champs sont renseignés, cliquez sur Enregistrer.

Créer la collection activeassist-business-rules

  1. Cliquez sur Démarrer la collection.

  2. Dans le champ ID de collection, saisissez la valeur suivante : activeassist-business-rules.

    Remplissez le document comme indiqué dans le tableau suivant. Pour ajouter le champ suivant, cliquez sur Ajouter un champ.

    Nom du champ Type de champ Valeur du champ Note
    action string Notify Si la valeur est définie sur Apply, le service applique la recommandation et supprime le rôle inutilisé.
    projectId string Stub-Project-ID Ce tutoriel utilise une recommandation de bouchon (stub). Si vous souhaitez utiliser les recommandations d'un projet Google Cloud existant, saisissez plutôt l'ID du projet.
    projectNumber string 999999999 Ce tutoriel utilise une recommandation de bouchon (stub).

    Si vous utilisez une recommandation d'un projet Google Cloud existant, saisissez plutôt le numéro du projet. Vous le trouverez sur la page d'accueil de la console Google Cloud.
    recommenderType string google.iam.policy.Recommender Non applicable.
    recommenderSubtype string REMOVE_ROLE Non applicable.
    slackWebhookURL string Saisissez l'URL du webhook Slack que vous avez généré à une étape précédente. L'URL ressemble à ceci :

    https://hooks.slack.com/services/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

    Ce tutoriel vous explique comment créer une règle pour déterminer si une recommandation est appliquée automatiquement ou si une notification est générée et envoyée à une plate-forme telle que Slack. Pour savoir comment une recommandation peut être automatiquement appliquée en fonction de l'évaluation d'exemples de règles métier que vous avez configurées, consultez le dépôt associé.

  3. Lorsque le document est rempli, cliquez sur Enregistrer.

Créer un service Cloud Run planifié

Dans cette section, vous allez créer un service Cloud Run planifié nommé recommendation-collector, qui appelle l'API Recommender et récupère les recommandations actives. L'API Recommender d'Identity and Access Management est utilisée dans ce tutoriel en tant qu'API Recommender. Le service lit les métadonnées de la collection Firestore activeassist-metadata que vous avez créée pour déterminer les recommandations à récupérer.

  1. Cliquez sur Ouvrir dans Cloud Shell pour ouvrir Cloud Shell pour le projet du gestionnaire de recommandations.

    Ouvrir dans Cloud Shell

    Lorsque Cloud Shell s'ouvre, les commandes suivantes s'exécutent :

    • La commande de clonage du dépôt GitHub.
    • La commande de changement de répertoire.

    Lorsque la boîte de dialogue Ouvrir dans Cloud Shell s'affiche, sélectionnez Approuver, puis cliquez sur Confirmer.

  2. Définissez l'ID et le numéro du projet du gestionnaire de recommandations actuel en tant que variables :

    export RECO_MGR_PROJECT=PROJECT_ID
gcloud config set project $RECO_MGR_PROJECT
export RECO_MGR_PROJECT_NUMBER=$(gcloud projects describe $DEVSHELL_PROJECT_ID --format='value(projectNumber)')

    Remplacez PROJECT_ID par l'ID du projet. Une fois les commandes saisies, cliquez sur Autoriser lorsque vous y êtes invité.

  3. Définissez la variable pour la région de déploiement :

    export REGION=us-central1

    Bien que ce tutoriel utilise la région us-central1, vous pouvez utiliser n'importe quelle région où Cloud Run est disponible.

  4. Créez une variable d'environnement pour votre image Docker :

    export RECOMMENDER_IMAGE=gcr.io/$RECO_MGR_PROJECT/recommendation-collector:1.0

  5. Créez l'image Docker et importez-la dans Container Registry :

     gcloud builds submit --tag $RECOMMENDER_IMAGE

  6. Créez un compte de service pour que le service recommendation-collector puisse interagir avec d'autres services Google Cloud du pipeline :

    gcloud iam service-accounts create recommendation-collector-sa \
  --description "Service Account that the recommendation-collector service uses to invoke other Google Cloud services" \
  --display-name "recommendation-collector-sa" \
  --project $RECO_MGR_PROJECT

    Il est recommandé d'accorder des autorisations précises à vos services Cloud Run en attribuant des rôles prédéfinis au compte de service. Pour en savoir plus, consultez la section Identité du service.

  7. Accordez au compte de service du service recommendation-collector l'accès à Firestore et à l'API Recommender :

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/datastore.user
gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/pubsub.publisher

  8. Si vous exécutez ce tutoriel à l'aide de l'exemple stub fourni dans le dépôt que vous avez cloné, passez à l'étape suivante.

    Si vous créez un pipeline en suivant ce tutoriel et en utilisant des recommandations générées pour un projet Google Cloud existant, vous devez attribuer des autorisations IAM aux comptes de service que vous avez créés pour exécuter les deux services Cloud Run.

    Définissez une variable d'environnement, TEST_PROJECT_ID, avec l'ID du projet pour lequel vous exécutez ce pipeline avant d'exécuter les commandes :

    export TEST_PROJECT_ID=TEST_PROJECT_ID
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/recommender.iamAdmin
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/serviceusage.serviceUsageConsumer
gcloud services enable recommender.googleapis.com --project $TEST_PROJECT_ID

    Assurez-vous que l'ID de projet que vous utilisez correspond à celui que vous avez saisi lors de la création des collections Firestore.

  9. Pour ce tutoriel, vous déployez le service avec une variable d'environnement appelée STUB_RECOMMENDATIONS. Cette variable vous permet d'utiliser un bouchon (stub) pour tester le pipeline.

    Déployez le service Cloud Run :

    gcloud run deploy recommendation-collector \
  --image=$RECOMMENDER_IMAGE \
  --no-allow-unauthenticated \
  --region $REGION \
  --platform managed \
  --service-account recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --set-env-vars="STUB_RECOMMENDATIONS=true" \
  --project $RECO_MGR_PROJECT \

    Acceptez toutes les requêtes du système.

    Si vous souhaitez exécuter le pipeline à l'aide des recommandations Active Assist générées pour un projet Google Cloud, supprimez la ligne suivante de la commande avant de la déployer :

    --set-env-vars="STUB_RECOMMENDATIONS=true"

Configurer une tâche Cloud Scheduler pour exécuter recommender-collector service

  1. Dans Cloud Shell, créez un compte de service pour les tâches Cloud Scheduler à utiliser pour exécuter le service recommendation-collector :

    gcloud iam service-accounts create recommender-scheduler-sa \
  --description "Service Account used by Cloud Scheduler to invoke the recommender-parser service" \
  --display-name "recommender-scheduler-sa" \
  --project $RECO_MGR_PROJECT

  2. Attribuez au compte de service le rôle run/invoker pour lui permettre d'appeler le service Cloud Run :

    gcloud run services add-iam-policy-binding recommendation-collector \
  --member=serviceAccount:recommender-scheduler-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role=roles/run.invoker \
  --region=$REGION \
  --platform=managed

  3. Obtenez l'URL du service recommendation-collector :

    export RECOMMENDER_SERVICE_URI=`gcloud run services describe recommendation-collector \
  --platform managed \
  --project $RECO_MGR_PROJECT \
  --region $REGION \
  --format="value(status.url)"`/run

  4. Créez une tâche Cloud Scheduler nommée recommender-iam-scheduler :

    gcloud scheduler jobs create http recommender-iam-scheduler \
  --project $RECO_MGR_PROJECT \
  --time-zone "America/Los_Angeles" \
  --schedule="0 */3 * * *" \
  --uri=$RECOMMENDER_SERVICE_URI \
  --description="Scheduler job to invoke recommendation pipeline" \
  --oidc-service-account-email="recommender-scheduler-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com" \
  --headers="Content-Type=application/json" \
  --http-method="POST"

    Définissez le fuseau horaire en fonction de votre emplacement. Le format de la valeur de fuseau horaire est basé sur la base de données tz.

    Pour plus d'informations, consultez la page sur gcloud scheduler jobs create http.

    Votre tâche Cloud Scheduler appelle la route /run pour le service recommendation-collector.

    Utiliser l'option --schedule="0 */3 * * *" permet d'exécuter la tâche Scheduler toutes les trois heures. Vous pouvez modifier ce paramètre en fonction de vos besoins. Pour plus d'informations, consultez la section Configurer les planifications de tâches Cron.

Créer le moteur de règles de recommandation pour traiter les recommandations

Dans cette section, vous allez créer un deuxième service Cloud Run nommé recommendation-rules-engine pour traiter les recommandations recueillies par le service recommendation-collector. Le service recommendation-rules-engine est appelé par Pub/Sub lorsque de nouvelles recommandations sont envoyées dans le sujet activeassist-recommendations.

Ce service analyse les recommandations en fonction des règles commerciales que vous avez définies dans la collection activeassist-business-rules.

  1. Dans Cloud Shell, ouvrez le répertoire recommendation-rules-engine :

    cd ../recommendation-rules-engine

  2. Créez une variable d'environnement pour votre image Docker :

    export RULES_ENGINE_IMAGE=gcr.io/$RECO_MGR_PROJECT/recommendation-rules-engine:1.0

  3. Créez l'image Docker et importez-la dans Container Registry :

    gcloud builds submit --tag $RULES_ENGINE_IMAGE

  4. Créez un compte de service pour que le service recommendation-rules-engine puisse interagir avec d'autres services Google Cloud du pipeline :

    gcloud iam service-accounts create recommendation-rules-sa \
 --description "Service Account that recommendation-rules-engine uses to invoke other Google Cloud services" \
 --display-name "recommendation-rules-sa" \
 --project $RECO_MGR_PROJECT

  5. Accordez au compte de service du service recommendation-rules-engine l'accès à Firestore :

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/datastore.user

    Si vous utilisez les bouchons (stubs) fournis pour ce tutoriel, passez à l'étape suivante.

    Si vous testez le pipeline à l'aide des recommandations générées pour un projet Google Cloud au lieu des bouchons fournis dans ce tutoriel, exécutez les commandes suivantes pour autoriser le compte de service du moteur de règles à accéder à votre projet :

    gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/serviceusage.serviceUsageConsumer
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/recommender.iamAdmin
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/resourcemanager.projectIamAdmin

  6. Déployez le service Cloud Run :

    gcloud run deploy recommendation-rules-engine \
  --image=$RULES_ENGINE_IMAGE \
  --no-allow-unauthenticated \
  --region $REGION \
  --platform managed \
  --service-account recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --project $RECO_MGR_PROJECT

    Acceptez toutes les invites du système.

  7. Obtenez l'URL recommendation-rules-engine :

    export RECOMMENDER_SERVICE_RULES_URI=`gcloud run services describe recommendation-rules-engine \
  --platform managed \
  --project $RECO_MGR_PROJECT \
  --region $REGION \
  --format="value(status.url)"`/process

    L'URL que vous récupérez à cette étape est appelée lorsque de nouvelles recommandations sont disponibles dans le sujet Pub/Sub que vous créez à l'étape suivante.

Créer un sujet Pub/Sub pour les recommandations actives

Dans cette section, vous allez créer un sujet Pub/Sub pour les recommandations Active Assist récupérées par le service recommender-collector en appelant l'API Recommender.

  1. Dans Cloud Shell, créez un sujet Pub/Sub :

    gcloud pubsub topics create activeassist-recommendations

  2. Créez un compte de service à utiliser par Pub/Sub pour appeler le Service Cloud Run recommendation-rules-engine :

    gcloud iam service-accounts create recommendation-engine-sub-sa \
  --description "Service Account used by Pub/Sub to push recommendations to the recommendation-rules-engine service" \
  --display-name "recommendation-engine-sub-sa" \
  --project $RECO_MGR_PROJECT

  3. Le compte de service Pub/Sub doit être associé aux rôles dont il a besoin pour publier des messages et pour appeler le service recommendation-rules-engine :

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/run.invoker \
  --project $RECO_MGR_PROJECT

Créer un abonnement au sujet Pub/Sub

  1. Créez un abonnement au service recommendation-rules-engine :

    # grant Pub/Sub the permission to create tokens
PUBSUB_SERVICE_ACCOUNT="service-$RECO_MGR_PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com"
gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member="serviceAccount:$PUBSUB_SERVICE_ACCOUNT"\
  --role='roles/iam.serviceAccountTokenCreator'
# configure the subscription push identity
gcloud pubsub subscriptions create active-assist-recommendations-for-rules-engine \
  --topic=activeassist-recommendations \
  --topic-project=$RECO_MGR_PROJECT \
  --push-auth-service-account=recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --ack-deadline=60 \
  --push-endpoint=$RECOMMENDER_SERVICE_RULES_URI

  2. Autorisez le compte de service recommendation-engine-sub-sa que vous avez créé à appeler le service recommendation-rules-engine :

    gcloud run services add-iam-policy-binding recommendation-rules-engine \
  --member=serviceAccount:recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role=roles/run.invoker \
  --region=$REGION \
  --platform=managed

Exécuter des tests de bout en bout à l'aide de simulations

Les recommandations Active Assist sont générées par la plate-forme en fonction des modèles d'utilisation et des métriques système. Chaque catégorie de recommandations peut utiliser une période par défaut différente dans le passé pour analyser les données d'utilisation et les métriques en fonction des recommandations générées. Par exemple, les recommandations IAM sont générées par la plate-forme en fonction des schémas d'utilisation des 90 derniers jours.

Pour tester le pipeline de bout en bout, le dépôt que vous avez cloné dans le cadre de ce tutoriel fournit des exemples de recommandations (simulations) que vous utilisez pour exécuter le pipeline de bout en bout.

Dans cette section, vous allez exécuter les opérations suivantes :

  • Inspectez les recommandations sur les simulations.
  • Appelez le pipeline manuellement.
  • Vérifiez si une notification est générée et envoyée au canal Slack que vous avez créé.

  1. Consultez les exemples de recommandations fournis dans le dépôt :

    cat ../recommendation-collector/stub.json

    Ce fichier fournit un exemple de recommandation avec une action REMOVE pour un exemple de rôle appelé roles/gkehub.connect.

  2. Exécutez la commande suivante pour que Cloud Scheduler exécute la tâche immédiatement, au lieu d'attendre la prochaine exécution programmée :

    gcloud scheduler jobs run recommender-iam-scheduler

  3. Sur la page de la console Cloud Scheduler, dans la colonne Résultat du job recommender-iam-scheduler, vérifiez que le résultat est Opération réussie.

    Pour obtenir une vue détaillée des étapes exécutées par chacun des services, vous pouvez également afficher les journaux de service Cloud Run pour les services recommendation-collector et recommendation-rules-engine.

  4. Lorsque le pipeline de bout en bout sans serveur que vous créez dans ce tutoriel s'exécute correctement, il génère une notification Slack contenant les détails de la liaison de rôle qu'il est recommandé de supprimer. Voici un exemple du type de notification que vous recevez :

    Project xxxxxxxx\
**Impact**: SECURITY\
This role has not been used during the observation window.\
**Role**: roles/gkehub.connect\
**Member**:
serviceAccount:sample-sa@recommendation-sample.iam.gserviceaccount.com\
**Action**: remove

Nettoyer

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 les ressources individuelles.

  • In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  • In the project list, select the project that you want to delete, and then click Delete.
  • In the dialog, type the project ID, and then click Shut down to delete the project.

    • Étape suivante