Inspecionar dados de fontes externas usando jobs híbridos

Neste tópico, descrevemos como usar jobs híbridos e gatilhos de jobs híbridos para inspecionar dados externos em busca de informações confidenciais. Para saber mais sobre jobs híbridos e acionadores de jobs híbridos, incluindo exemplos de ambientes híbridos, consulte Jobs híbridos e acionadores de jobs híbridos.

Introdução a jobs híbridos e gatilhos de jobs híbridos

Jobs híbridos e gatilhos de jobs híbridos permitem ampliar o escopo da proteção oferecida pela Proteção de dados sensíveis além de solicitações simples de inspeção de conteúdo e verificação de repositório do Google Cloud Storage. Ao usar jobs híbridos e acionadores de jobs híbridos, é possível fazer streaming de dados de praticamente qualquer fonte, incluindo fora do Google Cloud, diretamente para a proteção de dados sensíveis e permitir que a proteção de dados sensíveis inspecione os dados em busca de informações sensíveis. A proteção de dados sensíveis salva e agrega automaticamente os resultados da verificação para análise posterior.

Comparação entre jobs híbridos e acionadores de jobs híbridos

Os jobs híbridos são executados até que você os interrompa. Eles aceitam todos os dados recebidos, desde que eles sejam roteados e formatados corretamente.

Os acionadores de jobs híbridos funcionam de maneira semelhante aos jobs híbridos, mas não é necessário interromper explicitamente um job em um acionador desse tipo. A proteção de dados confidenciais interrompe automaticamente os jobs em acionadores de jobs híbridos ao fim de cada dia.

Além disso, com um gatilho de job híbrido, é possível interromper e iniciar novos jobs dentro do gatilho sem precisar reconfigurar as solicitações hybridInspect. Por exemplo, é possível enviar dados para um gatilho de jobs híbrido, interromper o job ativo, alterar a configuração, iniciar um novo job nesse gatilho e continuar a enviar dados para o mesmo gatilho.

Para mais orientações sobre qual opção se adequa ao seu caso de uso, consulte Cenários típicos de inspeção híbrida nesta página.

Definição de termos

Este tópico usa os seguintes termos:

• Dados externos: dados armazenados fora do Google Cloud ou dados que a proteção de dados sensíveis não oferece suporte nativo.

• Job híbrido: um job de inspeção configurado para verificar dados de virtualmente qualquer origem.

• Acionador de job híbrido: um acionador de job configurado para verificar dados de virtualmente qualquer fonte.

• Solicitação hybridInspect: uma solicitação que contém os dados externos que você quer inspecionar. Ao enviar essa solicitação, especifique o job híbrido ou o acionador de job híbrido que receberá a solicitação.

Para informações gerais sobre jobs e acionadores de jobs, consulte Jobs e acionadores de jobs.

Processo de inspeção híbrida

Há três etapas no processo de inspeção híbrido.

1. Escolha os dados que você quer enviar para a proteção de dados sensíveis.

   Os dados podem ser originados no Google Cloud ou fora dele. Por exemplo, é possível configurar um script ou aplicativo personalizado para enviar dados à proteção de dados confidenciais, permitindo que você inspecione os dados em trânsito, de outro serviço de nuvem, de um repositório de dados no local ou praticamente qualquer outra fonte de dados.

2. Configure um job híbrido ou um acionador de job híbrido na proteção de dados sensíveis do zero ou usando um modelo de inspeção.

   Depois que você configura um job híbrido ou um acionador de job híbrido, a proteção de dados sensíveis detecta ativamente os dados enviados a ele. Quando seu script ou aplicativo personalizado envia dados para esse job híbrido ou acionador de job híbrido, os dados são inspecionados e os resultados são armazenados de acordo com a configuração.

   Ao configurar o job híbrido ou o acionador de jobs híbridos, é possível especificar onde você quer salvar ou publicar as descobertas. As opções incluem salvar no BigQuery e publicar notificações no Pub/Sub, Cloud Monitoring ou e-mail.

3. Envie uma solicitação hybridInspect para o job híbrido ou o acionador de jobs híbridos.

   Uma solicitação hybridInspect contém os dados a serem verificados. Na solicitação, inclua metadados (também chamados de rótulos e identificadores de tabela) que descrevem o conteúdo e permitam que a proteção de dados sensíveis identifique as informações que você quer rastrear. Por exemplo, se você estiver verificando dados relacionados em várias solicitações (como linhas na mesma tabela de banco de dados), é possível usar os mesmos metadados nessas solicitações. É possível, então, coletar, calcular e analisar as descobertas dessa tabela de banco de dados.

À medida que o job híbrido é executado e inspeciona as solicitações, os resultados da inspeção ficam disponíveis quando são gerados pela proteção de dados sensíveis. Por outro lado, ações, como notificações do Pub/Sub, não ocorrem até que seu aplicativo encerre o job híbrido.

Observação :se houver problemas de configuração ou permissão com o tópico do Pub/Sub, a proteção de dados sensíveis tentará enviar a notificação do Pub/Sub por até duas semanas. Depois de duas semanas, a notificação será descartada.

Considerações

Ao trabalhar com jobs híbridos e gatilhos de jobs, considere os seguintes pontos:

• Os jobs híbridos e os gatilhos de jobs híbridos não são compatíveis com filtragem e amostragem.
• Os jobs e os gatilhos de jobs não estão sujeitos a objetivos de nível de serviço (SLO), mas há etapas que podem ser seguidas para reduzir a latência. Para mais informações, consulte Latência do job.

Antes de começar

Antes de configurar e usar jobs híbridos ou acionadores de jobs híbridos, faça o seguinte:

Crie um projeto, ative o faturamento e ative a proteção de dados sensíveis

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

5. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

6. Ative a API Sensitive Data Protection.

   Ative a API

configure a fonte de dados.

Para que a proteção de dados sensíveis possa inspecionar seus dados, eles precisam ser enviados para a proteção de dados sensíveis. Independentemente do método usado para configurar o job híbrido ou o acionador de jobs híbridos, é necessário configurar a fonte externa para enviar dados à API DLP.

