Como usar conjuntos de arquivos do Cloud Storage

Use as APIs do Data Catalog para criar e gerenciar entradas do conjunto de arquivos do Cloud Storage (chamadas de "conjuntos de arquivos" no restante deste documento).

Como os conjuntos de arquivos se encaixam no Data Catalog

Antes de analisar os conjuntos de arquivos, vejamos os principais conceitos do Data Catalog e como os conjuntos de dados se encaixam no Data Catalog.

Entrada
Um catálogo de dados entry representa um recurso do Google Cloud, como um conjunto de dados ou uma tabela do BigQuery, um tópico do Pub/Sub ou um conjunto de arquivos do Cloud Storage. Você cria, pesquisa e gerencia entradas do Data Catalog para explorar e gerenciar recursos de dados do Google Cloud. Uma entrada de conjunto de arquivos pode incluir um esquema opcional de dados do conjunto de arquivos.
Grupo de entrada

As entradas estão contidas em um entry group. Um grupo de entradas contém entradas relacionadas logicamente com políticas do Gerenciamento de identidade e acesso que especificam os usuários que podem criar, editar e visualizar entradas em um grupo de entradas.

O Data Catalog cria automaticamente um grupo de entradas para entradas do BigQuery ("@bigquery") e tópicos do Pub/Sub ("@pubsub"). Você cria seu próprio grupo de entradas para conter as entradas do conjunto de arquivos do Cloud Storage e as políticas do IAM associadas a essas entradas. Grupos de entradas, como entradas, podem ser pesquisados.

A ilustração a seguir mostra como os grupos de entrada predefinidos e criados pelo usuário se encaixam no modelo de dados do Data Catalog.

Conjunto de arquivos do Cloud Storage

Um conjunto de arquivos do Cloud Storage é uma entrada dentro de um grupo de entradas criado pelo usuário. Ele é definido por um ou mais padrões de arquivo que especificam um conjunto de um ou mais arquivos do Cloud Storage.

Requisitos de padrão de arquivo:

Como criar grupos de entrada e conjuntos de arquivos

Os conjuntos de arquivos precisam ser colocados em um grupo de entrada criado pelo usuário. Se você não criou um grupo de entrada, primeiro crie o grupo de entrada e, em seguida, crie o conjunto de arquivos dentro do grupo de entrada. É possível definir políticas do IAM no grupo de entrada para definir quem tem acesso a conjuntos de arquivos e outras entradas no grupo.

gcloud

1. Criar um grupo de entrada

Use o comando gcloud data-catalog entry-groups create para criar um grupo de entrada com um esquema e uma descrição anexados.

Exemplo:

gcloud data-catalog entry-groups create my_entrygroup \
    --location=us-central1

2. Criar um conjunto de arquivos no grupo de entrada

Use o comando gcloud data-catalog entries create para criar um conjunto de arquivos em um grupo de entrada. Este exemplo de comando gcloud, abaixo, cria uma entrada de conjunto de arquivos que inclui o esquema de dados do conjunto de arquivos.

gcloud data-catalog entries create my_fileset_entry \  
    --location=us-central1 \  
    --entry-group=my_entrygroup \  
    --type=FILESET \  
    --gcs-file-patterns=gs://my-bucket/*.csv \  
    --schema-from-file=path_to_schema_file \  
    --description="Fileset description ..."

Sinalizar notas:

  • --gcs-file-patterns: consulte Requisitos de padrão de arquivo.
  • --schema-from-file: a amostra a seguir mostra o formato JSON do arquivo de texto do esquema aceito pela sinalização --schema-from-file.
    [
      {
        "column": "first_name",
        "description": "First name",
        "mode": "REQUIRED",
        "type": "STRING"
      },
      {
        "column": "last_name",
        "description": "Last name",
        "mode": "REQUIRED",
        "type": "STRING"
      },
      {
        "column": "address",
        "description": "Address",
        "mode": "REPEATED",
        "type": "STRING"
      }
    ]
    

Console

  1. Selecione Criar grupo de entrada na lista suspensa CRIAR ou na seção Grupos de entrada da IU do Catálogo de dados no Console do Google Cloud.

  2. Preencha o formulário Criar grupo de entrada e clique em CRIAR.

  3. A página Detalhes do grupo de entrada é aberta. Com a guia ENTRADAS selecionada, clique em CRIAR.

  4. Preencha o formulário Criar conjunto de arquivos.

    1. Para anexar um esquema, clique em Definir esquema para abrir o formulário de esquema. Clique em + ADICIONAR CAMPOS para adicionar campos individualmente ou alterne para Editar como texto no canto superior direito do formulário para especificar os campos no formato JSON.
    2. Clique em Salvar para salvar o esquema.
  5. Clique em Criar para criar o conjunto de arquivos.

