Esta página foi traduzida pela API Cloud Translation.

Tutorial sobre o processamento de imagens do Cloud Storage

Este tutorial demonstra a utilização do Cloud Run, da Cloud Vision API e do ImageMagick para detetar e esbater imagens ofensivas carregadas para um contentor do Cloud Storage. Este tutorial baseia-se no tutorial Use o Pub/Sub com o Cloud Run.

Este tutorial explica como modificar uma app de exemplo existente. Também pode transferir o exemplo concluído, se quiser.

Objetivos

Escreva, crie e implemente um serviço de processamento de dados assíncrono no Cloud Run.
Invocar o serviço carregando um ficheiro para o Cloud Storage ou criando uma mensagem do Pub/Sub.
Use a API Cloud Vision para detetar conteúdo violento ou para adultos.
Use o ImageMagick para esbater imagens ofensivas.
Teste o serviço carregando uma imagem de um zombie carnívoro.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis 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

Verify 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

Verify 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 subscrição push segura e um serviço do Cloud Run inicial para processar mensagens seguindo o tutorial Usar o Pub/Sub

Funções necessárias

Para receber as autorizações de que precisa para concluir o tutorial, peça ao seu administrador para lhe conceder as seguintes funções da IAM no seu projeto:

Editor do Cloud Build (roles/cloudbuild.builds.editor)
Administrador do Cloud Run (roles/run.admin)
Aceder à vista de registos (roles/logging.viewAccessor)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Administrador do Pub/Sub (roles/pubsub.admin)
Utilizador da conta de serviço (roles/iam.serviceAccountUser)
Consumidor de utilização do serviço (roles/serviceusage.serviceUsageConsumer)
Administrador de armazenamento (roles/storage.admin)

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Configurar predefinições do gcloud

Para configurar o gcloud com as predefinições do seu serviço do Cloud Run:

Defina o projeto predefinido:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto que criou para este tutorial.
Configure o gcloud para a região escolhida:
```
gcloud config set run/region REGION
```
Substitua REGION pela região do Cloud Run suportada à sua escolha.

Localizações do Cloud Run

O Cloud Run é regional, o que significa que a infraestrutura que executa os seus serviços do Cloud Run está localizada numa região específica e é gerida pela Google para estar disponível de forma redundante em todas as zonas dessa região.

O cumprimento dos requisitos de latência, disponibilidade ou durabilidade são fatores principais para selecionar a região onde os seus serviços do Cloud Run são executados. Geralmente, pode selecionar a região mais próxima dos seus utilizadores, mas deve considerar a localização dos outros Google Cloudprodutos usados pelo seu serviço do Cloud Run. A utilização Google Cloud de produtos em conjunto em várias localizações pode afetar a latência do seu serviço, bem como o custo.

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

Sujeito aos preços de Nível 1

asia-east1 (Taiwan)
asia-northeast1 (Tóquio)
asia-northeast2 (Osaca)
asia-south1 (Mumbai, Índia)
europe-north1 (Finlândia) Baixo CO₂
europe-north2 (Estocolmo) Baixo CO₂
europe-southwest1 (Madrid) 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 (Telavive)
northamerica-south1 (México)
us-central1 (Iowa) Baixo CO₂
us-east1 (Carolina do Sul)
us-east4 (Virgínia do Norte)
us-east5 (Columbus)
us-south1 (Dallas) Baixo CO₂
us-west1 (Oregão) Baixo CO₂

Sujeito aos preços de Nível 2

africa-south1 (Joanesburgo)
asia-east2 (Hong Kong)
asia-northeast3 (Seul, Coreia do Sul)
asia-southeast1 (Singapura)
asia-southeast2 (Jacarta)
asia-south2 (Deli, Í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)
europe-west6 (Zurique, Suíça) Baixo CO₂
me-central1 (Doha)
me-central2 (Dammam)
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 já criou um serviço do Cloud Run, pode ver a região no painel de controlo do Cloud Run na Google Cloud consola.

