Cloud Data Loss Prevention (Cloud DLP) fait désormais partie de la protection des données sensibles. Le nom de l'API reste le même: API Cloud Data Loss Prevention (DLP). Pour en savoir plus sur les services qui constituent Sensitive Data Protection, consultez la section Présentation de Sensitive Data Protection.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Inspecter des images pour identifier les données sensibles

Ce document explique comment utiliser l'API Cloud Data Loss Prevention pour détecter du texte et des objets sensibles dans une image. Sensitive Data Protection renvoie l'emplacement de toutes les données sensibles qu'il détecte.

Remarques : Sensitive Data Protection peut inspecter de nombreux types d'images pour détecter les données sensibles, y compris JPEG, BMP, PNG, SVG et TIFF. Pour les images TIFF de plusieurs pages, consultez Inspecter une image TIFF de plusieurs pages. Sensitive Data Protection peut également inspecter d'autres formats de fichiers tels que PDF, DOCX, XLSX et PPTX, mais peut générer des résultats mitigés (y compris des décalages d'octets et des cadres de délimitation) en fonction du contenu de chaque fichier. Pour en savoir plus, consultez Types de fichiers acceptés.

L'inspection des fichiers à l'aide de la méthode décrite dans ce document est soumise à des limites de taille de fichier. Pour les fichiers plus volumineux, envisagez d'utiliser Sensitive Data Protection pour analyser un dépôt de stockage contenant les fichiers. Pour en savoir plus sur les limites de taille de fichier et Sensitive Data Protection, consultez Limites d'utilisation.

À partir d'une image en entrée, Sensitive Data Protection détecte les données sensibles qu'elle contient. Le résultat d'une opération d'inspection inclut les infoTypes détectés, la probabilité de correspondance, ainsi que les coordonnées de pixel et les valeurs de longueur qui indiquent les zones dans lesquelles Sensitive Data Protection a trouvé les données sensibles. Les coordonnées dans l'angle inférieur gauche d'une image sont (0,0).

Inspecter une image pour tous les infoTypes par défaut

Pour inspecter une image à la recherche de données sensibles, vous devez envoyer une image encodée en base64 à la méthode content.inspect. Si vous ne spécifiez pas de types d'informations (infoTypes) spécifiques à rechercher, Sensitive Data Protection recherche les infoTypes les plus courants.

Pour inspecter une image pour tous les types d'informations par défaut, procédez comme suit :

Encodez l'image en base64.
Envoyez une requête à la méthode content.inspect de l'API DLP. La requête ne nécessite que l'image encodée en base64.

Prenons l'exemple de cette image d'un document.

Image d'origine contenant les coordonnées d'une personne. — Image d'origine (cliquez pour agrandir).

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

Pour vous authentifier auprès de Sensitive Data Protection, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


using System;
using System.IO;
using System.Linq;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
using Google.Protobuf;

public class InspectImageForSensitiveDataWithInfoTypes
{
    public static InspectContentResponse InspectImage(
        string projectId,
        string filePath)
    {
        // Instantiate dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the content item.
        var contentItem = new ContentItem
        {
            ByteItem = new ByteContentItem
            {
                Type = ByteContentItem.Types.BytesType.ImagePng,
                Data = ByteString.FromStream(new FileStream(filePath, FileMode.Open))
            }
        };

        // Construct the request.
        var request = new InspectContentRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            Item = contentItem,
            InspectConfig = new InspectConfig
            {
                IncludeQuote = true,
                InfoTypes =
                    {
                        new InfoType { Name = "PHONE_NUMBER" },
                        new InfoType { Name = "EMAIL_ADDRESS" },
                        new InfoType { Name = "PERSON_NAME" }
                    }
            }
        };

        // Call the API.
        var response = dlp.InspectContent(request);

        // Inspect the response.
        var resultFindings = response.Result.Findings;

        Console.WriteLine($"Findings: {resultFindings.Count}\n");

        foreach (var f in resultFindings)
        {
            var data = from location in f.Location.ContentLocations
                       from b in location.ImageLocation.BoundingBoxes
                       select new { b.Height, b.Width, b.Top, b.Left };
            Console.WriteLine("Info type: " + f.InfoType.Name);
            Console.WriteLine("\tImageLocations: " + string.Join(',', data));
            Console.WriteLine("\tQuote: " + f.Quote);
            Console.WriteLine("\tLikelihood: " + f.Likelihood + "\n");
        }

        return response;
    }
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

import (
	"context"
	"fmt"
	"io"
	"os"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectImageFileAllInfoTypes inspects a image for sensitive data with infoTypes
func inspectImageFileAllInfoTypes(w io.Writer, projectID, inputPath string) error {
	// projectId := "your-project-id"
	// inputPath := "your-input-path"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// read the image file
	data, err := os.ReadFile(inputPath)
	if err != nil {
		return err
	}

	// Create and send the request.
	req := &dlppb.InspectContentRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
		Item: &dlppb.ContentItem{
			// Specify the content to be inspected.
			DataItem: &dlppb.ContentItem_ByteItem{
				ByteItem: &dlppb.ByteContentItem{
					Type: dlppb.ByteContentItem_IMAGE_JPEG,
					Data: data,
				},
			},
		},
	}

	// Send the request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		return fmt.Errorf("InspectContent: %w", err)
	}

	// Process the results.
	fmt.Fprintf(w, "Findings: %d\n", len(resp.Result.Findings))
	for _, f := range resp.Result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil

}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ByteContentItem;
import com.google.privacy.dlp.v2.ByteContentItem.BytesType;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.protobuf.ByteString;
import java.io.FileInputStream;
import java.io.IOException;

