Cloud Functions a été renommé Cloud Run Functions. Pour en savoir plus, consultez l'article de blog sur Cloud Run Functions.

Tutoriel ImageMagick (2e génération)

Ce tutoriel décrit l'utilisation de Cloud Functions, de l'API Google Cloud Vision et de l'outil ImageMagick pour détecter et flouter les images choquantes importées dans un bucket Cloud Storage.

Objectifs

Déployer une fonction CloudEvent déclenchée par Storage
Utiliser l'API Cloud Vision pour détecter les contenus violents ou réservés aux adultes
Utiliser ImageMagick pour flouter les images choquantes
Tester la fonction en important une image d'un zombie mangeur de chair

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Cloud Functions
Cloud Storage
Cloud Vision
Cloud Build
Pub/Sub
Artifact Registry
Eventarc
Cloud Logging

Pour en savoir plus, consultez la page Tarifs de Cloud Functions.

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

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.

Enable the Cloud Functions, Cloud Build, Artifact Registry, Eventarc, Cloud Storage, Cloud Vision, Logging, and Pub/Sub APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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 Cloud Functions, Cloud Build, Artifact Registry, Eventarc, Cloud Storage, Cloud Vision, Logging, and Pub/Sub APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Si la gcloud CLI est déjà installée, mettez-le à jour en exécutant la commande suivante :

gcloud components update

Préparez votre environnement de développement.

Node.js

Accéder au guide de configuration Node.js

Python

Accéder au guide de configuration Python

Go

Accéder au guide de configuration Go

Java

Accéder au guide de configuration Java

Visualiser le flux de données

Le flux de données dans l'application du tutoriel ImageMagick comprend plusieurs étapes :

Une image est importée dans un bucket Cloud Storage.
Cloud Function analyse l'image à l'aide de l'API Cloud Vision.
Si un contenu violent ou réservé aux adultes est détecté, la fonction Cloud utilise ImageMagick pour flouter l'image.
L'image floue est importée dans un autre bucket Cloud Storage pour être utilisée.

Préparer l'application

Créez un bucket Cloud Storage régional pour importer des images, où YOUR_INPUT_BUCKET_NAME est un nom de bucket unique et REGION est la région dans laquelle vous prévoyez de déployer votre fonction :
```
gsutil mb -l REGION gs://YOUR_INPUT_BUCKET_NAME
```
Créez un bucket Cloud Storage régional destiné à recevoir les images floues, où YOUR_OUTPUT_BUCKET_NAME est un nom de bucket unique et REGION est la région dans laquelle vous prévoyez de déployer votre fonction :
```
gsutil mb -l REGION gs://YOUR_OUTPUT_BUCKET_NAME
```
Clonez le dépôt de l'exemple d'application sur votre machine locale :
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Vous pouvez également télécharger l'exemple en tant que fichier ZIP et l'extraire.

Accédez au répertoire qui contient l'exemple de code de Cloud Functions :

Node.js

cd nodejs-docs-samples/functions/v2/imagemagick/

Python

cd python-docs-samples/functions/v2/imagemagick/

Go

cd golang-samples/functions/functionsv2/imagemagick/

Java

cd java-docs-samples/functions/v2/imagemagick/

Comprendre le code

L'exemple ImageMagick inclut des dépendances et deux fonctions différentes. La première fonction analyse l'image et la seconde la floute si elle comporte du contenu violent ou réservé aux adultes.

Importer des dépendances

L'application doit importer plusieurs dépendances afin d'interagir avec les services Google Cloud, ImageMagick et le système de fichiers :

convertRemarque : ImageMagick et son outil de ligne de commande sont inclus par défaut dans l'environnement d'exécution Cloud Functions pour la plupart des environnements d'exécution. Pour PHP, vous devrez peut-être effectuer une configuration manuelle. Notez que Cloud Functions n'est pas compatible avec l'installation de packages personnalisés au niveau du système.

Node.js

const functions = require('@google-cloud/functions-framework');
const gm = require('gm').subClass({imageMagick: true});
const fs = require('fs').promises;
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

import os
import tempfile

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

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

Go


// 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"
	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
	cloudevents "github.com/cloudevents/sdk-go/v2"
	"github.com/googleapis/google-cloudevents-go/cloud/storagedata"
	"google.golang.org/protobuf/encoding/protojson"
)

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

	bgctx := context.Background()
	storageClient, err = storage.NewClient(bgctx)
	if err != nil {
		log.Fatalf("storage.NewClient: %v", err)
	}

	visionClient, err = vision.NewImageAnnotatorClient(bgctx)
	if err != nil {
		log.Fatalf("vision.NewAnnotatorClient: %v", err)
	}
	functions.CloudEvent("blur-offensive-images", blurOffensiveImages)
}

Java


