Tutorial per elaborare le immagini da Cloud Storage

Questo tutorial dimostra l'utilizzo di Cloud Run, dell'API Cloud Vision e ImageMagick per rilevare e sfocare le immagini offensive caricate in un bucket Cloud Storage. Questo Il tutorial si basa sul tutorial Usa Pub/Sub con Cloud Run.

Questo tutorial illustra come modificare un'app di esempio esistente. Puoi anche scarica l'anteprima completata se vuoi.

Obiettivi

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

Costi

In questo documento vengono utilizzati 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.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  6. Abilita le API Artifact Registry, Cloud Build, Pub/Sub, Cloud Run, Cloud Storage and Cloud Vision.

    Abilita le API

  7. Installa e inizializza gcloud CLI.
  8. Aggiorna i componenti: 
    gcloud components update
  9. configura un argomento Pub/Sub, una sottoscrizione push sicura e per gestire i messaggi seguendo le istruzioni riportate nel servizio Cloud Run. Usa il tutorial su Pub/Sub

Ruoli obbligatori

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

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

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

Configurazione dei valori predefiniti di gcloud

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

  1. Imposta il progetto predefinito:

    gcloud config set project PROJECT_ID

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

  2. Configura gcloud per la regione scelta:

    gcloud config set run/region REGION

    Sostituisci REGION con il Cloud Run supportato regione di tua scelta.

Località Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura dei tuoi servizi Cloud Run si trova in una regione specifica gestiti da Google affinché siano disponibili in modo ridondante tutte le zone all'interno di quella regione.

Soddisfare i requisiti di latenza, disponibilità o durabilità è fondamentale i fattori necessari per selezionare la regione in cui vengono eseguiti i servizi Cloud Run. Generalmente puoi selezionare la regione più vicina ai tuoi utenti, ma devi considerare la località dell'altro account Google Cloud prodotti utilizzati dal tuo servizio Cloud Run. L'utilizzo combinato dei prodotti Google Cloud in più località può influire nonché la latenza del tuo servizio.

Cloud Run è disponibile nelle regioni seguenti:

Soggetto ai prezzi di Livello 1

Soggetto ai prezzi di Livello 2

Se hai già creato un servizio Cloud Run, puoi visualizzare nella dashboard di Cloud Run all'interno Console Google Cloud.

Comprensione della 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 esegue il push del messaggio in Cloud Run completamente gestito di Google Cloud.
  4. Il servizio Cloud Run recupera il file immagine a cui viene fatto riferimento nell' un 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 su un'altra per l'uso del bucket Cloud Storage.

L'uso successivo dell'immagine sfocata viene lasciato come esercizio per il lettore.

Crea un repository standard Artifact Registry

Crea un repository standard Artifact Registry per archiviare la tua 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.

Configura i bucket Cloud Storage

gcloud

  1. Creare un bucket Cloud Storage per caricare le immagini, in cui INPUT_BUCKET_NAME è un nome di bucket univoco a livello globale:

    gsutil mb gs://INPUT_BUCKET_NAME

    Il servizio Cloud Run legge solo da questo bucket.

  2. Creare un secondo bucket Cloud Storage per ricevere immagini sfocate, in cui BLURRED_BUCKET_NAME è un nome di bucket univoco a livello globale:

    gsutil mb gs://BLURRED_BUCKET_NAME

    Il servizio Cloud Run carica immagini sfocate in questo bucket. Utilizzo 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 Compute Engine.

    Se, invece, utilizzi una account di servizio gestito dall'utente, verifica di aver assegnato il necessario i ruoli IAM per dispone dell'autorizzazione storage.objects.get per leggere da Autorizzazione INPUT_BUCKET_NAME e storage.objects.create per caricamento in 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 caricare le immagini originali e un'altra per il servizio Cloud Run per caricare immagini sfocate.

Per creare entrambi i bucket Cloud Storage con nomi globalmente univoci, 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 Servizio predefinito Compute Engine Google Cloud.

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

Nei passaggi seguenti, creerai ed eseguirai il deployment di un servizio che elabora notifica relativa ai caricamenti di file su INPUT_BUCKET_NAME. Attivi la consegna delle notifiche dopo il deployment e il test del servizio, per evitare al nuovo servizio.

Modifica il codice campione del tutorial su Pub/Sub

Questo tutorial si basa sul codice assemblato nel Usa il tutorial su Pub/Sub. Se non hai ancora completato il tutorial, fallo ora, saltando la pulizia passaggi, 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 in termini di leggibilità e facilità di test. Per aggiungere il codice di elaborazione delle immagini:

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

  2. Aggiungi il codice per importare le dipendenze di elaborazione delle immagini, incluse le librerie si integrano 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 copialo nel seguenti: 
    
// 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 in l'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 nell'elaborazione delle immagini.

    L'evento contiene dati sull'immagine caricata in origine. Questo codice determina se l'immagine deve essere sfocata controllando i risultati di una 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 di riferimento dal bucket di input Cloud Storage creata sopra, usa ImageMagick per trasformare l'immagine con un effetto sfocato e per caricare 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);
  }
}