Para mais informações sobre o formato obrigatório para solicitações de inspeção híbrida, consulte Formatação de itens de conteúdo híbrido. Para saber mais sobre os tipos de metadados que podem ser incluídos com os dados na solicitação, consulte Tipos de metadados que você pode fornecer.

Criar um job híbrido ou acionador de jobs híbridos

Para permitir que a proteção de dados sensíveis inspecione os dados enviados a ela, configure um job híbrido ou um acionador de jobs híbridos. Para informações sobre qual precisa criar, consulte Cenários típicos de inspeção híbrida nesta página.

Console

No console do Google Cloud, acesse a página Criar job ou gatilho de jobs:

Acessar "Criar job ou gatilho de jobs"

As seções a seguir descrevem como preencher as seções da página Criar job ou acionador de job que são relevantes para operações de inspeção híbrida.

Escolher dados de entrada

Nesta seção, você especifica os dados de entrada para inspeção da proteção de dados sensíveis.

1. Opcional: em Nome, digite um valor no campo ID do job para nomear o job. Deixar esse campo em branco faz com que a proteção de dados sensíveis gere um identificador automaticamente.
2. Opcional: no menu Local do recurso, escolha a região em que quer armazenar o job híbrido ou o acionador de jobs híbridos. Para mais informações, consulte Como especificar locais de processamento.

3. Em Tipo de armazenamento, selecione Híbrido.

4. Opcional: em Descrição, descreva o job híbrido ou o acionador de job híbrido que você está criando. Por exemplo, você pode incluir informações sobre a fonte dos dados a serem inspecionados.

5. Opcional: em Rótulos obrigatórios, clique em Adicionar rótulo e digite um rótulo que você quer exigir das solicitações hybridInspect. Uma solicitação hybridInspect que não especifica esse rótulo não é processada por esse job híbrido ou acionador de job híbrido. É possível adicionar até 10 identificadores obrigatórios. Para mais informações, consulte Exigir rótulos de solicitações hybridInspect nesta página.

6. Opcional: em Rótulos opcionais, insira os pares de chave-valor que você quer anexar aos resultados de todas as solicitações hybridInspect enviadas a esse job ou acionador de jobs. É possível adicionar até 10 rótulos opcionais. Para mais informações, consulte Rótulos opcionais.

7. Opcional: em Opções de dados tabulares, insira o nome do campo da coluna da chave primária se planeja enviar dados tabulares nas solicitações hybridInspect. Para mais informações, consulte Opções de dados tabulares.

8. Clique em Continuar.

Configurar detecção

Nesta seção, você especifica os tipos de dados sensíveis para os quais a proteção de dados sensíveis inspecionará os dados de entrada. Suas opções são:

• Modelo: se você já criou um modelo no projeto atual que quer usar para definir os parâmetros de detecção da proteção de dados sensíveis, clique no campo Nome do modelo e escolha o modelo na lista que aparece.
• InfoTypes: a proteção de dados sensíveis seleciona os infoTypes integrados mais comuns para serem detectados. Para alterar os infoTypes ou escolher um infoType personalizado para usar, clique em Gerenciar infoTypes. Também é possível ajustar os critérios de detecção nas seções Conjuntos de regras de inspeção e Limite de confiança. Para mais detalhes, veja Configurar a detecção.

Depois de configurar os parâmetros de detecção, clique em Continuar.

Adicionar ações

Nesta seção, você especifica onde salvar as descobertas de cada verificação de inspeção e se quer ser notificado por e-mail ou por uma mensagem de notificação do Pub/Sub sempre que uma verificação for concluída. Se as descobertas não forem salvas no BigQuery, os resultados da verificação conterão apenas estatísticas sobre o número e os infoTypes delas.

• Salvar no BigQuery: sempre que uma verificação é executada, a proteção de dados sensíveis salva as descobertas na tabela do BigQuery especificada aqui. Se você não especificar um ID de tabela, o BigQuery atribuirá um nome padrão a uma nova tabela na primeira vez que a verificação for executada. Se você especificar uma tabela atual, a proteção de dados sensíveis anexa as descobertas da verificação a ela.

• Publicar no Pub/Sub: quando um job é concluído, uma mensagem do Pub/Sub é enviada.

  Observação :se houver problemas de configuração ou permissão com o tópico do Pub/Sub, a proteção de dados sensíveis tentará enviar a notificação do Pub/Sub por até duas semanas. Depois de duas semanas, a notificação é descartada.

• Notificar por e-mail: quando um job é concluído, uma mensagem de e-mail é enviada.

• Publicar no Cloud Monitoring: quando um job for concluído, as descobertas dele serão publicadas no Monitoring.

Depois de escolher as ações, clique em Continuar.

Programação

Nesta seção, você especifica se quer criar um único job que será executado imediatamente ou um acionador de jobs que será executado sempre que dados roteados e formatados corretamente forem recebidos pela proteção de dados sensíveis.

Escolha uma destas opções:

• Para executar o job híbrido imediatamente, escolha Nenhum (executar o job único imediatamente na criação).

• Para configurar o job de modo que os dados recebidos da origem acionem o job, escolha Criar um gatilho para executar o job em uma programação periódica.

  O job híbrido aciona chamadas de API agregadas, permitindo que você veja os resultados e as tendências de descoberta ao longo do tempo.

Para mais informações, consulte Comparação de jobs híbridos e acionadores de jobs híbridos.

Revisão

É possível revisar um resumo do JSON da verificação aqui. Anote o nome do acionador de job híbrido ou Objeto híbrido. Essas informações serão necessárias quando você enviar dados à Proteção de dados sensíveis para inspeção.

Depois de analisar o resumo JSON, clique em Criar.

A proteção de dados sensíveis inicia imediatamente o job híbrido ou o acionador de jobs híbridos. Uma verificação de inspeção é iniciada quando você envia uma solicitação hybridInspect para esse job híbrido ou acionador de jobs híbridos.

API

Um job é representado na API DLP pelo recurso DlpJobs. Para criar um job híbrido, chame o método projects.locations.dlpJobs.create.

