Inspecione dados de origens externas através de trabalhos híbridos

Este tópico descreve como usar tarefas híbridas e acionadores de tarefas híbridas para inspecionar dados externos quanto a informações confidenciais. Para saber mais sobre tarefas híbridas e acionadores de tarefas híbridas, incluindo exemplos de ambientes híbridos, consulte o artigo Tarefas híbridas e acionadores de tarefas híbridas.

Introdução aos empregos híbridos e aos acionadores de empregos híbridos

As tarefas híbridas e os acionadores de tarefas híbridas permitem-lhe alargar o âmbito da proteção que a proteção de dados confidenciais oferece além dos pedidos de inspeção de conteúdo simples e da Google Cloud análise de repositórios de armazenamento. Usando trabalhos híbridos e acionadores de trabalhos híbridos, pode transmitir dados de praticamente qualquer origem, incluindo fora Google Cloud, diretamente para a proteção de dados confidenciais e permitir que a proteção de dados confidenciais inspecione os dados para obter informações confidenciais. A proteção de dados confidenciais guarda e agrega automaticamente os resultados da análise para análise posterior.

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

Quando cria trabalhos híbridos, estes são executados até os parar. Aceitam todos os dados recebidos, desde que sejam devidamente encaminhados e formatados.

Os acionadores de tarefas híbridas funcionam de forma semelhante às tarefas híbridas, mas não tem de parar explicitamente uma tarefa num acionador de tarefas híbridas. A Proteção de dados confidenciais para automaticamente as tarefas em acionadores de tarefas híbridas no final de cada dia.

Além disso, com um acionador de tarefa híbrido, pode parar e iniciar novas tarefas no acionador sem ter de reconfigurar os pedidos hybridInspect. Por exemplo, pode enviar dados para um acionador de tarefa híbrida e, em seguida, parar a tarefa ativa, alterar a respetiva configuração, iniciar uma nova tarefa nesse acionador e, depois, continuar a enviar dados para o mesmo acionador.

Para mais orientações sobre a opção adequada ao seu exemplo de utilização, consulte os cenários de inspeção híbrida típicos nesta página.

Definição dos termos

Este tópico usa os seguintes termos:

• Dados externos: dados armazenados fora do Google Cloud Sensitive Data Protection ou dados que o Sensitive Data Protection não suporta nativamente.

• Tarefa híbrida: uma tarefa de inspeção configurada para analisar dados de praticamente qualquer origem.

• Acionador de tarefas híbrido: um acionador de tarefas configurado para analisar dados de praticamente qualquer origem.

• hybridInspect pedido: um pedido que contém os dados externos que quer inspecionar. Quando envia este pedido, especifica o trabalho híbrido ou o acionador de trabalho híbrido para o qual enviar o pedido.

Para informações gerais sobre tarefas e acionadores de tarefas, consulte o artigo Tarefas e acionadores de tarefas.

Processo de inspeção híbrido

O processo de inspeção híbrida tem três passos.

1. Escolha os dados que quer enviar para a proteção de dados confidenciais.

   Os dados podem ter origem no interior Google Cloud ou no exterior da empresa. Por exemplo, pode configurar um script ou uma aplicação personalizada para enviar dados para a Proteção de dados confidenciais, o que lhe permite inspecionar dados em trânsito, a partir de outro serviço na nuvem, um repositório de dados no local ou praticamente qualquer outra origem de dados.

2. Configure uma tarefa híbrida ou um acionador de tarefa híbrida na proteção de dados confidenciais a partir do zero ou usando um modelo de inspeção.

   Depois de configurar uma tarefa híbrida ou um acionador de tarefa híbrida, a proteção de dados confidenciais ouve ativamente os dados que lhe são enviados. Quando o seu script personalizado ou aplicação envia dados para esta tarefa híbrida ou acionador de tarefa híbrida, os dados são inspecionados e os respetivos resultados são armazenados de acordo com a configuração.

   Quando configura a tarefa híbrida ou o acionador de tarefa híbrida, pode especificar onde quer guardar ou publicar os resultados. As opções incluem guardar no BigQuery e publicar notificações no Pub/Sub, Cloud Monitoring ou email.