Python

  1. Instalar a biblioteca cliente
  2. Configurar as credenciais padrão do aplicativo
  3. Execute o código
    """
    This application demonstrates how to perform core operations with the
    Data Catalog API.
    
    For more information, see the README.md and the official documentation at
    https://cloud.google.com/data-catalog/docs.
    """
    
    # -------------------------------
    # Import required modules.
    # -------------------------------
    from google.api_core.exceptions import NotFound, PermissionDenied
    from google.cloud import datacatalog_v1
    
    # -------------------------------
    # Set your Google Cloud Platform project ID.
    # -------------------------------
    project_id = 'your-project-id'
    
    # -------------------------------
    # Currently, Data Catalog stores metadata in the
    # us-central1 region.
    # -------------------------------
    location = 'us-central1'
    
    # -------------------------------
    # Use Application Default Credentials to create a new
    # Data Catalog client. GOOGLE_APPLICATION_CREDENTIALS
    # environment variable must be set with the location
    # of a service account key file.
    # -------------------------------
    datacatalog = datacatalog_v1.DataCatalogClient()
    
    # -------------------------------
    # 1. Environment cleanup: delete pre-existing data.
    # -------------------------------
    # Delete any pre-existing Entry with the same name
    # that will be used in step 3.
    expected_entry_name = datacatalog_v1.DataCatalogClient\
        .entry_path(project_id, location, 'fileset_entry_group', 'fileset_entry_id')
    
    try:
        datacatalog.delete_entry(name=expected_entry_name)
    except (NotFound, PermissionDenied):
        pass
    
    # Delete any pre-existing Entry Group with the same name
    # that will be used in step 2.
    expected_entry_group_name = datacatalog_v1.DataCatalogClient\
        .entry_group_path(project_id, location, 'fileset_entry_group')
    
    try:
        datacatalog.delete_entry_group(name=expected_entry_group_name)
    except (NotFound, PermissionDenied):
        pass
    
    # -------------------------------
    # 2. Create an Entry Group.
    # -------------------------------
    entry_group_obj = datacatalog_v1.types.EntryGroup()
    entry_group_obj.display_name = 'My Fileset Entry Group'
    entry_group_obj.description = 'This Entry Group consists of ....'
    
    entry_group = datacatalog.create_entry_group(
        parent=datacatalog_v1.DataCatalogClient.location_path(project_id, location),
        entry_group_id='fileset_entry_group',
        entry_group=entry_group_obj)
    print('Created entry group: {}'.format(entry_group.name))
    
    # -------------------------------
    # 3. Create a Fileset Entry.
    # -------------------------------
    entry = datacatalog_v1.types.Entry()
    entry.display_name = 'My Fileset'
    entry.description = 'This fileset consists of ....'
    entry.gcs_fileset_spec.file_patterns.append('gs://my_bucket/*')
    entry.type = datacatalog_v1.enums.EntryType.FILESET
    
    # Create the Schema, for example when you have a csv file.
    columns = []
    columns.append(datacatalog_v1.types.ColumnSchema(
        column='first_name',
        description='First name',
        mode='REQUIRED',
        type='STRING'))
    
    columns.append(datacatalog_v1.types.ColumnSchema(
        column='last_name',
        description='Last name',
        mode='REQUIRED',
        type='STRING'))
    
    # Create sub columns for the addresses parent column
    subcolumns = []
    
    subcolumns.append(datacatalog_v1.types.ColumnSchema(
        column='city',
        description='City',
        mode='NULLABLE',
        type='STRING'))
    
    subcolumns.append(datacatalog_v1.types.ColumnSchema(
        column='state',
        description='State',
        mode='NULLABLE',
        type='STRING'))
    
    columns.append(datacatalog_v1.types.ColumnSchema(
        column='addresses',
        description='Addresses',
        mode='REPEATED',
        subcolumns = subcolumns,
        type='RECORD'))
    
    entry.schema.columns.extend(columns)
    
    entry = datacatalog.create_entry(
        parent=entry_group.name,
        entry_id='fileset_entry_id',
        entry=entry)
    print('Created entry: {}'.format(entry.name))
      

