Esta página foi traduzida pela API Cloud Translation.

Tutorial para processar imagens do Cloud Storage

Neste tutorial, demonstramos como usar o Cloud Run, a API Cloud Vision e o ImageMagick para detectar e desfocar imagens ofensivas enviadas para um bucket do Cloud Storage. Este documento se baseia no tutorial Usar o Pub/Sub com o Cloud Run.

Neste tutorial, explicamos como modificar um aplicativo de amostra atual. Também é possível fazer o download da amostra concluída.

Objetivos

Grave, crie e implante um serviço de processamento de dados assíncrono no Cloud Run.
Invocar o serviço fazendo upload de um arquivo para o Cloud Storage, criando uma mensagem do Pub/Sub.
Usar a API Cloud Vision para detectar conteúdo violento ou adulto.
Usar o ImageMagick para desfocar imagens ofensivas.
Testar o serviço fazendo upload de uma imagem de um zumbi comedor de carne.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

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.

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

Go to project selector

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

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

Go to project selector

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

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

Instale e inicialize a CLI gcloud.
Atualize os componentes:
```
gcloud components update
```
Configure um tópico do Pub/Sub, uma assinatura de push segura e um serviço inicial do Cloud Run para lidar com mensagens seguindo o tutorial Usar o Pub/Sub

Funções exigidas

Para conseguir as permissões necessárias para concluir o tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:

Editor do Cloud Build (roles/cloudbuild.builds.editor)
Administrador do Cloud Run (roles/run.admin)
Acessador de exibição de registros (roles/logging.viewAccessor)
Administrador de projetos do IAM (roles/resourcemanager.projectIamAdmin)
Administrador do Pub/Sub (roles/pubsub.admin)
Usuário da conta de serviço (roles/iam.serviceAccountUser)
Consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer)
Administrador de armazenamento (roles/storage.admin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias por meio de papéis personalizados ou de outros papéis predefinidos.

Como configurar padrões do gcloud

Para configurar a gcloud com os padrões do serviço do Cloud Run, realize as etapas a seguir:

Defina seu projeto padrão:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto que você criou para este tutorial.
Configure a gcloud para a região escolhida:
```
gcloud config set run/region REGION
```
Substitua REGION pela região compatível do Cloud Run.

Locais do Cloud Run

O Cloud Run é regional, o que significa que a infraestrutura que executa seus serviços do Cloud Run está localizada em uma região específica e é gerenciada pelo Google para estar disponível de maneira redundante em todas as zonas da região.

Atender aos seus requisitos de latência, disponibilidade ou durabilidade são os principais fatores para selecionar a região em que seus serviços do Cloud Run são executados. Geralmente, é possível selecionar a região mais próxima de seus usuários, mas considere a localização dos outros produtos do Google Cloud usados pelo serviço do Cloud Run. O uso de produtos do Google Cloud em vários locais pode afetar a latência e o custo do serviço.

O Cloud Run está disponível nas regiões a seguir:

Sujeitas aos preços do nível 1

asia-east1 (Taiwan)
asia-northeast1 (Tóquio)
asia-northeast2 (Osaka)
asia-south1 (Mumbai, Índia)
europe-north1 (Finlândia) Baixo CO₂
europe-southwest1 (Madri) Baixo CO₂
europe-west1 (Bélgica) Baixo CO₂
europe-west4 (Países Baixos) Baixo CO₂
europe-west8 (Milão)
europe-west9 (Paris) Baixo CO₂
me-west1 (Tel Aviv)
us-central1 (Iowa) Baixo CO₂
us-east1 (Carolina do Sul)
us-east4 (Norte da Virgínia)
us-east5 (Columbus)
us-south1 (Dallas) Baixo CO₂
us-west1 (Oregon) Baixo CO₂

Sujeitas aos preços do nível 2

africa-south1 (Johannesburgo)
asia-east2 (Hong Kong)
asia-northeast3 (Seul, Coreia do Sul)
asia-southeast1 (Singapura)
asia-southeast2 (Jacarta)
asia-south2 (Déli, Índia)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Varsóvia, Polônia)
europe-west10 (Berlim) Baixo CO₂
europe-west12 (Turim)
europe-west2 (Londres, Reino Unido) Baixo CO₂
europe-west3 (Frankfurt, Alemanha) Baixo CO₂
europe-west6 (Zurique, Suíça) Baixo CO₂
me-central1 (Doha)
me-central2 (Damã)
northamerica-northeast1 (Montreal) Baixo CO₂
northamerica-northeast2 (Toronto) Baixo CO₂
southamerica-east1 (São Paulo, Brasil) Baixo CO₂
southamerica-west1 (Santiago, Chile) Baixo CO₂
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Se você já criou um serviço do Cloud Run, é possível visualizar a região no painel do Cloud Run no console do Google Cloud.

