Procesar imágenes en forma asíncrona

En este instructivo, se demuestra cómo usar Cloud Run for Anthos, ImageMagick y la API de Cloud Vision para detectar y difuminar imágenes ofensivas subidas a un bucket de Cloud Storage. Este instructivo se basa en el instructivo Usa Pub/Sub con Cloud Run for Anthos.

En este instructivo, se explica cómo modificar una app de muestra existente. También puedes descargar la muestra completa si lo deseas.

Objetivos

• Escribir, compilar e implementar un servicio de procesamiento de datos asíncrono en Cloud Run for Anthos
• Invocar el servicio mediante la carga de un archivo a Cloud Storage y la creación de un mensaje de Pub/Sub
• Usar la API de Cloud Vision para detectar contenido violento o destinado a adultos
• Usar ImageMagick para difuminar imágenes ofensivas
• Probar el servicio mediante la carga de una imagen de un zombi que come carne humana

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

• Cloud Build
• Container Registry
• Pub/Sub
• Cloud Storage
• API de Cloud Vision
• /anthos/run/archive/

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

5. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

6. Habilita las API de Cloud Run for Anthos and Cloud Vision.

   Habilita las API

7. Instala e inicializa la CLI de gcloud.
8. Instala el componente kubectl:

   gcloud components install kubectl

9. Actualiza los componentes, como se indica a continuación:

   gcloud components update

10. Mediante Cloud Run for Anthos, crea un clúster nuevo según las instrucciones de Configura Cloud Run for Anthos.
11. Configura un tema de Pub/Sub, una suscripción de envío segura y un servicio inicial de Cloud Run for Anthos para controlar los mensajes de acuerdo con el instructivo Usa Pub/Sub con Cloud Run for Anthos.

Configura los valores predeterminados de gcloud

Si deseas configurar gcloud con la configuración predeterminada para el servicio de Cloud Run for Anthos, haz lo siguiente:

1. Configura el proyecto predeterminado:

   gcloud config set project PROJECT_ID

   Reemplaza PROJECT_ID por el nombre del proyecto que creaste para este instructivo.

2. Configura gcloud para tu clúster:

   gcloud config set run/platform gke
   gcloud config set run/cluster CLUSTER-NAME
   gcloud config set run/cluster_location REGION

   Reemplaza lo siguiente:

   • CLUSTER-NAME por el nombre que usaste para el clúster
   • REGION por la ubicación de clúster compatible que elijas

Comprende la secuencia de operaciones

El flujo de datos en este instructivo sigue estos pasos:

1. Un usuario sube una imagen a un bucket de Cloud Storage.
2. Cloud Storage publica un mensaje sobre el archivo nuevo en Pub/Sub.
3. Pub/Sub envía el mensaje al servicio de Cloud Run for Anthos.
4. El servicio de Cloud Run for Anthos recupera el archivo de imagen al que se hace referencia en el mensaje de Pub/Sub.
5. El servicio de Cloud Run for Anthos usa la API de Cloud Vision para analizar la imagen.
6. Si se detecta contenido violento o para adultos, el servicio de Cloud Run for Anthos usa ImageMagick para difuminar la imagen.
7. El servicio de Cloud Run for Anthos sube la imagen difuminada a otro bucket de Cloud Storage para usarla.

El uso posterior de la imagen difuminada se deja como un ejercicio para el lector.

Configura depósitos de Cloud Storage

1. Crea un bucket de Cloud Storage para subir imágenes, en el que INPUT_BUCKET_NAME es un nombre de bucket único a nivel global:

   gsutil mb gs://INPUT_BUCKET_NAME

   El servicio de Cloud Run for Anthos solo lee desde este bucket.

2. Crea un segundo bucket de Cloud Storage para recibir imágenes difuminadas, en el que BLURRED_BUCKET_NAME es un nombre de bucket único a nivel global:

   gsutil mb gs://BLURRED_BUCKET_NAME

   El servicio de Cloud Run for Anthos sube imágenes difuminadas a este bucket. Si usas un bucket diferente, evitarás que las imágenes procesadas vuelvan a activar el servicio.

