Tutorial sull'elaborazione di immagini da Cloud Storage

---

Questo tutorial mostra come utilizzare Cloud Run, l'API Cloud Vision e ImageMagick per rilevare e sfocare le immagini offensive caricate in un bucket Cloud Storage. Questo tutorial si basa sul tutorial Utilizzare Pub/Sub con Cloud Run.

Questo tutorial illustra la modifica di un'app di esempio esistente. Se vuoi, puoi anche scaricare l'esempio completato.

Obiettivi

• Scrivi, crea ed esegui il deployment di un servizio di elaborazione dati asincrona in Cloud Run.
• Richiama il servizio caricando un file su Cloud Storage e creando un messaggio Pub/Sub.
• Utilizza l'API Cloud Vision per rilevare contenuti violenti o per adulti.
• Utilizza ImageMagick per sfocare le immagini offensive.
• Testa il servizio caricando un'immagine di uno zombie cannibale.

Costi

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

• Artifact Registry
• Cloud Build
• Pub/Sub
• Cloud Run
• Cloud Storage
• Cloud Vision API

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.

Prima di iniziare

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, 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.

   Go to project selector

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

4. In the Google Cloud console, on the project selector page, 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.

   Go to project selector

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

6. Enable the Artifact Registry, Cloud Build, Pub/Sub, Cloud Run, Cloud Storage and Cloud Vision APIs.

   Enable the APIs

7. Installa e inizializza la gcloud CLI.
8. Aggiorna i componenti:

   gcloud components update

9. Configura un argomento Pub/Sub, una sottoscrizione push sicura e un servizio Cloud Run iniziale per gestire i messaggi seguendo il tutorial sull'utilizzo di Pub/Sub.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per completare il tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