3. Envie um pedido hybridInspect para o trabalho híbrido ou o acionador de trabalho híbrido.

   Um pedido hybridInspect contém os dados a serem analisados. Na solicitação, inclua metadados (também denominados etiquetas e identificadores de tabelas) que descrevem o conteúdo e permitem que a Proteção de dados confidenciais identifique as informações que quer monitorizar. Por exemplo, se estiver a analisar dados relacionados em vários pedidos (como linhas na mesma tabela de base de dados), pode usar os mesmos metadados nesses pedidos relacionados. Em seguida, pode recolher, calcular e analisar as conclusões dessa tabela de base de dados.

À medida que a tarefa híbrida é executada e inspeciona os pedidos, os resultados da inspeção ficam disponíveis quando a proteção de dados confidenciais os gera. Por outro lado, as ações, como as notificações do Pub/Sub, não ocorrem até que a sua aplicação termine a tarefa híbrida.

Nota: Se existirem problemas de configuração ou autorização com o tópico Pub/Sub, a Proteção de dados confidenciais tenta reenviar a notificação Pub/Sub durante um período máximo de duas semanas. Após duas semanas, a notificação é rejeitada.

Considerações

Quando trabalhar com tarefas híbridas e acionadores de tarefas, tenha em atenção os seguintes pontos:

• Os trabalhos híbridos e os acionadores de trabalhos híbridos não suportam a filtragem nem a amostragem.
• Os trabalhos e os acionadores de trabalhos não estão sujeitos a objetivos ao nível do serviço (SLOs), mas existem medidas que pode tomar para reduzir a latência. Para mais informações, consulte o artigo Latência da tarefa.

Antes de começar

Antes de configurar e usar trabalhos híbridos ou acionadores de trabalhos híbridos, certifique-se de que fez o seguinte:

Crie um novo projeto, ative a faturação e ative a Proteção de dados confidenciais

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. Enable the Sensitive Data Protection API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

Configure a origem de dados

Antes de a proteção de dados confidenciais poder inspecionar os seus dados, tem de enviar os dados para a proteção de dados confidenciais. Independentemente do método que usar para configurar a tarefa híbrida ou o acionador de tarefa híbrida, tem de configurar a sua origem externa para enviar dados para a API DLP.

Para informações sobre o formato necessário para pedidos de inspeção híbrida, consulte o artigo Formatação de itens de conteúdo híbrido. Para obter informações sobre os tipos de metadados que pode incluir com os dados na sua solicitação, consulte o artigo Tipos de metadados que pode facultar.

Crie um trabalho híbrido ou um acionador de trabalho híbrido

Para permitir que a proteção de dados confidenciais inspecione os dados que lhe envia, tem de configurar primeiro uma tarefa híbrida ou um acionador de tarefas híbridas. Para obter informações sobre qual deve criar, consulte Cenários de inspeção híbrida típicos nesta página.

Consola

Na Google Cloud consola, aceda à página Criar tarefa ou acionador de tarefas:

Aceda a Criar trabalho ou acionador de trabalho

As secções seguintes descrevem como preencher as secções da página Criar tarefa ou acionador de tarefas relevantes para operações de inspeção híbridas.

Escolha os dados de entrada

Nesta secção, especifica os dados de entrada para inspeção da proteção de dados confidenciais.

1. Opcional: em Nome, atribua um nome à tarefa introduzindo um valor no campo ID da tarefa. Se deixar este campo em branco, a proteção de dados confidenciais gera automaticamente um identificador.
2. Opcional: no menu Localização do recurso, escolha a região onde quer armazenar a tarefa híbrida ou o acionador de tarefa híbrida. Para mais informações, consulte o artigo Especificar localizações de processamento.

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

4. Opcional: em Descrição, descreva o trabalho híbrido ou o acionador de trabalho híbrido que está a criar. Por exemplo, pode incluir informações sobre a origem dos dados a inspecionar.

5. Opcional: para Etiquetas obrigatórias, clique em Adicionar etiqueta e introduza uma etiqueta que quer exigir dos pedidos hybridInspect. Um pedido que não especifique esta etiqueta não é processado por esta tarefa híbrida nem por este acionador de tarefa híbrida.hybridInspect Pode adicionar até 10 etiquetas obrigatórias. Para mais informações, consulte a secção Exigir etiquetas de hybridInspect pedidos nesta página.