import com.google.cloud.functions.CloudEventsFunction;
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.events.cloud.storage.v1.StorageObjectData;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.util.JsonFormat;
import io.cloudevents.CloudEvent;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ImageMagick implements CloudEventsFunction {

  private static Storage storage = StorageOptions.getDefaultInstance().getService();
  private static final String BLURRED_BUCKET_NAME = System.getenv("BLURRED_BUCKET_NAME");
  private static final Logger logger = Logger.getLogger(ImageMagick.class.getName());
}

Analysez des images

La fonction suivante est appelée lorsqu'une image est importée dans le bucket Cloud Storage que vous avez créé pour l'entrée d'images. La fonction utilise l'API Cloud Vision pour détecter le contenu violent ou réservé aux adultes dans les images importées.

Node.js

// Blurs uploaded images that are flagged as Adult or Violence.
functions.cloudEvent('blurOffensiveImages', async cloudEvent => {
  // This event represents the triggering Cloud Storage object.
  const bucket = cloudEvent.data.bucket;
  const name = cloudEvent.data.name;
  const file = storage.bucket(bucket).file(name);
  const filePath = `gs://${bucket}/${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 await 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

# Blurs uploaded images that are flagged as Adult or Violent imagery.
@functions_framework.cloud_event
def blur_offensive_images(cloud_event):
    file_data = cloud_event.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(gcs_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
    # 5 maps to VERY_LIKELY
    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


// blurOffensiveImages blurs offensive images uploaded to GCS.
func blurOffensiveImages(ctx context.Context, e cloudevents.Event) error {
	outputBucket := os.Getenv("BLURRED_BUCKET_NAME")
	if outputBucket == "" {
		return errors.New("environment variable BLURRED_BUCKET_NAME must be set")
	}

	var gcsEvent storagedata.StorageObjectData
	if err := protojson.Unmarshal(e.Data(), &gcsEvent); err != nil {
		return fmt.Errorf("protojson.Unmarshal: failed to decode event data: %w", err)
	}
	img := vision.NewImageFromURI(fmt.Sprintf("gs://%s/%s", gcsEvent.GetBucket(), gcsEvent.GetName()))

	resp, err := visionClient.DetectSafeSearch(ctx, img, nil)
	if err != nil {
		return fmt.Errorf("visionClient.DetectSafeSearch: %w", err)
	}

	if resp.GetAdult() == visionpb.Likelihood_VERY_LIKELY ||
		resp.GetViolence() == visionpb.Likelihood_VERY_LIKELY {
		return blur(ctx, gcsEvent.Bucket, outputBucket, gcsEvent.Name)
	}
	log.Printf("The image %q was detected as OK.", gcsEvent.Name)
	return nil
}

Java

@Override
// Blurs uploaded images that are flagged as Adult or Violence.
public void accept(CloudEvent event) throws InvalidProtocolBufferException {
  // Extract the GCS Event data from the CloudEvent's data payload.
  StorageObjectData data = getEventData(event);
  // Validate parameters
  if (data == null) {
    logger.severe("Error: Malformed GCS event.");
    return;
  }

  BlobInfo blobInfo = BlobInfo.newBuilder(data.getBucket(), data.getName()).build();

  // Construct URI to GCS bucket and file.
  String gcsPath = String.format("gs://%s/%s", data.getBucket(), data.getName());
  logger.info(String.format("Analyzing %s", data.getName()));

  // Construct request.
  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();
  List<AnnotateImageRequest> requests = List.of(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()) {
        logger.info(String.format("Error: %s", res.getError().getMessage()));
        return;
      }
      // Get Safe Search Annotations
      SafeSearchAnnotation annotation = res.getSafeSearchAnnotation();
      if (annotation.getAdultValue() == 5 || annotation.getViolenceValue() == 5) {
        logger.info(String.format("Detected %s as inappropriate.", data.getName()));
        blur(blobInfo);
      } else {
        logger.info(String.format("Detected %s as OK.", data.getName()));
      }
    }
  } catch (IOException e) {
    logger.log(Level.SEVERE, "Error with Vision API: " + e.getMessage(), e);
  }
}

Flouter des images

La fonction suivante est appelée lorsqu'un contenu violent ou réservé aux adultes est détecté dans une image importée. La fonction télécharge l'image choquante, utilise ImageMagick pour flouter l'image, puis importe l'image floutée dans votre bucket de sortie.

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.
  return fs.unlink(tempLocalPath);
};

Python

# Blurs the given file using ImageMagick.
def __blur_image(current_blob):
    file_name = current_blob.name
    _, temp_local_filename = tempfile.mkstemp()

    # Download file from bucket.
    current_blob.download_to_filename(temp_local_filename)
    print(f"Image {file_name} was downloaded to {temp_local_filename}.")

    # Blur the image using ImageMagick.
    with Image(filename=temp_local_filename) as image:
        image.resize(*image.size, blur=16, filter="hamming")
        image.save(filename=temp_local_filename)

    print(f"Image {file_name} was blurred.")

    # Upload result to a second bucket, to avoid re-triggering the function.
    # You could instead re-upload it to the same bucket + tell your function
    # to ignore files marked as blurred (e.g. those with a "blurred" prefix)
    blur_bucket_name = os.getenv("BLURRED_BUCKET_NAME")
    blur_bucket = storage_client.bucket(blur_bucket_name)
    new_blob = blur_bucket.blob(file_name)
    new_blob.upload_from_filename(temp_local_filename)
    print(f"Blurred image uploaded to: gs://{blur_bucket_name}/{file_name}")

    # Delete the temporary file.
    os.remove(temp_local_filename)

Go


// 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("inputBlob.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)
	}

	if err := w.Close(); err != nil {
		return fmt.Errorf("failed to write output file: %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.
private 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.
  Path upload = Paths.get("/tmp/", "blurred-" + fileName);
  List<String> args = List.of("convert", download.toString(), "-blur", "0x8", upload.toString());
  try {
    ProcessBuilder pb = new ProcessBuilder(args);
    Process process = pb.start();
    process.waitFor();
  } catch (Exception e) {
    logger.info(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();

  byte[] blurredFile = Files.readAllBytes(upload);
  storage.create(blurredBlobInfo, blurredFile);
  logger.info(
      String.format("Blurred image uploaded to: gs://%s/%s", BLURRED_BUCKET_NAME, fileName));

  // Remove images from fileSystem
  Files.delete(download);
  Files.delete(upload);
}

Déployer la fonction

Pour déployer votre fonction Cloud avec un déclencheur Cloud Storage, exécutez la commande suivante dans le répertoire contenant l'exemple de code (ou, dans le cas de Java, le fichier pom.xml) :

Node.js

gcloud functions deploy nodejs-blur-function \
--gen2 \
--runtime=RUNTIME \
--region=REGION \
--source=. \
--entry-point=blurOffensiveImages \
--trigger-bucket=YOUR_INPUT_BUCKET_NAME \
--set-env-vars=BLURRED_BUCKET_NAME=YOUR_OUTPUT_BUCKET_NAME

Python

gcloud functions deploy python-blur-function \
--gen2 \
--runtime=RUNTIME \
--region=REGION \
--source=. \
--entry-point=blur_offensive_images \
--trigger-bucket=YOUR_INPUT_BUCKET_NAME \
--set-env-vars=BLURRED_BUCKET_NAME=YOUR_OUTPUT_BUCKET_NAME

Go

gcloud functions deploy go-blur-function \
--gen2 \
--runtime=RUNTIME \
--region=REGION \
--source=. \
--entry-point=blur-offensive-images \
--trigger-bucket=YOUR_INPUT_BUCKET_NAME \
--set-env-vars=BLURRED_BUCKET_NAME=YOUR_OUTPUT_BUCKET_NAME

Java

gcloud functions deploy java-blur-function \
--gen2 \
--runtime=RUNTIME \
--region=REGION \
--source=. \
--entry-point=functions.ImageMagick \
--trigger-bucket=YOUR_INPUT_BUCKET_NAME \
--set-env-vars=BLURRED_BUCKET_NAME=YOUR_OUTPUT_BUCKET_NAME

Remplacez les éléments suivants :

RUNTIME: environnement d'exécution basé sur Ubuntu 18.04 ou une version ultérieure
REGION : nom de la région Google Cloud dans laquelle vous souhaitez déployer votre fonction (par exemple, us-west1).
YOUR_INPUT_BUCKET_NAME : nom du bucket Cloud Storage pour l'importation d'images.
YOUR_OUTPUT_BUCKET_NAME : nom du bucket dans lequel les images floutées doivent être enregistrées.

Lorsque vous déployez des fonctions de 2e génération, spécifiez uniquement le nom du bucket, sans le gs:// initial ; par exemple : --trigger-event-filters="bucket=my-bucket".

Importer une image

Importez une image choquante, telle que cette image d'un zombie mangeur de chair :
```
gsutil cp zombie.jpg gs://YOUR_INPUT_BUCKET_NAME
```
où YOUR_INPUT_BUCKET_NAME est le bucket Cloud Storage que vous avez créé précédemment pour importer des images.

L'analyse de l'image doit s'afficher dans les journaux :

gcloud beta functions logs read YOUR_FUNCTION_NAME --gen2 --limit=100

Vous pouvez afficher les images floues dans le bucket Cloud Storage YOUR_OUTPUT_BUCKET_NAME que vous avez créé précédemment.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

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.

Supprimer la fonction Cloud

La suppression de fonctions Cloud Functions ne supprime pas les ressources stockées dans Cloud Storage.

Pour supprimer la fonction que vous avez déployée dans ce tutoriel, exécutez la commande suivante :

Node.js

gcloud functions delete nodejs-blur-function --gen2 --region REGION

Python

gcloud functions delete python-blur-function --gen2 --region REGION

Go

gcloud functions delete go-blur-function --gen2 --region REGION

Java

gcloud functions delete java-blur-function --gen2 --region REGION

Vous pouvez également supprimer des fonctions Cloud Functions à partir de Google Cloud Console.