Como entender a sequência de operações

O fluxo de dados neste tutorial segue estas etapas:

Um usuário faz o upload de uma imagem para um bucket do Cloud Storage.
O Cloud Storage publica uma mensagem sobre o novo arquivo no Pub/Sub.
O Pub/Sub envia a mensagem ao serviço do Cloud Run.
O serviço do Cloud Run recupera o arquivo de imagem mencionado na mensagem do Pub/Sub.
O serviço do Cloud Run usa a API Cloud Vision para analisar a imagem.
Se for detectado conteúdo violento ou adulto, o serviço do Cloud Run usará o ImageMagick para desfocar a imagem.
O serviço do Cloud Run faz upload da imagem desfocada em outro bucket do Cloud Storage para uso.

O próximo uso da imagem desfocada é deixado como um exercício para o leitor.

Criar um repositório padrão do Artifact Registry

Crie um repositório padrão do Artifact Registry para armazenar a imagem do contêiner:

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

Substitua:

REPOSITORY por um nome exclusivo para o repositório.
REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.

Configurar buckets do Cloud Storage

gcloud

Crie um bucket do Cloud Storage para fazer upload de imagens, em que INPUT_BUCKET_NAME é um nome de bucket globalmente exclusivo:
```
gcloud storage buckets create gs://INPUT_BUCKET_NAME
```
O serviço do Cloud Run só lê a partir desse bucket.
Crie um segundo bucket do Cloud Storage para receber imagens desfocadas, em que BLURRED_BUCKET_NAME é um nome de bucket globalmente exclusivo:
```
gcloud storage buckets create gs://BLURRED_BUCKET_NAME
```
O serviço do Cloud Run faz upload de imagens desfocadas para esse bucket. Usar um bucket separado evita que imagens processadas acionem novamente o serviço.

Por padrão, as revisões do Cloud Run são executadas como a conta de serviço padrão do Compute Engine.

Se, em vez disso, você estiver usando umaconta de serviço gerenciada pelo usuário, verifique se você atribuiu os Papéis do IAM necessários, de modo a ter a permissão storage.objects.get para leitura de INPUT_BUCKET_NAME e a permissão storage.objects.create para fazer upload para BLURRED_BUCKET_NAME.

Terraform

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Crie dois buckets do Cloud Storage: um para fazer upload de imagens originais e outro para o serviço do Cloud Run fazer upload de imagens desfocadas.

Para criar buckets do Cloud Storage com nomes globalmente exclusivos, adicione o seguinte ao seu arquivo main.tf atual:

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
}

Por padrão, as revisões do Cloud Run são executadas como a conta de serviço padrão do Compute Engine.

Se, em vez disso, você estiver usando umaconta de serviço gerenciada pelo usuário, verifique se você atribuiu os Papéis do IAM necessários, de modo a ter a permissão storage.objects.get para leitura de google_storage_bucket.imageproc_input e a permissão storage.objects.create para fazer upload para google_storage_bucket.imageproc_output.

Nas etapas a seguir, você cria e implanta um serviço que processa notificações de uploads de arquivos para o INPUT_BUCKET_NAME. Você ativa a entrega de notificações depois de implantar e testar o serviço, para evitar a invocação prematura do novo serviço.