• Editor Cloud Build (roles/cloudbuild.builds.editor)
• Amministratore Cloud Run (roles/run.admin)
• Logs View Accessor (roles/logging.viewAccessor)
• Amministratore IAM del progetto (roles/resourcemanager.projectIamAdmin)
• Amministratore Pub/Sub (roles/pubsub.admin)
• Utente account di servizio (roles/iam.serviceAccountUser)
• Consumatore di utilizzo del servizio (roles/serviceusage.serviceUsageConsumer)
• Amministratore archiviazione (roles/storage.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Nota: i ruoli di base IAM potrebbero contenere anche le autorizzazioni per completare il tutorial. Non dovresti concedere i ruoli di base in un ambiente di produzione, ma puoi farlo in un ambiente di sviluppo o di test.

Configurare i valori predefiniti di gcloud

Per configurare gcloud con i valori predefiniti per il servizio Cloud Run:

1. Imposta il progetto predefinito:

   gcloud config set project PROJECT_ID

   Sostituisci PROJECT_ID con il nome del progetto che hai creato per questo tutorial.

2. Configura gcloud per la regione scelta:

   gcloud config set run/region REGION

   Sostituisci REGION con la regione di Cloud Run supportata che preferisci.

Località Cloud Run

Cloud Run è un servizio a livello di regione, il che significa che l'infrastruttura che gestisce i tuoi servizi Cloud Run si trova in una regione specifica ed è gestita da Google in modo da essere disponibile in modo ridondante in tutte le zone all'interno della regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è uno dei fattori principali per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. In genere puoi selezionare la regione più vicina ai tuoi utenti, ma devi prendere in considerazione la posizione degli altri prodotti Google Cloud utilizzati dal servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire sulla latenza e sul costo del servizio.

Cloud Run è disponibile nelle seguenti regioni:

Soggetto ai prezzi di Livello 1

• asia-east1 (Taiwan)
• asia-northeast1 (Tokyo)
• asia-northeast2 (Osaka)
• asia-south1 (Mumbai, India)
• europe-north1 (Finlandia) Bassi livelli di CO₂
• europe-southwest1 (Madrid) Basso livello di CO₂
• europe-west1 (Belgio) Bassi livelli di CO₂
• europe-west4 (Paesi Bassi) Bassi livelli di CO₂
• europe-west8 (Milano)
• europe-west9 (Parigi) Bassi livelli di CO₂
• me-west1 (Tel Aviv)
• us-central1 (Iowa) Bassi livelli di CO₂
• us-east1 (Carolina del Sud)
• us-east4 (Virginia del Nord)
• us-east5 (Columbus)
• us-south1 (Dallas) Bassi livelli di CO₂
• us-west1 (Oregon) Bassi livelli di CO₂

Soggetto ai prezzi di Livello 2

• africa-south1 (Johannesburg)
• asia-east2 (Hong Kong)
• asia-northeast3 (Seul, Corea del Sud)
• asia-southeast1 (Singapore)
• asia-southeast2 (Giacarta)
• asia-south2 (Delhi, India)
• australia-southeast1 (Sydney)
• australia-southeast2 (Melbourne)
• europe-central2 (Varsavia, Polonia)
• europe-west10 (Berlino) Bassi livelli di CO₂
• europe-west12 (Torino)
• europe-west2 (Londra, Regno Unito) Bassi livelli di CO₂
• europe-west3 (Francoforte, Germania) Bassi livelli di CO₂
• europe-west6 (Zurigo, Svizzera) Bassi livelli di CO₂
• me-central1 (Doha)
• me-central2 (Dammam)
• northamerica-northeast1 (Montreal) Bassi livelli di CO₂
• northamerica-northeast2 (Toronto) Bassi livelli di CO₂
• southamerica-east1 (San Paolo, Brasile) Bassi livelli di CO₂
• southamerica-west1 (Santiago, Cile) Bassi livelli di CO₂
• us-west2 (Los Angeles)
• us-west3 (Salt Lake City)
• us-west4 (Las Vegas)

Se hai già creato un servizio Cloud Run, puoi visualizzare la regione nella dashboard di Cloud Run nella console Google Cloud.

Ok

Informazioni sulla sequenza delle operazioni

Il flusso di dati in questo tutorial segue questi passaggi:

1. Un utente carica un'immagine in un bucket Cloud Storage.
2. Cloud Storage pubblica un messaggio sul nuovo file in Pub/Sub.
3. Pub/Sub invia il messaggio al servizio Cloud Run.
4. Il servizio Cloud Run recupera il file immagine a cui si fa riferimento nel messaggio Pub/Sub.
5. Il servizio Cloud Run utilizza l'API Cloud Vision per analizzare l'immagine.
6. Se vengono rilevati contenuti violenti o per adulti, il servizio Cloud Run utilizza ImageMagick per sfocare l'immagine.
7. Il servizio Cloud Run carica l'immagine sfocata in un altro bucket Cloud Storage per utilizzarla.

L'utilizzo successivo dell'immagine sfocata è lasciato come esercizio per il lettore.

Creare un repository standard Artifact Registry

Crea un repository standard Artifact Registry per archiviare l'immagine container:

gcloud artifacts repositories create REPOSITORY \
    --repository-format=docker \
    --location=REGION

Sostituisci:

• REPOSITORY con un nome univoco per il repository.
• REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

Configurare i bucket Cloud Storage

gcloud

1. Crea un bucket Cloud Storage per il caricamento delle immagini, dove INPUT_BUCKET_NAME è un nome del bucket univoco a livello globale:

   gcloud storage buckets create gs://INPUT_BUCKET_NAME

   Il servizio Cloud Run legge solo da questo bucket.

2. Crea un secondo bucket Cloud Storage per ricevere le immagini sfocate, dove BLURRED_BUCKET_NAME è un nome di bucket univoco a livello globale:

   gcloud storage buckets create gs://BLURRED_BUCKET_NAME

   Il servizio Cloud Run carica le immagini sfocate in questo bucket. L'utilizzo di un bucket separato impedisce alle immagini elaborate di riattivare il servizio.

   Per impostazione predefinita, le revisioni di Cloud Run vengono eseguite come account di servizio predefinito di Compute Engine.

   Se invece utilizzi un account di servizio gestito dall'utente, assicurati di aver assegnato i ruoli IAM richiesti in modo che disponga dell'autorizzazione storage.objects.get per la lettura da INPUT_BUCKET_NAME e dell'autorizzazione storage.objects.create per il caricamento su BLURRED_BUCKET_NAME.

Terraform

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

Crea due bucket Cloud Storage: uno per il caricamento delle immagini originali e un altro per il caricamento delle immagini sfocate da parte del servizio Cloud Run.

Per creare entrambi i bucket Cloud Storage con nomi univoci a livello globale, aggiungi quanto segue al file main.tf esistente:

resource "random_id" "bucket_suffix" {
  byte_length = 8
}

resource "google_storage_bucket" "imageproc_input" {
  name     = "input-bucket-${random_id.bucket_suffix.hex}"
  location = "us-central1"
}

output "input_bucket_name" {
  value = google_storage_bucket.imageproc_input.name
}

resource "google_storage_bucket" "imageproc_output" {
  name     = "output-bucket-${random_id.bucket_suffix.hex}"
  location = "us-central1"
}

output "blurred_bucket_name" {
  value = google_storage_bucket.imageproc_output.name
}

Per impostazione predefinita, le revisioni di Cloud Run vengono eseguite come account di servizio predefinito di Compute Engine.

Se invece utilizzi un account di servizio gestito dall'utente, assicurati di aver assegnato i ruoli IAM richiesti in modo che disponga dell'autorizzazione storage.objects.get per la lettura da google_storage_bucket.imageproc_input e dell'autorizzazione storage.objects.create per il caricamento su google_storage_bucket.imageproc_output.

Nei passaggi seguenti, crei ed esegui il deployment di un servizio che elabora la notifica dei caricamenti di file su INPUT_BUCKET_NAME. Attiva la spedizione delle notifiche dopo aver eseguito il deployment e il test del servizio, per evitare l'invocazione prematura del nuovo servizio.

Modificare il codice campione del tutorial Pub/Sub

Questo tutorial si basa sul codice assemblato nel tutorial sull'utilizzo di Pub/Sub. Se non l'hai ancora fatto, completa il tutorial ora, saltando i passaggi di pulizia, quindi torna qui per aggiungere il comportamento di elaborazione delle immagini.

Aggiungi il codice di elaborazione delle immagini

Il codice di elaborazione delle immagini è separato dalla gestione delle richieste per favorire la leggibilità e la facilità di test. Per aggiungere il codice di elaborazione delle immagini:

1. Passa alla directory del codice campione del tutorial di Pub/Sub.

2. Aggiungi il codice per importare le dipendenze di elaborazione delle immagini, incluse le librerie per integrarsi con i servizi Google Cloud, ImageMagick e il file system.

   Node.js

   Apri un nuovo file image.js nell'editor e copia quanto segue:

   const gm = require('gm').subClass({imageMagick: true});
   const fs = require('fs');
   const {promisify} = require('util');
   const path = require('path');
   const vision = require('@google-cloud/vision');
   
   const {Storage} = require('@google-cloud/storage');
   const storage = new Storage();
   const client = new vision.ImageAnnotatorClient();
   
   const {BLURRED_BUCKET_NAME} = process.env;

   Python

   Apri un nuovo file image.py nell'editor e copia quanto segue:

   import os
   import tempfile
   
   from google.cloud import storage, vision
   from wand.image import Image
   
   storage_client = storage.Client()
   vision_client = vision.ImageAnnotatorClient()

   Vai

   Apri un nuovo file imagemagick/imagemagick.go nell'editor e copia quanto segue:

   
   // Package imagemagick contains an example of using ImageMagick to process a
   // file uploaded to Cloud Storage.
   package imagemagick
   
   import (
   	"context"
   	"errors"
   	"fmt"
   	"log"
   	"os"
   	"os/exec"
   
   	"cloud.google.com/go/storage"
   	vision "cloud.google.com/go/vision/apiv1"
   	"cloud.google.com/go/vision/v2/apiv1/visionpb"
   )
   
   // Global API clients used across function invocations.
   var (
   	storageClient *storage.Client
   	visionClient  *vision.ImageAnnotatorClient
   )
   
   func init() {
   	// Declare a separate err variable to avoid shadowing the client variables.
   	var err error
   
   	storageClient, err = storage.NewClient(context.Background())
   	if err != nil {
   		log.Fatalf("storage.NewClient: %v", err)
   	}
   
   	visionClient, err = vision.NewImageAnnotatorClient(context.Background())
   	if err != nil {
   		log.Fatalf("vision.NewAnnotatorClient: %v", err)
   	}
   }
   

   Java

   Apri un nuovo file src/main/java/com/example/cloudrun/ImageMagick.java nel tuo editor e copia quanto segue:

   import com.google.cloud.storage.Blob;
   import com.google.cloud.storage.BlobId;
   import com.google.cloud.storage.BlobInfo;
   import com.google.cloud.storage.Storage;
   import com.google.cloud.storage.StorageOptions;
   import com.google.cloud.vision.v1.AnnotateImageRequest;
   import com.google.cloud.vision.v1.AnnotateImageResponse;
   import com.google.cloud.vision.v1.BatchAnnotateImagesResponse;
   import com.google.cloud.vision.v1.Feature;
   import com.google.cloud.vision.v1.Feature.Type;
   import com.google.cloud.vision.v1.Image;
   import com.google.cloud.vision.v1.ImageAnnotatorClient;
   import com.google.cloud.vision.v1.ImageSource;
   import com.google.cloud.vision.v1.SafeSearchAnnotation;
   import com.google.gson.JsonObject;
   import java.io.IOException;
   import java.nio.file.Files;
   import java.nio.file.Path;
   import java.nio.file.Paths;
   import java.util.ArrayList;
   import java.util.List;
   
   public class ImageMagick {
   
     private static final String BLURRED_BUCKET_NAME = System.getenv("BLURRED_BUCKET_NAME");
     private static Storage storage = StorageOptions.getDefaultInstance().getService();

3. Aggiungi il codice per ricevere un messaggio Pub/Sub come oggetto evento e controllare l'elaborazione delle immagini.

   L'evento contiene i dati dell'immagine caricata originariamente. Questo codice determina se l'immagine deve essere sfocata controllando i risultati di un'analisi di Cloud Vision per contenuti violenti o per adulti.

   Node.js

   // Blurs uploaded images that are flagged as Adult or Violence.
   exports.blurOffensiveImages = async event => {
     // This event represents the triggering Cloud Storage object.
     const object = event;
   
     const file = storage.bucket(object.bucket).file(object.name);
     const filePath = `gs://${object.bucket}/${object.name}`;
   
     console.log(`Analyzing ${file.name}.`);
   
     try {
       const [result] = await client.safeSearchDetection(filePath);
       const detections = result.safeSearchAnnotation || {};
   
       if (
         // Levels are defined in https://cloud.google.com/vision/docs/reference/rest/v1/AnnotateImageResponse#likelihood
         detections.adult === 'VERY_LIKELY' ||
         detections.violence === 'VERY_LIKELY'
       ) {
         console.log(`Detected ${file.name} as inappropriate.`);
         return blurImage(file, BLURRED_BUCKET_NAME);
       } else {
         console.log(`Detected ${file.name} as OK.`);
       }
     } catch (err) {
       console.error(`Failed to analyze ${file.name}.`, err);
       throw err;
     }
   };

   Python

   def blur_offensive_images(data):
       """Blurs uploaded images that are flagged as Adult or Violence.
   
       Args:
           data: Pub/Sub message data
       """
       file_data = data
   
       file_name = file_data["name"]
       bucket_name = file_data["bucket"]
   
       blob = storage_client.bucket(bucket_name).get_blob(file_name)
       blob_uri = f"gs://{bucket_name}/{file_name}"
       blob_source = vision.Image(source=vision.ImageSource(image_uri=blob_uri))
   
       # Ignore already-blurred files
       if file_name.startswith("blurred-"):
           print(f"The image {file_name} is already blurred.")
           return
   
       print(f"Analyzing {file_name}.")
   
       result = vision_client.safe_search_detection(image=blob_source)
       detected = result.safe_search_annotation
   
       # Process image
       if detected.adult == 5 or detected.violence == 5:
           print(f"The image {file_name} was detected as inappropriate.")
           return __blur_image(blob)
       else:
           print(f"The image {file_name} was detected as OK.")
   
   

   Vai

   
   // GCSEvent is the payload of a GCS event.
   type GCSEvent struct {
   	Bucket string `json:"bucket"`
   	Name   string `json:"name"`
   }
   
   // BlurOffensiveImages blurs offensive images uploaded to GCS.
   func BlurOffensiveImages(ctx context.Context, e GCSEvent) error {
   	outputBucket := os.Getenv("BLURRED_BUCKET_NAME")
   	if outputBucket == "" {
   		return errors.New("BLURRED_BUCKET_NAME must be set")
   	}
   
   	img := vision.NewImageFromURI(fmt.Sprintf("gs://%s/%s", e.Bucket, e.Name))
   
   	resp, err := visionClient.DetectSafeSearch(ctx, img, nil)
   	if err != nil {
   		return fmt.Errorf("AnnotateImage: %w", err)
   	}
   
   	if resp.GetAdult() == visionpb.Likelihood_VERY_LIKELY ||
   		resp.GetViolence() == visionpb.Likelihood_VERY_LIKELY {
   		return blur(ctx, e.Bucket, outputBucket, e.Name)
   	}
   	log.Printf("The image %q was detected as OK.", e.Name)
   	return nil
   }
   

   Java

   // Blurs uploaded images that are flagged as Adult or Violence.
   public static void blurOffensiveImages(JsonObject data) {
     String fileName = data.get("name").getAsString();
     String bucketName = data.get("bucket").getAsString();
     BlobInfo blobInfo = BlobInfo.newBuilder(bucketName, fileName).build();
     // Construct URI to GCS bucket and file.
     String gcsPath = String.format("gs://%s/%s", bucketName, fileName);
     System.out.println(String.format("Analyzing %s", fileName));
   
     // Construct request.
     List<AnnotateImageRequest> requests = new ArrayList<>();
     ImageSource imgSource = ImageSource.newBuilder().setImageUri(gcsPath).build();
     Image img = Image.newBuilder().setSource(imgSource).build();
     Feature feature = Feature.newBuilder().setType(Type.SAFE_SEARCH_DETECTION).build();
     AnnotateImageRequest request =
         AnnotateImageRequest.newBuilder().addFeatures(feature).setImage(img).build();
     requests.add(request);
   
     // Send request to the Vision API.
     try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
       BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
       List<AnnotateImageResponse> responses = response.getResponsesList();
       for (AnnotateImageResponse res : responses) {
         if (res.hasError()) {
           System.out.println(String.format("Error: %s\n", res.getError().getMessage()));
           return;
         }
         // Get Safe Search Annotations
         SafeSearchAnnotation annotation = res.getSafeSearchAnnotation();
         if (annotation.getAdultValue() == 5 || annotation.getViolenceValue() == 5) {
           System.out.println(String.format("Detected %s as inappropriate.", fileName));
           blur(blobInfo);
         } else {
           System.out.println(String.format("Detected %s as OK.", fileName));
         }
       }
     } catch (Exception e) {
       System.out.println(String.format("Error with Vision API: %s", e.getMessage()));
     }
   }

4. Recupera l'immagine a cui si fa riferimento dal bucket di input Cloud Storage creato sopra, utilizza ImageMagick per trasformare l'immagine con un effetto sfocatura e carica il risultato nel bucket di output.

   Node.js

   // Blurs the given file using ImageMagick, and uploads it to another bucket.
   const blurImage = async (file, blurredBucketName) => {
     const tempLocalPath = `/tmp/${path.parse(file.name).base}`;
   
     // Download file from bucket.
     try {
       await file.download({destination: tempLocalPath});
   
       console.log(`Downloaded ${file.name} to ${tempLocalPath}.`);
     } catch (err) {
       throw new Error(`File download failed: ${err}`);
     }
   
     await new Promise((resolve, reject) => {
       gm(tempLocalPath)
         .blur(0, 16)
         .write(tempLocalPath, (err, stdout) => {
           if (err) {
             console.error('Failed to blur image.', err);
             reject(err);
           } else {
             console.log(`Blurred image: ${file.name}`);
             resolve(stdout);
           }
         });
     });
   
     // Upload result to a different bucket, to avoid re-triggering this function.
     const blurredBucket = storage.bucket(blurredBucketName);
   
     // Upload the Blurred image back into the bucket.
     const gcsPath = `gs://${blurredBucketName}/${file.name}`;
     try {
       await blurredBucket.upload(tempLocalPath, {destination: file.name});
       console.log(`Uploaded blurred image to: ${gcsPath}`);
     } catch (err) {
       throw new Error(`Unable to upload blurred image to ${gcsPath}: ${err}`);
     }
   
     // Delete the temporary file.
     const unlink = promisify(fs.unlink);
     return unlink(tempLocalPath);
   };

   Python

   def __blur_image(current_blob):
       """Blurs the given file using ImageMagick.
   
       Args:
           current_blob: a Cloud Storage blob
       """
       file_name = current_blob.name
       _, temp_local_filename = tempfile.mkstemp()
   
       # Download file from bucket.
       current_blob.download_to_filename(temp_local_filename)
       print(f"Image {file_name} was downloaded to {temp_local_filename}.")
   
       # Blur the image using ImageMagick.
       with Image(filename=temp_local_filename) as image:
           image.resize(*image.size, blur=16, filter="hamming")
           image.save(filename=temp_local_filename)
   
       print(f"Image {file_name} was blurred.")
   
       # Upload result to a second bucket, to avoid re-triggering the function.
       # You could instead re-upload it to the same bucket + tell your function
       # to ignore files marked as blurred (e.g. those with a "blurred" prefix)
       blur_bucket_name = os.getenv("BLURRED_BUCKET_NAME")
       blur_bucket = storage_client.bucket(blur_bucket_name)
       new_blob = blur_bucket.blob(file_name)
       new_blob.upload_from_filename(temp_local_filename)
       print(f"Blurred image uploaded to: gs://{blur_bucket_name}/{file_name}")
   
       # Delete the temporary file.
       os.remove(temp_local_filename)
   
   

   Vai

   
   // blur blurs the image stored at gs://inputBucket/name and stores the result in
   // gs://outputBucket/name.
   func blur(ctx context.Context, inputBucket, outputBucket, name string) error {
   	inputBlob := storageClient.Bucket(inputBucket).Object(name)
   	r, err := inputBlob.NewReader(ctx)
   	if err != nil {
   		return fmt.Errorf("NewReader: %w", err)
   	}
   
   	outputBlob := storageClient.Bucket(outputBucket).Object(name)
   	w := outputBlob.NewWriter(ctx)
   	defer w.Close()
   
   	// Use - as input and output to use stdin and stdout.
   	cmd := exec.Command("convert", "-", "-blur", "0x8", "-")
   	cmd.Stdin = r
   	cmd.Stdout = w
   
   	if err := cmd.Run(); err != nil {
   		return fmt.Errorf("cmd.Run: %w", err)
   	}
   
   	log.Printf("Blurred image uploaded to gs://%s/%s", outputBlob.BucketName(), outputBlob.ObjectName())
   
   	return nil
   }
   

   Java

     // Blurs the file described by blobInfo using ImageMagick,
     // and uploads it to the blurred bucket.
     public static void blur(BlobInfo blobInfo) throws IOException {
       String bucketName = blobInfo.getBucket();
       String fileName = blobInfo.getName();
       // Download image
       Blob blob = storage.get(BlobId.of(bucketName, fileName));
       Path download = Paths.get("/tmp/", fileName);
       blob.downloadTo(download);
   
       // Construct the command.
       List<String> args = new ArrayList<>();
       args.add("convert");
       args.add(download.toString());
       args.add("-blur");
       args.add("0x8");
       Path upload = Paths.get("/tmp/", "blurred-" + fileName);
       args.add(upload.toString());
       try {
         ProcessBuilder pb = new ProcessBuilder(args);
         Process process = pb.start();
         process.waitFor();
       } catch (Exception e) {
         System.out.println(String.format("Error: %s", e.getMessage()));
       }
   
       // Upload image to blurred bucket.
       BlobId blurredBlobId = BlobId.of(BLURRED_BUCKET_NAME, fileName);
       BlobInfo blurredBlobInfo =
           BlobInfo.newBuilder(blurredBlobId).setContentType(blob.getContentType()).build();
       try {
         byte[] blurredFile = Files.readAllBytes(upload);
         Blob blurredBlob = storage.create(blurredBlobInfo, blurredFile);
         System.out.println(
             String.format("Blurred image uploaded to: gs://%s/%s", BLURRED_BUCKET_NAME, fileName));
       } catch (Exception e) {
         System.out.println(String.format("Error in upload: %s", e.getMessage()));
       }
   
       // Remove images from fileSystem
       Files.delete(download);
       Files.delete(upload);
     }
   }