class InspectImageFileAllInfoTypes {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String inputPath = "src/test/resources/sensitive-data-image.jpeg";
    inspectImageFileAllInfoTypes(projectId, inputPath);
  }

  static void inspectImageFileAllInfoTypes(String projectId, String inputPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlp = DlpServiceClient.create()) {
      // Specify the content to be inspected.
      ByteString fileBytes = ByteString.readFrom(new FileInputStream(inputPath));
      ByteContentItem byteItem =
          ByteContentItem.newBuilder().setType(BytesType.IMAGE_JPEG).setData(fileBytes).build();

      // Construct the Inspect request to be sent by the client.
      // Do not specify the type of info to inspect.
      InspectContentRequest request =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setItem(ContentItem.newBuilder().setByteItem(byteItem).build())
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(request);

      // Parse the response and process results.
      System.out.println("Findings: " + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfo type: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood());
      }
    }
  }
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');
const mime = require('mime');
const fs = require('fs');

// Instantiates a client
const dlp = new DLP.DlpServiceClient();

// The project ID to run the API call under
// const projectId = 'my-project';

// Image Path
// const imagePath = './test.jpeg';

async function inspectImageFileAllType() {
  let fileBytes = null;
  let fileTypeConstant = null;
  try {
    // Load Image
    fileTypeConstant =
      ['image/jpeg', 'image/bmp', 'image/png', 'image/svg'].indexOf(
        mime.getType(imagePath)
      ) + 1;
    fileBytes = Buffer.from(fs.readFileSync(imagePath)).toString('base64');
  } catch (error) {
    console.error(error.message);
    return;
  }
  // Specify the content to be inspected.
  const item = {
    byteItem: {
      type: fileTypeConstant,
      data: fileBytes,
    },
  };

  // Construct the Inspect request to be sent by the client.
  // Do not specify the type of info to inspect.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    item: item,
    inspectConfig: {
      includeQuote: true,
    },
  };

  // Use the client to send the API request.
  const [response] = await dlp.inspectContent(request);

  // Print findings.
  const findings = response.result.findings;
  if (findings.length > 0) {
    console.log(`Findings: ${findings.length}\n`);
    findings.forEach(finding => {
      console.log(`InfoType: ${finding.infoType.name}`);
      console.log(`\tQuote: ${finding.quote}`);
      console.log(`\tLikelihood: ${finding.likelihood} \n`);
    });
  } else {
    console.log('No findings.');
  }
}
inspectImageFileAllType();

PHP

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

use Google\Cloud\Dlp\V2\ByteContentItem;
use Google\Cloud\Dlp\V2\ByteContentItem\BytesType;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\InspectContentRequest;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * Inspect image for sensitive data with infoTypes.
 * To inspect an image for sensitive data, you submit a base64-encoded image to the Cloud DLP API's
 * content.inspect method. Unless you specify information types (infoTypes) to search for, Cloud DLP
 * searches for the most common infoTypes.
 *
 * @param string $projectId         The Google Cloud project id to use as a parent resource.
 * @param string $inputPath         The image path to inspect.
 */