Compreender a sequência de operações

O fluxo de dados neste tutorial segue estes passos:

Um utilizador carrega uma imagem para um contentor do Cloud Storage.
O Cloud Storage publica uma mensagem sobre o novo ficheiro no Pub/Sub.
O Pub/Sub envia a mensagem para o serviço do Cloud Run.
O serviço do Cloud Run obtém o ficheiro de imagem referenciado na mensagem do Pub/Sub.
O serviço do Cloud Run usa a API Cloud Vision para analisar a imagem.
Se for detetado conteúdo violento ou para adultos, o serviço Cloud Run usa o ImageMagick para esbater a imagem.
O serviço do Cloud Run carrega a imagem esbatida para outro contentor do Cloud Storage para utilização.

A utilização subsequente da imagem esbatida é deixada como um exercício para o leitor.

Crie um repositório padrão do Artifact Registry

Crie um repositório padrão do Artifact Registry para armazenar a imagem de contentor:

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

Substituir:

REPOSITORY com um nome exclusivo para o repositório.
REGION com a Google Cloud região a usar para o repositório do Artifact Registry.

Configure contentores do Cloud Storage

gcloud

Crie um contentor do Cloud Storage para carregar imagens, em que INPUT_BUCKET_NAME é um nome de contentor exclusivo a nível global:
```
gcloud storage buckets create gs://INPUT_BUCKET_NAME
```
O serviço do Cloud Run só lê a partir deste contentor.
Crie um segundo contentor do Cloud Storage para receber imagens com efeito de esbatimento, em que BLURRED_BUCKET_NAME é um nome de contentor exclusivo a nível global:
```
gcloud storage buckets create gs://BLURRED_BUCKET_NAME
```
O serviço do Cloud Run carrega imagens esbatidas para este contentor. A utilização de um contentor separado impede que as imagens processadas voltem a acionar o serviço.

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

Em alternativa, se estiver a usar uma conta de serviço gerida pelo utilizador, certifique-se de que atribuiu as funções do IAM necessárias para que tenha autorização storage.objects.get para ler a partir de INPUT_BUCKET_NAME e autorização storage.objects.create para carregar para BLURRED_BUCKET_NAME.

Terraform

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

Crie dois contentores do Cloud Storage: um para carregar as imagens originais e outro para o serviço do Cloud Run carregar as imagens esbatidas.

Para criar ambos os contentores do Cloud Storage com nomes exclusivos a nível global, adicione o seguinte ao seu ficheiro main.tf existente:

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 predefinição, as revisões do Cloud Run são executadas como a conta de serviço predefinida do Compute Engine.

Em alternativa, se estiver a usar uma conta de serviço gerida pelo utilizador, certifique-se de que atribuiu as funções IAM necessárias para que tenha autorização storage.objects.get para ler a partir de google_storage_bucket.imageproc_input e autorização storage.objects.create para carregar para google_storage_bucket.imageproc_output.

Nos passos seguintes, cria e implementa um serviço que processa a notificação de carregamentos de ficheiros para o INPUT_BUCKET_NAME. Ative a entrega de notificações depois de implementar e testar o serviço para evitar a invocação prematura do novo serviço.

Modifique o código de exemplo do tutorial do Pub/Sub

Este tutorial baseia-se no código reunido no tutorial de utilização do Pub/Sub. Se ainda não concluiu esse tutorial, faça-o agora, ignorando os passos de limpeza e, em seguida, volte aqui para adicionar o comportamento de processamento de imagens.

Adicione código de processamento de imagens

O código de processamento de imagens está separado do processamento de pedidos para facilitar a leitura e os testes. Para adicionar código de processamento de imagens:

Altere para o diretório do código de exemplo do tutorial do Pub/Sub.

Adicione código para importar as dependências de processamento de imagens, incluindo bibliotecas para integrar com Google Cloud serviços, o ImageMagick e o sistema de ficheiros.

