Pic-a-daily: lab 5 - Pulizia dopo l'eliminazione dell'immagine

1. Panoramica

In questo codelab, creerai un nuovo servizio Cloud Run, il garbage collector di immagini, che verrà attivato da Eventarc, un nuovo servizio per la ricezione di eventi in Cloud Run. Quando un'immagine viene eliminata dal bucket delle immagini, il servizio riceve un evento da Eventarc. Dopodiché, elimina l'immagine dal bucket delle miniature e la rimuove anche dalla raccolta di immagini Firestore.

Cosa imparerai a fare

Cloud Run
Cloud Storage
Cloud Firestore
Eventarc

2. Configurazione e requisiti

Configurazione dell'ambiente autonomo

Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google e puoi aggiornarla in qualsiasi momento.
L'ID progetto deve essere univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). Cloud Console genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, devi fare riferimento all'ID progetto (che in genere è identificato come PROJECT_ID), quindi, se non ti piace, generane un altro casuale oppure puoi provare il tuo e vedere se è disponibile. Viene "congelato" dopo la creazione del progetto.
Esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. L'esecuzione di questo codelab non dovrebbe costare molto, se non nulla. Per arrestare le risorse in modo da non incorrere in costi di fatturazione al termine di questo tutorial, segui le istruzioni di "pulizia" riportate alla fine del codelab. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Nella console GCP, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere un risultato simile a questo:

Questa macchina virtuale è caricata con tutti gli strumenti per sviluppatori di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Tutto il lavoro di questo lab può essere svolto semplicemente con un browser.

3. Introduzione a Eventarc

Eventarc semplifica la connessione dei servizi Cloud Run con eventi provenienti da varie origini. Si occupa dell'inserimento, della distribuzione, della sicurezza, dell'autorizzazione e della gestione degli errori degli eventi.

Puoi estrarre eventi da origini Google Cloud e applicazioni personalizzate che pubblicano su Cloud Pub/Sub e inviarli ai sink Google Cloud Run.

Gli eventi provenienti da un'ampia gamma di origini Google Cloud vengono forniti tramite Cloud Audit Logs. La latenza e la disponibilità della distribuzione degli eventi da queste origini sono legate a quelle di Cloud Audit Logs. Ogni volta che viene attivato un evento da un'origine Google Cloud, viene creata una voce di audit log di Cloud corrispondente.

Le applicazioni personalizzate che pubblicano su Cloud Pub/Sub possono pubblicare messaggi in un argomento Pub/Sub specificato in qualsiasi formato.

I trigger evento sono il meccanismo di filtraggio per specificare quali eventi inviare a quale sink.

Tutti gli eventi vengono pubblicati nel formato CloudEvents v1.0 per l'interoperabilità tra i servizi.

4. Prima di iniziare

Abilita API

Per attivare il servizio Cloud Run, devi utilizzare il servizio Eventarc. Assicurati che sia abilitato:

gcloud services enable eventarc.googleapis.com

Dovresti vedere che l'operazione è stata completata correttamente:

Operation "operations/acf.5c5ef4f6-f734-455d-b2f0-ee70b5a17322" finished successfully.

Configura account di servizio

Nei trigger verrà utilizzato il service account Compute predefinito. Concedi il ruolo eventarc.eventReceiver al service account Compute predefinito:

PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format='value(projectNumber)')

gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
    --member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role roles/eventarc.eventReceiver

Concedi il ruolo pubsub.publisher al service account Cloud Storage. Questo è necessario per il trigger Eventarc Cloud Storage:

SERVICE_ACCOUNT=$(gsutil kms serviceaccount -p $PROJECT_NUMBER)

gcloud projects add-iam-policy-binding $PROJECT_NUMBER \
    --member serviceAccount:$SERVICE_ACCOUNT \
    --role roles/pubsub.publisher

Se hai attivato l'account di servizio Pub/Sub il giorno 8 aprile 2021 o in una data precedente, concedi il ruolo iam.serviceAccountTokenCreator all'account di servizio Pub/Sub:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com \
  --role roles/iam.serviceAccountTokenCreator

5. Clona il codice

Clona il codice, se non l'hai già fatto nel lab precedente:

git clone https://github.com/GoogleCloudPlatform/serverless-photosharing-workshop