function inspect_image_all_infotypes(
    // TODO(developer): Replace sample parameters before running the code.
    string $projectId,
    string $inputPath = './test/data/test.png'
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Get the bytes of the file.
    $fileBytes = (new ByteContentItem())
        ->setType(BytesType::IMAGE_PNG)
        ->setData(file_get_contents($inputPath));

    $parent = "projects/$projectId/locations/global";

    // Specify what content you want the service to Inspect.
    $item = (new ContentItem())
        ->setByteItem($fileBytes);

    // Run request.
    $inspectContentRequest = (new InspectContentRequest())
        ->setParent($parent)
        ->setItem($item);
    $response = $dlp->inspectContent($inspectContentRequest);

    // Print the results.
    $findings = $response->getResult()->getFindings();
    if (count($findings) == 0) {
        printf('No findings.' . PHP_EOL);
    } else {
        printf('Findings:' . PHP_EOL);
        foreach ($findings as $finding) {
            printf('  Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
            printf('  Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
        }
    }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

import google.cloud.dlp


def inspect_image_file_all_infotypes(
    project: str,
    filename: str,
    include_quote: bool = True,
) -> None:
    """Uses the Data Loss Prevention API to analyze strings for protected data in image file.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        filename: The path to the file to inspect.
        include_quote: Boolean for whether to display a quote of the detected
            information in the results.

    Returns:
        None; the response from the API is printed to the terminal.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Construct the byte_item, containing the image file's byte data.
    with open(filename, mode="rb") as f:
        byte_item = {"type_": "IMAGE", "data": f.read()}

    # Convert the project id into a full resource id.
    parent = f"projects/{project}"

    # Call the API.
    response = dlp.inspect_content(
        request={
            "parent": parent,
            "inspect_config": {"include_quote": include_quote},
            "item": {"byte_item": byte_item},
        }
    )

    # Print out the results.
    print("Findings: ", response.result.findings.count)
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Quote: {finding.quote}")
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")

REST

Important : Avant d'envoyer cette requête, utilisez un utilitaire base64 pour encoder l'image en données texte ASCII, puis remplacez l'espace réservé BASE64_ENCODED_IMAGE par l'image encodée en base64. La plupart des environnements de développement contiennent un utilitaire base64 natif. Pour encoder un fichier image, procédez comme suit :

Linux : base64 input.jpg > output.txt
macOS : base64 -i input.jpg -o output.txt
PowerShell : [Convert]::ToBase64String([IO.File]::ReadAllBytes("./input.jpg")) > output.txt

Pour inspecter cette image à la recherche d'infoTypes par défaut, envoyez le code JSON suivant à la méthode content.inspect :

{
  "item": {
    "byteItem": {
      "data": "BASE64_ENCODED_IMAGE",
      "type": "IMAGE_PNG"
    }
  }
}

Le résultat ressemble à ce qui suit :

{
  "result": {
    "findings": [
      {
        "infoType": {
          "name": "PERSON_NAME",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 383,
                    "left": 419,
                    "width": 82,
                    "height": 38
                  },
                  {
                    "top": 383,
                    "left": 494,
                    "width": 91,
                    "height": 37
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:27:03.730Z",
        "findingId": "2025-05-22T20:27:03.731510Z4997664074931396457"
      },
      {
        "infoType": {
          "name": "EMAIL_ADDRESS",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "VERY_LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 445,
                    "left": 390,
                    "width": 357,
                    "height": 48
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:27:03.728Z",
        "findingId": "2025-05-22T20:27:03.731538Z284444825812417100"
      },
      {
        "infoType": {
          "name": "PHONE_NUMBER",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "VERY_LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 515,
                    "left": 404,
                    "width": 223,
                    "height": 34
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:27:03.729Z",
        "findingId": "2025-05-22T20:27:03.731544Z7910624062018243126"
      },
      {
        "infoType": {
          "name": "PERSON_NAME",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "UNLIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 798,
                    "left": 473,
                    "width": 81,
                    "height": 45
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:27:03.730Z",
        "findingId": "2025-05-22T20:27:03.731551Z2345136870450870227"
      },
      {
        "infoType": {
          "name": "PERSON_NAME",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "UNLIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 837,
                    "left": 1166,
                    "width": 46,
                    "height": 45
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:27:03.730Z",
        "findingId": "2025-05-22T20:27:03.731557Z6725780456697828166"
      },
      {
        "infoType": {
          "name": "PERSON_NAME",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "UNLIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 915,
                    "left": 453,
                    "width": 141,
                    "height": 43
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:27:03.730Z",
        "findingId": "2025-05-22T20:27:03.731562Z7328853308213386463"
      },
      {
        "infoType": {
          "name": "PERSON_NAME",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "UNLIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 915,
                    "left": 1180,
                    "width": 105,
                    "height": 43
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:27:03.730Z",
        "findingId": "2025-05-22T20:27:03.731569Z5618332947461439057"
      }
    ]
  }
}

Dans cet exemple, Sensitive Data Protection a trouvé les infoTypes suivants, bien que son niveau de confiance varie pour chacun d'eux :

PERSON_NAME
EMAIL_ADDRESS
PHONE_NUMBER

Pour en savoir plus sur l'utilisation de l'API DLP avec JSON, consultez le guide de démarrage rapide JSON.

Sachez que Sensitive Data Protection utilise souvent plusieurs cadres pour indiquer l'emplacement d'une seule instance de données sensibles dans l'image.

Inspecter une image pour détecter des infoTypes spécifiques

Pour inspecter une image uniquement pour certains types de données sensibles, spécifiez les infoTypes intégrés correspondants.

Pour inspecter une image à la recherche d'infoTypes spécifiques, procédez comme suit :

Encodez l'image en base64.
Envoyez une requête à la méthode content.inspect de l'API DLP. La requête doit inclure les éléments suivants :
- L'image encodée en base64
- Un ou plusieurs détecteurs d'infoTypes

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.


using System;
using System.IO;
using System.Linq;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
using Google.Protobuf;

public class InspectImageForSensitiveDataWithListedInfoTypes
{
    public static InspectContentResponse InspectImage(
        string projectId,
        string filePath)
    {
        // Instantiate dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the content item by providing the image file and its type.
        var contentItem = new ContentItem
        {
            ByteItem = new ByteContentItem
            {
                Type = ByteContentItem.Types.BytesType.ImagePng,
                Data = ByteString.FromStream(new FileStream(filePath, FileMode.Open))
            }
        };

        // Specify the type of info the inspection will look for.
        var infoTypes = new InfoType[]
        {
            new InfoType { Name = "PHONE_NUMBER" },
            new InfoType { Name = "EMAIL_ADDRESS" },
            new InfoType { Name = "US_SOCIAL_SECURITY_NUMBER" }
        };

        // Construct the Inspect config.
        var inspectConfig = new InspectConfig
        {
            InfoTypes = { infoTypes },
            IncludeQuote = true
        };

        // Construct the request.
        var request = new InspectContentRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            InspectConfig = inspectConfig,
            Item = contentItem
        };

        // Call the API.
        InspectContentResponse response = dlp.InspectContent(request);

        // Inspect the response.
        var resultFindings = response.Result.Findings;

        Console.WriteLine($"Findings: {resultFindings.Count}");

        foreach (var f in resultFindings)
        {
            var data = from location in f.Location.ContentLocations
                       from b in location.ImageLocation.BoundingBoxes
                       select new { b.Height, b.Width, b.Top, b.Left };

            Console.WriteLine("Info type: " + f.InfoType.Name);
            Console.WriteLine("\tQuote: " + f.Quote);
            Console.WriteLine("\tImageLocations: " + string.Join(",", data));
            Console.WriteLine("\tLikelihood: " + f.Likelihood);
        }

        return response;
    }
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

import (
	"context"
	"fmt"
	"io"
	"os"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectImageFileListedInfoTypes inspects an image for sensitive data listed infoTypes.
func inspectImageFileListedInfoTypes(w io.Writer, projectID, filePath string) error {
	// projectId := "my-project-id"
	// filePath := "testdata/image.jpg"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Read a image file
	data, err := os.ReadFile(filePath)
	if err != nil {
		return err
	}

	// Specify the type and content to be inspected.
	item := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_ByteItem{
			ByteItem: &dlppb.ByteContentItem{
				Type: dlppb.ByteContentItem_IMAGE_JPEG,
				Data: data,
			},
		},
	}

	// Construct the configuration for the Inspect request.
	inspectConfig := &dlppb.InspectConfig{
		InfoTypes: []*dlppb.InfoType{
			{Name: "PHONE_NUMBER"},
			{Name: "EMAIL_ADDRESS"},
			{Name: "US_SOCIAL_SECURITY_NUMBER"},
		},
		IncludeQuote: true,
	}

	// Construct the Inspect request to be sent by the client.
	req := &dlppb.InspectContentRequest{
		Parent:        fmt.Sprintf("projects/%s/locations/global", projectID),
		Item:          item,
		InspectConfig: inspectConfig,
	}

	// Send the request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		return err
	}

	// Process the results.
	fmt.Fprintf(w, "Findings: %d\n", len(resp.Result.Findings))
	for _, f := range resp.Result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil
}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ByteContentItem;
import com.google.privacy.dlp.v2.ByteContentItem.BytesType;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.protobuf.ByteString;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

class InspectImageFileListedInfoTypes {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String inputPath = "src/test/resources/sensitive-data-image.jpeg";
    inspectImageFileListedInfoTypes(projectId, inputPath);
  }

  static void inspectImageFileListedInfoTypes(String projectId, String inputPath)
      throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlp = DlpServiceClient.create()) {
      // Specify the content to be inspected.
      ByteString fileBytes = ByteString.readFrom(new FileInputStream(inputPath));
      ByteContentItem byteItem =
          ByteContentItem.newBuilder().setType(BytesType.IMAGE_JPEG).setData(fileBytes).build();

      // Specify the type of info the inspection will look for.
      List<InfoType> infoTypes = new ArrayList<>();
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      for (String typeName :
          new String[] {"US_SOCIAL_SECURITY_NUMBER", "EMAIL_ADDRESS", "PHONE_NUMBER"}) {
        infoTypes.add(InfoType.newBuilder().setName(typeName).build());
      }

      // Construct the configuration for the Inspect request.
      InspectConfig inspectConfig = InspectConfig.newBuilder().addAllInfoTypes(infoTypes).build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest request =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setItem(ContentItem.newBuilder().setByteItem(byteItem).build())
              .setInspectConfig(inspectConfig)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(request);

      // Parse the response and process results.
      System.out.println("Findings: " + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfo type: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood());
      }
    }
  }
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');
const mime = require('mime');
const fs = require('fs');

// Instantiates a client
const dlp = new DLP.DlpServiceClient();

// The project ID to run the API call under
// const imagePath = './test.pdf';

// InfoTypes
const infoTypes = [
  {name: 'PHONE_NUMBER'},
  {name: 'EMAIL_ADDRESS'},
  {name: 'US_SOCIAL_SECURITY_NUMBER'},
];

async function inspectImageFileListedInfoTypes() {
  let fileBytes = null;
  let fileTypeConstant = null;
  try {
    // Load Image
    fileTypeConstant =
      ['image/jpeg', 'image/bmp', 'image/png', 'image/svg'].indexOf(
        mime.getType(imagePath)
      ) + 1;
    fileBytes = Buffer.from(fs.readFileSync(imagePath)).toString('base64');
  } catch (error) {
    console.log(error);
    return;
  }
  // Specify item to inspect
  const item = {
    byteItem: {
      type: fileTypeConstant,
      data: fileBytes,
    },
  };

  // Specify inspect configuration to match information with mentioned infotypes.
  const inspectConfig = {
    infoTypes: infoTypes,
    includeQuote: true,
  };

  // Combine configurations into a request for the service.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectConfig: inspectConfig,
    item: item,
  };

  // Use the client to send the request.
  const [response] = await dlp.inspectContent(request);

  // Print Findings
  const findings = response.result.findings;
  if (findings.length > 0) {
    console.log(`Findings: ${findings.length}\n`);
    findings.forEach(finding => {
      console.log(`InfoType: ${finding.infoType.name}`);
      console.log(`\tQuote: ${finding.quote}`);
      console.log(`\tLikelihood: ${finding.likelihood} \n`);
    });
  } else {
    console.log('No findings.');
  }
}
inspectImageFileListedInfoTypes();

PHP

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

use Google\Cloud\Dlp\V2\ByteContentItem;
use Google\Cloud\Dlp\V2\ByteContentItem\BytesType;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectContentRequest;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * Inspect an image for sensitive data with listed infoTypes.
 * If you want to inspect an image for only certain sensitive data types, specify their corresponding
 * built-in infoTypes.
 *
 * @param string $projectId         The Google Cloud project id to use as a parent resource.
 * @param string $inputPath         The image path to inspect.
 */
function inspect_image_listed_infotypes(
    // TODO(developer): Replace sample parameters before running the code.
    string $projectId,
    string $inputPath = './test/data/test.png'
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Get the bytes of the file.
    $fileBytes = (new ByteContentItem())
        ->setType(BytesType::IMAGE_PNG)
        ->setData(file_get_contents($inputPath));

    $parent = "projects/$projectId/locations/global";

    // Specify what content you want the service to Inspect.
    $item = (new ContentItem())
        ->setByteItem($fileBytes);

    // Create inspect config configuration.
    $inspectConfig = (new InspectConfig())
        // The infoTypes of information to match.
        ->setInfoTypes([
            (new InfoType())->setName('PHONE_NUMBER'),
            (new InfoType())->setName('EMAIL_ADDRESS'),
            (new InfoType())->setName('US_SOCIAL_SECURITY_NUMBER')
        ]);

    // Run request.
    $inspectContentRequest = (new InspectContentRequest())
        ->setParent($parent)
        ->setInspectConfig($inspectConfig)
        ->setItem($item);
    $response = $dlp->inspectContent($inspectContentRequest);

    // Print the results.
    $findings = $response->getResult()->getFindings();
    if (count($findings) == 0) {
        printf('No findings.' . PHP_EOL);
    } else {
        printf('Findings:' . PHP_EOL);
        foreach ($findings as $finding) {
            printf('  Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
            printf('  Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
        }
    }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

from typing import List

import google.cloud.dlp


def inspect_image_file_listed_infotypes(
    project: str,
    filename: str,
    info_types: List[str],
    include_quote: bool = True,
) -> None:
    """Uses the Data Loss Prevention API to analyze strings in an image for
    data matching the given infoTypes.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        filename: The path of the image file to inspect.
        info_types:  A list of strings representing infoTypes to look for.
            A full list of info type categories can be fetched from the API.
        include_quote: Boolean for whether to display a matching snippet of
            the detected information in the results.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries.
    info_types = [{"name": info_type} for info_type in info_types]

    # Construct the configuration dictionary.
    inspect_config = {
        "info_types": info_types,
        "include_quote": include_quote,
    }

    # Construct the byte_item, containing the image file's byte data.
    with open(filename, mode="rb") as f:
        byte_item = {"type_": "IMAGE", "data": f.read()}

    # Convert the project id into a full resource id.
    parent = f"projects/{project}"

    # Call the API.
    response = dlp.inspect_content(
        request={
            "parent": parent,
            "inspect_config": inspect_config,
            "item": {"byte_item": byte_item},
        }
    )

    # Print out the results.
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Info type: {finding.info_type.name}")
            if include_quote:
                print(f"Quote: {finding.quote}")
            print(f"Likelihood: {finding.likelihood} \n")
    else:
        print("No findings.")

REST

Linux : base64 input.jpg > output.txt
macOS : base64 -i input.jpg -o output.txt
PowerShell : [Convert]::ToBase64String([IO.File]::ReadAllBytes("./input.jpg")) > output.txt

Prenons l'exemple de l'image d'origine de la section précédente. Pour n'inspecter que les adresses e-mail et les numéros de téléphone, envoyez le code JSON suivant à la méthode content.inspect.

{
  "item": {
    "byteItem": {
      "data": "BASE64_ENCODED_IMAGE",
      "type": "IMAGE_PNG"
    }
  },
  "inspectConfig": {
    "infoTypes": [
      {
        "name": "PHONE_NUMBER"
      },
      {
        "name": "EMAIL_ADDRESS"
      }
    ]
  }
}

Le résultat ressemble à ce qui suit :

{
  "result": {
    "findings": [
      {
        "infoType": {
          "name": "EMAIL_ADDRESS",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "VERY_LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 445,
                    "left": 390,
                    "width": 357,
                    "height": 48
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:59:48.653Z",
        "findingId": "2025-05-22T20:59:48.654873Z3907900286477341146"
      },
      {
        "infoType": {
          "name": "PHONE_NUMBER",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "VERY_LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 515,
                    "left": 404,
                    "width": 223,
                    "height": 34
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T20:59:48.653Z",
        "findingId": "2025-05-22T20:59:48.654914Z7486984971818202511"
      }
    ]
  }
}

Pour découvrir comment utiliser le format JSON avec l'API DLP, consultez le démarrage rapide JSON.

Inspecter une image pour détecter des objets sensibles

Pour inspecter une image à la recherche d'objets sensibles, spécifiez les détecteurs d'infoTypes d'objets intégrés dans la requête.

Pour inspecter une image à la recherche d'infoTypes d'objets spécifiques, procédez comme suit :

Encodez l'image en base64.
Envoyez une requête à la méthode content.inspect de l'API DLP. La requête doit inclure les éléments suivants :
- L'image encodée en base64
- Un ou plusieurs détecteurs d'infoTypes d'objets.

Par exemple, considérons l'image suivante.

Image générée par l'IA contenant un code-barres, une plaque d'immatriculation et un tableau blanc. — Image générée par l'IA contenant un code-barres, une plaque d'immatriculation et un tableau blanc (cliquez pour agrandir).

Linux : base64 input.jpg > output.txt
macOS : base64 -i input.jpg -o output.txt
PowerShell : [Convert]::ToBase64String([IO.File]::ReadAllBytes("./input.jpg")) > output.txt

Pour inspecter cette image à la recherche d'infoTypes d'objets spécifiques, envoyez le code JSON suivant à la méthode content.inspect :

{
  "item": {
    "byteItem": {
      "data": "BASE64_ENCODED_IMAGE",
      "type": "IMAGE_PNG"
    }
  },
  "inspectConfig": {
    "infoTypes": [
      {
        "name": "OBJECT_TYPE/BARCODE"
      },
      {
        "name": "OBJECT_TYPE/LICENSE_PLATE"
      },
      {
        "name": "OBJECT_TYPE/WHITEBOARD"
      }
    ]
  }
}

Le résultat ressemble à ce qui suit :

{
  "result": {
    "findings": [
      {
        "infoType": {
          "name": "OBJECT_TYPE/WHITEBOARD",
          "sensitivityScore": {
            "score": "SENSITIVITY_LOW"
          }
        },
        "likelihood": "LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "left": 427,
                    "width": 561,
                    "height": 678
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T22:25:09.564718Z",
        "findingId": "2025-05-22T22:25:09.564721Z3400818180961962648"
      },
      {
        "infoType": {
          "name": "OBJECT_TYPE/LICENSE_PLATE",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 554,
                    "left": 137,
                    "width": 187,
                    "height": 70
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T22:25:09.564752Z",
        "findingId": "2025-05-22T22:25:09.564753Z2359274424382836782"
      },
      {
        "infoType": {
          "name": "OBJECT_TYPE/BARCODE",
          "sensitivityScore": {
            "score": "SENSITIVITY_LOW"
          }
        },
        "likelihood": "LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 569,
                    "left": 666,
                    "width": 306,
                    "height": 274
                  }
                ]
              }
            }
          ]
        },
        "createTime": "2025-05-22T22:25:09.564762Z",
        "findingId": "2025-05-22T22:25:09.564762Z1655085669963455621"
      }
    ]
  }
}