Modificar o código de amostra do tutorial do Pub/Sub

Este documento se baseia no código criado no tutorial Usar o Pub/Sub. Se você ainda não concluiu esse tutorial, faça isso agora, ignore as etapas de limpeza e retorne a este documento para adicionar um comportamento de processamento de imagem.

Adicionar código de processamento de imagem

O código de processamento de imagem é separado da manipulação da solicitação para facilitar a leitura e o teste. Para adicionar código de processamento de imagem, siga estas etapas:

Mude para o diretório do código de amostra do tutorial do Pub/Sub.

Adicione o código para importar as dependências de processamento de imagem, incluindo as bibliotecas a serem integradas aos serviços do Google Cloud, ao ImageMagick e ao sistema de arquivos.

Node.js

Abra um novo arquivo image.js no seu editor e copie o seguinte:

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

Abra um novo arquivo image.py no seu editor e copie o seguinte:

import os
import tempfile

from google.cloud import storage, vision
from wand.image import Image

storage_client = storage.Client()
vision_client = vision.ImageAnnotatorClient()

Go

Abra um novo arquivo imagemagick/imagemagick.go no seu editor e copie o seguinte:


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

Abra um novo arquivo src/main/java/com/example/cloudrun/ImageMagick.java no seu editor e copie o seguinte:

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

Adicione o código para receber uma mensagem do Pub/Sub como um objeto de evento e controlar o processamento da imagem.

O evento contém dados sobre a imagem enviada originalmente. Esse código determina se a imagem precisa ser desfocada verificando os resultados de uma análise do Cloud Vision em busca de conteúdo violento ou adulto.

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.")

Go


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

Recupere a imagem referenciada do bucket de entrada do Cloud Storage criado acima, use o ImageMagick para transformar a imagem com um efeito de desfoque e faça upload do resultado para o bucket de saída.

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)

Go


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

Integrar o processamento de imagens ao código de amostra do Pub/Sub

Para modificar o serviço atual para incorporar o código de processamento de imagem, siga estas etapas:

Adicione novas dependências ao serviço, incluindo as bibliotecas de cliente do Cloud Vision e do Cloud Storage:

Node.js

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

Python

Adicione as bibliotecas de cliente necessárias para que o requirements.txt fique assim:

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

Go

A amostra de aplicativo em Go usa módulos do Go. Será feito o download automático das novas dependências adicionadas acima na instrução de importação imagemagick/imagemagick.go pelo próximo comando que precisar delas.

Java

Adicione a dependência a seguir em <dependencyManagement> no 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>

Adicione as dependências a seguir em <dependencies> no 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>

Adicione o pacote de sistema do ImageMagick ao seu contêiner. Para isso, modifique o Dockerfile abaixo da instrução FROM. Se estiver usando um Dockerfile "de vários estágios", coloque-o no estágio final.

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

Leia mais sobre como trabalhar com pacotes do sistema no serviço do Cloud Run no tutorial Como usar pacotes do sistema.

Substitua o código de tratamento da mensagem do Pub/Sub atual por uma chamada de função para nossa nova lógica de desfoque.

Node.js

O arquivo app.js define o aplicativo Express.js e prepara mensagens do Pub/Sub recebidas para uso. Faça as mudanças a seguir:

Adicione código para importar o novo arquivo image.js.
Remova o código "Hello World" atual da rota.
Adicione código para validar ainda mais a mensagem do Pub/Sub.
Adicione código para chamar a nova função de processamento de imagens.

Quando terminar, o código ficará assim:


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

O arquivo main.py define o aplicativo Flask e prepara as mensagens do Pub/Sub recebidas para uso. Faça as mudanças a seguir:

Adicione código para importar o novo arquivo image.py.
Remova o código "Hello World" atual da rota.
Adicione código para validar ainda mais a mensagem do Pub/Sub.
Adicione código para chamar a nova função de processamento de imagens.

Quando terminar, o código ficará assim:

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)