Um gatilho de job é representado na API DLP pelo recurso JobTrigger. Para criar um gatilho de job híbrido, chame o método projects.locations.jobTriggers.create.

O objeto DlpJobs ou JobTrigger criado precisa ter as seguintes configurações:

1. No campo inspectJob, defina um objeto InspectJobConfig.
2. No objeto InspectJobConfig, no campo storageConfig, defina um objeto StorageConfig.
3. No objeto StorageConfig, no campo hybridOptions, defina um objeto HybridOptions. Esse objeto contém metadados sobre os dados que você quer inspecionar.

4. No objeto InspectJobConfig, no campo actions, adicione todas as ações (Action) que você quer que a proteção de dados sensíveis execute ao final de cada job.

   As ações publishSummaryToCscc e publishFindingsToCloudDataCatalog não são compatíveis com essa operação. Para saber mais sobre ações, consulte Ações.

5. Especifique o que verificar e como verificar seguindo um destes procedimentos ou ambos:

   • Defina o campo inspectTemplateName como o nome completo do recurso de um modelo de inspeção que você quer usar, se disponível.

   • Defina o campo inspectConfig.

   Se você definir os campos inspectTemplateName e inspectConfig, as configurações serão combinadas.

Sobre os exemplos de JSON

As guias a seguir contêm exemplos de JSON que podem ser enviados à Proteção de dados sensíveis para criar um job híbrido ou um acionador de jobs híbrido. Esses exemplos de acionadores de jobs híbridos e híbridos são configurados para fazer o seguinte:

• Processe qualquer solicitação hybridInspect se ela tiver o rótulo appointment-bookings-comments.
• Verifique o conteúdo na solicitação hybridInspect em busca de endereços de e-mail.
• Anexe o rótulo "env": "prod" às descobertas.
• Para dados tabulares, encontre o valor da célula na coluna booking_id (a chave primária) que está na mesma linha da célula em que os dados confidenciais foram encontrados. A proteção de dados sensíveis anexa esse identificador à descoberta para que você possa rastrear a descoberta até a linha específica de onde ela veio.
• Envie um e-mail quando o job for interrompido. O e-mail vai para os proprietários do projeto do IAM e os Contatos essenciais.
• Envie as descobertas ao Cloud Monitoring quando o job for interrompido.

Confira as guias abaixo para conferir os exemplos de JSON.

Emprego híbrido

Esta guia contém um exemplo de JSON que pode ser usado para criar um job híbrido.

Para criar um job híbrido, envie uma solicitação POST para o endpoint a seguir.

Método e URL HTTP

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs

Substitua:

• PROJECT_ID: o ID do projeto em que você quer armazenar o job híbrido.
• REGION: a região geográfica em que você quer armazenar o job híbrido.

Entrada JSON

{
  "jobId": "postgresql-table-comments",
  "inspectJob": {
    "actions": [
      {
        "jobNotificationEmails": {}
      },
      {
        "publishToStackdriver": {}
      }
    ],
    "inspectConfig": {
      "infoTypes": [
        {
          "name": "EMAIL_ADDRESS"
        }
      ],
      "minLikelihood": "POSSIBLE",
      "includeQuote": true
    },
    "storageConfig": {
      "hybridOptions": {
        "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
        "requiredFindingLabelKeys": [
          "appointment-bookings-comments"
        ],
        "labels": {
          "env": "prod"
        },
        "tableOptions": {
          "identifyingFields": [
            {
              "name": "booking_id"
            }
          ]
        }
      }
    }
  }
}

Saída JSON

{
"name": "projects/PROJECT_ID/locations/REGION/dlpJobs/i-postgresql-table-comments",
"type": "INSPECT_JOB",
"state": "ACTIVE",
"inspectDetails": {
  "requestedOptions": {
    "snapshotInspectTemplate": {},
    "jobConfig": {
      "storageConfig": {
        "hybridOptions": {
          "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
          "requiredFindingLabelKeys": [
            "appointment-bookings-comments"
          ],
          "labels": {
            "env": "prod"
          },
          "tableOptions": {
            "identifyingFields": [
              {
                "name": "booking_id"
              }
            ]
          }
        }
      },
      "inspectConfig": {
        "infoTypes": [
          {
            "name": "EMAIL_ADDRESS"
          }
        ],
        "minLikelihood": "POSSIBLE",
        "limits": {},
        "includeQuote": true
      },
      "actions": [
        {
          "jobNotificationEmails": {}
        },
        {
          "publishToStackdriver": {}
        }
      ]
    }
  },
  "result": {
    "hybridStats": {}
  }
},
"createTime": "JOB_CREATION_DATETIME",
"startTime": "JOB_START_DATETIME"
}

A proteção de dados sensíveis cria o job híbrido e gera um ID de job. Neste exemplo, o ID do job é i-postgresql-table-comments. Anote o ID da tarefa. Você precisa dela na sua solicitação hybridInspect.

Para interromper um job híbrido, chame o método projects.locations.dlpJobs.finish explicitamente. A API DLP não interrompe automaticamente os jobs híbridos. Por outro lado, a API DLP interrompe automaticamente os jobs em acionadores de jobs híbridos ao final de cada dia.

Gatilho de job híbrido

Esta guia contém um exemplo de JSON que pode ser usado para criar um acionador de job híbrido.

Para criar um gatilho de jobs híbridos, envie uma solicitação POST para o endpoint a seguir.

Método e URL HTTP

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers

Substitua:

• PROJECT_ID: o ID do projeto em que você quer armazenar o acionador de jobs híbridos.
• REGION: a região geográfica em que você quer armazenar o acionador de job híbrido.

Entrada JSON