Java

  1. Instalar a biblioteca cliente
  2. Configurar as credenciais padrão do aplicativo
  3. Execute o código
    /*
    This application demonstrates how to perform core operations with the
    Data Catalog API.
    
    For more information, see the README.md and the official documentation at
    https://cloud.google.com/data-catalog/docs.
    */
    
    package com.example.datacatalog;
    
    import com.google.cloud.datacatalog.v1.ColumnSchema;
    import com.google.cloud.datacatalog.v1.CreateEntryGroupRequest;
    import com.google.cloud.datacatalog.v1.CreateEntryRequest;
    import com.google.cloud.datacatalog.v1.Entry;
    import com.google.cloud.datacatalog.v1.EntryGroup;
    import com.google.cloud.datacatalog.v1.EntryGroupName;
    import com.google.cloud.datacatalog.v1.EntryName;
    import com.google.cloud.datacatalog.v1.EntryType;
    import com.google.cloud.datacatalog.v1.GcsFilesetSpec;
    import com.google.cloud.datacatalog.v1.LocationName;
    import com.google.cloud.datacatalog.v1.Schema;
    
    import com.google.cloud.datacatalog.v1.DataCatalogClient;
    
    public class CreateFilesetEntry {
    
      public static void createEntry() {
        // TODO(developer): Replace these variables before running the sample.
        String projectId = "my-project-id";
        String entryGroupId = "fileset_entry_group";
        String entryId = "fileset_entry_id";
        createEntry(projectId, entryGroupId, entryId);
      }
    
      /**
       * Create Fileset Entry
       */
      public static void createEntry(String projectId, String entryGroupId, String entryId) {
    
        // -------------------------------
        // Currently, Data Catalog stores metadata in the
        // us-central1 region.
        // -------------------------------
        String location = "us-central1";
    
        // 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 (DataCatalogClient dataCatalogClient = DataCatalogClient.create()) {
    
          // -------------------------------
          // 1. Environment cleanup: delete pre-existing data.
          // -------------------------------
          // Delete any pre-existing Entry with the same name
          // that will be used in step 3.
          try {
            dataCatalogClient.deleteEntry(
                EntryName.of(projectId, location, entryGroupId, entryId).toString());
          } catch (Exception e) {
            System.out.println("Entry does not exist.");
          }
    
          // Delete any pre-existing Entry Group with the same name
          // that will be used in step 2.
          try {
            dataCatalogClient.deleteEntryGroup(
                EntryGroupName.of(projectId, location, entryGroupId).toString());
          } catch (Exception e) {
            System.out.println("Entry Group does not exist.");
          }
    
          // -------------------------------
          // 2. Create an Entry Group.
          // -------------------------------
          // Construct the EntryGroup for the EntryGroup request.
          EntryGroup entryGroup =
              EntryGroup.newBuilder()
                  .setDisplayName("My Fileset Entry Group")
                  .setDescription("This Entry Group consists of ....")
                  .build();
    
          // Construct the EntryGroup request to be sent by the client.
          CreateEntryGroupRequest entryGroupRequest = CreateEntryGroupRequest.newBuilder()
              .setParent(LocationName.of(projectId, location).toString())
              .setEntryGroupId(entryGroupId)
              .setEntryGroup(entryGroup)
              .build();
    
          // Use the client to send the API request.
          EntryGroup entryGroupResponse = dataCatalogClient.createEntryGroup(entryGroupRequest);
    
          System.out.printf("\nEntry Group created with name: %s\n", entryGroupResponse.getName());
    
          // -------------------------------
          // 3. Create a Fileset Entry.
          // -------------------------------
          // Construct the Entry for the Entry request.
          Entry entry =
              Entry.newBuilder()
                  .setDisplayName("My Fileset")
                  .setDescription("This fileset consists of ....")
                  .setGcsFilesetSpec(
                      GcsFilesetSpec.newBuilder().addFilePatterns("gs://my_bucket/*").build())
                  .setSchema(
                      Schema.newBuilder()
                          .addColumns(
                              ColumnSchema.newBuilder()
                                  .setColumn("first_name")
                                  .setDescription("First name")
                                  .setMode("REQUIRED")
                                  .setType("STRING")
                                  .build())
                          .addColumns(
                              ColumnSchema.newBuilder()
                                  .setColumn("last_name")
                                  .setDescription("Last name")
                                  .setMode("REQUIRED")
                                  .setType("STRING")
                                  .build())
                          .addColumns(
                              ColumnSchema.newBuilder()
                                  .setColumn("addresses")
                                  .setDescription("Addresses")
                                  .setMode("REPEATED")
                                  .setType("RECORD")
                                  .addSubcolumns(
                                      ColumnSchema.newBuilder()
                                          .setColumn("city")
                                          .setDescription("City")
                                          .setMode("NULLABLE")
                                          .setType("STRING")
                                          .build())
                                  .addSubcolumns(
                                      ColumnSchema.newBuilder()
                                          .setColumn("state")
                                          .setDescription("State")
                                          .setMode("NULLABLE")
                                          .setType("STRING")
                                          .build())
                                  .build())
                          .build())
                  .setType(EntryType.FILESET)
                  .build();
    
          // Construct the Entry request to be sent by the client.
          CreateEntryRequest entryRequest = CreateEntryRequest.newBuilder()
              .setParent(entryGroupResponse.getName())
              .setEntryId(entryId)
              .setEntry(entry)
              .build();
    
          // Use the client to send the API request.
          Entry entryResponse = dataCatalogClient.createEntry(entryRequest);
    
          System.out.printf("\nEntry created with name: %s\n", entryResponse.getName());
    
        } catch (Exception e) {
          System.out.println("Error in create entry process:\n" + e.toString());
        }
      }
    }
    

