Esta página se ha traducido con Cloud Translation API.
Switch to English

Usa conjuntos de archivos de Cloud Storage

Puedes usar las API de Data Catalog para crear y administrar entradas de conjuntos de archivos de Cloud Storage (llamadas “conjuntos de archivos” en el resto de este documento).

Cómo encajan los conjuntos de archivos en Data Catalog

Antes de ver los conjuntos de archivos, analicemos los conceptos clave de Data Catalog y cómo se ajustan los conjuntos de datos dentro de Data Catalog.

Entrada
Un Data Catalog entry representa un recurso de Google Cloud, como un conjunto de datos o una tabla de BigQuery, un tema de Pub/Sub o un conjunto de archivos de Cloud Storage. Puedes crear, buscar y administrar entradas de Data Catalog para explorar y administrar recursos de datos de Google Cloud. Una entrada de conjunto de archivos puede incluir un esquema opcional de datos del conjunto de archivos.
Grupo de entrada

Las entradas se incluyen en un entry group. Un grupo de entradas contiene entradas relacionadas con la lógica junto con las políticas de administración de identidades y accesos que especifican los usuarios que pueden crear, editar y ver entradas en un grupo de entradas.

De forma automática, Data Catalog crea un grupo de entradas para entradas de BigQuery (“@bigquery”) y temas de Pub/Sub (“@pubsub”). Creas tu propio grupo de entrada para contener tus entradas de conjunto de archivos de Cloud Storage y las políticas de IAM asociadas con esas entradas. Se pueden buscar grupos de entrada, como entradas.

En la siguiente ilustración, se muestra cómo se ajustan los grupos de entradas predefinidos y creados por el usuario en el modelo de datos de Data Catalog.

Conjunto de archivos de Cloud Storage

Un conjunto de archivos de Cloud Storage es una entrada dentro de un grupo de entradas creado por el usuario. Se define mediante uno o más patrones de archivo que especifican un conjunto de uno o más archivos de Cloud Storage.

Requisitos del patrón de archivo:

Crea grupos de entrada y conjuntos de archivos

Los conjuntos de archivos deben colocarse dentro del grupo de entrada creado por el usuario. Si no creaste un grupo de entrada, primero crea uno y, luego, crea el conjunto de archivos dentro del grupo de entrada. Puedes establecer políticas de IAM en el grupo de entrada para definir quién tiene acceso a los conjuntos de archivos y otras entradas dentro del grupo de entrada.

.

gcloud

1. Crea un grupo de entrada

Usa el comando gcloud data-catalog entry-groups create para crear un grupo de entradas con un esquema y una descripción adjuntos.

Ejemplo:

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

2. Crea un conjunto de archivos dentro del grupo de entrada

Usa el comando gcloud data-catalog entries create para crear un conjunto de archivos dentro de un grupo de entradas. Este ejemplo de comando gcloud, a continuación, crea una entrada de conjunto de archivos que incluye el esquema de datos.

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 ..."

Notas de las marcas:

  • --gcs-file-patterns: Consulta los Requisitos del patrón de archivos.
  • --schema-from-file: En el siguiente ejemplo, se muestra el formato JSON del archivo de texto del esquema que acepta la marca --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. Selecciona Crear grupo de entrada (Create entry group) en la lista desplegable CREAR (CREATE) o en la sección Grupos de entrada de IU de Data Catalog en Google Cloud Console.

  2. Completa el formulario Crear grupo de entrada (Create Entry Group) y haz clic en CREAR (CREATE).

  3. Se abrirá la página Detalles del grupo de entrada (Entry group details). Con la pestaña ENTRADAS seleccionada, haz clic en CREAR.

  4. Completa el formulario Crear conjunto de archivos (Create Fileset).

    1. Para adjuntar un esquema, haz clic en Definir esquema (Define Schema) a fin de abrir el formulario correspondiente. Haz clic en + ADD FIELDS a fin de agregar campos de forma individual o selecciona Editar como texto (Edit as text) en la esquina superior derecha del formulario para especificar los campos en formato JSON.
    2. Haz clic en Guardar (Save) para guardar el esquema.
  5. Haz clic en Crear (Create) para crear el conjunto de archivos.

Python

  1. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el 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. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el 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. Instala la biblioteca cliente
  2. Configura credenciales predeterminadas de la aplicación
  3. Ejecuta el 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));
    

LÍNEA DE REST Y CMD