{
    "triggerId": "postgresql-table-comments",
    "jobTrigger": {
      "triggers": [
        {
          "manual": {}
        }
      ],
      "inspectJob": {
        "actions": [
          {
            "jobNotificationEmails": {}
          },
          {
            "publishToStackdriver": {}
          }
        ],
        "inspectConfig": {
          "infoTypes": [
              {
                "name": "EMAIL_ADDRESS"
              }
          ],
          "minLikelihood": "POSSIBLE",
          "limits": {},
          "includeQuote": true
        },
        "storageConfig": {
          "hybridOptions": {
            "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
            "requiredFindingLabelKeys": [
                "appointment-bookings-comments"
              ],
            "labels": {
              "env": "prod"
            },
            "tableOptions": {
              "identifyingFields": [
                {
                  "name": "booking_id"
                }
              ]
            }
          }
        }
      }
    }
  }

Saída JSON

{
"name": "projects/PROJECT_ID/locations/REGION/jobTriggers/postgresql-table-comments",
"inspectJob": {
  "storageConfig": {
    "hybridOptions": {
      "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
      "requiredFindingLabelKeys": [
        "appointment-bookings-comments"
      ],
      "labels": {
        "env": "prod"
      },
      "tableOptions": {
        "identifyingFields": [
          {
            "name": "booking_id"
          }
        ]
      }
    }
  },
  "inspectConfig": {
    "infoTypes": [
      {
        "name": "EMAIL_ADDRESS"
      }
    ],
    "minLikelihood": "POSSIBLE",
    "limits": {},
    "includeQuote": true
  },
  "actions": [
    {
      "jobNotificationEmails": {}
    },
    {
      "publishToStackdriver": {}
    }
  ]
},
"triggers": [
  {
    "manual": {}
  }
],
"createTime": ""JOB_CREATION_DATETIME",
"updateTime": "TRIGGER_UPDATE_DATETIME",
"status": "HEALTHY"
}

A proteção de dados sensíveis cria o acionador de jobs híbridos. A saída contém o nome do gatilho de jobs híbridos. Neste exemplo, é postgresql-table-comments. Anote o nome. Você precisa dela na sua solicitação hybridInspect.

Ao contrário dos jobs híbridos, a API DLP interrompe automaticamente os jobs nos acionadores de jobs híbridos ao final de cada dia. Portanto, não é necessário chamar explicitamente o método projects.locations.dlpJobs.finish.

Ao criar um job híbrido ou um acionador de jobs híbridos, é possível usar as APIs Explorer nas seguintes páginas de referência da API, respectivamente:

• projects.locations.dlpJobs.create
• projects.locations.jobTriggers.create

No campo Parâmetros de solicitação, insira projects/PROJECT_ID/locations/REGION. Depois, no campo Corpo da solicitação, cole o JSON de amostra do objeto que você está tentando criar.

Uma solicitação bem-sucedida, mesmo uma criada no APIs Explorer, cria um job híbrido ou acionador de jobs híbridos.

Para informações gerais sobre como usar JSON para enviar solicitações à API DLP, consulte o guia de início rápido do JSON.

Enviar dados para o job híbrido ou o acionador de jobs híbridos

Para inspecionar dados, é preciso enviar uma solicitação hybridInspect, no formato correto, para um job híbrido ou um acionador de jobs híbridos.

Formatação de itens de conteúdo híbrido

Confira a seguir um exemplo simples de uma solicitação hybridInspect enviada à Proteção de dados sensíveis para processamento por um job híbrido ou acionador de jobs híbridos. Observe a estrutura do objeto JSON, incluindo o campo hybridItem, que contém os seguintes campos:

• item: contém o conteúdo real a ser inspecionado.
• findingDetails: contém metadados a serem associados ao conteúdo.

{
  "hybridItem": {
    "item": {
      "value": "My email is [e-mail]"
    },
    "findingDetails": {
      "containerDetails": {
        "fullPath": "10.0.0.2:logs1:app1",
        "relativePath": "app1",
        "rootPath": "10.0.0.2:logs1",
        "type": "logging_sys",
        "version": "1.2"
      },
      "labels": {
        "env": "prod",
        "appointment-bookings-comments": ""
      }
    }
  }
}

Para ver informações abrangentes sobre o conteúdo de itens de inspeção híbridos, veja o conteúdo de "Referência da API" para o objeto HybridContentItem.

Endpoints de inspeção híbrida

Para que os dados sejam inspecionados usando um job híbrido ou um acionador de job híbrido, envie uma solicitação hybridInspect para o endpoint correto.

Método HTTP e URL para jobs híbridos

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs/JOB_ID:hybridInspect

Para mais informações sobre esse endpoint, veja a página de "Referência da API" para o método projects.locations.dlpJobs.hybridInspect.

Método HTTP e URL para acionadores de jobs híbridos

https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers/TRIGGER_NAME:hybridInspect

Para mais informações sobre esse endpoint, veja a página de "Referência da API" para o método projects.locations.jobTriggers.hybridInspect.

Substitua:

• PROJECT_ID: o identificador do projeto.
• REGION: a região geográfica em que você quer armazenar a solicitação hybridInspect. Essa região precisa ser a mesma do job híbrido.

• JOB_ID: o ID que você deu ao job híbrido, com o prefixo i-.

  Para procurar o ID do job, em Proteção de dados sensíveis, clique em Inspeção > Inspecionar jobs.

• TRIGGER_NAME: o nome que você deu ao gatilho de jobs híbridos.

  Para pesquisar o nome do acionador de jobs, em Proteção de dados confidenciais, clique em Inspeção > Acionadores de jobs.

Exigir identificadores de hybridInspect solicitações

Se você quiser controlar quais solicitações hybridInspect podem ser processadas por um job híbrido ou um acionador de jobs híbridos, defina os rótulos obrigatórios. Todas as solicitações hybridInspect para esse job híbrido ou acionador de job híbrido que não incluir esses rótulos obrigatórios serão rejeitadas.

Para definir um rótulo obrigatório, siga estas etapas:

1. Ao criar o job híbrido ou o gatilho de jobs híbridos, defina o campo requiredFindingLabelKeys como uma lista de rótulos obrigatórios.

   No exemplo a seguir, appointment-bookings-comments é definido como um rótulo obrigatório em um job híbrido ou acionador de jobs híbridos.

   "hybridOptions": {
     ...
     "requiredFindingLabelKeys": [
       "appointment-bookings-comments"
     ],
     "labels": {
       "env": "prod"
     },
     ...
   }
   

