Utilizzo di pipeline serverless con Active Assist

Last reviewed 2021-06-09 UTC

Questo documento è destinato a architetti aziendali e sviluppatori di software che vogliono creare una pipeline di automazione per utilizzare Active Assist nella loro organizzazione Google Cloud. Fa parte di una serie che tratta modelli architettonici che le aziende possono utilizzare per ottimizzare la propria impronta cloud su larga scala utilizzando Active Assist. La serie è composta dalle seguenti parti:

Modelli per l'utilizzo di Active Assist su larga scala
Utilizzo di pipeline serverless con Active Assist (questo documento)
Utilizzare la catena degli strumenti Anthos con Active Assist

Questo tutorial mostra come utilizzare le tecnologie serverless di Google Cloud per creare una pipeline di automazione per recuperare ed elaborare i suggerimenti di Active Assist. Basi i consigli sulle regole aziendali impostate dalla tua azienda. La pipeline di automazione che configuri in questo tutorial ti aiuta a lavorare con Active Assist su larga scala, pur mantenendo un processo di revisione e attuazione gestito dal team. Questo approccio è utile quando la tua azienda vuole scalare l'utilizzo del portafoglio Active Assist, ma mantenere il controllo del processo di revisione e attivazione all'interno dei team. Offre un'alternativa all'utilizzo di una pipeline di integrazione e distribuzione continue (CI/CD).

L'architettura dimostrata in questo tutorial è generica e puoi estenderla per funzionare con altri prodotti serverless. Il tutorial presuppone che tu conosca le seguenti tecnologie Google Cloud:

Per completare questo tutorial, devi avere un account per Slack o uno strumento di elaborazione di ticket o notifiche simile. Lo strumento deve essere configurato sulla macchina e pronto per l'uso.

Architettura

Poiché l'architettura dimostrata in questo tutorial è modulare, puoi adattare il componente delle notifiche in base ai requisiti della tua attività. Questo tutorial mostra come generare notifiche e inviarle a Slack. Puoi anche scegliere di inviare notifiche a Pub/Sub o a qualsiasi altro strumento di elaborazione di notifiche o ticket.

Il seguente diagramma architetturale mostra i componenti utilizzati in questo tutorial:

Pipeline serverless.

L'architettura prevede i seguenti componenti:

Un servizio Cloud Run attivato da uno scheduler a intervalli fissi. Il servizio richiama le API del motore per suggerimenti leggendo i metadati (ID progetto e tipi di motore per suggerimenti) definiti e conservati in una raccolta Firestore.
Un argomento Pub/Sub in cui i suggerimenti Active Assist vengono trasferiti e elaborati.
Un secondo servizio Cloud Run che analizza i suggerimenti di Active Assist. Questo servizio determina il modo in cui i suggerimenti vengono elaborati in base alle regole aziendali definite dall'azienda e memorizzati in una raccolta Firestore.
Due raccolte Firestore per archiviare i metadati aziendali e le regole aziendali. Le raccolte Firestore operano come segue:
- Nella prima raccolta sono memorizzati i metadati aziendali pertinenti per il recupero dei suggerimenti di Active Assist. In questo tutorial, gli attributi recommendation type, Google Cloud project IDs e locations vengono utilizzati come metadati aziendali. Questi attributi vengono utilizzati dal servizio Cloud Run recommendation-collector per determinare quali tipi di suggerimenti vengono recuperati.
- Nella seconda raccolta sono archiviate le regole aziendali applicate quando i consigli vengono elaborati.

Obiettivi

Creare un servizio Cloud Run di esempio per recuperare i suggerimenti di Active Assist per un progetto di esempio ed eseguirne il push in un argomento Pub/Sub.
Crea due raccolte Firestore per archiviare rispettivamente metadati e regole aziendali di esempio.
Crea un secondo servizio Cloud Run per elaborare i suggerimenti in base alle regole aziendali di esempio definite in questo tutorial.
Creare un canale Slack a cui il servizio Cloud Run invia suggerimenti di Active Assist di esempio.
Testa la pipeline end-to-end con i suggerimenti di Active Assist di esempio.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Al termine di questo tutorial, puoi evitare una fatturazione continua eliminando le risorse che hai creato. Per scoprire di più, vedi Pulizia.

Prima di iniziare

Nella console Google Cloud, vai alla pagina del selettore dei progetti.