Node.js

  1. Instalar a biblioteca cliente
  2. Configurar as credenciais padrão do aplicativo
  3. Execute o código
    /**
     * This application demonstrates how to create an Entry Group and a fileset
     * Entry with the Cloud Data Catalog API.
    
     * For more information, see the README.md under /datacatalog and the
     * documentation at https://cloud.google.com/data-catalog/docs.
     */
    const main = async (
      projectId = process.env.GCLOUD_PROJECT,
      entryGroupId,
      entryId
    ) => {
        // -------------------------------
      // Import required modules.
      // -------------------------------
      const { DataCatalogClient } = require('@google-cloud/datacatalog').v1;
      const datacatalog = new DataCatalogClient();
    
      // -------------------------------
      // Currently, Data Catalog stores metadata in the
      // us-central1 region.
      // -------------------------------
      const location = "us-central1";
    
      // -------------------------------
      // 1. Environment cleanup: delete pre-existing data.
      // -------------------------------
      // Delete any pre-existing Entry with the same name
      // that will be used in step 3.
      try {
        const formattedName = datacatalog.entryPath(projectId, location, entryGroupId, entryId);
        await datacatalog.deleteEntry({ name: formattedName });
      } catch (err) {
        console.log('Entry does not exist.');
      }
    
      // Delete any pre-existing Entry Group with the same name
      // that will be used in step 2.
      try {
        const formattedName = datacatalog.entryGroupPath(projectId, location, entryGroupId);
        await datacatalog.deleteEntryGroup({ name: formattedName });
      } catch (err) {
        console.log('Entry Group does not exist.');
      }
    
      // -------------------------------
      // 2. Create an Entry Group.
      // -------------------------------
      // Construct the EntryGroup for the EntryGroup request.
      const entryGroup = {
        displayName: 'My Fileset Entry Group',
        description: 'This Entry Group consists of ....'
      }
    
      // Construct the EntryGroup request to be sent by the client.
      const entryGroupRequest = {
        parent: datacatalog.locationPath(projectId, location),
        entryGroupId: entryGroupId,
        entryGroup: entryGroup,
      };
    
      // Use the client to send the API request.
      await datacatalog.createEntryGroup(entryGroupRequest)
    
      // -------------------------------
      // 3. Create a Fileset Entry.
      // -------------------------------
      // Construct the Entry for the Entry request.
      const FILESET_TYPE = 4
    
      const entry = {
        displayName: 'My Fileset',
        description: 'This fileset consists of ....',
        gcsFilesetSpec: {filePatterns: ['gs://my_bucket/*']},
        schema: {
          columns: [
            {
              column: 'city',
              description: 'City',
              mode: 'NULLABLE',
              type: 'STRING',
            },
            {
              column: 'state',
              description: 'State',
              mode: 'NULLABLE',
              type: 'STRING',
            },
            {
              column: 'addresses',
              description: 'Addresses',
              mode: 'REPEATED',
              subcolumns: [
                {
                  column: 'city',
                  description: 'City',
                  mode: 'NULLABLE',
                  type: 'STRING',
                },
                {
                  column: 'state',
                  description: 'State',
                  mode: 'NULLABLE',
                  type: 'STRING',
                },
              ],
              type: 'RECORD',
            },
          ],
        },
        type: FILESET_TYPE,
      };
    
      // Construct the Entry request to be sent by the client.
      const request = {
        parent: datacatalog.entryGroupPath(projectId, location, entryGroupId),
        entryId: entryId,
        entry: entry,
      };
    
      // Use the client to send the API request.
      const [response] = await datacatalog.createEntry(request)
    
      console.log(response);
    };
    // [END datacatalog_create_fileset_quickstart_tag]
    
    // node createFilesetEntry.js   
    main(...process.argv.slice(2));
    