2. Na solicitação hybridInspect, no campo labels, adicione cada rótulo necessário como uma chave em um par de chave-valor. O valor correspondente pode ser uma string vazia.

   O exemplo a seguir define o rótulo obrigatório, appointment-bookings-comments, em uma solicitação hybridInspect.

   {
     "hybridItem": {
       "item": {
         "value": "My email is [e-mail]"
       },
       "findingDetails": {
         "containerDetails": {...},
         "labels": {
           "appointment-bookings-comments": ""
         }
       }
     }
   }
   

Se você não incluir o rótulo obrigatório na sua solicitação hybridInspect, receberá um erro como este:

{
  "error": {
    "code": 400,
    "message": "Trigger required labels that were not included: [appointment-bookings-comments]",
    "status": "INVALID_ARGUMENT"
  }
}

Exemplo de código: criar um acionador de jobs híbrido e enviar dados a ele

Importante :o código nesta página exige a configuração inicial de um cliente de proteção de dados sensíveis. Para mais informações sobre como instalar e criar um cliente de proteção de dados sensíveis, consulte Bibliotecas de cliente de proteção de dados sensíveis. O envio de JSON para endpoints REST de proteção de dados sensíveis não requer uma biblioteca de cliente.

C#

Para saber como instalar e usar a biblioteca de cliente para proteção de dados sensíveis, consulte Bibliotecas de cliente de proteção de dados sensíveis.

Para usar a proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

using System;
using Google.Api.Gax.ResourceNames;
using Google.Api.Gax;
using Google.Cloud.Dlp.V2;
using Grpc.Core;

public class SendDataToTheHybridJobTrigger
{
    public static DlpJob SendToHybridJobTrigger(
       string projectId,
       string jobTriggerId,
       string text = null)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the hybrid finding details which will be used as metadata with the content.
        // Refer to this for more information: https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#google.privacy.dlp.v2.Container
        var findingDetails = new HybridFindingDetails
        {
            ContainerDetails = new Container
            {
                FullPath = "10.0.0.2:logs1:aap1",
                RelativePath = "app1",
                RootPath = "10.0.0.2:logs1",
                Type = "System Logs"
            }
        };

        // Construct the hybrid content item using the finding details and text to be inspected.
        var hybridContentItem = new HybridContentItem
        {
            Item = new ContentItem { Value = text ?? "My email is [e-mail] and name is Ariel." },
            FindingDetails = findingDetails
        };

        var jobTriggerName = new JobTriggerName(projectId, jobTriggerId);

        // Construct the request to activate the Job Trigger.
        var activate = new ActivateJobTriggerRequest
        {
            JobTriggerName = jobTriggerName
        };

        DlpJob triggerJob = null;

        try
        {
            // Call the API to activate the trigger.
            triggerJob = dlp.ActivateJobTrigger(activate);
        }
        catch (RpcException)
        {
            ListDlpJobsRequest listJobsRequest = new ListDlpJobsRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
                Filter = $"trigger_name={jobTriggerName}"
            };

            PagedEnumerable<ListDlpJobsResponse, DlpJob> res = dlp.ListDlpJobs(listJobsRequest);
            foreach (DlpJob j in res)
            {
                triggerJob = j;
            }
        }

        // Construct the request using hybrid content item.
        var request = new HybridInspectJobTriggerRequest
        {
            HybridItem = hybridContentItem,
            JobTriggerName = jobTriggerName
        };

        // Call the API.
        HybridInspectResponse _ = dlp.HybridInspectJobTrigger(request);

        Console.WriteLine($"Hybrid job created successfully. Job name: {triggerJob.Name}");

        return triggerJob;
    }
}

Go

Para saber como instalar e usar a biblioteca de cliente para proteção de dados sensíveis, consulte Bibliotecas de cliente de proteção de dados sensíveis.

Para usar a proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

import (
	"context"
	"fmt"
	"io"
	"log"
	"time"

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

// inspectDataToHybridJobTrigger uses the Data Loss Prevention API to inspect sensitive
// information using Hybrid jobs trigger that scans payloads of data sent from
// virtually any source and stores findings in Google Cloud.
func inspectDataToHybridJobTrigger(w io.Writer, projectID, textToDeIdentify, jobTriggerName string) error {
	// projectId := "your-project-id"
	// jobTriggerName := "your-job-trigger-name"
	// textToDeIdentify := "My email is [e-mail]"

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

	// Specify the content to be inspected.
	contentItem := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_Value{
			Value: textToDeIdentify,
		},
	}

	// Contains metadata to associate with the content.
	// Refer to https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#container for specifying the paths in container object.
	container := &dlppb.Container{
		Type:         "logging_sys",
		FullPath:     "10.0.0.2:logs1:app1",
		RelativePath: "app1",
		RootPath:     "10.0.0.2:logs1",
		Version:      "1.2",
	}

	// Set the required label.
	labels := map[string]string{
		"env":                           "prod",
		"appointment-bookings-comments": "",
	}

	hybridFindingDetails := &dlppb.HybridFindingDetails{
		ContainerDetails: container,
		Labels:           labels,
	}

	hybridContentItem := &dlppb.HybridContentItem{
		Item:           contentItem,
		FindingDetails: hybridFindingDetails,
	}

	// Activate the job trigger.
	activateJobreq := &dlppb.ActivateJobTriggerRequest{
		Name: jobTriggerName,
	}

	dlpJob, err := client.ActivateJobTrigger(ctx, activateJobreq)
	if err != nil {
		log.Printf("Error from return part %v", err)
		return err
	}
	// Build the hybrid inspect request.
	req := &dlppb.HybridInspectJobTriggerRequest{
		Name:       jobTriggerName,
		HybridItem: hybridContentItem,
	}

	// Send the hybrid inspect request.
	_, err = client.HybridInspectJobTrigger(ctx, req)
	if err != nil {
		return err
	}

	getDlpJobReq := &dlppb.GetDlpJobRequest{
		Name: dlpJob.Name,
	}

	var result *dlppb.DlpJob
	for i := 0; i < 5; i++ {
		// Get DLP job
		result, err = client.GetDlpJob(ctx, getDlpJobReq)
		if err != nil {
			fmt.Printf("Error getting DLP job: %v\n", err)
			return err
		}

		// Check if processed bytes is greater than 0
		if result.GetInspectDetails().GetResult().GetProcessedBytes() > 0 {
			break
		}

		// Wait for 5 seconds before checking again
		time.Sleep(5 * time.Second)
		i++
	}

	fmt.Fprintf(w, "Job Name: %v\n", result.Name)
	fmt.Fprintf(w, "Job State: %v\n", result.State)

	inspectionResult := result.GetInspectDetails().GetResult()
	fmt.Fprint(w, "Findings: \n")
	for _, v := range inspectionResult.GetInfoTypeStats() {
		fmt.Fprintf(w, "Infotype: %v\n", v.InfoType.Name)
		fmt.Fprintf(w, "Likelihood: %v\n", v.GetCount())
	}

	fmt.Fprint(w, "successfully inspected data using hybrid job trigger ")
	return nil
}