Go

O arquivo main.go define o serviço HTTP e prepara mensagens do Pub/Sub recebidas para uso. Faça as mudanças a seguir:

Adicione código para importar o novo arquivo imagemagick.go.
Remova o código "Hello World" atual do gerenciador.
Adicione código para validar ainda mais a mensagem do Pub/Sub.
Adicione código para chamar a nova função de processamento de imagens.


// Sample image-processing is a Cloud Run service which performs asynchronous processing on images.
package main

import (
	"encoding/json"
	"io"
	"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 := io.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

O arquivo PubSubController.java define o controlador que manipula solicitações HTTP e prepara mensagens do Pub/Sub recebidas para uso. Faça as mudanças a seguir:

Adicione as novas importações.
Remova o código "Hello World" atual do controlador.
Adicione código para validar ainda mais a mensagem do Pub/Sub.
Adicione código para chamar a nova função de processamento de imagens.

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

Faça o download da amostra completa

Para recuperar o exemplo de código de processamento de imagem completo para uso:

Clone o repositório do aplicativo de amostra na máquina local:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.

Mude para o diretório que contém o código de amostra do Cloud Run:

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/

Enviar o código

O código de envio consiste em três etapas: criar uma imagem de contêiner com o Cloud Build, fazer upload da imagem de contêiner no Container Artifact e implantar a imagem de contêiner no Cloud Run.

Para enviar o código, siga estas etapas:

Compile seu contêiner e publique no Artifact Registry:
Node.js
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
/REPOSITORY/pubsub
```
Em que pubsub é o nome do serviço.

Substitua:
- PROJECT_ID pelo ID do projeto do Google Cloud
- REPOSITORY pelo nome do repositório do Artifact Registry.
- REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.
Após a conclusão, você verá uma mensagem de SUCESSO contendo o ID, a hora da criação e o nome da imagem. A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
/REPOSITORY/pubsub
```
Em que pubsub é o nome do serviço.

Substitua:
- PROJECT_ID pelo ID do projeto do Google Cloud
- REPOSITORY pelo nome do repositório do Artifact Registry.
- REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.
Após a conclusão, você verá uma mensagem de SUCESSO contendo o ID, a hora da criação e o nome da imagem. A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.
Go
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
/REPOSITORY/pubsub
```
Em que pubsub é o nome do serviço.

Substitua:
- PROJECT_ID pelo ID do projeto do Google Cloud
- REPOSITORY pelo nome do repositório do Artifact Registry.
- REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.
Após a conclusão, você verá uma mensagem de SUCESSO contendo o ID, a hora da criação e o nome da imagem. A imagem é armazenada no Artifact Registry e poderá ser reutilizada se necessário.
Java
Esta amostra usa o Jib (em inglês) para criar imagens do Docker usando ferramentas comuns do Java. O Jib otimiza builds de contêiner sem a necessidade de um Dockerfile ou de ter o Docker (em inglês) instalado. Saiba mais sobre como criar contêineres Java com o Jib.
1. Usando o Dockerfile, configure e crie uma imagem base com os pacotes do sistema instalados para substituir a imagem base padrão do 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
  Substitua:
  - PROJECT_ID pelo ID do projeto do Google Cloud
  - REPOSITORY pelo nome do repositório do Artifact Registry.
  - REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.
2. Use o auxiliar de credencial do gcloud para autorizar o Docker a enviar por push ao Artifact Registry.
  gcloud auth configure-docker
3. Crie seu contêiner final com o Jib e publique no 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
  Substitua:
  - PROJECT_ID pelo ID do projeto do Google Cloud
  - REPOSITORY pelo nome do repositório do Artifact Registry.
  - REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.
Execute o comando a seguir para implantar o serviço com o mesmo nome de serviço usado no tutorial Usar o 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
```
Go
```
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
```
Em que pubsub é o nome do contêiner e pubsub-tutorial é o nome do serviço. A imagem do contêiner é implantada no serviço e na região (Cloud Run) que você configurou anteriormente em Como configurar os padrões do gcloud. Substitua:
- PROJECT_ID pelo ID do projeto do Google Cloud
- REPOSITORY pelo nome do repositório do Artifact Registry.
- REGION pela região do Google Cloud a ser usada para o repositório do Artifact Registry.
- BLURRED_BUCKET_NAME pelo bucket do Cloud Storage criado anteriormente para receber imagens desfocadas e definir a variável de ambiente.
A sinalização --no-allow-unauthenticated restringe o acesso não autenticado ao serviço. Mantendo o serviço particular, é possível contar com a integração automática do Pub/Sub no Cloud Run para autenticar as solicitações. Consulte Como integrar ao Pub/Sub para mais detalhes sobre como isso é configurado. Consulte Como gerenciar o acesso para mais detalhes sobre a autenticação baseada em IAM.

Aguarde até que a implantação esteja concluída. Isso pode levar cerca de 30 segundos. Em caso de sucesso, a linha de comando exibe o URL de serviço.

Ativar as notificações no Cloud Storage

Configure o Cloud Storage para publicar uma mensagem em um tópico do Pub/Sub sempre que um arquivo (conhecido como objeto) for carregado ou alterado. Envie a notificação para o tópico criado anteriormente para que o novo upload do arquivo invoque o serviço.

gcloud

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

myRunTopic é o tópico que você criou no tutorial anterior.

Substitua INPUT_BUCKET_NAME pelo nome usado quando você criou os buckets.

Para mais detalhes sobre notificações de bucket de armazenamento, leia Notificações de alteração de objeto.

Terraform

Para saber como aplicar ou remover uma configuração do Terraform, consulte Comandos básicos do Terraform.

Para ativar as notificações, a conta de serviço do Cloud Storage exclusiva do projeto precisa existir e ter a permissão do IAM pubsub.publisher no tópico do Pub/Sub. Para conceder essa permissão e criar uma notificação do Cloud Storage, adicione o seguinte ao arquivo main.tf atual:

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]
}