Node.js

Abra um novo ficheiro image.js no 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 ficheiro image.py no 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()

Ir

Abra um novo ficheiro imagemagick/imagemagick.go no 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 ficheiro src/main/java/com/example/cloudrun/ImageMagick.java no 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 código para receber uma mensagem Pub/Sub como um objeto de evento e controlar o processamento de imagens.

O evento contém dados sobre a imagem carregada originalmente. Este código determina se a imagem tem de ser esbatida verificando os resultados de uma análise do Cloud Vision quanto a conteúdo violento ou para adultos.

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

Ir


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

Obtenha a imagem referenciada do contentor de entrada do Cloud Storage criado acima, use o ImageMagick para transformar a imagem com um efeito de esbatimento e carregue o resultado para o contentor 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)

Ir


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

Integre o processamento de imagens no código de exemplo do Pub/Sub

Para modificar o serviço existente de forma a incorporar o código de processamento de imagens:

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

Node.js

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

Python

Adicione as bibliotecas cliente necessárias para que o seu requirements.txt se pareça com o seguinte:

Flask==3.0.3
google-cloud-storage==2.12.0
google-cloud-vision==3.8.1
gunicorn==23.0.0
Wand==0.6.13
Werkzeug==3.0.3

Ir

A aplicação de exemplo go usa módulos go. As novas dependências adicionadas acima na declaração imagemagick/imagemagick.go import são transferidas automaticamente pelo comando seguinte que as necessita.

Java

Adicione a seguinte dependência 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 seguintes dependências 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 do sistema ImageMagick ao seu contentor modificando o Dockerfile abaixo da declaração FROM. Se usar um Dockerfile "de várias fases", coloque isto na fase 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 seu serviço do Cloud Run no tutorial sobre a utilização de pacotes do sistema.

Substitua o código de processamento de mensagens Pub/Sub existente por uma chamada de função à nossa nova lógica de esbatimento.

Node.js

O ficheiro app.js define a app Express.js e prepara as mensagens do Pub/Sub recebidas para utilização. Faça as seguintes alterações:

Adicione código para importar o novo ficheiro image.js
Remova o código "Hello World" existente do caminho
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 tem o seguinte aspeto:


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 ficheiro main.py define a app Flask e prepara as mensagens do Pub/Sub recebidas para utilização. Faça as seguintes alterações:

Adicione código para importar o novo ficheiro image.py
Remova o código "Hello World" existente do caminho
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 tem o seguinte aspeto:

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)

Ir

O ficheiro main.go define o serviço HTTP e prepara as mensagens do Pub/Sub recebidas para utilização. Faça as seguintes alterações:

Adicione código para importar o novo ficheiro imagemagick.go
Remova o código "Hello World" existente 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


// 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 ficheiro PubSubController.java define o controlador que processa os pedidos HTTP e prepara as mensagens Pub/Sub recebidas para utilização. Faça as seguintes alterações:

Adicione as novas importações
Remova o código "Hello World" existente 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);
  }
}

Transfira o exemplo completo

Para obter o exemplo de código de processamento de imagens completo para utilização:

Clone o repositório da app de exemplo para a sua máquina local:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.
Ir
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

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

Node.js

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

Python

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

Ir

cd golang-samples/run/image-processing/

Java

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

Envie o código

O código de envio consiste em três passos: criar uma imagem de contentor com o Cloud Build, carregar a imagem de contentor para o Artifact Registry e implementar a imagem de contentor no Cloud Run.

Para enviar o código:

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