Pour en savoir plus sur l'utilisation de l'API DLP avec JSON, consultez le guide de démarrage rapide JSON.

Inspecter une image TIFF multipage

Sensitive Data Protection peut inspecter les images TIFF, y compris les images TIFF multipages comportant jusqu'à 50 pages. Il inspecte chaque page de l'image et renvoie les résultats de toutes les pages dans une seule réponse.

Pour inspecter une image TIFF, procédez comme suit :

Encodez l'image TIFF en base64.
Envoyez une requête à la méthode content.inspect de l'API DLP. Dans la requête, définissez le champ type de l'élément d'octet sur IMAGE_TIFF.

Linux : base64 input.jpg > output.txt
macOS : base64 -i input.jpg -o output.txt
PowerShell : [Convert]::ToBase64String([IO.File]::ReadAllBytes("./input.jpg")) > output.txt

Par exemple, pour inspecter une image TIFF à la recherche d'infoTypes par défaut, envoyez le corps de requête JSON suivant à la méthode content.inspect :

{
  "item": {
    "byteItem": {
      "data": "BASE64_ENCODED_IMAGE",
      "type": "IMAGE_TIFF"
    }
  }
}

Dans la réponse, l'élément imageLocation de chaque résultat inclut un champ pageNumber qui identifie la page contenant le résultat. Les numéros de page commencent à 0. Le résultat ressemble à ce qui suit :