Java

Para saber como instalar e usar a biblioteca de cliente para proteção de dados sensíveis, consulte Bibliotecas de cliente de proteção de dados sensíveis.

Para usar a proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

import com.google.api.gax.rpc.InvalidArgumentException;
import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ActivateJobTriggerRequest;
import com.google.privacy.dlp.v2.Container;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.DlpJob;
import com.google.privacy.dlp.v2.GetDlpJobRequest;
import com.google.privacy.dlp.v2.HybridContentItem;
import com.google.privacy.dlp.v2.HybridFindingDetails;
import com.google.privacy.dlp.v2.HybridInspectJobTriggerRequest;
import com.google.privacy.dlp.v2.InfoTypeStats;
import com.google.privacy.dlp.v2.InspectDataSourceDetails;
import com.google.privacy.dlp.v2.JobTriggerName;
import com.google.privacy.dlp.v2.ListDlpJobsRequest;

public class InspectDataToHybridJobTrigger {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    // The Google Cloud project id to use as a parent resource.
    String projectId = "your-project-id";
    // The job trigger id used to for processing a hybrid job trigger.
    String jobTriggerId = "your-job-trigger-id";
    // The string to de-identify.
    String textToDeIdentify = "My email is [e-mail] and my name is Gary.";
    inspectDataToHybridJobTrigger(textToDeIdentify, projectId, jobTriggerId);
  }

  // Inspects data using a hybrid job trigger.
  // Hybrid jobs trigger allows to scan payloads of data sent from virtually any source for
  // sensitive information and then store the findings in Google Cloud.
  public static void inspectDataToHybridJobTrigger(
      String textToDeIdentify, String projectId, String jobTriggerId) throws Exception {
    // 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 dlpClient = DlpServiceClient.create()) {
      // Specify the content to be inspected.
      ContentItem contentItem = ContentItem.newBuilder().setValue(textToDeIdentify).build();

      // Contains metadata to associate with the content.
      // Refer to https://cloud.google.com/dlp/docs/reference/rest/v2/Container for specifying the
      // paths in container object.
      Container container =
          Container.newBuilder()
              .setFullPath("10.0.0.2:logs1:app1")
              .setRelativePath("app1")
              .setRootPath("10.0.0.2:logs1")
              .setType("logging_sys")
              .setVersion("1.2")
              .build();

      HybridFindingDetails hybridFindingDetails =
          HybridFindingDetails.newBuilder().setContainerDetails(container).build();

      HybridContentItem hybridContentItem =
          HybridContentItem.newBuilder()
              .setItem(contentItem)
              .setFindingDetails(hybridFindingDetails)
              .build();

      // Activate the job trigger.
      ActivateJobTriggerRequest activateJobTriggerRequest =
          ActivateJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .build();

      DlpJob dlpJob;

      try {
        dlpJob = dlpClient.activateJobTrigger(activateJobTriggerRequest);
      } catch (InvalidArgumentException e) {
        ListDlpJobsRequest request =
            ListDlpJobsRequest.newBuilder()
                .setParent(JobTriggerName.of(projectId, jobTriggerId).toString())
                .setFilter("trigger_name=" + JobTriggerName.of(projectId, jobTriggerId).toString())
                .build();

        // Retrieve the DLP jobs triggered by the job trigger
        DlpServiceClient.ListDlpJobsPagedResponse response = dlpClient.listDlpJobs(request);
        dlpJob = response.getPage().getResponse().getJobs(0);
      }

      // Build the hybrid inspect request.
      HybridInspectJobTriggerRequest request =
          HybridInspectJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .setHybridItem(hybridContentItem)
              .build();

      // Send the hybrid inspect request.
      dlpClient.hybridInspectJobTrigger(request);

      // Build a request to get the completed job
      GetDlpJobRequest getDlpJobRequest =
          GetDlpJobRequest.newBuilder().setName(dlpJob.getName()).build();

      DlpJob result = null;

      do {
        result = dlpClient.getDlpJob(getDlpJobRequest);
        Thread.sleep(5000);
      } while (result.getInspectDetails().getResult().getProcessedBytes() <= 0);

      System.out.println("Job status: " + result.getState());
      System.out.println("Job name: " + result.getName());
      // Parse the response and process results.
      InspectDataSourceDetails.Result inspectionResult = result.getInspectDetails().getResult();
      System.out.println("Findings: ");
      for (InfoTypeStats infoTypeStat : inspectionResult.getInfoTypeStatsList()) {
        System.out.println("\tInfoType: " + infoTypeStat.getInfoType().getName());
        System.out.println("\tCount: " + infoTypeStat.getCount() + "\n");
      }
    }
  }
}

Node.js

Para saber como instalar e usar a biblioteca de cliente para proteção de dados sensíveis, consulte Bibliotecas de cliente de proteção de dados sensíveis.

Para usar a proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

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

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

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The string to de-identify
// const string = 'My email is [e-mail]';