A questo punto, puoi andare alla directory contenente il servizio:

cd serverless-photosharing-workshop/services/garbage-collector/nodejs

Per il servizio avrai il seguente layout dei file:

services
 |
 ├── garbage-collector
      |
      ├── nodejs
           |
           ├── index.js
           ├── package.json

All'interno della cartella sono presenti tre file:

index.js contiene il codice Node.js
package.json definisce le dipendenze della libreria

6. Esplora il codice

Dipendenze

Il file package.json definisce le dipendenze della libreria necessarie:

{
  "name": "garbage_collector_service",
  "version": "0.0.1",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "cloudevents": "^4.0.1",
    "express": "^4.17.1",
    "@google/events": "^3.1.0",
    "@google-cloud/firestore": "^4.9.9",
    "@google-cloud/storage": "^5.8.3"
  }
}

Ci affidiamo alla libreria Cloud Storage per eliminare le immagini all'interno di Cloud Storage. Dichiariamo una dipendenza da Cloud Firestore per eliminare anche i metadati delle immagini che abbiamo archiviato in precedenza. Inoltre, ci affidiamo all'SDK CloudEvents e alle librerie Google Events per leggere gli eventi CloudEvents inviati da Eventarc. Express è un framework web JavaScript / Node. Bluebird viene utilizzato per la gestione delle promesse.

index.js

Diamo un'occhiata più da vicino al nostro codice index.js:

const express = require('express');
const {Storage} = require('@google-cloud/storage');
const Firestore = require('@google-cloud/firestore');
const { HTTP } = require("cloudevents");
const {toStorageObjectData} = require('@google/events/cloud/storage/v1/StorageObjectData');

Richiediamo le varie dipendenze necessarie per l'esecuzione del nostro programma: Express è il framework web Node che utilizzeremo, Bluebird è una libreria per la gestione delle promesse JavaScript, Storage e Firestore servono rispettivamente per lavorare con Google Cloud Storage (i nostri bucket di immagini) e con l'archivio Cloud Firestore. Inoltre, richiediamo a CloudEvent di leggere CloudEvent inviato da Eventarc StoreObjectData dalla libreria Google Events per leggere il corpo dell'evento Cloud Storage di CloudEvent.

const app = express();
app.use(express.json());

app.post('/', async (req, res) => {
    try {
        const cloudEvent = HTTP.toEvent({ headers: req.headers, body: req.body });
        console.log(cloudEvent);


        /* ... */

    } catch (err) {
        console.log(`Error: ${err}`);
        res.status(500).send(err);
    }
});

Sopra, abbiamo la struttura del nostro gestore Node: la nostra app risponde alle richieste HTTP POST. Legge CloudEvent dalla richiesta HTTP e gestisce gli errori in caso di problemi. Ora diamo un'occhiata a cosa c'è all'interno di questa struttura.

Il passaggio successivo consiste nel recuperare e analizzare il corpo di CloudEvent e recuperare il nome dell'oggetto:

const storageObjectData = toStorageObjectData(cloudEvent.data);
console.log(storageObjectData);

const objectName = storageObjectData.name;

Una volta che conosciamo il nome dell'immagine, possiamo eliminarla dal bucket delle miniature:

try {
    await storage.bucket(bucketThumbnails).file(objectName).delete();
    console.log(`Deleted '${objectName}' from bucket '${bucketThumbnails}'.`);
}
catch(err) {
    console.log(`Failed to delete '${objectName}' from bucket '${bucketThumbnails}': ${err}.`);
}

Come ultimo passaggio, elimina anche i metadati dell'immagine dalla raccolta Firestore:

try {
    const pictureStore = new Firestore().collection('pictures');
    const docRef = pictureStore.doc(objectName);
    await docRef.delete();

    console.log(`Deleted '${objectName}' from Firestore collection 'pictures'`);
}
catch(err) {
    console.log(`Failed to delete '${objectName}' from Firestore: ${err}.`);
}

res.status(200).send(`Processed '${objectName}'.`);

Ora è il momento di fare in modo che lo script Node ascolti le richieste in arrivo. Controlla anche che siano impostate le variabili di ambiente richieste:

app.listen(PORT, () => {
    if (!bucketThumbnails) throw new Error("BUCKET_THUMBNAILS not set");
    console.log(`Started service on port ${PORT}`);
});