{
  "result": {
    "findings": [
      {
        "infoType": {
          "name": "EMAIL_ADDRESS",
          "sensitivityScore": {
            "score": "SENSITIVITY_MODERATE"
          }
        },
        "likelihood": "LIKELY",
        "location": {
          "contentLocations": [
            {
              "imageLocation": {
                "boundingBoxes": [
                  {
                    "top": 213,
                    "left": 128,
                    "width": 345,
                    "height": 40
                  }
                ],
                "pageNumber": 1
              }
            }
          ]
        },
        "createTime": "2026-10-23T10:15:03.730Z",
        "findingId": "2026-10-23T10:15:03.731510Z4997664074931396457"
      }
    ]
  }
}

Dans cet exemple, Sensitive Data Protection a trouvé un EMAIL_ADDRESS sur la deuxième page de l'image.

Tenez compte des points suivants lorsque vous inspectez des images TIFF :

Une image TIFF peut comporter jusqu'à 50 pages. Si une image TIFF comporte plus de pages, la requête échoue. Pour en savoir plus, consultez Limites d'analyse des fichiers TIFF.
Les règles d'exclusion et d'ajustement basées sur des images (ExcludeByImageFindings et AdjustByImageFindings) ne sont pas compatibles avec les images TIFF. Si votre configuration d'inspection inclut ces règles, la requête échoue.
Vous pouvez inspecter les images TIFF, mais vous ne pouvez pas les masquer.
Comme pour les autres types d'images, vous ne pouvez inspecter les images TIFF que dans les emplacements compatibles avec l'analyse d'images.