6. Opcional: em Etiquetas opcionais, introduza quaisquer pares chave-valor que queira anexar aos resultados de todos os pedidos hybridInspect enviados para esta tarefa ou acionador de tarefas. Pode adicionar até 10 etiquetas opcionais. Para mais informações, consulte o artigo Etiquetas opcionais.

7. Opcional: para Opções de dados tabulares, introduza o nome do campo da coluna de chave primária se planear enviar dados tabulares nos seus pedidos.hybridInspect Para mais informações, consulte as Opções de dados tabulares.

8. Clique em Continuar.

Configure a deteção

Nesta secção, especifica os tipos de dados confidenciais para os quais a proteção de dados confidenciais vai inspecionar os dados de entrada. As suas opções são:

• Modelo: se já criou um modelo no projeto atual que quer usar para definir os parâmetros de deteção da proteção de dados confidenciais, clique no campo Nome do modelo e, de seguida, escolha o modelo na lista apresentada.
• InfoTypes: a proteção de dados confidenciais seleciona os infoTypes incorporados mais comuns para deteção. Para alterar os infoTypes ou escolher um infoType personalizado a usar, clique em Gerir infoTypes. Também pode ajustar os critérios de deteção nas secções Conjuntos de regras de inspeção e Limite de confiança. Para mais detalhes, consulte o artigo Configure a deteção.

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

Adicione ações

Para Adicionar ações, selecione uma ou mais ações que a proteção de dados confidenciais deve realizar após a conclusão da tarefa. Para mais informações, consulte Ative ações de inspeção ou análise de riscos.

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

Agendar

Nesta secção, especifica se quer criar uma única tarefa que é executada imediatamente ou um acionador de tarefas que é executado sempre que o Sensitive Data Protection recebe dados devidamente encaminhados e formatados.

Efetue um dos seguintes passos:

• Para executar a tarefa híbrida imediatamente, escolha Nenhuma (executar a tarefa única imediatamente após a criação).

• Para configurar a tarefa de modo que os dados recebidos da origem acionem a tarefa, escolha Criar um acionador para executar a tarefa num horário periódico.

  As tarefas híbridas acionam chamadas de API agregadas, o que lhe permite ver os resultados da pesquisa e as tendências ao longo do tempo.

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

Reveja

Pode rever um resumo JSON da análise aqui. Certifique-se de que anota o nome do objeto híbrido ou do acionador de tarefa híbrida. Precisa destas informações quando envia dados para o Google Cloud Sensitive Data Protection para inspeção.

Depois de rever o resumo JSON, clique em Criar.

A proteção de dados confidenciais inicia a tarefa híbrida ou o acionador de tarefas híbridas imediatamente. Uma análise de inspeção é iniciada quando envia um hybridInspect pedido para esta tarefa híbrida ou acionador de tarefa híbrida.

API

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

Um acionador de tarefa é representado na API DLP pelo recurso JobTrigger. Para criar um acionador de emprego híbrido, chama o método projects.locations.jobTriggers.create.

O objeto DlpJobs ou JobTrigger que criar tem de ter as seguintes definiçõ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. Este objeto contém metadados sobre os dados que quer inspecionar.

4. No objeto InspectJobConfig, no campo actions, adicione as ações (Action) que quer que a Proteção de dados confidenciais realize no final de cada tarefa.

   As ações publishSummaryToCscc e publishFindingsToCloudDataCatalog não são suportadas para esta operação. Para mais informações sobre ações, consulte o artigo Ações.

5. Especifique o que analisar e como analisar através de uma ou ambas as seguintes opções:

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

   • Defina o campo inspectConfig.

   Se definir os campos inspectTemplateName e inspectConfig, as respetivas definições são combinadas.

Acerca dos exemplos JSON

Os seguintes separadores contêm exemplos JSON que pode enviar para a proteção de dados confidenciais para criar uma tarefa híbrida ou um acionador de tarefas híbridas. Estes exemplos de acionadores de trabalhos híbridos e trabalhos híbridos estão configurados para fazer o seguinte:

• Processar qualquer pedido hybridInspect se o pedido tiver a etiqueta appointment-bookings-comments.
• Analise o conteúdo do pedido de endereços de email hybridInspect.
• Anexe a etiqueta "env": "prod" aos resultados.
• Para dados tabulares, obtenha o valor da célula na coluna booking_id (a chave primária) que se encontra na mesma linha que a célula onde os dados confidenciais foram encontrados. A proteção de dados confidenciais anexa este identificador à descoberta para que possa rastrear a descoberta até à linha específica de onde provém.
• Enviar um email quando a tarefa parar. O email é enviado para os proprietários do projeto do IAM e os contactos essenciais técnicos.
• Enviar as conclusões para o Cloud Monitoring quando a tarefa for interrompida.

Para ver os exemplos JSON, consulte os separadores seguintes.

Trabalho híbrido

Este separador contém um exemplo JSON que pode usar para criar uma tarefa híbrida.

Para criar um emprego híbrido, envie um pedido POST para o seguinte ponto final.

Método HTTP e URL

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

Substitua o seguinte:

• PROJECT_ID: o ID do projeto onde quer armazenar a tarefa híbrida.
• REGION: a região geográfica onde quer armazenar o trabalho 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 confidenciais cria a tarefa híbrida e gera um ID da tarefa. Neste exemplo, o ID da tarefa é i-postgresql-table-comments. Tome nota do ID da tarefa. Precisa dele no seu pedido hybridInspect.

Para parar uma tarefa híbrida, tem de chamar o método projects.locations.dlpJobs.finish explicitamente. A API DLP não para automaticamente as tarefas híbridas. Por outro lado, a API DLP para automaticamente as tarefas em acionadores de tarefas híbridas no final de cada dia.

Acionador de emprego híbrido

Este separador contém um exemplo JSON que pode usar para criar um acionador de tarefa híbrida.

Para criar um acionador de tarefa híbrida, envie um pedido POST para o seguinte ponto final.

Método HTTP e URL

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

Substitua o seguinte:

• PROJECT_ID: o ID do projeto onde quer armazenar o acionador de tarefas híbridas.
• REGION: a região geográfica onde quer armazenar o acionador de emprego 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 confidenciais cria o acionador de tarefas híbrido. A saída contém o nome do acionador de emprego híbrido. Neste exemplo, é postgresql-table-comments. Tome nota do nome. Precisa dele no seu pedido hybridInspect.

Ao contrário do que acontece com as tarefas híbridas, a API DLP para automaticamente as tarefas nos acionadores de tarefas híbridas no final de cada dia. Assim, não precisa de chamar explicitamente o método projects.locations.dlpJobs.finish.

Quando cria uma tarefa híbrida ou um acionador de tarefa híbrida, pode usar o Explorador de APIs nas seguintes páginas de referência da API, respetivamente:

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

No campo Parâmetros de pedido, introduza projects/PROJECT_ID/locations/REGION. Em seguida, no campo Corpo do pedido, cole o exemplo de JSON para o objeto que está a tentar criar.

Um pedido bem-sucedido, mesmo que criado no APIs Explorer, cria uma tarefa híbrida ou um acionador de tarefas híbridas.

Para informações gerais sobre a utilização de JSON para enviar pedidos à API DLP, consulte o início rápido de JSON.

Enviar dados para a tarefa híbrida ou o acionador de tarefa híbrida

Para inspecionar os dados, tem de enviar um pedido hybridInspect no formato correto para uma tarefa híbrida ou um acionador de tarefas híbridas.

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

Segue-se um exemplo simples de um pedido hybridInspect enviado para a proteção de dados confidenciais para processamento por uma tarefa híbrida ou um acionador de tarefa híbrida. Tenha em atenção a estrutura do objeto JSON, incluindo o campo hybridItem, que contém os seguintes campos:

• item: contém o conteúdo real a inspecionar.
• findingDetails: contém metadados a associar 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 dos itens de inspeção híbrida, consulte o conteúdo de referência da API para o objeto HybridContentItem.

Pontos finais de inspeção híbrida

