Utilizzo di pipeline serverless con Active Assist

Last reviewed 2021-06-09 UTC

Questo documento è rivolto agli architetti aziendali 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 modelli di architettura che le aziende possono utilizzare per ottimizzare la propria presenza nel cloud su larga scala mediante Active Assist. La serie è costituita dalle 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 impostato in questo tutorial ti aiuta a lavorare con Active Assist su larga scala, mantenendo al contempo un processo di revisione e attivazione 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 attuazione all'interno dei team. Offre un'alternativa all'uso di pipeline di integrazione continua e distribuzione continua (CI/CD).

L'architettura dimostrata in questo tutorial è generica e puoi estenderla per funzionare con altri prodotti serverless. Il tutorial presuppone la conoscenza delle seguenti tecnologie Google Cloud:

Per completare questo tutorial, devi avere un account per Slack o una notifica o uno strumento di elaborazione di ticket simile. Lo strumento deve essere configurato sul tuo 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 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 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 metadati aziendali e regole aziendali. Le raccolte Firestore funzionano nel seguente modo:
- Nella prima raccolta sono archiviati 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 dell'attività. 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 suggerimenti.

Obiettivi

Crea 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 esempi di suggerimenti di Active Assist.

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.

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

Nella console Google Cloud, vai alla pagina del selettore progetto.

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

Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.
Prendi nota dell'ID progetto Google Cloud per il progetto del gestore dei suggerimenti. Questo ID sarà necessario nella sezione successiva della 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 utilizzerai le credenziali predefinite dell'applicazione. Se ti viene richiesto di creare le credenziali nella pagina Aggiungi credenziali al progetto, fai clic su Annulla.
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
Crea quanto segue:
- Un canale Slack di esempio.
- Un'app Slack di esempio e un webhook in arrivo per ricevere le notifiche generate da un motore denominato recommendation-rules-engine. Configurerai 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 arrivo, prendi nota dell'URL di cui hai bisogno più avanti in questo tutorial.

Creazione di una pipeline serverless

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

Se hai 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 il recupero dei consigli di Active Assist. La seconda, la raccolta activeassist-business-rules, archivia le regole aziendali 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 di 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. Bastano pochi istanti per completare la configurazione.
Nella pagina di Firestore, fai clic su Avvia raccolta.
Nel campo ID raccolta, inserisci activeassist-metadata.

Compila i campi come illustrato 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 una 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 per zona, ad esempio quelli 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 compilati, 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

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 consiglio stub. Se vuoi utilizzare i suggerimenti di un progetto Google Cloud esistente, inserisci l'ID progetto.
`projectNumber`	`string`	`999999999`	Questo tutorial utilizza un consiglio stub. Se utilizzi 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 Slack che hai 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 e inviata una notifica a una piattaforma come Slack. Per scoprire come applicare automaticamente un suggerimento 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 activeassist-metadata che hai creato per determinare quali suggerimenti recuperare.

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

Apri in Cloud Shell

All'apertura di Cloud Shell, vengono eseguiti i seguenti comandi:
- Il comando di clonazione del repository GitHub.
- Il comando change directory.
Quando viene visualizzata la finestra di dialogo Apri in Cloud Shell, seleziona Attendibile e fai clic su Conferma.
Imposta l'ID e il numero del progetto del progetto gestore 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 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 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 del 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 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 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 il set 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 una 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 \
```
Accettare qualsiasi richiesta 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

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 dei valori 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 Pianificazione ogni tre ore. Puoi modificare questa impostazione in base alle tue esigenze. Per ulteriori informazioni, consulta Configurazione delle pianificazioni dei cron job.

Crea 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 ti disconnetti dalla sessione Cloud Shell e devi riconnetterti, puoi trovare la directory del repository clonata 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 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 del 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 stai testando la pipeline utilizzando i suggerimenti generati per un progetto Google Cloud anziché gli stub forniti in 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

Accettare qualsiasi richiesta 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 nuovi suggerimenti diventano disponibili dall'argomento Pub/Sub che crei nel passaggio successivo.

Crea un argomento Pub/Sub per i 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 che Pub/Sub deve 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 modelli 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 della stub.
Richiamare la pipeline manualmente.
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 la successiva esecuzione pianificata:
```
gcloud scheduler jobs run recommender-iam-scheduler
```
Nella pagina della console Cloud Scheduler, nella colonna Risultato del job recommender-iam-scheduler, verifica che il risultato sia Successo.

Per una visualizzazione dettagliata dei passaggi eseguiti da ciascuno dei servizi, puoi anche visualizzare i log di servizio Cloud Run per il servizio recommendation-collector e recommendation-rules-engine.
Quando la pipeline end-to-end serverless creata in questo tutorial viene eseguita correttamente, genera una notifica Slack contenente i dettagli dell'associazione di 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.

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 di Recommendations for Infrastructure as Code.
Scopri di più sulle tecnologie serverless di Google Cloud.
Scopri come integrare i suggerimenti di Policy Intelligence in una pipeline IaC.