// Job Trigger ID
// const jobTriggerId = 'your-job-trigger-id';

async function inspectDataToHybridJobTrigger() {
  // Contains metadata to associate with the content.
  const container = {
    full_path: '10.0.0.2:logs1:app1',
    relative_path: 'app1',
    root_path: '10.0.0.2:logs1',
    type: 'logging_sys',
    version: '1.2',
  };

  const labels = {env: 'prod', 'appointment-bookings-comments': ''};

  // Build the hybrid content item.
  const hybridContentItem = {
    item: {value: string},
    findingDetails: {
      containerDetails: container,
      labels,
    },
  };
  let jobName;
  const fullTriggerName = `projects/${projectId}/jobTriggers/${jobTriggerId}`;
  // Activate the job trigger.
  try {
    const response = await dlpClient.activateJobTrigger({
      name: fullTriggerName,
    });
    jobName = response[0].name;
  } catch (err) {
    console.log(err);
    if (err.code === 3) {
      const response = await dlpClient.listDlpJobs({
        parent: fullTriggerName,
        filter: `trigger_name=${fullTriggerName}`,
      });
      jobName = response[0][0].name;
    }
    // Ignore error related to job trigger already active
    if (err.code !== 3) {
      console.log(err.message);
      return;
    }
  }
  // Build the hybrid inspect request.
  const request = {
    name: `projects/${projectId}/jobTriggers/${jobTriggerId}`,
    hybridItem: hybridContentItem,
  };
  // Send the hybrid inspect request.
  await dlpClient.hybridInspectJobTrigger(request);
  // Waiting for a maximum of 15 minutes for the job to get complete.
  let job;
  let numOfAttempts = 30;
  while (numOfAttempts > 0) {
    // Fetch DLP Job status
    [job] = await dlpClient.getDlpJob({name: jobName});

    if (job.state === 'FAILED') {
      console.log('Job Failed, Please check the configuration.');
      return;
    }
    // Check if the job has completed.
    if (job.inspectDetails.result.processedBytes > 0) {
      break;
    }
    // Sleep for a short duration before checking the job status again.
    await new Promise(resolve => {
      setTimeout(() => resolve(), 30000);
    });
    numOfAttempts -= 1;
  }
  // Finish the job once the inspection is complete.
  await dlpClient.finishDlpJob({name: jobName});

  // Print out the results.
  const infoTypeStats = job.inspectDetails.result.infoTypeStats;
  if (infoTypeStats.length > 0) {
    infoTypeStats.forEach(infoTypeStat => {
      console.log(
        `  Found ${infoTypeStat.count} instance(s) of infoType ${infoTypeStat.infoType.name}.`
      );
    });
  } else {
    console.log('No findings.');
  }
}
await inspectDataToHybridJobTrigger();

PHP

Para saber como instalar e usar a biblioteca de cliente para proteção de dados sensíveis, consulte Bibliotecas de cliente de proteção de dados sensíveis.

Para usar a proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

use Google\ApiCore\ApiException;
use Google\Cloud\Dlp\V2\Container;
use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\HybridContentItem;
use Google\Cloud\Dlp\V2\HybridFindingDetails;

/**
 * Inspect data hybrid job trigger.
 * Send data to the hybrid job or hybrid job trigger.
 *
 * @param string $callingProjectId  The Google Cloud project id to use as a parent resource.
 * @param string $string            The string to inspect (will be treated as text).
 */

function inspect_send_data_to_hybrid_job_trigger(
    // TODO(developer): Replace sample parameters before running the code.
    string $callingProjectId,
    string $jobTriggerId,
    string $string
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $content = (new ContentItem())
        ->setValue($string);

    $container = (new Container())
        ->setFullPath('10.0.0.2:logs1:app1')
        ->setRelativePath('app1')
        ->setRootPath('10.0.0.2:logs1')
        ->setType('logging_sys')
        ->setVersion('1.2');

    $findingDetails = (new HybridFindingDetails())
        ->setContainerDetails($container)
        ->setLabels([
            'env' => 'prod',
            'appointment-bookings-comments' => ''
        ]);

    $hybridItem = (new HybridContentItem())
        ->setItem($content)
        ->setFindingDetails($findingDetails);

    $parent = "projects/$callingProjectId/locations/global";
    $name = "projects/$callingProjectId/locations/global/jobTriggers/" . $jobTriggerId;

    $triggerJob = null;
    try {
        $triggerJob = $dlp->activateJobTrigger($name);
    } catch (ApiException $e) {
        $result = $dlp->listDlpJobs($parent, ['filter' => 'trigger_name=' . $name]);
        foreach ($result as $job) {
            $triggerJob = $job;
        }
    }

    $dlp->hybridInspectJobTrigger($name, [
        'hybridItem' => $hybridItem,
    ]);

    $numOfAttempts = 10;
    do {
        printf('Waiting for job to complete' . PHP_EOL);
        sleep(10);
        $job = $dlp->getDlpJob($triggerJob->getName());
        if ($job->getState() != JobState::RUNNING) {
            break;
        }
        $numOfAttempts--;
    } while ($numOfAttempts > 0);

    // Print finding counts.
    printf('Job %s status: %s' . PHP_EOL, $job->getName(), JobState::name($job->getState()));
    switch ($job->getState()) {
        case JobState::DONE:
            $infoTypeStats = $job->getInspectDetails()->getResult()->getInfoTypeStats();
            if (count($infoTypeStats) === 0) {
                printf('No findings.' . PHP_EOL);
            } else {
                foreach ($infoTypeStats as $infoTypeStat) {
                    printf(
                        '  Found %s instance(s) of infoType %s' . PHP_EOL,
                        $infoTypeStat->getCount(),
                        $infoTypeStat->getInfoType()->getName()
                    );
                }
            }
            break;
        case JobState::FAILED:
            printf('Job %s had errors:' . PHP_EOL, $job->getName());
            $errors = $job->getErrors();
            foreach ($errors as $error) {
                var_dump($error->getDetails());
            }
            break;
        case JobState::PENDING:
            printf('Job has not completed. Consider a longer timeout or an asynchronous execution model' . PHP_EOL);
            break;
        default:
            printf('Unexpected job state. Most likely, the job is either running or has not yet started.');
    }
}