Vai al selettore progetti
Seleziona o crea un progetto Google Cloud.

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto e rimuovere tutte le risorse associate.
Prendi nota dell'ID progetto Google Cloud per il progetto di gestione dei suggerimenti. Questo ID è necessario nella sezione successiva relativa alla configurazione dell'ambiente.
Abilita le API Cloud Build, Firestore, App Engine,Pub/Sub, Cloud Run, Cloud Scheduler e Cloud Source Repositories .
Abilita le API
Per questo tutorial utilizzi le credenziali dell'applicazione predefinite. Se ti viene chiesto di creare le credenziali nella pagina Aggiungi credenziali al progetto, fai clic su Annulla.
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verificare se la fatturazione è abilitata per un progetto.
Crea quanto segue:
- Un esempio di canale Slack.
- Un'app Slack di esempio e un webhook in arrivo per ricevere notifiche generate da un motore denominato recommendation-rules-engine. Configura il motore più tardi in questo tutorial.
Per saperne di più, consulta Creare un canale Slack e Inviare messaggi tramite webhook in arrivo.

Quando hai creato un'app Slack e un URL webhook in arrivo, prendi nota dell'URL poiché ti servirà più avanti in questo tutorial.

Creazione della pipeline serverless

In questa sezione creerai i componenti necessari per la creazione della pipeline serverless. La piattaforma genera suggerimenti di Active Assist in base ai pattern di utilizzo e alle metriche di sistema. A seconda dei consigli generati, ogni categoria di suggerimenti potrebbe utilizzare un periodo di tempo predefinito diverso nel passato per analizzare i dati di utilizzo e le metriche.

Se hai un progetto Google Cloud di esempio con risorse esistenti e suggerimenti di Active Assist, puoi eseguire la pipeline per elaborare questi suggerimenti dopo aver apportato le modifiche appropriate al codice campione fornito.

Crea le raccolte Firestore

In questa sezione creerai due raccolte Firestore. La prima raccolta, activeassist-metadata, memorizza i metadati aziendali pertinenti al recupero dei suggerimenti di Active Assist. La seconda, la raccolta activeassist-business-rules, archivia le regole aziendali che vengono applicate quando la pipeline elabora i suggerimenti.

Quando i suggerimenti di Active Assist vengono analizzati, in base alle regole aziendali nella raccolta Firestore, viene generata e inviata una notifica oppure il consiglio viene applicato automaticamente alla risorsa Google Cloud pertinente.

Crea la raccolta `activeassist-metadata`

Nella console Google Cloud, vai alla pagina Firestore.

Apri Firestore
Crea un database Firestore se non ne hai già uno. In alternativa, se hai già un database Firestore, vai al passaggio successivo.

Crea il database:
1. Fai clic su Seleziona modalità Native per attivare Firestore.
2. Seleziona una località vicina alla regione in cui vengono eseguiti i servizi Cloud Run.
3. Fai clic su Crea database. Il completamento della configurazione richiede alcuni istanti.
Nella pagina Firestore, fai clic su Inizia raccolta.
Nel campo ID raccolta, inserisci quanto segue: activeassist-metadata.

Completa i campi come mostrato nella seguente tabella. Per aggiungere il campo successivo, fai clic su Aggiungi campo.

Nome campo	Tipo di campo	Valore campo	Nota
`project`	`string`	`Stub-Project-ID`	Questo tutorial utilizza uno stub per il valore del campo. Se vuoi utilizzare i suggerimenti di un progetto Google Cloud esistente, inserisci invece l'ID progetto.
`locations`	`array`	`global`	Alcuni suggerimenti potrebbero essere specifici per regione o zona, come i suggerimenti per il dimensionamento ottimale delle VM. Altri suggerimenti sono globali, ad esempio i suggerimenti IAM.
`recommenderType`	`string`	`google.iam.policy.Recommender`	Non applicabile.

Una volta completati i campi, fai clic su Salva.

Crea la raccolta `activeassist-business-rules`

Fai clic su Avvia raccolta.

Nel campo ID raccolta, inserisci quanto segue: activeassist-business-rules

Completa il documento, come mostrato nella seguente tabella. Per aggiungere il campo successivo, fai clic su Aggiungi campo.

Nome campo	Tipo di campo	Valore campo	Nota
`action`	`string`	`Notify`	Se imposti il valore su `Apply`, il servizio applica il suggerimento e rimuove il ruolo non utilizzato.
`projectId`	`string`	`Stub-Project-ID`	Questo tutorial utilizza un suggerimento relativo allo stub. Se vuoi utilizzare i suggerimenti di un progetto Google Cloud esistente, inserisci invece l'ID progetto.
`projectNumber`	`string`	`999999999`	Questo tutorial utilizza un suggerimento relativo allo stub. Se utilizzi un suggerimento da un progetto Google Cloud esistente, inserisci il numero di progetto. Puoi trovare il numero del progetto nella dashboard della console Google Cloud
`recommenderType`	`string`	`google.iam.policy.Recommender`	Non applicabile.
`recommenderSubtype`	`string`	`REMOVE_ROLE`	Non applicabile.
`slackWebhookURL`	`string`		Inserisci l'URL del webhook di Slack generato in un passaggio precedente. L'URL è simile al seguente: `https://hooks.slack.com/services/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`

