Questa pagina è stata tradotta dall'API Cloud Translation.

Utilizzo di pipeline serverless con Active Assist

Last reviewed 2021-06-09 UTC

Questo documento è destinato agli enterprise architect e agli sviluppatori di software che vogliono creare una pipeline di automazione per utilizzare Active Assist nella propria organizzazione Google Cloud. Fa parte di una serie che illustra i pattern architetturali che le aziende possono utilizzare per ottimizzare l'impronta del cloud su larga scala utilizzando Active Assist. La serie è composta dai seguenti parti:

Pattern per l'utilizzo di Active Assist su larga scala
Utilizzo di pipeline serverless con Active Assist (questo documento)
Utilizzo della Toolchain di GKE Enterprise 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. I suggerimenti si basano sulle regole aziendali impostate dalla tua azienda. La pipeline di automazione che hai configurato in questo tutorial ti aiuta a lavorare con Active Assist su larga scala, mantenendo al contempo un processo di revisione e attuazione gestito dal team. Questo approccio è utile quando la tua azienda vuole scalare l'utilizzo del portafoglio Active Assist, mantenendo al contempo il controllo del processo di revisione e implementazione all'interno dei team. Offre un'alternativa all'utilizzo di una pipeline di integrazione continua e distribuzione continua (CI/CD).

L'architettura mostrata 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 simile per l'elaborazione di notifiche o ticket. Lo strumento deve essere configurato sul computer e pronto all'uso.

Architettura

Poiché l'architettura mostrata in questo tutorial è modulare, puoi adattare il componente delle notifiche in base ai requisiti della tua azienda. Questo tutorial illustra 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 dell'architettura mostra i componenti utilizzati in questo tutorial:

Pipeline serverless.

L'architettura include 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 vengono inviati ed elaborati i suggerimenti di Active Assist.
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 dalla tua azienda e archiviati in una raccolta Firestore.
Due raccolte Firestore per archiviare i metadati e le regole aziendali. Le raccolte Firestore funzionano come seguente:
- Nella prima raccolta sono archiviati i metadati aziendali pertinenti per il recupero dei consigli 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.
- La seconda include le regole aziendali applicate al momento dell'elaborazione dei consigli.

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 di esempio e regole aziendali.
Crea un secondo servizio Cloud Run per elaborare i suggerimenti in base alle regole aziendali di esempio che definisci in questo tutorial.
Creare un canale Slack a cui il servizio Cloud Run invia esempi di suggerimenti di Active Assist.
Testa la pipeline end-to-end con esempi di suggerimenti di Active Assist.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

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

Go to project selector
Select or create a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
Prendi nota dell'ID progetto Google Cloud per il progetto del gestore suggerimenti. Ti servirà nella sezione successiva relativa alla configurazione dell'ambiente.
Enable the Cloud Build, Firestore, App Engine,Pub/Sub, Cloud Run, Cloud Scheduler e Cloud Source Repositories APIs.
Enable the APIs
Per questo tutorial, devi utilizzare le credenziali dell'applicazione predefinite. Se ti viene chiesto di creare le credenziali nella pagina Aggiungi credenziali al progetto, fai clic su Annulla.
Make sure that billing is enabled for your Google Cloud project.
Crea quanto segue:
- Un canale Slack di esempio.
- 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ù avanti in questo tutorial.
Per maggiori informazioni, vedi Creare un canale Slack e Inviare messaggi utilizzando webhook in arrivo.

Dopo aver creato un'app Slack e un URL webhook in entrata, prendi nota dell'URL in base alle tue esigenze più avanti in questo tutorial.

Creazione della pipeline serverless

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

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

Crea le raccolte Firestore

In questa sezione creerai due raccolte Firestore. La prima, la raccolta activeassist-metadata, memorizza i metadati aziendali pertinenti per recuperare i consigli 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 suggerimento 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 a quella in cui vengono eseguiti i servizi Cloud Run.
3. Fai clic su Crea database. La configurazione richiede alcuni istanti.
Nella pagina di Firestore, fai clic su Inizia raccolta.
Nel campo ID raccolta, inserisci i seguenti valori: activeassist-metadata.

Completa i campi come mostrato nella tabella seguente. 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 l'ID progetto.
`locations`	`array`	`global`	Alcuni suggerimenti possono essere specifici per regione o zona, ad esempio suggerimenti per il dimensionamento ottimale delle VM. Altri suggerimenti sono globali, ad esempio i suggerimenti IAM.
`recommenderType`	`string`	`google.iam.policy.Recommender`	Non applicabile.

Quando i campi sono completati, fai clic su Salva.

Crea la raccolta `activeassist-business-rules`

Fai clic su Avvia raccolta.

Nel campo ID raccolta, inserisci i seguenti valori: activeassist-business-rules

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