Si no tienes acceso a las bibliotecas cliente de Cloud para tu lenguaje o quieres probar la API con solicitudes REST, consulta los siguientes ejemplos y consulta las API de REST de Data Catalog entryGroups.create y entryGroups.entries.create.

1. Crea un grupo de entrada

Antes de usar cualquiera de los datos de solicitud siguientes, realiza los siguientes reemplazos:

  • project-id: Es el ID de tu proyecto de GCP.
  • entryGroupId: El ID debe comenzar con una letra o un guion bajo, contener solo letras del alfabeto inglés, números y guiones bajos, y tener 64 caracteres como máximo.
  • displayName: El nombre textual del grupo de entrada

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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. Crea un conjunto de archivos dentro del grupo de entrada

Antes de usar cualquiera de los datos de solicitud siguientes, realiza los siguientes reemplazos:

  • project_id: Es el ID de tu proyecto de GCP.
  • entryGroupId: ID del entryGroup existente. El conjunto de archivos se creará en este entryGroup.
  • entryId: EntryId del conjunto de archivos nuevo. El ID debe comenzar con una letra o un guion bajo, contener solo letras del alfabeto inglés, números y guiones bajos, y tener como máximo 64 caracteres.
  • description: Es la descripción del conjunto de archivos.
  • displayName: Es el nombre textual de la entrada del conjunto de archivos.
  • filePatterns: Debe comenzar con “gs://bucket_name/”. Consulta Requisitos del patrón de archivos.
  • schema: Es el esquema del conjunto de archivos.

    Esquema JSON de ejemplo:
    { ...
      "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 y URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "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"
}

Funciones, permisos y políticas de IAM

Data Catalog define las funciones de entrada y entryGroup para facilitar la administración de permisos de conjuntos de archivos y otros recursos de Data Catalog.

Funciones de entrada Descripción
dataCatalog.entryOwner Propietario de una entrada o un grupo de entradas en particular.
  • Permisos
    • datacatalog.entries.(*)
    • datacatalog.entryGroups.get
  • Aplicabilidad.
    • Organización, proyecto y entryGroup.
dataCatalog.entryViewer Puede ver los detalles de entrada y entryGroup.
  • Permisos
    • datacatalog.entries.get
    • datacatalog.entryGroups.get
  • Aplicabilidad.
    • Organización, proyecto y entryGroup.
Funciones de entryGroup Descripción
dataCatalog.entryGroupOwner Propietario de un entryGroup en particular.
  • Permisos
    • datacatalog.entryGroups.(*)
    • datacatalog entries.(*)
  • Aplicabilidad.
    • Nivel de organización, proyecto y entryGroups.
dataCatalog.entryGroupCreator Puede crear entryGroups dentro de un proyecto. El creador de un entryGroup recibe de forma automática la función dataCatalog.entryGroupOwner.
  • Permisos
    • datacatalog.entryGroups.(get | create)
  • Aplicabilidad.
    • Nivel de organización y proyecto

Configura políticas de IAM

Los usuarios con el permiso datacatalog.<resource>.setIamPolicy pueden establecer políticas de IAM en grupos de entradas de Data Catalog y otros recursos de Data Catalog (consulta funciones de Data Catalog).

gcloud

Console

Navega a la página Detalles del grupo de entrada en la IU de Data Catalog y usa el panel IAM ubicado en el lado derecho para otorgar o revocar permisos.

Otorga funciones de grupo de entrada

Ejemplo 1:

Una empresa con diferentes contextos empresariales para sus conjuntos de archivos crea grupos de entrada order-files y user-files independientes:

La empresa otorga a los usuarios la función de Visualizador de EntryGroup para order-files, lo que significa que solo pueden buscar entradas contenidas en ese grupo de entrada. Sus resultados de la búsqueda no muestran entradas en el grupo de entrada user-files.

Ejemplo 2:

Una empresa otorga la función de visualizador de EntryGroup a un usuario solo en el proyecto project_entry_group. El usuario solo podrá ver las entradas dentro de ese proyecto.

Busca conjuntos de archivos

Los usuarios pueden restringir el alcance de la búsqueda en Data Catalog mediante la faceta type. type=entry_group restringe la búsqueda a los grupos de entrada, mientras que type=fileset solo busca conjuntos de archivos. Las facetas type se pueden usar junto con otras facetas, como projectid.

gcloud

  • Busca grupos de entrada en un proyecto:

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

  • Busca todos los grupos de entrada a los que puedas acceder:

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

  • Busca conjuntos de archivos en un proyecto:

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

  • Busca conjuntos de archivos en un proyecto: sintaxis simplificada:

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