Python

Para saber como instalar e usar a biblioteca de cliente para proteção de dados sensíveis, consulte Bibliotecas de cliente de proteção de dados sensíveis.

Para usar a proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

import time

import google.cloud.dlp

def inspect_data_to_hybrid_job_trigger(
    project: str,
    trigger_id: str,
    content_string: str,
) -> None:
    """
    Uses the Data Loss Prevention API to inspect sensitive information
    using Hybrid jobs trigger that scans payloads of data sent from
    virtually any source and stores findings in Google Cloud.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        trigger_id: The job trigger identifier for hybrid job trigger.
        content_string: The string to inspect.
    """

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

    # Construct the `item` to inspect.
    item = {"value": content_string}

    # Construct the container details that contains metadata to be
    # associated with the content. For more details, please refer to
    # https://cloud.google.com/dlp/docs/reference/rest/v2/Container
    container_details = {
        "full_path": "10.0.0.2:logs1:app1",
        "relative_path": "app1",
        "root_path": "10.0.0.2:logs1",
        "type_": "logging_sys",
        "version": "1.2",
    }

    # Construct hybrid inspection configuration.
    hybrid_config = {
        "item": item,
        "finding_details": {
            "container_details": container_details,
            "labels": {
                "env": "prod",
                "appointment-bookings-comments": "",
            },
        },
    }

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

    # Activate the job trigger.
    dlp_job = dlp.activate_job_trigger(request={"name": trigger_id})

    # Call the API.
    dlp.hybrid_inspect_job_trigger(
        request={
            "name": trigger_id,
            "hybrid_item": hybrid_config,
        }
    )

    # Get inspection job details.
    job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Wait for dlp job to get finished.
    while job.inspect_details.result.processed_bytes <= 0:
        time.sleep(5)
        job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Print the results.
    print(f"Job name: {dlp_job.name}")
    if job.inspect_details.result.info_type_stats:
        for finding in job.inspect_details.result.info_type_stats:
            print(f"Info type: {finding.info_type.name}; Count: {finding.count}")
    else:
        print("No findings.")

Cenários típicos de inspeção híbrida

As seções a seguir descrevem os usos típicos de inspeção híbrida e os fluxos de trabalho correspondentes.

Faça uma verificação única

Execute uma verificação única de um banco de dados fora do Google Cloud como parte de uma verificação trimestral de bancos de dados.

1. Crie um job híbrido usando o console do Google Cloud ou a API DLP.

2. Envie dados para o job chamando projects.locations.dlpJobs.hybridInspect. Se quiser inspecionar mais dados, repita esta etapa quantas vezes forem necessárias.

3. Depois de enviar dados para inspeção, chame o método projects.locations.dlpJobs.finish.

   A proteção de dados sensíveis executa as ações especificadas na solicitação projects.locations.dlpJobs.create.

Configurar o monitoramento contínuo

Monitore todo o conteúdo novo adicionado diariamente a um banco de dados que não tem suporte nativo da proteção de dados sensíveis.

1. Crie um gatilho de jobs híbrido usando o console do Google Cloud ou a API DLP.

2. Ative o gatilho de jobs chamando o método projects.locations.jobTriggers.activate.

3. Envie dados para o gatilho de jobs chamando projects.locations.jobTriggers.hybridInspect. Se quiser inspecionar mais dados, repita esta etapa quantas vezes forem necessárias.

Nesse caso, não é necessário chamar o método projects.locations.dlpJobs.finish. A proteção de dados sensíveis particiona automaticamente os dados que você envia. Enquanto o acionador de jobs estiver ativo, a proteção de dados sensíveis realizará as ações que você especificou ao criar o acionador de jobs híbridos ao final de cada dia.

Verificar dados que entram em um banco de dados

Verifique os dados que entram em um banco de dados enquanto controla como eles são particionados. Cada job em um gatilho de jobs é uma partição única.

1. Crie um gatilho de jobs híbrido usando o console do Google Cloud ou a API DLP.

2. Ative o gatilho de jobs chamando o método projects.locations.jobTriggers.activate.

   O sistema retorna o ID de um único trabalho. Você vai precisar desse ID do job na próxima etapa.

3. Envie dados para o job chamando projects.locations.dlpJobs.hybridInspect.

   Nesse caso, você envia os dados para o job em vez do acionador de jobs. Essa abordagem permite controlar como os dados enviados para inspeção são particionados. Se você quiser adicionar mais dados para inspeção na partição atual, repita esta etapa.

4. Depois de enviar dados para o job, chame o método projects.locations.dlpJobs.finish.

   A proteção de dados sensíveis executa as ações especificadas na solicitação projects.locations.jobTriggers.create.

5. Se você quiser criar outro job para a próxima partição, ative o acionador de jobs novamente e envie os dados para o job resultante.

Monitorar o tráfego de um proxy

Monitore o tráfego de um proxy instalado entre dois aplicativos personalizados.

1. Crie um gatilho de jobs híbrido usando o console do Google Cloud ou a API DLP.

2. Ative o gatilho de jobs chamando o método projects.locations.jobTriggers.activate.

3. Envie dados para o gatilho de jobs chamando projects.locations.jobTriggers.hybridInspect. Se quiser inspecionar mais dados, repita esta etapa quantas vezes forem necessárias.

   Você pode chamar essa solicitação indefinidamente para todo o tráfego de rede. Inclua metadados em cada solicitação.

Nesse caso, não é necessário chamar o método projects.locations.dlpJobs.finish. A proteção de dados sensíveis particiona automaticamente os dados que você envia. Enquanto o acionador de jobs estiver ativo, a proteção de dados sensíveis realizará as ações que você especificou ao criar o acionador de jobs híbridos ao final de cada dia.

A seguir

• Saiba mais sobre como funcionam os jobs híbridos e acionadores de jobs híbridos.