Questo tutorial mostra come creare una regola per determinare se un suggerimento viene applicato automaticamente o se viene generata una notifica e inviata a una piattaforma come Slack. Per scoprire come applicare automaticamente un suggerimento in base alla valutazione delle regole aziendali di esempio configurate, consulta il repository associato.

Quando il documento è compilato, fai clic su Salva.

Creazione di un servizio Cloud Run pianificato

In questa sezione creerai un servizio Cloud Run pianificato chiamato recommendation-collector che richiama l'API Recommender e recupera i suggerimenti attivi. Identity and Access Management API motore per suggerimenti è utilizzato in questo tutorial come API per suggerimenti. Il servizio legge i metadati dalla raccolta activeassist-metadata Firestore che hai creato per determinare quali suggerimenti recuperare.

Fai clic su Apri in Cloud Shell per aprire Cloud Shell per il progetto di Gestione suggerimenti.

Apri in Cloud Shell

All'apertura di Cloud Shell, vengono eseguiti i seguenti comandi:
- Il comando di clonazione del repository GitHub.
- Comando di modifica della directory.
Nella finestra di dialogo Apri in Cloud Shell, seleziona Attendibile, quindi fai clic su Conferma.
Imposta l'ID progetto e il numero di progetto del progetto di gestione dei suggerimenti corrente come variabili:
```
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)')
```
Sostituisci PROJECT_ID con l'ID progetto. Dopo aver inserito i comandi, fai clic su Autorizza.
Imposta la variabile per la regione di deployment:
```
export REGION=us-central1
```
Anche se questo tutorial utilizza la regione us-central1, puoi utilizzare qualsiasi regione in cui è disponibile Cloud Run.

Crea una variabile di ambiente per l'immagine Docker:

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

Crea l'immagine Docker e caricala in Container Registry:
```
 gcloud builds submit --tag $RECOMMENDER_IMAGE
```
Crea un account di servizio per consentire al servizio recommendation-collector di interagire con altri servizi Google Cloud nella 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
```
È buona norma concedere autorizzazioni granulari ai servizi Cloud Run assegnando ruoli predefiniti all'account di servizio. Per scoprire di più, consulta Identità di servizio.

Concedi all'account di servizio per recommendation-collector l'accesso al servizio Firestore e all'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

Se stai eseguendo questo tutorial utilizzando l'esempio stub fornito nel repository che hai clonato, vai al passaggio successivo.

Se stai creando la pipeline in questo tutorial utilizzando i suggerimenti generati per un progetto Google Cloud esistente, devi assegnare le autorizzazioni IAM agli account di servizio che hai creato per eseguire i due servizi Cloud Run.

Imposta una variabile di ambiente TEST_PROJECT_ID con l'ID del progetto per cui esegui questa pipeline prima di eseguire i comandi:
```
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
```
Assicurati che l'ID progetto che utilizzi corrisponda a quello inserito in Creazione delle raccolte Firestore.

Nota: se esegui questa pipeline per i tipi di motore per suggerimenti non utilizzati in questo tutorial, assicurati di identificare e assegnare l'insieme corretto di autorizzazioni aggiuntive. Gli account di servizio che crei per eseguire i due servizi Cloud Run richiedono queste autorizzazioni.
Per questo tutorial, esegui il deployment del servizio con una variabile di ambiente denominata STUB_RECOMMENDATIONS. Questa variabile ti consente di utilizzare uno stub per testare la pipeline.

Esegui il deployment del servizio 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 \
```
Accetta le eventuali richieste del sistema.

Se vuoi eseguire la pipeline utilizzando i suggerimenti di Active Assist generati per un progetto Google Cloud, rimuovi la seguente riga dal comando prima di eseguire il deployment:
```
--set-env-vars="STUB_RECOMMENDATIONS=true"
```

Configura un job Cloud Scheduler per eseguire il `recommender-collector service`

In Cloud Shell, crea un account di servizio per i job Cloud Scheduler da utilizzare per eseguire il servizio 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

Concedi all'account di servizio il ruolo run/invoker per abilitare la chiamata al servizio 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

Recupera l'URL del servizio 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