Mediante los siguientes pasos, crearás y, luego, implementarás un servicio que procesa la notificación de las cargas de archivos a INPUT_BUCKET_NAME. Debes activar la entrega de notificaciones después de implementar y probar el servicio para evitar la invocación prematura del servicio nuevo.

Modifica el código de muestra del instructivo de Pub/Sub

Este instructivo se basa en el código ensamblado en el instructivo Usa Pub/Sub. Si aún no completaste ese instructivo, hazlo ahora. Omite los pasos de limpieza y, luego, regresa para agregar el comportamiento del procesamiento de imágenes.

Agrega el código de procesamiento de imágenes

El código de procesamiento de imágenes está separado de la administración de solicitudes para facilitar la lectura y la prueba. Para agregar código de procesamiento de imágenes, sigue estos pasos:

1. Ve al directorio en el que se encuentra el código de muestra del instructivo de Pub/Sub.

2. Agrega el código a fin de importar las dependencias de procesamiento de imágenes, incluidas las bibliotecas para integrar en los servicios de Google Cloud, ImageMagick y el sistema de archivos.

   Node.js

   Abre un archivo image.js nuevo en el editor y copia lo que se muestra a continuación:

   run/image-processing/image.js

   Ver en GitHub Comentarios

   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

   Abre un archivo image.py nuevo en el editor y copia lo que se muestra a continuación:

   run/image-processing/image.py

   Ver en GitHub Comentarios

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

   Go

   Abre un archivo imagemagick/imagemagick.go nuevo en el editor y copia lo que se muestra a continuación:

   run/image-processing/imagemagick/imagemagick.go

   Ver en GitHub Comentarios

   
   // 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"
   	visionpb "google.golang.org/genproto/googleapis/cloud/vision/v1"
   )
   
   // 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

   Abre un archivo src/main/java/com/example/cloudrun/ImageMagick.java nuevo en el editor y copia lo que se muestra a continuación:

   run/image-processing/src/main/java/com/example/cloudrun/ImageMagick.java

   Ver en GitHubComentarios

   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. Agrega el código a fin de recibir un mensaje de Pub/Sub como objeto de evento y controla el procesamiento de imágenes.

   El evento contiene datos sobre la imagen que se subió originalmente. Este código verifica los resultados de un análisis de Cloud Vision de contenido violento o para adultos y determina si la imagen debe difuminarse.

   Node.js

   run/image-processing/image.js

   Ver en GitHub Comentarios

   // 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

   run/image-processing/image.py

   Ver en GitHub Comentarios

   # Blurs uploaded images that are flagged as Adult or Violence.
   def blur_offensive_images(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.")
   
   

   Go

   run/image-processing/imagemagick/imagemagick.go

   Ver en GitHub Comentarios

   
   // 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: %v", 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

   run/image-processing/src/main/java/com/example/cloudrun/ImageMagick.java

   Ver en GitHub Comentarios

   // 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 la imagen a la que se hace referencia desde el bucket de entrada de Cloud Storage creado antes, usa ImageMagick para transformar la imagen con un efecto de difuminado y sube el resultado al bucket de salida.

   Node.js

   run/image-processing/image.js

   Ver en GitHub Comentarios

   // 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

   run/image-processing/image.py

   Ver en GitHub Comentarios

   # Blurs the given file using ImageMagick.
   def __blur_image(current_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)
   
   

   Go

   run/image-processing/imagemagick/imagemagick.go

   Ver en GitHub Comentarios

   
   // 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: %v", 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: %v", err)
   	}
   
   	log.Printf("Blurred image uploaded to gs://%s/%s", outputBlob.BucketName(), outputBlob.ObjectName())
   
   	return nil
   }
   

   Java

   run/image-processing/src/main/java/com/example/cloudrun/ImageMagick.java

   Ver en GitHub Comentarios

     // 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<String>();
       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 el procesamiento de imágenes en el código de muestra de Pub/Sub

Para modificar el servicio existente a fin de incorporar el código de procesamiento de imágenes, sigue estos pasos:

1. Agrega dependencias nuevas para el servicio, incluidas las bibliotecas cliente de Cloud Vision y Cloud Storage:

   Node.js

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

   Python

   Agrega las bibliotecas cliente necesarias para que requirements.txt se vea similar esto:

   run/image-processing/requirements.txt

   Ver en GitHub Comentarios

   Flask==2.1.0
   pytest==7.0.1; python_version > "3.0"
   # pin pytest to 4.6.11 for Python2.
   pytest==7.0.1; python_version < "3.0"
   gunicorn==20.1.0
   google-cloud-vision==2.7.3
   google-cloud-storage==2.1.0
   Wand==0.6.7
   

   Go

   La aplicación de muestra de Go usa módulos de Go; el siguiente comando que necesite las dependencias nuevas agregadas antes en la instrucción de importación imagemagick/imagemagick.go, las descargará de forma automática.

   Java

   Agrega la siguiente dependencia en <dependencyManagement> en el pom.xml:

   run/image-processing/pom.xml

   Ver en GitHub Comentarios

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

   Agrega las siguientes dependencias en <dependencies> en el pom.xml:

   run/image-processing/pom.xml

   Ver en GitHub Comentarios

   <dependency>
     <groupId>com.google.code.gson</groupId>
     <artifactId>gson</artifactId>
     <version>2.8.9</version>
     <scope>compile</scope>
   </dependency>
   <dependency>
     <groupId>org.json</groupId>
     <artifactId>json</artifactId>
     <version>20220320</version>
   </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>
   <dependency>
     <groupId>commons-io</groupId>
     <artifactId>commons-io</artifactId>
     <version>2.11.0</version>
   </dependency>
   

2. Puedes agregar el paquete del sistema de ImageMagick al contenedor mediante la modificación de Dockerfile en la instrucción FROM. Si usas un Dockerfile de “etapas múltiples”, colócalo en la etapa final.

   Debian y 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
   

   Obtén más información sobre cómo trabajar con paquetes del sistema en el servicio de Cloud Run for Anthos en el Instructivo sobre cómo usar paquetes del sistema.

3. Reemplaza el código de administración de mensajes de Pub/Sub existente con una llamada a función a nuestra lógica de difuminado nueva.

   Node.js

   El archivo app.js define la app de Express.js y prepara los mensajes de Pub/Sub recibidos para su uso. Realiza los siguientes cambios:

   • Agrega el código para importar el archivo image.js nuevo.
   • Quita el código “Hello World” existente de la ruta.
   • Agrega el código para validar el mensaje de Pub/Sub.

   • Agrega el código para llamar a la función de procesamiento de imágenes nueva.

     Cuando termines, el código se verá de la siguiente manera:

   run/image-processing/app.js

   Ver en GitHub Comentarios

   
   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

   El archivo main.py define la app de Flask y prepara los mensajes de Pub/Sub recibidos para su uso. Realiza los siguientes cambios:

   • Agrega el código para importar el archivo image.py nuevo.
   • Quita el código “Hello World” existente de la ruta.
   • Agrega el código para validar el mensaje de Pub/Sub.

   • Agrega el código para llamar a la función de procesamiento de imágenes nueva.

     Cuando termines, el código se verá de la siguiente manera:

   run/image-processing/main.py

   Ver en GitHub Comentarios

   import base64
   import json
   import os
   
   from flask import Flask, request
   
   import image
   
   app = Flask(__name__)
   
   @app.route("/", methods=["POST"])
   def index():
       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)

   Go

   El archivo main.go define el servicio HTTP y prepara los mensajes de Pub/Sub recibidos para su uso. Realiza los siguientes cambios:

   • Agrega el código para importar el archivo imagemagick.go nuevo.
   • Quita el código “Hello World” existente del controlador.
   • Agrega el código para validar el mensaje de Pub/Sub.
   • Agrega el código para llamar a la función de procesamiento de imágenes nueva.

   run/image-processing/main.go

   Ver en GitHub Comentarios

   
   // 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

   El archivo PubSubController.java define el controlador que administra las solicitudes HTTP y prepara los mensajes de Pub/Sub recibidos para su uso. Realiza los siguientes cambios:

   • Agrega las importaciones nuevas.
   • Quita el código “Hello World” existente del controlador.
   • Agrega el código para validar el mensaje de Pub/Sub.
   • Agrega el código para llamar a la función de procesamiento de imágenes nueva.

   run/image-processing/src/main/java/com/example/cloudrun/PubSubController.java

   Ver en GitHub Comentarios

   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);
     }
   }