Faça um teste

Faça upload de uma imagem ofensiva, como esta imagem de um zumbi comedor de carne:
```
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
```
em que INPUT_BUCKET_NAME é o bucket do Cloud Storage criado anteriormente para o upload de imagens.
Navegue até os registros de serviço:
1. Navegue até a página do Cloud Run no Console do Google Cloud
2. Clique no serviço pubsub-tutorial.
3. Selecione a guia Registros. Os registros podem demorar alguns instantes para aparecer. Se você não os vir imediatamente, verifique outra vez após alguns instantes.
Procure a mensagem Blurred image: zombie.png.
É possível ver as imagens desfocadas no bucket do Cloud Storage BLURRED_BUCKET_NAME criado anteriormente: localize o bucket na página do Cloud Storage no Console do Google Cloud.

Limpar

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual e quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial.

Como excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Como excluir recursos do tutorial

Exclua o serviço do Cloud Run que você implantou neste tutorial:
```
gcloud run services delete SERVICE-NAME
```
SERVICE-NAME é o nome escolhido do serviço.

Também é possível excluir os serviços do Cloud Run no Console do Google Cloud.
Remova a configuração da região padrão da gcloud que você adicionou durante a configuração do tutorial:
```
 gcloud config unset run/region
```
Remova a configuração do projeto:
```
 gcloud config unset project
```
Exclua outros recursos do Google Cloud criados neste tutorial:
- Exclua o tópico Pub/Sub myRunTopic
- Exclua a assinatura do Pub/Sub myRunSubscription.
- Exclua a imagem do contêiner no Artifact Registry.
- Exclua a conta de serviço do invocador cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com.
- Exclua os buckets do Cloud Storage criados para os marcadores INPUT_BUCKET_NAME e BLURRED_BUCKET_NAME.

A seguir

Saiba mais sobre a persistência de dados com o Cloud Run usando o Cloud Storage.
Entenda como usar a API Cloud Vision para detectar elementos além do conteúdo explícito.
Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.