Crea un job Cloud Scheduler denominato 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"
```
Imposta il fuso orario in modo che corrisponda alla tua posizione. Il formato del valore del fuso orario si basa sul database tz.

Per saperne di più, vedi gcloud scheduler job create http.

Il tuo job Cloud Scheduler richiama la route /run per il servizio recommendation-collector.

L'impostazione del flag --schedule="0 */3 * * *" esegue il job Scheduler ogni tre ore. Puoi modificare questa impostazione in base alle tue esigenze. Per saperne di più, consulta Configurazione delle pianificazioni dei cron job.

Creare il motore delle regole per i consigli per elaborare i consigli

In questa sezione creerai un secondo servizio Cloud Run denominatorecommendation-rules-engine per elaborare i suggerimenti raccolti dal servizio recommendation-collector. Il servizio recommendation-rules-engine viene richiamato da Pub/Sub quando nuovi suggerimenti vengono trasferiti nell'argomento activeassist-recommendations.

Questo servizio analizza i suggerimenti in base alle regole aziendali che hai definito nella raccolta activeassist-business-rules.

In Cloud Shell, apri la directory recommendation-rules-engine:
```
cd ../recommendation-rules-engine
```
Nota: se viene eseguita la disconnessione dalla sessione di Cloud Shell e devi riconnetterti, puoi trovare la directory del repository clonato all'indirizzo ~/cloudshell_open/activeassist-serverless-pipeline.

Crea una variabile di ambiente per l'immagine Docker:

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

Crea l'immagine Docker e caricala in Container Registry:
```
gcloud builds submit --tag $RULES_ENGINE_IMAGE
```

Crea un account di servizio per consentire al servizio recommendation-rules-engine di interagire con altri servizi Google Cloud nella 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

Concedi all'account di servizio per il servizio recommendation-rules-engine l'accesso a 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

Se utilizzi gli stub forniti per questo tutorial, vai al passaggio successivo.

Se testi la pipeline utilizzando i suggerimenti generati per un progetto Google Cloud anziché gli stub forniti per questo tutorial, esegui i comandi seguenti per consentire all'account di servizio del motore di regole di accedere al progetto:

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

Esegui il deployment del servizio 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

Accetta le eventuali richieste del sistema.

Ottieni 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 recuperato in questo passaggio viene richiamato quando diventano disponibili nuovi consigli dall'argomento Pub/Sub che crei nel passaggio successivo.

Crea un argomento Pub/Sub per suggerimenti attivi

In questa sezione, creerai un argomento Pub/Sub per i suggerimenti di Active Assist che il servizio recommender-collector recupera richiamando l'API Recommender.

In Cloud Shell, crea un argomento Pub/Sub:

gcloud pubsub topics create activeassist-recommendations

Crea un account di servizio da utilizzare in Pub/Sub per richiamare il servizio 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

L'account di servizio Pub/Sub deve essere associato ai ruoli necessari per pubblicare messaggi e richiamare il servizio 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

Crea una sottoscrizione per l'argomento Pub/Sub

Crea un abbonamento per il servizio 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

Consenti all'account di servizio recommendation-engine-sub-sa creato per richiamare il servizio 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

Esecuzione di test end-to-end utilizzando stub

I suggerimenti di Active Assist vengono generati dalla piattaforma in base a pattern di utilizzo e metriche di sistema. Ogni categoria di consigli potrebbe utilizzare una finestra temporale diversa nel passato per analizzare i dati sull'utilizzo e le metriche in base ai consigli generati. Ad esempio, i suggerimenti IAM vengono generati dalla piattaforma in base ai modelli di utilizzo degli ultimi 90 giorni.

Per testare la pipeline end-to-end, il repository che hai clonato per questo tutorial fornisce suggerimenti (stub) di esempio da utilizzare per eseguire la pipeline end-to-end.

In questa sezione, segui questi passaggi:

Esamina i suggerimenti relativi agli stub.
Richiamare manualmente la pipeline.
Controlla se una notifica viene generata e inviata al canale Slack che hai creato.

Esamina i suggerimenti di esempio forniti nel repository:
```
cat ../recommendation-collector/stub.json
```
Questo file fornisce un suggerimento di esempio con un'azione REMOVE per un ruolo di esempio denominato roles/gkehub.connect.
Esegui questo comando per fare in modo che Cloud Scheduler esegua il job immediatamente, anziché attendere la successiva esecuzione pianificata:
```
gcloud scheduler jobs run recommender-iam-scheduler
```
Nella pagina della console di Cloud Scheduler, nella colonna Risultato per il job recommender-iam-scheduler, verifica che il risultato sia Riuscita.

Per una visualizzazione dettagliata dei passaggi eseguiti da ciascuno dei servizi, puoi anche visualizzare i log del servizio Cloud Run per il servizio recommendation-collector e il servizio recommendation-rules-engine.
Quando la pipeline end-to-end serverless creata in questo tutorial viene eseguita correttamente, viene generata una notifica Slack contenente i dettagli dell'associazione dei ruoli consigliata da rimuovere. Di seguito è riportato un esempio di notifica che ricevi:
```
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
```

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Nella console Google Cloud, vai alla pagina Gestisci risorse.

Vai a Gestisci risorse

Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.

Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Scopri di più sull'utilizzo dei suggerimenti per Infrastructure as Code.
Scopri di più sulle tecnologie Google Cloud serverless.
Scopri come integrare i suggerimenti di Policy Intelligence in una pipeline IaC.