Descarga la muestra completa

Si deseas recuperar la muestra de código del procesamiento de imágenes completa para usar, sigue estos pasos:

1. Clona el repositorio de la app de muestra en tu máquina local:

   Node.js

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

   De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.

   Python

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

   De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.

   Go

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

   De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.

   Java

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

   De manera opcional, puedes descargar la muestra como un archivo ZIP y extraerla.

2. Cambia al directorio que contiene el código de muestra de Cloud Run for Anthos:

   Node.js

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

   Python

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

   Go

   cd golang-samples/run/image-processing/

   Java

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

Envía el código

El código de envío consta de tres pasos: compilar una imagen de contenedor con Cloud Build, subir la imagen de contenedor a Container Registry y, luego, implementar la imagen de contenedor en Cloud Run for Anthos.

Para enviar el código, haz lo siguiente:

1. Compila el contenedor y publica en Container Registry:

   Node.js

   gcloud builds submit --tag gcr.io/PROJECT_ID/pubsub

   En el ejemplo anterior, PROJECT_ID es el ID de tu proyecto de GCP y pubsub es el nombre que deseas darle al servicio.

   Si la operación se completa de manera correcta, verás un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Container Registry y puede volver a usarse si así se desea.

   Python

   gcloud builds submit --tag gcr.io/PROJECT_ID/pubsub

   En el ejemplo anterior, PROJECT_ID es el ID de tu proyecto de GCP y pubsub es el nombre que deseas darle al servicio.

   Si la operación se completa de manera correcta, verás un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Container Registry y puede volver a usarse si así se desea.

   Go

   gcloud builds submit --tag gcr.io/PROJECT_ID/pubsub

   En el ejemplo anterior, PROJECT_ID es el ID de tu proyecto de GCP y pubsub es el nombre que deseas darle al servicio.

   Si la operación se completa de manera correcta, verás un mensaje de ÉXITO con el ID, la hora de creación y el nombre de la imagen. La imagen se almacena en Container Registry y puede volver a usarse si así se desea.

   Java

   En esta muestra, se usa Jib para compilar imágenes de Docker mediante herramientas de Java comunes. Jib optimiza las compilaciones de contenedores sin la necesidad de tener un Dockerfile o tener Docker instalado. Obtén más información sobre la compilación de contenedores de Java con Jib.

   1. Mediante Dockerfile, configura y compila una imagen base con los paquetes de sistema instalados a fin de anular la imagen base predeterminada de Jib:

      run/image-processing/Dockerfile

      Ver en GitHub Comentarios

      # 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-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 gcr.io/PROJECT_ID/imagemagick

      En el ejemplo anterior, PROJECT_ID es el ID de tu proyecto de GCP.

   2. Compila el contenedor final con Jib y publica en Container Registry:

      run/image-processing/pom.xml

      Ver en GitHub Comentarios

      <plugin>
        <groupId>com.google.cloud.tools</groupId>
        <artifactId>jib-maven-plugin</artifactId>
        <version>3.2.1</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=gcr.io/PROJECT_ID/pubsub \
        -Djib.from.image=gcr.io/PROJECT_ID/imagemagick

      En el ejemplo anterior, PROJECT_ID es el ID de tu proyecto de GCP.

2. Ejecuta el siguiente comando para implementar tu servicio con el mismo nombre de servicio que usaste en el instructivo de Pub/Sub:

   Node.js

   gcloud run deploy pubsub-tutorial --image gcr.io/PROJECT_ID/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME

   Python

   gcloud run deploy pubsub-tutorial --image gcr.io/PROJECT_ID/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME

   Go

   gcloud run deploy pubsub-tutorial --image gcr.io/PROJECT_ID/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME

   Java

   gcloud run deploy pubsub-tutorial --image gcr.io/PROJECT_ID/pubsub --set-env-vars=BLURRED_BUCKET_NAME=BLURRED_BUCKET_NAME --memory 512M

   Reemplaza PROJECT_ID por el ID del proyecto de GCP. pubsub es el nombre del contenedor y pubsub-tutorial es el nombre del servicio. Ten en cuenta que la imagen de contenedor se implementa en el servicio y en el clúster que configuraste antes en Configura los valores predeterminados de gcloud.

   Reemplaza BLURRED_BUCKET_NAME por el depósito de Cloud Storage que creaste antes para recibir imágenes difuminadas a fin de configurar la variable de entorno.

   Espera hasta que finalice la implementación; esto puede tomar alrededor de medio minuto. Si la operación se completa de forma correcta, la línea de comandos mostrará la URL de servicio.