Nome campo	Tipo di campo	Valore campo	Nota
`action`	`string`	`Notify`	Se il valore è impostato su `Apply`, il servizio applica il suggerimento e rimuove il ruolo inutilizzato.
`projectId`	`string`	`Stub-Project-ID`	Questo tutorial utilizza un suggerimento di base. Se vuoi utilizzare i suggerimenti di un progetto Google Cloud esistente, inserisci l'ID progetto.
`projectNumber`	`string`	`999999999`	Questo tutorial utilizza un suggerimento di base. Se stai utilizzando un suggerimento di un progetto Google Cloud esistente, inserisci il numero del progetto. Puoi trovare il numero del progetto nella pagina di benvenuto della console Google Cloud
`recommenderType`	`string`	`google.iam.policy.Recommender`	Non applicabile.
`recommenderSubtype`	`string`	`REMOVE_ROLE`	Non applicabile.
`slackWebhookURL`	`string`		Inserisci l'URL 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 informazioni su come un suggerimento può essere applicato automaticamente in base alla valutazione di regole aziendali di esempio che hai configurato, 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 denominato recommendation-collector che richiama l'API Recommender e recupera i suggerimenti attivi. In questo tutorial viene utilizzata l'API Recommender di Identity and Access Management come API Recommender. Il servizio legge i metadati dalla raccolta Firestore di activeassist-metadata che hai creato per determinare quali suggerimenti recuperare.

Fai clic su Apri in Cloud Shell per aprire Cloud Shell per il progetto del gestore suggerimenti.

Apri in Cloud Shell

All'apertura di Cloud Shell, vengono eseguiti i seguenti comandi:
- Il comando di clonazione repository GitHub.
- Il comando change directory.
Nella finestra di dialogo Apri in Cloud Shell, seleziona Attendibile e fai clic su Conferma.

Imposta l'ID e il numero del progetto gestore 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 quando ti viene richiesto.

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 il servizio recommendation-collector per 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à del servizio.

Concedi all'account di servizio per il servizio recommendation-collector l'accesso a 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 esegui questo tutorial utilizzando l'esempio di stub fornito nel repository che hai clonato, vai al passaggio successivo.

Se in questo tutorial crei la pipeline utilizzando i suggerimenti generati per un progetto Google Cloud esistente, devi assegnare 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 il quale 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 durante la creazione delle raccolte Firestore.

Nota: se esegui questa pipeline per 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 hanno bisogno di queste autorizzazioni.
Per questo tutorial, eseguirai il deployment del servizio con una variabile di ambiente denominata STUB_RECOMMENDATIONS. Questa variabile 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 richieste di 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 eseguirne il deployment:
```
--set-env-vars="STUB_RECOMMENDATIONS=true"
```

Configura un job Cloud Scheduler per eseguire `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 abilitarlo a richiamare il 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

Ottieni 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 ulteriori informazioni, consulta gcloud scheduler job create http.

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

L'impostazione del flag --schedule="0 */3 * * *" esegue il job dello scheduler ogni tre ore. Puoi modificare questa impostazione in base ai tuoi requisiti. Per ulteriori informazioni, consulta Configurazione delle pianificazioni dei cron job.

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

In questa sezione creerai un secondo servizio Cloud Run denominato recommendation-rules-engine per elaborare i suggerimenti raccolti dal servizio recommendation-collector. Il servizio recommendation-rules-engine viene richiamato da Pub/Sub quando viene eseguito il push di nuovi suggerimenti 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 la sessione di Cloud Shell viene disconnessa e devi riconnetterti, puoi trovare la directory del repository clonata in ~/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 il servizio recommendation-rules-engine per 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 stai utilizzando gli stub forniti per questo tutorial, vai al passaggio successivo.

Se stai testando 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 delle regole di accedere al tuo 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 richieste di 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 suggerimenti 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 per Pub/Sub da utilizzare 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 al 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 che hai creato di 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 sono generati dalla piattaforma in base a pattern di utilizzo e metriche di sistema. Ogni categoria di suggerimenti potrebbe utilizzare una diversa finestra temporale predefinita nel passato per analizzare i dati e le metriche sull'utilizzo in base ai suggerimenti generati. Ad esempio, i suggerimenti IAM vengono generati dalla piattaforma in base a modelli di utilizzo degli ultimi 90 giorni.

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

In questa sezione:

Esamina i suggerimenti relativi agli stub.
Richiama manualmente la pipeline.
Controlla se viene generata e inviata una notifica 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 immediatamente il job, anziché attendere l'esecuzione pianificata successiva:
```
gcloud scheduler jobs run recommender-iam-scheduler
```
Nella pagina della console Cloud Scheduler, nella colonna Risultato per il job recommender-iam-scheduler, verifica che il risultato sia Successo.

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

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.

Passaggi successivi

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