Exemples de code

Voici des exemples de code dans plusieurs langages qui montrent comment utiliser Sensitive Data Protection pour inspecter une image à la recherche de données sensibles.

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
using Google.Protobuf;

public class InspectImage
{
    public static InspectContentResponse Inspect(
        string projectId,
        string filePath,
        IEnumerable<InfoType> infoTypes = null)
    {
        // Instantiate dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the content item by setting the type of image and data to be inspected.
        var contentItem = new ContentItem
        {
            ByteItem = new ByteContentItem
            {
                Type = ByteContentItem.Types.BytesType.ImagePng,
                Data = ByteString.FromStream(new FileStream(filePath, FileMode.Open))
            }
        };

        // Construct the Inspect config by specifying the type of info to be inspected.
        var inspectConfig = new InspectConfig
        {
            InfoTypes =
            {
                infoTypes ?? new InfoType[]
                {
                    new InfoType { Name = "PHONE_NUMBER" },
                    new InfoType { Name = "EMAIL_ADDRESS" },
                    new InfoType { Name = "CREDIT_CARD_NUMBER" }
                }
            },
            IncludeQuote = true
        };

        // Construct the request.
        var request = new InspectContentRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            InspectConfig = inspectConfig,
            Item = contentItem
        };

        // Call the API.
        InspectContentResponse response = dlp.InspectContent(request);