REST e LINHA DE CMD

Se você não tiver acesso às bibliotecas de cliente do Cloud para sua linguagem ou quiser testar a API usando solicitações REST, consulte os exemplos a seguir e consulte as documentações entryGroups.create e entryGroups.entries.create da API REST do Data Catalog.

1. Criar um grupo de entrada

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • project-id: ID do projeto do GCP.
  • entryGroupId: o ID deve começar com uma letra ou um sublinhado, conter somente letras, números e sublinhados ingleses e ter no máximo 64 caracteres.
  • displayName: o nome textual do grupo de entrada.

Método HTTP e URL:

POST https://datacatalog.googleapis.com/v1/projects/project-id/locations/us-central1/entryGroups?entryGroupId=entryGroupId

Corpo JSON da solicitação:

{
  "displayName": "Entry Group display name"
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/my_projectid/locations/us-central1/entryGroups/my_entry_group",
  "displayName": "Entry Group display name",
  "dataCatalogTimestamps": {
    "createTime": "2019-10-19T16:35:50.135Z",
    "updateTime": "2019-10-19T16:35:50.135Z"
  }
}

2. Criar um conjunto de arquivos no grupo de entrada

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • project_id: ID do projeto do GCP.
  • entryGroupId: ID do entryGroup existente. O conjunto de arquivos será criado neste entryGroup.
  • entryId: entryId do novo conjunto de arquivos. O código precisa começar com uma letra ou sublinhado, conter apenas letras, números e sublinhados em inglês e ter no máximo 64 caracteres.
  • description: descrição do conjunto de arquivos.
  • displayName: o nome textual da entrada do conjunto de arquivos.
  • filePatterns: precisa começar com "gs://bucket_name/". Consulte Requisitos de padrão de arquivo.
  • schema: esquema do conjunto de arquivos.

    Exemplo de esquema JSON:
    { ...
      "schema": {
        "columns": [
          {
            "column": "first_name",
            "description": "First name",
            "mode": "REQUIRED",
            "type": "STRING"
          },
          {
            "column": "last_name",
            "description": "Last name",
            "mode": "REQUIRED",
            "type": "STRING"
          },
          {
            "column": "address",
            "description": "Address",
            "mode": "REPEATED",
            "subcolumns": [
              {
                "column": "city",
                "description": "City",
                "mode": "NULLABLE",
                "type": "STRING"
              },
              {
                "column": "state",
                "description": "State",
                "mode": "NULLABLE",
                "type": "STRING"
              }
            ],
            "type": "RECORD"
          }
        ]
      }
    ...
    }
    

Método HTTP e URL:

POST https://datacatalog.googleapis.com/v1/projects/project_id/locations/us-central1/entryGroups/entryGroupId/entries?entryId=entryId

Corpo JSON da solicitação:

{
  "description": "Fileset description.",
  "displayName": "Display name",
  "gcsFilesetSpec": {
    "filePatterns": [
      "gs://bucket_name/file_pattern"
    ]
  },
  "type": "FILESET",
  "schema": { schema }
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "name": "projects/my_project_id/locations/us-central1/entryGroups/my_entryGroup_id/entries/my_entry_id",
  "type": "FILESET",
  "displayName": "My Fileset",
  "description": "My Fileset description.",
  "schema": {
    "columns": [
      {
        "type": "STRING",
        "description": "First name",
        "mode": "REQUIRED",
        "column": "first_name"
      },
      {
        "type": "STRING",
        "description": "Last name",
        "mode": "REQUIRED",
        "column": "last_name"
      },
      {
        "type": "RECORD",
        "description": "Address",
        "mode": "REPEATED",
        "column": "address",
        "subcolumns": [
          {
            "type": "STRING",
            "description": "City",
            "mode": "NULLABLE",
            "column": "city"
          },
          {
            "type": "STRING",
            "description": "State",
            "mode": "NULLABLE",
            "column": "state"
          }
        ]
      }
    ]
  },
  "gcsFilesetSpec": {
    "filePatterns": [
      "gs://my_bucket_name/chicago_taxi_trips/csv/shard-*.csv"
    ]
  },
  "sourceSystemTimestamps": {
    "createTime": "2019-10-23T23:11:26.326Z",
    "updateTime": "2019-10-23T23:11:26.326Z"
  },
"linkedResource": "//datacatalog.googleapis.com/projects/my_project_id/locations/us-central1/entryGroups/my_entryGroup_id/entries/my_entry_id"
}

Papéis, permissões e políticas do IAM

O Data Catalog define os papéis entry e entryGroup para facilitar o gerenciamento de conjuntos de arquivos e outros recursos do Data Catalog.

Papéis de entrada Descrição
dataCatalog.entryOwner Proprietário de uma determinada entrada ou grupo de entradas.
  • Permissões:
    • datacatalog.entries.(*)
    • datacatalog.entryGroups.get
  • Aplicabilidade:
    • Organização, projeto e entryGroup.
dataCatalog.entryViewer Pode visualizar detalhes de entry e entryGroup.
  • Permissões
    • datacatalog.entries.get
    • datacatalog.entryGroups.get
  • Aplicabilidade:
    • Organização, projeto e entryGroup.
Papéis de entryGroup Descrição
dataCatalog.entryGroupOwner Proprietário de um entryGroup específico.
  • Permissões:
    • datacatalog.entryGroups.(*)
    • datacatalog entries.(*)
  • Aplicabilidade:
    • Organização, projeto e nível de entryGroups.
dataCatalog.entryGroupCreator Pode criar entryGroups dentro de um projeto. O criador de um entryGroup recebe automaticamente o papel dataCatalog.entryGroupOwner.
  • Permissões
    • datacatalog.entryGroups.(get | create)
  • Aplicabilidade:
    • Nível da organização e do projeto.

Como definir políticas do IAM

Os usuários com permissão datacatalog.<resource>.setIamPolicy podem definir políticas do IAM em grupos de entrada do Data Catalog e outros recursos do Data Catalog (consulte Papéis do Data Catalog).

gcloud

Console

Navegue até a página Detalhes do grupo de entrada na IU do Data Catalog e use o painel do IAM localizado no lado direito para conceder ou revogar permissões.

Como conceder papéis do grupo de entrada

Exemplo 1:

Uma empresa com diferentes contextos de negócios para seus conjuntos de arquivos cria grupos de entrada order-files e user-files separados:

A empresa concede aos usuários o papel Leitor do EntryGroup para order-files, o que significa que eles só podem pesquisar entradas contidas nesse grupo de entrada. Os resultados da pesquisa não retornam entradas no grupo de entradas user-files.

Exemplo 2:

Uma empresa concede o papel Leitor do EntryGroup a um usuário apenas no projeto project_entry_group. O usuário só poderá ver as entradas nesse projeto.

Como pesquisar conjuntos de arquivos

Os usuários podem restringir o escopo da pesquisa no Data Catalog usando o atributo type. type=entry_group restringe a consulta de pesquisa a grupos de entrada, enquanto type=fileset pesquisa apenas conjuntos de arquivos. Os atributos type podem ser usados em conjunto com outros atributos, como projectid.

gcloud

  • Pesquisar grupos de entrada em um projeto:

    gcloud data-catalog search \  
        --include-project-ids=my-project
        "projectid=my-project type=entry_group"
    

  • Pesquisar todos os grupos de entrada que você pode acessar:

    gcloud data-catalog search \  
        --include-project-ids=my-project
        "type=entry_group"
    

  • Pesquisar conjuntos de arquivos em um projeto:

    gcloud data-catalog search \  
        --include-project-ids=my-project
        "type=entry.fileset"
    

  • Pesquisar conjuntos de arquivos em um projeto - sintaxe simplificada:

    gcloud data-catalog search \  
        --include-project-ids=my-project
        "type=fileset"