Substituir:
- PROJECT_ID com o Google Cloud ID do projeto
- REPOSITORY com o nome do repositório do Artifact Registry.
- REGION com a Google Cloud região a usar para o repositório do Artifact Registry.
Após a conclusão com êxito, é apresentada uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.
Python
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
/REPOSITORY/pubsub
```
Em que pubsub é o nome do seu serviço.

Substituir:
- PROJECT_ID com o Google Cloud ID do projeto
- REPOSITORY com o nome do repositório do Artifact Registry.
- REGION com a Google Cloud região a usar para o repositório do Artifact Registry.
Após a conclusão com êxito, é apresentada uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.
Ir
```
gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID
/REPOSITORY/pubsub
```
Em que pubsub é o nome do seu serviço.

Substituir:
- PROJECT_ID com o Google Cloud ID do projeto
- REPOSITORY com o nome do repositório do Artifact Registry.
- REGION com a Google Cloud região a usar para o repositório do Artifact Registry.
Após a conclusão com êxito, é apresentada uma mensagem SUCCESS com o ID, a hora de criação e o nome da imagem. A imagem é armazenada no Artifact Registry e pode ser reutilizada, se necessário.
Java
Este exemplo usa o Jib para criar imagens do Docker com ferramentas Java comuns. O Jib otimiza as compilações de contentores sem precisar de um Dockerfile nem ter o Docker instalado. Saiba mais sobre como criar contentores Java com o Jib.
1. Usando o Dockerfile, configure e crie uma imagem de base com os pacotes do sistema instalados para substituir a imagem de base predefinida 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.15_6-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
  Substituir:
  - PROJECT_ID com o Google Cloud ID do projeto
  - REPOSITORY com o nome do repositório do Artifact Registry.
  - REGION com a Google Cloud região a usar para o repositório do Artifact Registry.
2. Use o auxiliar de credenciais gcloud para autorizar o Docker a enviar para o seu Artifact Registry.
  gcloud auth configure-docker
3. Crie o contentor final com o Jib e publique-o 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
  Substituir:
  - PROJECT_ID com o Google Cloud ID do projeto
  - REPOSITORY com o nome do repositório do Artifact Registry.
  - REGION com a Google Cloud região a usar para o repositório do Artifact Registry.
Execute o seguinte comando para implementar o seu serviço, usando o mesmo nome do serviço que usou 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
```
Ir
```
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
```
Onde pubsub é o nome do contentor e pubsub-tutorial é o nome do serviço. Tenha em atenção que a imagem do contentor é implementada no serviço e na região (Cloud Run) que configurou anteriormente em Configurar predefinições do gcloud. Substituir:
- PROJECT_ID com o Google Cloud ID do projeto
- REPOSITORY com o nome do repositório do Artifact Registry.
- REGION com a Google Cloud região a usar para o repositório do Artifact Registry.
- BLURRED_BUCKET_NAME com o contentor do Cloud Storage que criou anteriormente para receber imagens esbatidas para definir a variável de ambiente.
A flag --no-allow-unauthenticated restringe o acesso não autenticado ao serviço. Ao manter o serviço privado, pode confiar na integração automática do Pub/Sub do Cloud Run para autenticar pedidos. Consulte o artigo Integração com o Pub/Sub para ver mais detalhes sobre como esta opção é configurada. Consulte o artigo Gerir o acesso para mais detalhes sobre a autenticação baseada na IAM.

Aguarde até que a implementação esteja concluída. Este processo pode demorar cerca de meio minuto. Se for bem-sucedido, a linha de comandos apresenta o URL do serviço.

Ative as notificações do Cloud Storage

Configurar o Cloud Storage para publicar uma mensagem num tópico do Pub/Sub sempre que um ficheiro (conhecido como um objeto) é carregado ou alterado. Envie a notificação para o tópico criado anteriormente para que qualquer novo carregamento de ficheiro 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 criou no tutorial anterior.

Substitua INPUT_BUCKET_NAME pelo nome que usou quando criou os grupos.

Para mais detalhes sobre as notificações de contentores de armazenamento, leia o artigo sobre as notificações de alterações de objetos.

Terraform

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