Activa las notificaciones desde Cloud Storage

Configura Cloud Storage para publicar un mensaje en un tema de Pub/Sub cada vez que se suba o se cambie un archivo (conocido como objeto). Envía la notificación al tema creado antes de modo que cualquier carga de archivo nuevo invoque el servicio.

gsutil notification create -t myRunTopic -f json gs://INPUT_BUCKET_NAME

El comando de gsutil se instala como parte de Google Cloud CLI. myRunTopic es el tema que creaste en el instructivo anterior.

Reemplaza INPUT_BUCKET_NAME por el nombre que usaste cuando creaste los buckets.

Para obtener más detalles sobre las notificaciones del depósito de almacenamiento, lee las notificaciones de cambios de objetos.

Haz una prueba

1. Sube una imagen ofensiva, como esta imagen de un zombi que come carne humana:

   gsutil cp zombie.jpg gs://INPUT_BUCKET_NAME

   En el ejemplo anterior, INPUT_BUCKET_NAME es el depósito de Cloud Storage que creaste antes para subir imágenes.

2. Navega a los registros de servicio:

   1. Navega a la página de Cloud Run for Anthos en Cloud Console:

      Ir a Cloud Run for Anthos

   2. Haz clic en el servicio pubsub-tutorial.

   3. Selecciona la pestaña Registros. Los registros pueden tardar un poco en aparecer. Si no los ves de inmediato, vuelve a revisar en unos minutos.

3. Busca el mensaje Blurred image: zombie.png.

4. Puedes ver las imágenes difuminadas en el depósito de Cloud Storage BLURRED_BUCKET_NAME que creaste antes: ubica el depósito en la página de Cloud Storage en Cloud Console.

Limpia

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y deseas conservarlo sin los cambios que se agregaron en este instructivo, borra los recursos creados para el instructivo.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

Precaución: Borrar un proyecto tiene estas consecuencias:

• Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

1. En la consola de Google Cloud, ve a la página Administrar recursos.

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borra los recursos del instructivo

1. Borra el servicio de Cloud Run for Anthos que implementaste en este instructivo:

   gcloud run services delete SERVICE-NAME

   En el ejemplo anterior, SERVICE-NAME es el nombre del servicio que elegiste.

   También puedes borrar los servicios de Cloud Run for Anthos desde la consola de Cloud:

   Ir a Cloud Run for Anthos

2. Quita las opciones de configuración predeterminadas de gcloud que agregaste durante la configuración del instructivo.

    gcloud config unset run/platform
    gcloud config unset run/cluster
    gcloud config unset run/cluster_location
   

3. Quita la configuración del proyecto:

    gcloud config unset project
   

4. Borra otros recursos de Google Cloud que creaste en este instructivo:

   • Borra el tema de Pub/Sub myRunTopic.
   • Borra la suscripción a Pub/Sub myRunSubscription.
   • Borra la imagen del contenedor llamada gcr.io/PROJECT_ID/pubsub de Container Registry.
   • Borra la cuenta de servicio de invocador cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com.
   • Borra los depósitos de Cloud Storage que se crearon para los marcadores de posición INPUT_BUCKET_NAME y BLURRED_BUCKET_NAME.
   • Si creaste un clúster para este instructivo, bórralo

¿Qué sigue?

• Obtén más información sobre la persistencia de los datos con Cloud Run for Anthos a través de Cloud Storage
• Aprende a usar la API de Cloud Vision para detectar el contenido que no sea explícito.
• Explora arquitecturas de referencia, diagramas, instructivos y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.