Integrare l'elaborazione delle immagini nel codice campione Pub/Sub

Per modificare il servizio esistente in modo da incorporare il codice di elaborazione delle immagini:

1. Aggiungi nuove dipendenze per il servizio, tra cui le librerie client Cloud Vision e Cloud Storage:

   Node.js

   npm install --save gm @google-cloud/storage @google-cloud/vision

   Python

   Aggiungi le librerie client necessarie in modo che requirements.txt abbia il seguente aspetto:

   Flask==3.0.3
   google-cloud-storage==2.12.0
   google-cloud-vision==3.4.5
   gunicorn==22.0.0
   Wand==0.6.13
   Werkzeug==3.0.3
   

   Vai

   L'applicazione di esempio Go utilizza i moduli Go, le nuove dipendenze aggiunte sopra nell'istruzione di importazioneimagemagick/imagemagick.go verranno scaricate automaticamente dal prossimo comando che ne ha bisogno.

   Java

   Aggiungi la seguente dipendenza in <dependencyManagement> in pom.xml:

   <dependency>
     <groupId>com.google.cloud</groupId>
     <artifactId>spring-cloud-gcp-dependencies</artifactId>
     <version>4.9.2</version>
     <type>pom</type>
     <scope>import</scope>
   </dependency>
   

   Aggiungi le seguenti dipendenze in <dependencies> in pom.xml:

   <dependency>
     <groupId>com.google.code.gson</groupId>
     <artifactId>gson</artifactId>
     <scope>compile</scope>
   </dependency>
   <dependency>
     <groupId>com.google.cloud</groupId>
     <artifactId>spring-cloud-gcp-starter-vision</artifactId>
   </dependency>
   <dependency>
     <groupId>com.google.cloud</groupId>
     <artifactId>spring-cloud-gcp-starter-storage</artifactId>
   </dependency>
   