Para que os dados sejam inspecionados através de uma tarefa híbrida ou de um acionador de tarefas híbridas, tem de enviar um pedido hybridInspect para o ponto final correto.

Método HTTP e URL para trabalhos híbridos

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

Para mais informações sobre este ponto final, consulte a página de referência da API para o método projects.locations.dlpJobs.hybridInspect.

Método HTTP e URL para acionadores de tarefas híbridas

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

Para mais informações sobre este ponto final, consulte a página de referência da API para o método projects.locations.jobTriggers.hybridInspect.

Substitua o seguinte:

• PROJECT_ID: o seu identificador do projeto.
• REGION: a região geográfica onde quer armazenar o pedido hybridInspect. Esta região tem de ser igual à região do trabalho híbrido.

• JOB_ID: o ID que atribuiu à tarefa híbrida, com o prefixo i-.

  Para procurar o ID da tarefa, em Proteção de dados confidenciais, clique em Inspeção > Tarefas de inspeção.

• TRIGGER_NAME: o nome que atribuiu ao acionador de tarefas híbridas.

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

Exija etiquetas de pedidos de hybridInspect

Se quiser controlar que pedidos podem ser processados por uma tarefa híbrida ou um acionador de tarefas híbridas, pode definir etiquetas obrigatórias.hybridInspect Todas as hybridInspect solicitações para esse trabalho híbrido ou acionador de trabalho híbrido que não incluam estas etiquetas obrigatórias são rejeitadas.

Para definir uma etiqueta obrigatória, faça o seguinte:

1. Ao criar a tarefa híbrida ou o acionador de tarefa híbrida, defina o campo requiredFindingLabelKeys como uma lista de etiquetas necessárias.

   O exemplo seguinte define appointment-bookings-comments como uma etiqueta obrigatória num trabalho híbrido ou num acionador de trabalho híbrido.

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

2. No pedido hybridInspect, no campo labels, adicione cada etiqueta necessária como uma chave num par de chave-valor. O valor correspondente pode ser uma string vazia.

   O exemplo seguinte define a etiqueta necessária, appointment-bookings-comments, num pedido hybridInspect.

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

Se não incluir a etiqueta necessária no seu pedido hybridInspect, recebe um erro semelhante ao seguinte:

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

Exemplo de código: crie um acionador de tarefas híbrido e envie dados para o mesmo

Importante: O código nesta página requer que configure primeiro um cliente da proteção de dados confidenciais. Para mais informações sobre a instalação e a criação de um cliente da Proteção de dados confidenciais, consulte Bibliotecas de cliente da Proteção de dados confidenciais. (O envio de JSON para pontos finais REST de proteção de dados confidenciais não requer uma biblioteca de cliente.)

C#

Para saber como instalar e usar a biblioteca cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

Para se autenticar na Proteção de dados confidenciais, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

Para se autenticar na Proteção de dados confidenciais, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

Para se autenticar na Proteção de dados confidenciais, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

Para se autenticar na Proteção de dados confidenciais, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

// 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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

Para se autenticar na Proteção de dados confidenciais, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

use Google\ApiCore\ApiException;
use Google\Cloud\Dlp\V2\ActivateJobTriggerRequest;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\Container;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\GetDlpJobRequest;
use Google\Cloud\Dlp\V2\HybridContentItem;
use Google\Cloud\Dlp\V2\HybridFindingDetails;
use Google\Cloud\Dlp\V2\HybridInspectJobTriggerRequest;
use Google\Cloud\Dlp\V2\ListDlpJobsRequest;