Integra 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 Cloud Vision e Librerie client di 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 un aspetto simile a questo: 
    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'importazione imagemagick/imagemagick.go verrà scaricata automaticamente con il comando successivo che le richiede.

    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 container modificando il valore Dockerfile sotto l'istruzione FROM. Se utilizzi un modello "multifase" Dockerfile 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 servizio Cloud Run nel tutorial sull'utilizzo dei pacchetti di sistema.

  3. Sostituisci il codice per la 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 file "Hello World" esistente il codice fornito
    • Aggiungi il codice per convalidare ulteriormente il messaggio Pub/Sub

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

      Al termine, il codice sarà simile al seguente:

    
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 file "Hello World" esistente il codice fornito
    • Aggiungi il codice per convalidare ulteriormente il messaggio Pub/Sub

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

      Al termine, il codice sarà simile al seguente:

    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 per l'utilizzo i messaggi Pub/Sub ricevuti. Apporta le seguenti modifiche:

    • Aggiungi il codice per importare il nuovo file imagemagick.go
    • Rimuovi il file "Hello World" esistente il codice generato dal gestore
    • Aggiungi il 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 file "Hello World" esistente il codice del controller
    • Aggiungi il 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 l'esempio completo

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

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

    Node.js 

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

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

    Python 

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

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

    Vai 

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

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

    Java 

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

    In alternativa, puoi scarica 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/

Spedisci il codice

Il codice di spedizione prevede tre passaggi: la creazione di un'immagine container con Cloud Build, caricando l'immagine container in Artifact Registry e il deployment dell'immagine container in Cloud Run.

Per spedire il codice:

  1. Crea il tuo container e pubblicalo su Artifact Registry:

    Node.js 

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

    Dove pubsub è il nome del tuo 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.

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se necessario.

    Python 

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

    Dove pubsub è il nome del tuo 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.

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se necessario.

    Vai 

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

    Dove pubsub è il nome del tuo 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.

    Se l'operazione riesce, verrà visualizzato il messaggio SUCCESS contenente l'ID, la creazione ora e nome dell'immagine. L'immagine è archiviata in Artifact Registry e può essere se necessario.

    Java

    Questo esempio utilizza Jib per creare utilizzando strumenti Java comuni. Jib ottimizza le build di container senza la necessità di un Dockerfile o di avere Docker installato. Scopri di più sulla creazione di container Java con Jib.

    1. Utilizzando il Dockerfile, configura e crea un'immagine di base con il sistema pacchetti 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.11_9-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 gcloud credentials helper per autorizzare Docker a eseguire il push in 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 questo comando per eseguire il deployment del tuo servizio, utilizzando lo stesso nome di servizio che hai utilizzato nel tutorial sull'uso 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 si trova pubsub il nome del container, mentre pubsub-tutorial è il nome del servizio. Nota che viene eseguito il deployment dell'immagine container nel servizio regione (Cloud Run) configurata in precedenza Configurare i 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 creati in precedenza per ricevere immagini sfocate e impostare la variabile di ambiente.

    Il flag --no-allow-unauthenticated limita l'accesso non autenticato al completamente gestito di Google Cloud. Mantenendo privato il servizio puoi fare affidamento Integrazione automatica di Pub/Sub di Cloud Run per l'autenticazione richieste. Vedi Integrazione con Pub/Sub per e ulteriori dettagli sulla configurazione. Consulta Gestire l'accesso per ulteriori dettagli su Autenticazione basata su IAM.

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

Attiva le notifiche da Cloud Storage

Configura Cloud Storage per pubblicare un messaggio in un argomento Pub/Sub ogni volta che un file (noto come oggetto) viene caricato o modificato. Invia il all'argomento creato in precedenza, in modo che qualsiasi nuovo caricamento di file richiami il servizio.

gcloud 

gsutil kms serviceaccount -p PROJECT_ID
gsutil notification create -t myRunTopic -f json gs://INPUT_BUCKET_NAME

Il comando gsutil è installato come parte di Google Cloud CLI. myRunTopic è il creato nel tutorial precedente.

Sostituisci INPUT_BUCKET_NAME con il nome che hai utilizzato quando hai creato i bucket.

Per maggiori dettagli sulle notifiche dei bucket di archiviazione, leggi notifiche di modifica degli oggetti.

Terraform

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

Per abilitare le notifiche, l'account di servizio Cloud Storage univoco del progetto deve esistere e avere l'autorizzazione IAM pubsub.publisher nell'argomento Pub/Sub. Per concedere l'autorizzazione e crea una notifica di Cloud Storage, aggiungi quanto segue il tuo 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. Carica un'immagine offensiva, come questa immagine di uno zombi che mangia carne:

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

    dove INPUT_BUCKET_NAME è il bucket Cloud Storage che hai creato per caricare le immagini.

  2. Accedi 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 di Blurred image: zombie.png.

  4. Puoi visualizzare le immagini sfocate in Cloud Storage BLURRED_BUCKET_NAME che hai creato in precedenza: individua il bucket Pagina Cloud Storage nella console Google Cloud

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi mantenerlo senza l'aggiunta delle modifiche In questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione creato per il tutorial.

Per eliminare il progetto:

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione delle risorse del tutorial in corso...

  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 che hai scelto.

    I servizi Cloud Run possono essere eliminati anche Console Google Cloud.

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

     gcloud config unset run/region

  3. Rimuovi la configurazione del progetto:

     gcloud config unset project

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

Passaggi successivi

  • Scopri di più su come conservare i dati in modo permanente con Cloud Run utilizzando Cloud Storage.
  • Scopri come utilizzare l'API Cloud Vision per rilevare elementi oltre ai contenuti espliciti.
  • Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Dai un'occhiata al nostro Centro architetture cloud.