7. Testare localmente

Testa il codice localmente per assicurarti che funzioni prima del deployment nel cloud.

All'interno della cartella garbage-collector/nodejs, installa le dipendenze npm e avvia il server:

export BUCKET_THUMBNAILS=thumbnails-$GOOGLE_CLOUD_PROJECT

npm install; npm start

Se tutto è andato a buon fine, il server dovrebbe avviarsi sulla porta 8080:

Started service on port 8080

Usa CTRL-C per uscire.

8. Crea ed esegui il deployment in Cloud Run

Prima di eseguire il deployment in Cloud Run, imposta la regione Cloud Run su una delle regioni supportate e la piattaforma su managed:

REGION=europe-west1
gcloud config set run/region $REGION
gcloud config set run/platform managed

Puoi verificare che la configurazione sia impostata:

gcloud config list

...
[run]
platform = managed
region = europe-west1

Anziché creare e pubblicare manualmente l'immagine container utilizzando Cloud Build, puoi anche fare affidamento su Cloud Run per creare l'immagine container per te utilizzando Google Cloud Buildpacks.

Esegui questo comando per creare l'immagine container utilizzando i buildpack di Google Cloud e poi eseguirne il deployment su Cloud Run:

SERVICE_NAME=garbage-collector-service

gcloud run deploy $SERVICE_NAME \
    --source . \
    --no-allow-unauthenticated \
    --update-env-vars BUCKET_THUMBNAILS=$BUCKET_THUMBNAILS

Prendi nota del flag –-source. Questo flag indica a Cloud Run di utilizzare i buildpack di Google Cloud per creare l'immagine container senza un Dockerfile.. Il flag --no-allow-unauthenticated rende il servizio Cloud Run un servizio interno che verrà attivato solo da service account specifici. In un secondo momento, creerai un trigger con il service account Compute predefinito che ha il ruolo run.invoker per chiamare i servizi Cloud Run interni.

9. Crea un trigger

In Eventarc, un trigger definisce quale servizio deve ricevere quale tipo di eventi. In questo caso, vuoi che il servizio riceva eventi quando un file viene eliminato in un bucket.

Imposta la posizione del trigger nella stessa regione del bucket delle immagini caricate:

gcloud config set eventarc/location eu

Crea un trigger AuditLog per filtrare gli eventi storage.objects.delete e inviarli al servizio Cloud Run:

BUCKET_IMAGES=uploaded-pictures-$GOOGLE_CLOUD_PROJECT

gcloud eventarc triggers create trigger-$SERVICE_NAME \
  --destination-run-service=$SERVICE_NAME \
  --destination-run-region=$REGION \
  --event-filters="type=google.cloud.storage.object.v1.deleted" \
  --event-filters="bucket=$BUCKET_IMAGES" \
  --service-account=$PROJECT_NUMBER-compute@developer.gserviceaccount.com

Puoi verificare che il trigger sia stato creato con questo comando:

gcloud eventarc triggers list

10. Testare il servizio

Per verificare se il servizio funziona, vai al bucket uploaded-pictures ed elimina una delle immagini. Nei log del servizio dovresti vedere che l'immagine pertinente è stata eliminata nel bucket thumbnails e che il documento è stato eliminato dalla raccolta Firestore pictures.

11. Pulizia (facoltativo)

Se non intendi continuare con gli altri lab della serie, puoi eseguire la pulizia delle risorse per risparmiare sui costi e per essere un buon cittadino del cloud. Puoi ripulire le risorse singolarmente nel seguente modo.

Elimina il servizio:

gcloud run services delete $SERVICE_NAME -q

Elimina il trigger Eventarc:

gcloud eventarc triggers delete trigger-$SERVICE_NAME -q

In alternativa, puoi eliminare l'intero progetto:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

12. Complimenti!

Complimenti! Hai creato un servizio Cloud Run, image garbage collector, attivato da Eventarc, un nuovo servizio per la ricezione di eventi in Cloud Run. Quando un'immagine viene eliminata dal bucket delle immagini, il servizio riceve un evento da Eventarc. Dopodiché, elimina l'immagine dal bucket delle miniature e la rimuove anche dalla raccolta di immagini Firestore.

Argomenti trattati

Cloud Run
Cloud Storage
Cloud Firestore
Eventarc