/**
 * 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 {
        $activateJobTriggerRequest = (new ActivateJobTriggerRequest())
            ->setName($name);
        $triggerJob = $dlp->activateJobTrigger($activateJobTriggerRequest);
    } catch (ApiException $e) {
        $listDlpJobsRequest = (new ListDlpJobsRequest())
            ->setParent($parent)
            ->setFilter('trigger_name=' . $name);
        $result = $dlp->listDlpJobs($listDlpJobsRequest);
        foreach ($result as $job) {
            $triggerJob = $job;
        }
    }
    $hybridInspectJobTriggerRequest = (new HybridInspectJobTriggerRequest())
        ->setName($name)
        ->setHybridItem($hybridItem);

    $dlp->hybridInspectJobTrigger($hybridInspectJobTriggerRequest);

    $numOfAttempts = 10;
    do {
        printf('Waiting for job to complete' . PHP_EOL);
        sleep(10);
        $getDlpJobRequest = (new GetDlpJobRequest())
            ->setName($triggerJob->getName());
        $job = $dlp->getDlpJob($getDlpJobRequest);
        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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

Para se autenticar na Proteção de dados confidenciais, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local.

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 secções seguintes descrevem as utilizações típicas da inspeção híbrida e os respetivos fluxos de trabalho.

Faça uma análise única

Executar uma análise única de uma base de dados fora do Google Cloud como parte de uma verificação pontual trimestral de bases de dados.

1. Crie uma tarefa híbrida através da Google Cloud consola ou da API DLP.

2. Envie dados para a tarefa chamando projects.locations.dlpJobs.hybridInspect. Se quiser inspecionar mais dados, repita este passo as vezes que forem necessárias.

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

   A proteção de dados confidenciais realiza as ações especificadas no seu pedido.projects.locations.dlpJobs.create

Configure a monitorização contínua

Monitorizar todo o novo conteúdo adicionado diariamente a uma base de dados que a proteção de dados confidenciais não suporta nativamente.

1. Crie um acionador de tarefa híbrida através da Google Cloud consola ou da API DLP.

2. Ative o acionador de tarefas chamando o método projects.locations.jobTriggers.activate.

3. Envie dados para o acionador de tarefas chamando projects.locations.jobTriggers.hybridInspect. Se quiser inspecionar mais dados, repita este passo as vezes que forem necessárias.

Neste caso, não precisa de chamar o método projects.locations.dlpJobs.finish A proteção de dados confidenciais divide automaticamente os dados que envia. Enquanto o acionador da tarefa estiver ativo, no final de cada dia, a proteção de dados confidenciais executa as ações que especificou quando criou o acionador da tarefa híbrida.

Analise os dados que entram numa base de dados

Analisar os dados que entram numa base de dados, enquanto controla a forma como os dados são particionados. Cada trabalho num acionador de trabalhos é uma única partição.

1. Crie um acionador de tarefa híbrida através da Google Cloud consola ou da API DLP.

2. Ative o acionador de tarefas chamando o método projects.locations.jobTriggers.activate.

   O sistema devolve o ID da tarefa de uma única tarefa. Precisa deste ID da tarefa no passo seguinte.

3. Envie dados para a tarefa chamando projects.locations.dlpJobs.hybridInspect.

   Neste caso, envia os dados para a tarefa em vez do acionador da tarefa. Esta abordagem permite-lhe controlar a forma como os dados que envia para inspeção são particionados. Se quiser adicionar mais dados para inspeção na partição atual, repita este passo.

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

   A proteção de dados confidenciais realiza as ações especificadas no seu pedido.projects.locations.jobTriggers.create

5. Se quiser criar outra tarefa para a partição seguinte, ative novamente o acionador da tarefa e, em seguida, envie os dados para a tarefa resultante.

Monitorize o tráfego de um proxy

Monitorize o tráfego de um proxy instalado entre duas aplicações personalizadas.

1. Crie um acionador de tarefa híbrida através da Google Cloud consola ou da API DLP.

2. Ative o acionador de tarefas chamando o método projects.locations.jobTriggers.activate.

3. Envie dados para o acionador de tarefas chamando projects.locations.jobTriggers.hybridInspect. Se quiser inspecionar mais dados, repita este passo as vezes que forem necessárias.

   Pode chamar este pedido indefinidamente para todo o tráfego de rede. Certifique-se de que inclui metadados em cada pedido.

Neste caso, não precisa de chamar o método projects.locations.dlpJobs.finish A proteção de dados confidenciais divide automaticamente os dados que envia. Enquanto o acionador da tarefa estiver ativo, no final de cada dia, a proteção de dados confidenciais executa as ações que especificou quando criou o acionador da tarefa híbrida.

O que se segue?

• Saiba como funcionam os empregos híbridos e os acionadores de empregos híbridos.