2. Aggiungi il pacchetto di sistema ImageMagick al contenitore modificando il Dockerfile sotto l'istruzione FROM. Se utilizzi un Dockerfile "multi-stage", collocalo nella fase finale.

   Debian/Ubuntu

   
   # Install Imagemagick into the container image.
   # For more on system packages review the system packages tutorial.
   # https://cloud.google.com/run/docs/tutorials/system-packages#dockerfile
   RUN set -ex; \
     apt-get -y update; \
     apt-get -y install imagemagick; \
     rm -rf /var/lib/apt/lists/*
   

   Alpine

   
   # Install Imagemagick into the container image.
   # For more on system packages review the system packages tutorial.
   # https://cloud.google.com/run/docs/tutorials/system-packages#dockerfile
   RUN apk add --no-cache imagemagick
   

   Scopri di più sull'utilizzo dei pacchetti di sistema nel tuo servizio Cloud Run nel tutorial sull'utilizzo dei pacchetti di sistema.

3. Sostituisci il codice di gestione dei messaggi Pub/Sub esistente con una chiamata di funzione alla nostra nuova logica di sfocatura.

   Node.js

   Il file app.js definisce l'app Express.js e prepara i messaggi Pub/Sub ricevuti per l'utilizzo. Apporta le seguenti modifiche:

   • Aggiungi il codice per importare il nuovo file image.js
   • Rimuovi il codice "Hello World" esistente dalla route
   • Aggiungi codice per convalidare ulteriormente il messaggio Pub/Sub

   • Aggiungi il codice per chiamare la nuova funzione di elaborazione delle immagini

     Al termine, il codice avrà il seguente aspetto:

   
   const express = require('express');
   const app = express();
   
   // This middleware is available in Express v4.16.0 onwards
   app.use(express.json());
   
   const image = require('./image');
   
   app.post('/', async (req, res) => {
     if (!req.body) {
       const msg = 'no Pub/Sub message received';
       console.error(`error: ${msg}`);
       res.status(400).send(`Bad Request: ${msg}`);
       return;
     }
     if (!req.body.message || !req.body.message.data) {
       const msg = 'invalid Pub/Sub message format';
       console.error(`error: ${msg}`);
       res.status(400).send(`Bad Request: ${msg}`);
       return;
     }
   
     // Decode the Pub/Sub message.
     const pubSubMessage = req.body.message;
     let data;
     try {
       data = Buffer.from(pubSubMessage.data, 'base64').toString().trim();
       data = JSON.parse(data);
     } catch (err) {
       const msg =
         'Invalid Pub/Sub message: data property is not valid base64 encoded JSON';
       console.error(`error: ${msg}: ${err}`);
       res.status(400).send(`Bad Request: ${msg}`);
       return;
     }
   
     // Validate the message is a Cloud Storage event.
     if (!data.name || !data.bucket) {
       const msg =
         'invalid Cloud Storage notification: expected name and bucket properties';
       console.error(`error: ${msg}`);
       res.status(400).send(`Bad Request: ${msg}`);
       return;
     }
   
     try {
       await image.blurOffensiveImages(data);
       res.status(204).send();
     } catch (err) {
       console.error(`error: Blurring image: ${err}`);
       res.status(500).send();
     }
   });

   Python

   Il file main.py definisce l'app Flask e prepara i messaggi Pub/Sub ricevuti per l'utilizzo. Apporta le seguenti modifiche:

   • Aggiungi il codice per importare il nuovo file image.py
   • Rimuovi il codice "Hello World" esistente dalla route
   • Aggiungi codice per convalidare ulteriormente il messaggio Pub/Sub

   • Aggiungi il codice per chiamare la nuova funzione di elaborazione delle immagini

     Al termine, il codice avrà il seguente aspetto:

   import base64
   import json
   import os
   
   from flask import Flask, request
   
   import image
   
   
   app = Flask(__name__)
   
   
   @app.route("/", methods=["POST"])
   def index():
       """Receive and parse Pub/Sub messages containing Cloud Storage event data."""
       envelope = request.get_json()
       if not envelope:
           msg = "no Pub/Sub message received"
           print(f"error: {msg}")
           return f"Bad Request: {msg}", 400
   
       if not isinstance(envelope, dict) or "message" not in envelope:
           msg = "invalid Pub/Sub message format"
           print(f"error: {msg}")
           return f"Bad Request: {msg}", 400
   
       # Decode the Pub/Sub message.
       pubsub_message = envelope["message"]
   
       if isinstance(pubsub_message, dict) and "data" in pubsub_message:
           try:
               data = json.loads(base64.b64decode(pubsub_message["data"]).decode())
   
           except Exception as e:
               msg = (
                   "Invalid Pub/Sub message: "
                   "data property is not valid base64 encoded JSON"
               )
               print(f"error: {e}")
               return f"Bad Request: {msg}", 400
   
           # Validate the message is a Cloud Storage event.
           if not data["name"] or not data["bucket"]:
               msg = (
                   "Invalid Cloud Storage notification: "
                   "expected name and bucket properties"
               )
               print(f"error: {msg}")
               return f"Bad Request: {msg}", 400
   
           try:
               image.blur_offensive_images(data)
               return ("", 204)
   
           except Exception as e:
               print(f"error: {e}")
               return ("", 500)
   
       return ("", 500)
   

   Vai

   Il file main.go definisce il servizio HTTP e prepara i messaggi Pub/Sub ricevuti per l'utilizzo. Apporta le seguenti modifiche:

   • Aggiungi il codice per importare il nuovo file imagemagick.go
   • Rimuovi il codice "Hello World" esistente dall'handler
   • Aggiungi codice per convalidare ulteriormente il messaggio Pub/Sub
   • Aggiungi il codice per chiamare la nuova funzione di elaborazione delle immagini

   
   // Sample image-processing is a Cloud Run service which performs asynchronous processing on images.
   package main
   
   import (
   	"encoding/json"
   	"io/ioutil"
   	"log"
   	"net/http"
   	"os"
   
   	"github.com/GoogleCloudPlatform/golang-samples/run/image-processing/imagemagick"
   )
   
   func main() {
   	http.HandleFunc("/", HelloPubSub)
   	// Determine port for HTTP service.
   	port := os.Getenv("PORT")
   	if port == "" {
   		port = "8080"
   	}
   	// Start HTTP server.
   	log.Printf("Listening on port %s", port)
   	if err := http.ListenAndServe(":"+port, nil); err != nil {
   		log.Fatal(err)
   	}
   }
   
   // PubSubMessage is the payload of a Pub/Sub event.
   // See the documentation for more details:
   // https://cloud.google.com/pubsub/docs/reference/rest/v1/PubsubMessage
   type PubSubMessage struct {
   	Message struct {
   		Data []byte `json:"data,omitempty"`
   		ID   string `json:"id"`
   	} `json:"message"`
   	Subscription string `json:"subscription"`
   }
   
   // HelloPubSub receives and processes a Pub/Sub push message.
   func HelloPubSub(w http.ResponseWriter, r *http.Request) {
   	var m PubSubMessage
   	body, err := ioutil.ReadAll(r.Body)
   	if err != nil {
   		log.Printf("ioutil.ReadAll: %v", err)
   		http.Error(w, "Bad Request", http.StatusBadRequest)
   		return
   	}
   	if err := json.Unmarshal(body, &m); err != nil {
   		log.Printf("json.Unmarshal: %v", err)
   		http.Error(w, "Bad Request", http.StatusBadRequest)
   		return
   	}
   
   	var e imagemagick.GCSEvent
   	if err := json.Unmarshal(m.Message.Data, &e); err != nil {
   		log.Printf("json.Unmarshal: %v", err)
   		http.Error(w, "Bad Request", http.StatusBadRequest)
   		return
   	}
   
   	if e.Name == "" || e.Bucket == "" {
   		log.Printf("invalid GCSEvent: expected name and bucket")
   		http.Error(w, "Bad Request", http.StatusBadRequest)
   		return
   	}
   
   	if err := imagemagick.BlurOffensiveImages(r.Context(), e); err != nil {
   		log.Printf("imagemagick.BlurOffensiveImages: %v", err)
   		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
   	}
   }
   

   Java

   Il file PubSubController.java definisce il controller che gestisce le richieste HTTP e prepara i messaggi Pub/Sub ricevuti per l'utilizzo. Apporta le seguenti modifiche:

   • Aggiungi le nuove importazioni
   • Rimuovi il codice "Hello World" esistente dal controller
   • Aggiungi codice per convalidare ulteriormente il messaggio Pub/Sub
   • Aggiungi il codice per chiamare la nuova funzione di elaborazione delle immagini

   import com.google.gson.JsonObject;
   import com.google.gson.JsonParser;
   import java.util.Base64;
   import org.springframework.http.HttpStatus;
   import org.springframework.http.ResponseEntity;
   import org.springframework.web.bind.annotation.RequestBody;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RequestMethod;
   import org.springframework.web.bind.annotation.RestController;
   
   // PubsubController consumes a Pub/Sub message.
   @RestController
   public class PubSubController {
     @RequestMapping(value = "/", method = RequestMethod.POST)
     public ResponseEntity<String> receiveMessage(@RequestBody Body body) {
       // Get PubSub message from request body.
       Body.Message message = body.getMessage();
       if (message == null) {
         String msg = "Bad Request: invalid Pub/Sub message format";
         System.out.println(msg);
         return new ResponseEntity<>(msg, HttpStatus.BAD_REQUEST);
       }
   
       // Decode the Pub/Sub message.
       String pubSubMessage = message.getData();
       JsonObject data;
       try {
         String decodedMessage = new String(Base64.getDecoder().decode(pubSubMessage));
         data = JsonParser.parseString(decodedMessage).getAsJsonObject();
       } catch (Exception e) {
         String msg = "Error: Invalid Pub/Sub message: data property is not valid base64 encoded JSON";
         System.out.println(msg);
         return new ResponseEntity<>(msg, HttpStatus.BAD_REQUEST);
       }
   
       // Validate the message is a Cloud Storage event.
       if (data.get("name") == null || data.get("bucket") == null) {
         String msg = "Error: Invalid Cloud Storage notification: expected name and bucket properties";
         System.out.println(msg);
         return new ResponseEntity<>(msg, HttpStatus.BAD_REQUEST);
       }
   
       try {
         ImageMagick.blurOffensiveImages(data);
       } catch (Exception e) {
         String msg = String.format("Error: Blurring image: %s", e.getMessage());
         System.out.println(msg);
         return new ResponseEntity<>(msg, HttpStatus.INTERNAL_SERVER_ERROR);
       }
       return new ResponseEntity<>(HttpStatus.OK);
     }
   }

Scarica il campione completo

Per recuperare l'esempio di codice completo di elaborazione delle immagini da utilizzare:

1. Clona il repository dell'app di esempio sulla tua macchina locale:

   Node.js

   git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

   In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

   Python

   git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

   In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

   Vai

   git clone https://github.com/GoogleCloudPlatform/golang-samples.git

   In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

   Java

   git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

   In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

2. Passa alla directory che contiene il codice campione di Cloud Run:

   Node.js

   cd nodejs-docs-samples/run/image-processing/

   Python

   cd python-docs-samples/run/image-processing/

   Vai

   cd golang-samples/run/image-processing/

   Java

   cd java-docs-samples/run/image-processing/

Spedire il codice

Il codice di spedizione è composto da tre passaggi: creazione di un'immagine container con Cloud Build, caricamento dell'immagine container in Artifact Registry ed esecuzione del deployment dell'immagine container in Cloud Run.

Per spedire il codice:

1. Crea il contenitore e pubblicalo su Artifact Registry:

   Node.js

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
   /REPOSITORY/pubsub

   dove pubsub è il nome del servizio.

   Sostituisci:

   • PROJECT_ID con il tuo ID progetto Google Cloud
   • REPOSITORY con il nome del repository Artifact Registry.
   • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

   In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

   Python

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
   /REPOSITORY/pubsub

   dove pubsub è il nome del servizio.

   Sostituisci:

   • PROJECT_ID con il tuo ID progetto Google Cloud
   • REPOSITORY con il nome del repository Artifact Registry.
   • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

   In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

   Vai

   gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
   /REPOSITORY/pubsub

   dove pubsub è il nome del servizio.

   Sostituisci:

   • PROJECT_ID con il tuo ID progetto Google Cloud
   • REPOSITORY con il nome del repository Artifact Registry.
   • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

   In caso di esito positivo, viene visualizzato un messaggio di successo contenente l'ID, l'ora di creazione e il nome dell'immagine. L'immagine è archiviata in Artifact Registry e, se necessario, può essere riutilizzata.

   Java

   Questo esempio utilizza Jib per creare immagini Docker utilizzando strumenti Java comuni. Jib ottimizza le build dei container senza dover disporre di un Dockerfile o di Docker. Scopri di più sulla creazione di container Java con Jib.

   1. Utilizzando il Dockerfile, configura e crea un'immagine di base con i pacchetti di sistema installati per sostituire l'immagine di base predefinita di Jib:

      # Use eclipse-temurin for base image.
      # It's important to use JDK 8u191 or above that has container support enabled.
      # https://hub.docker.com/_/eclipse-temurin/
      # https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
      FROM eclipse-temurin:17.0.12_7-jre
      
      # Install Imagemagick into the container image.
      # For more on system packages review the system packages tutorial.
      # https://cloud.google.com/run/docs/tutorials/system-packages#dockerfile
      RUN set -ex; \
        apt-get -y update; \
        apt-get -y install imagemagick; \
        rm -rf /var/lib/apt/lists/*

      gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
      /REPOSITORY/imagemagick

      Sostituisci:

      • PROJECT_ID con il tuo ID progetto Google Cloud
      • REPOSITORY con il nome del repository Artifact Registry.
      • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

   2. Utilizza l'assistente per le credenziali gcloud per autorizzare Docker a eseguire il push nel tuo Artifact Registry.

      gcloud auth configure-docker

   3. Crea il container finale con Jib e pubblicalo su Artifact Registry:

      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>3.4.0</version>
        <configuration>
          <from>
            <image>gcr.io/PROJECT_ID/imagemagick</image>
          </from>
          <to>
            <image>gcr.io/PROJECT_ID/pubsub</image>
          </to>
        </configuration>
      </plugin>
      

      mvn compile jib:build \
        -Dimage=REGION-docker.pkg.dev/PROJECT_ID
      /REPOSITORY/pubsub \
        -Djib.from.image=REGION-docker.pkg.dev/PROJECT_ID
      /REPOSITORY/imagemagick

      Sostituisci:

      • PROJECT_ID con il tuo ID progetto Google Cloud
      • REPOSITORY con il nome del repository Artifact Registry.
      • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.

2. Esegui il seguente comando per eseguire il deployment del servizio utilizzando lo stesso nome del servizio che hai utilizzato nel tutorial sull'utilizzo di Pub/Sub:

   Node.js

   gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID
   /REPOSITORY/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME --no-allow-unauthenticated

   Python

   gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID
   /REPOSITORY/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME --no-allow-unauthenticated

   Vai

   gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID
   /REPOSITORY/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME --no-allow-unauthenticated

   Java

   gcloud run deploy pubsub-tutorial --image REGION-docker.pkg.dev/PROJECT_ID
   /REPOSITORY/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME --memory 512M --no-allow-unauthenticated

   dove pubsub è il nome del contenitore e pubsub-tutorial è il nome del servizio. Tieni presente che l'immagine del contenitore viene dispiattata nel servizio e nella regione (Cloud Run) che hai configurato in precedenza in Configurazione dei valori predefiniti di gcloud. Sostituisci:

   • PROJECT_ID con il tuo ID progetto Google Cloud
   • REPOSITORY con il nome del repository Artifact Registry.
   • REGION con la regione Google Cloud da utilizzare per il repository Artifact Registry.
   • BLURRED_BUCKET_NAME con il tuo bucket Cloud Storage creato in precedenza per ricevere le immagini sfocate per impostare la variabile di ambiente.

   Il flag --no-allow-unauthenticated limita l'accesso non autenticato al servizio. Mantenendo il servizio privato, puoi fare affidamento sull'integrazione automatica di Pub/Sub di Cloud Run per autenticare le richieste. Per maggiori dettagli sulla configurazione, consulta Integrazione con Pub/Sub. Per ulteriori dettagli sull'autenticazione basata su IAM, consulta la pagina Gestire l'accesso.

   Attendi il completamento del deployment, che potrebbe richiedere circa mezzo minuto. Se l'operazione riesce, la riga di comando visualizza l'URL del servizio.

Attivare le notifiche di Cloud Storage

Configura Cloud Storage in modo che pubblichi un messaggio in un argomento Pub/Sub ogni volta che un file (chiamato oggetto) viene caricato o modificato. Invia la notifica all'argomento creato in precedenza in modo che ogni nuovo caricamento di file richiami il servizio.

gcloud

gcloud storage service-agent --project=PROJECT_ID
gcloud storage buckets notifications create gs://INPUT_BUCKET_NAME --topic=myRunTopic --payload-format=json

myRunTopic è l'argomento che hai creato nel tutorial precedente.

Sostituisci INPUT_BUCKET_NAME con il nome che hai utilizzato per creare i bucket.

Per maggiori dettagli sulle notifiche dei bucket di archiviazione, consulta notifiche relative alle modifiche degli oggetti.

Terraform

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

Per attivare le notifiche, l'account di servizio Cloud Storage deve essere unico per il progetto e disporre dell'autorizzazione IAMpubsub.publisher per l'argomento Pub/Sub. Per concedere questa autorizzazione e creare una notifica Cloud Storage, aggiungi quanto segue al file main.tf esistente:

data "google_storage_project_service_account" "gcs_account" {}

resource "google_pubsub_topic_iam_binding" "binding" {
  topic   = google_pubsub_topic.default.name
  role    = "roles/pubsub.publisher"
  members = ["serviceAccount:${data.google_storage_project_service_account.gcs_account.email_address}"]
}

resource "google_storage_notification" "notification" {
  bucket         = google_storage_bucket.imageproc_input.name
  payload_format = "JSON_API_V1"
  topic          = google_pubsub_topic.default.id
  depends_on     = [google_pubsub_topic_iam_binding.binding]
}

Fai una prova

1. Caricare un'immagine offensiva, ad esempio questa di uno zombie cannibale:

   curl -o zombie.jpg https://cdn.pixabay.com/photo/2015/09/21/14/24/zombie-949916_960_720.jpg
   gcloud storage cp zombie.jpg gs://INPUT_BUCKET_NAME

   dove INPUT_BUCKET_NAME è il bucket Cloud Storage che hai creato in precedenza per il caricamento delle immagini.

2. Vai ai log del servizio:

   1. Vai alla pagina Cloud Run nella console Google Cloud
   2. Fai clic sul servizio pubsub-tutorial.
   3. Seleziona la scheda Log. La visualizzazione dei log potrebbe richiedere alcuni istanti. Se non li vedi immediatamente, ricontrolla dopo qualche istante.

3. Cerca il messaggio Blurred image: zombie.png.

4. Puoi visualizzare le immagini sfocate nel BLURRED_BUCKET_NAMEbucket Cloud Storage che hai creato in precedenza: individua il bucket nella pagina Cloud Storage della console Google Cloud

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, eliminalo. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

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

   Go to Manage resources

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

Eliminazione delle risorse dei tutorial

1. Elimina il servizio Cloud Run di cui hai eseguito il deployment in questo tutorial:

   gcloud run services delete SERVICE-NAME

   dove SERVICE-NAME è il nome del servizio scelto.

   Puoi anche eliminare i servizi Cloud Run dalla console Google Cloud.

2. Rimuovi la configurazione della regione predefinita di gcloud che hai aggiunto durante la configurazione del tutorial:

    gcloud config unset run/region
   

3. Rimuovi la configurazione del progetto:

    gcloud config unset project
   

4. Elimina le altre risorse Google Cloud create in questo tutorial:

   • Elimina l'argomento Pub/Sub myRunTopic
   • Elimina l'abbonamento Pub/Sub myRunSubscription
   • Elimina l'immagine container da Artifact Registry.
   • Elimina l'account di servizio invocante cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com
   • Elimina i bucket Cloud Storage creati per i segnaposto INPUT_BUCKET_NAME e BLURRED_BUCKET_NAME

Passaggi successivi

• Scopri di più sulla persistenza dei dati con Cloud Run utilizzando Cloud Storage.
• Scopri come utilizzare l'API Cloud Vision per rilevare elementi diversi dai contenuti espliciti.
• Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Consulta il nostro Cloud Architecture Center.