Para ativar as notificações, a conta de serviço do Cloud Storage exclusiva do projeto tem de existir e ter a autorização do IAM pubsub.publisher no tópico do Pub/Sub. Para conceder esta autorização e criar uma notificação do Cloud Storage, adicione o seguinte ao seu ficheiro main.tf existente:

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

Experimentar

Carregar uma imagem ofensiva, como esta imagem de um zombie carnívoro:
```
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
```
onde INPUT_BUCKET_NAME é o contentor do Cloud Storage que criou anteriormente para carregar imagens.
Navegue para os registos de serviço:
1. Navegue para a página do Cloud Run na Google Cloud consola
2. Clique no serviço pubsub-tutorial.
3. Selecione o separador Registos. Os registos podem demorar alguns momentos a aparecer. Se não os vir imediatamente, verifique novamente após alguns momentos.
Procure a mensagem Blurred image: zombie.png.
Pode ver as imagens esbatidas no contentor do BLURRED_BUCKET_NAMECloud Storage que criou anteriormente: localize o contentor na página do Cloud Storage na Google Cloud consola

Êxito: implementou um serviço do Cloud Run com a Cloud Vision API e o ImageMagick para detetar imagens carregadas para um contentor do Cloud Storage.

Limpar

Se criou um novo projeto para este tutorial, elimine o projeto. Se usou um projeto existente e quer mantê-lo sem as alterações adicionadas neste tutorial, elimine os recursos criados para o tutorial.

Eliminar o projeto

A forma mais fácil de eliminar a faturação é eliminar o projeto que criou para o tutorial.

Para eliminar o 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.

Eliminar recursos do tutorial

Elimine o serviço do Cloud Run que implementou neste tutorial:
```
gcloud run services delete SERVICE-NAME
```
Onde SERVICE-NAME é o nome do serviço escolhido.

Também pode eliminar serviços do Cloud Run a partir da Google Cloud consola.
Remova a configuração da região predefinida do gcloud que adicionou durante a configuração do tutorial:
```
 gcloud config unset run/region
```
Remova a configuração do projeto:
```
 gcloud config unset project
```
Elimine outros Google Cloud recursos criados neste tutorial:
- Elimine o tópico do Pub/Sub myRunTopic
- Elimine a subscrição do Pub/Sub myRunSubscription
- Elimine a imagem de contentor do Artifact Registry.
- Elimine a conta de serviço do invocador cloud-run-pubsub-invoker@PROJECT_ID.iam.gserviceaccount.com
- Elimine os contentores do Cloud Storage criados para os marcadores de posição INPUT_BUCKET_NAME e BLURRED_BUCKET_NAME

O que se segue?

Saiba mais sobre a persistência de dados com o Cloud Run através do Cloud Storage.
Compreenda como usar a API Cloud Vision para detetar elementos além de conteúdo explícito.
Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.

Tutorial sobre o processamento de imagens do Cloud Storage Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Objetivos

Custos

Antes de começar

Funções necessárias

Configurar predefinições do gcloud

Localizações do Cloud Run

Sujeito aos preços de Nível 1

Sujeito aos preços de Nível 2

Compreender a sequência de operações

Crie um repositório padrão do Artifact Registry

Configure contentores do Cloud Storage

gcloud

Terraform

Modifique o código de exemplo do tutorial do Pub/Sub

Adicione código de processamento de imagens

Node.js

Python

Ir

Java

Node.js

Python

Ir

Java

Node.js

Python

Ir

Java

Integre o processamento de imagens no código de exemplo do Pub/Sub

Node.js

Python

Ir

Java

Node.js

Python

Ir

Java

Transfira o exemplo completo

Node.js

Python

Ir

Java

Node.js

Python

Ir

Java

Envie o código

Node.js

Python

Ir

Java

Node.js

Python

Ir

Java

Ative as notificações do Cloud Storage

gcloud

Terraform

Experimentar

Limpar

Eliminar o projeto

Eliminar recursos do tutorial

O que se segue?

Tutorial sobre o processamento de imagens do Cloud Storage