        // Inspect the response.
        var resultFindings = response.Result.Findings;

        Console.WriteLine($"Findings: {resultFindings.Count}\n");

        // Print the results.
        foreach (var f in resultFindings)
        {
            var data = from location in f.Location.ContentLocations
                       from b in location.ImageLocation.BoundingBoxes
                       select new { b.Height, b.Width, b.Top, b.Left };

            Console.WriteLine("Info type: " + f.InfoType.Name);
            Console.WriteLine("\tQuote: " + f.Quote);
            Console.WriteLine("\tImageLocations: " + string.Join(",", data));
            Console.WriteLine("\tLikelihood: " + f.Likelihood);
        }

        return response;
    }
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

import (
	"context"
	"fmt"
	"io"
	"os"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectImageFile inspects an image file for sensitive data
func inspectImageFile(w io.Writer, projectID, filePath string) error {
	// projectId := "my-project-id"
	// filePath := "inspect/testdata/test.png"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Read a image file
	data, err := os.ReadFile(filePath)
	if err != nil {
		return err
	}

	// Specify the type and content to be inspected.
	item := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_ByteItem{
			ByteItem: &dlppb.ByteContentItem{
				Type: dlppb.ByteContentItem_IMAGE,
				Data: data,
			},
		},
	}

	// Construct the configuration for the Inspect request.
	inspectConfig := &dlppb.InspectConfig{
		InfoTypes: []*dlppb.InfoType{
			{Name: "PHONE_NUMBER"},
			{Name: "EMAIL_ADDRESS"},
			{Name: "CREDIT_CARD_NUMBER"},
		},
		IncludeQuote: true,
	}

	// Construct the Inspect request to be sent by the client.
	req := &dlppb.InspectContentRequest{
		Parent:        fmt.Sprintf("projects/%s/locations/global", projectID),
		Item:          item,
		InspectConfig: inspectConfig,
	}

	// Send the request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		return err
	}

	// Process the results.
	fmt.Fprintf(w, "Findings: %d\n", len(resp.Result.Findings))
	for _, f := range resp.Result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil
}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ByteContentItem;
import com.google.privacy.dlp.v2.ByteContentItem.BytesType;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.protobuf.ByteString;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class InspectImageFile {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String filePath = "path/to/image.png";
    inspectImageFile(projectId, filePath);
  }

  // Inspects the specified image file.
  public static void inspectImageFile(String projectId, String filePath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlp = DlpServiceClient.create()) {
      // Specify the type and content to be inspected.
      ByteString fileBytes = ByteString.readFrom(new FileInputStream(filePath));
      ByteContentItem byteItem =
          ByteContentItem.newBuilder().setType(BytesType.IMAGE).setData(fileBytes).build();
      ContentItem item = ContentItem.newBuilder().setByteItem(byteItem).build();

      // Specify the type of info the inspection will look for.
      List<InfoType> infoTypes = new ArrayList<>();
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      for (String typeName : new String[] {"PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER"}) {
        infoTypes.add(InfoType.newBuilder().setName(typeName).build());
      }

      // Construct the configuration for the Inspect request.
      InspectConfig config =
          InspectConfig.newBuilder().addAllInfoTypes(infoTypes).setIncludeQuote(true).build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest request =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setItem(item)
              .setInspectConfig(config)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(request);

      // Parse the response and process results.
      System.out.println("Findings: " + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfo type: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood());
      }
    }
  }
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');
const mime = require('mime');
const fs = require('fs');

// Instantiates a client
const dlp = new DLP.DlpServiceClient();

// The project ID to run the API call under
// const imagePath = './test.jpeg';

// InfoTypes
const infoTypes = [
  {name: 'PHONE_NUMBER'},
  {name: 'EMAIL_ADDRESS'},
  {name: 'CREDIT_CARD_NUMBER'},
];

async function inspectImageFile() {
  let fileBytes = null;
  let fileTypeConstant = null;
  try {
    // Load Image
    fileTypeConstant =
      ['image/jpeg', 'image/bmp', 'image/png', 'image/svg'].indexOf(
        mime.getType(imagePath)
      ) + 1;
    fileBytes = Buffer.from(fs.readFileSync(imagePath)).toString('base64');
  } catch (error) {
    console.log(error);
    return;
  }

  // Specify item to inspect
  const item = {
    byteItem: {
      type: fileTypeConstant,
      data: fileBytes,
    },
  };

  // Specify inspect configuration to match information with mentioned infotypes.
  const inspectConfig = {
    infoTypes: infoTypes,
    includeQuote: true,
  };

  // Combine configurations into a request for the service.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectConfig: inspectConfig,
    item: item,
  };

  // Use the client to send the request.
  const [response] = await dlp.inspectContent(request);

  // Print Findings
  const findings = response.result.findings;
  if (findings.length > 0) {
    console.log(`Findings: ${findings.length}\n`);
    findings.forEach(finding => {
      console.log(`InfoType: ${finding.infoType.name}`);
      console.log(`\tQuote: ${finding.quote}`);
      console.log(`\tLikelihood: ${finding.likelihood} \n`);
    });
  } else {
    console.log('No findings.');
  }
}
inspectImageFile();

PHP

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

use Google\Cloud\Dlp\V2\ByteContentItem;
use Google\Cloud\Dlp\V2\ByteContentItem\BytesType;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectContentRequest;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * @param string $projectId
 * @param string $filepath
 */
function inspect_image_file(string $projectId, string $filepath): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Get the bytes of the file
    $fileBytes = (new ByteContentItem())
        ->setType(BytesType::IMAGE_PNG)
        ->setData(file_get_contents($filepath));

    // Construct request
    $parent = "projects/$projectId/locations/global";
    $item = (new ContentItem())
        ->setByteItem($fileBytes);
    $inspectConfig = (new InspectConfig())
        // The infoTypes of information to match
        ->setInfoTypes([
            (new InfoType())->setName('PHONE_NUMBER'),
            (new InfoType())->setName('EMAIL_ADDRESS'),
            (new InfoType())->setName('CREDIT_CARD_NUMBER')
        ])
        // Whether to include the matching string
        ->setIncludeQuote(true);

    // Run request
    $inspectContentRequest = (new InspectContentRequest())
        ->setParent($parent)
        ->setInspectConfig($inspectConfig)
        ->setItem($item);
    $response = $dlp->inspectContent($inspectContentRequest);

    // Print the results
    $findings = $response->getResult()->getFindings();
    if (count($findings) == 0) {
        print('No findings.' . PHP_EOL);
    } else {
        print('Findings:' . PHP_EOL);
        foreach ($findings as $finding) {
            print('  Quote: ' . $finding->getQuote() . PHP_EOL);
            print('  Info type: ' . $finding->getInfoType()->getName() . PHP_EOL);
            $likelihoodString = Likelihood::name($finding->getLikelihood());
            print('  Likelihood: ' . $likelihoodString . PHP_EOL);
        }
    }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez Bibliothèques clientes Sensitive Data Protection.

import google.cloud.dlp


def inspect_image_file(
    project: str,
    filename: str,
    include_quote: bool = True,
) -> None:
    """Uses the Data Loss Prevention API to analyze strings for
    protected data in image file.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        filename: The path to the file to inspect.
        include_quote: Boolean for whether to display a quote of the detected
            information in the results.
    """
    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries.
    info_types = ["PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER"]
    info_types = [{"name": info_type} for info_type in info_types]

    # Construct the configuration for the Inspect request.
    inspect_config = {
        "info_types": info_types,
        "include_quote": include_quote,
    }

    # Construct the byte_item, containing the image file's byte data.
    with open(filename, mode="rb") as f:
        byte_item = {"type_": "IMAGE", "data": f.read()}

    # Convert the project id into a full resource id.
    parent = f"projects/{project}/locations/global"

    # Call the API.
    response = dlp.inspect_content(
        request={
            "parent": parent,
            "inspect_config": inspect_config,
            "item": {"byte_item": byte_item},
        }
    )

    # Parse the response and process results.
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Quote: {finding.quote}")
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")

Essayer

Vous pouvez tester chacun de ces exemples vous-même ou tester vos propres images dans l'explorateur d'API sur la page de référence de content.inspect :

Accéder à l'explorateur d'API

Conseil : Pour effectuer des tests sur des documents non sensibles, il suffit de décocher Google OAuth 2.0 et de saisir projects/testff dans le champ parent.

Étape suivante

Apprenez-en plus sur l'inspection et le masquage d'images.
Découvrez comment masquer des données sensibles dans des images.

Inspecter des images pour identifier les données sensibles Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Inspecter une image pour tous les infoTypes par défaut

C#

Go

Java

Node.js

PHP

Python

REST

Inspecter une image pour détecter des infoTypes spécifiques

C#

Go

Java

Node.js

PHP

Python

REST

Inspecter une image pour détecter des objets sensibles

Inspecter une image TIFF multipage

Exemples de code

C#

Go

Java

Node.js

PHP

Python

Essayer

Étape suivante

Inspecter des images pour identifier les données sensibles