Visualizza i file da Cloud Storage con voci di set di file

Puoi utilizzare le API Data Catalog per creare e cercare voci di set di file Cloud Storage (chiamate "set di file" nel resto di questo documento).

Set di file

Un set di file Cloud Storage è una voce all'interno di un gruppo di voci creato dall'utente. Per ulteriori informazioni, consulta Voci e gruppi di voci.

È definito da uno o più pattern di file che specificano un set di uno o più file Cloud Storage.

Requisiti relativi ai pattern dei file:

• Un pattern di file deve iniziare con gs://bucket_name/.
• Il nome del bucket deve rispettare i requisiti per i nomi dei bucket Cloud Storage.
• I caratteri jolly sono consentiti nella cartella e in parti di file dei pattern di file, ma i caratteri jolly non sono consentiti nei nomi dei bucket. Per alcuni esempi, consulta:
  • Nomi con caratteri jolly
  • Documentazione di riferimento dell'API GcsFilesetSpec.filePatterns
• Un set di file deve avere un pattern del set di file (non più di 500).

Puoi eseguire query sui set di file Data Catalog con Dataflow SQL, ma solo se hanno uno schema definito e contengono solo file CSV senza righe di intestazione.

Crea gruppi di voci e set di file

I set di file devono essere posizionati all'interno di un gruppo di voci creato dall'utente. Se non hai creato un gruppo di voci, crea prima il gruppo di voci, quindi crea il fileset all'interno del gruppo di voci. Puoi impostare i criteri IAM nel gruppo di voci per definire chi può accedere ai set di file e ad altre voci all'interno del gruppo.

Gestione dei set di file. Puoi elencare, modificare ed eliminare i set di file utilizzando lo strumento a riga di comando gcloud o l'API Data Catalog.

Console

Console

1. Vai alla pagina Dataplex > Gruppi di voci.

   Vai ai gruppi di voci Dataplex

2. Fai clic su Crea gruppo di voci.

3. Compila il modulo Crea gruppo di voci, quindi fai clic su CREA.

4. Viene visualizzata la pagina Dettagli gruppo di voci. Con la scheda ENTRIES selezionata, fai clic su CREA.

5. Compila il modulo Crea set di file.

   

   1. Per collegare uno schema, fai clic su Definisci schema per aprire il modulo Schema. Fai clic su + AGGIUNGI CAMPI per aggiungere campi singolarmente o attiva Modifica come testo nell'angolo in alto a destra del modulo per specificare i campi in formato JSON.

      

      

   2. Fai clic su Salva per salvare lo schema.

6. Fai clic su Crea per creare il set di file.

gcloud

gcloud

1. Crea un gruppo di voci

Utilizza il comando gcloud data-catalog entry-groups create per creare un gruppo di voci con uno schema e una descrizione allegati.

Esempio:

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

2. Crea un set di file all'interno del gruppo di voci

Usa il comando gcloud data-catalog entities create per creare un set di file all'interno di un gruppo di voci. L'esempio di comando gcloud riportato di seguito crea una voce del set di file che include lo schema dei dati del set di file.

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

Segnala note:

• --gcs-file-patterns: consulta i requisiti relativi ai pattern dei file.
• --schema-from-file: l'esempio seguente mostra il formato JSON del file di testo dello schema accettato dal flag --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"
    }
  ]
  

Java

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nella guida rapida di Data Catalog sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Data Catalog.

Per eseguire l'autenticazione in Data Catalog, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.datacatalog.v1.ColumnSchema;
import com.google.cloud.datacatalog.v1.CreateEntryRequest;
import com.google.cloud.datacatalog.v1.DataCatalogClient;
import com.google.cloud.datacatalog.v1.Entry;
import com.google.cloud.datacatalog.v1.EntryGroupName;
import com.google.cloud.datacatalog.v1.EntryType;
import com.google.cloud.datacatalog.v1.GcsFilesetSpec;
import com.google.cloud.datacatalog.v1.Schema;
import java.io.IOException;

// Sample to create file set entry
public class CreateFilesetEntry {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String entryGroupId = "fileset_entry_group";
    String entryId = "fileset_entry_id";
    createFilesetEntry(projectId, entryGroupId, entryId);
  }

  // Create Fileset Entry.
  public static void createFilesetEntry(String projectId, String entryGroupId, String entryId)
      throws IOException {
    // 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()) {
      // Construct the Entry for the Entry request.
      Entry entry =
          Entry.newBuilder()
              .setDisplayName("My Fileset")
              .setDescription("This fileset consists of ....")
              .setGcsFilesetSpec(
                  GcsFilesetSpec.newBuilder().addFilePatterns("gs://cloud-samples-data/*").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(EntryGroupName.of(projectId, location, entryGroupId).toString())
              .setEntryId(entryId)
              .setEntry(entry)
              .build();

      // Use the client to send the API request.
      Entry entryCreated = dataCatalogClient.createEntry(entryRequest);
      System.out.printf("Entry created with name: %s", entryCreated.getName());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nella guida rapida di Data Catalog sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Data Catalog.

Per eseguire l'autenticazione in Data Catalog, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

// Import the Google Cloud client library.
const {DataCatalogClient} = require('@google-cloud/datacatalog').v1;
const datacatalog = new DataCatalogClient();

async function createFileset() {
  // Create a fileset within an entry group.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const projectId = 'my_project';
  // const entryGroupId = 'my_entry_group';
  // const entryId = 'my_entry';

  // Currently, Data Catalog stores metadata in the us-central1 region.
  const location = 'us-central1';

  // Delete any pre-existing Entry with the same name that will be used
  // when creating the new Entry.
  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 to create the new Entry Group.
  try {
    const formattedName = datacatalog.entryGroupPath(
      projectId,
      location,
      entryGroupId
    );
    await datacatalog.deleteEntryGroup({name: formattedName});
  } catch (err) {
    console.log('Entry Group does not exist.');
  }

  // Construct the Entry Group for the Entry Group request.
  const entryGroup = {
    displayName: 'My Fileset Entry Group',
    description: 'This Entry Group consists of ....',
  };

  // Construct the Entry Group 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);

  // 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(`Name: ${response.name}`);
  console.log(`Display name: ${response.displayName}`);
  console.log(`Type: ${response.type}`);
}
createFileset();

Python

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nella guida rapida di Data Catalog sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python di Data Catalog.

Per eseguire l'autenticazione in Data Catalog, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

# Import required modules.
from google.cloud import datacatalog_v1

# TODO: Set these values before running the sample.
project_id = "project_id"
fileset_entry_group_id = "entry_group_id"
fileset_entry_id = "entry_id"

# For all regions available, see:
# https://cloud.google.com/data-catalog/docs/concepts/regions
location = "us-central1"

datacatalog = datacatalog_v1.DataCatalogClient()

# 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.common_location_path(
        project_id, location
    ),
    entry_group_id=fileset_entry_group_id,
    entry_group=entry_group_obj,
)
print(f"Created entry group: {entry_group.name}")

# 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/*.csv")
entry.type_ = datacatalog_v1.EntryType.FILESET

# Create the Schema, for example when you have a csv file.
entry.schema.columns.append(
    datacatalog_v1.types.ColumnSchema(
        column="first_name",
        description="First name",
        mode="REQUIRED",
        type_="STRING",
    )
)

entry.schema.columns.append(
    datacatalog_v1.types.ColumnSchema(
        column="last_name", description="Last name", mode="REQUIRED", type_="STRING"
    )
)

# Create the addresses parent column
addresses_column = datacatalog_v1.types.ColumnSchema(
    column="addresses", description="Addresses", mode="REPEATED", type_="RECORD"
)

# Create sub columns for the addresses parent column
addresses_column.subcolumns.append(
    datacatalog_v1.types.ColumnSchema(
        column="city", description="City", mode="NULLABLE", type_="STRING"
    )
)

addresses_column.subcolumns.append(
    datacatalog_v1.types.ColumnSchema(
        column="state", description="State", mode="NULLABLE", type_="STRING"
    )
)

entry.schema.columns.append(addresses_column)

entry = datacatalog.create_entry(
    parent=entry_group.name, entry_id=fileset_entry_id, entry=entry
)
print(f"Created fileset entry: {entry.name}")

LINEA REST e CMD

REST

Se non hai accesso alle librerie client di Cloud per il tuo linguaggio o vuoi testare l'API utilizzando richieste REST, consulta gli esempi seguenti e fai riferimento alla documentazione dell'API REST Data Catalog entryGroups.create e entryGroups.entries.create.

1. Crea un gruppo di voci

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• project-id: l'ID del tuo progetto Google Cloud
• entryGroupId: l'ID deve iniziare con una lettera o un trattino basso, contenere solo lettere dell'alfabeto latino, numeri e trattini bassi e contenere al massimo 64 caratteri.
• displayName: il nome testuale del gruppo di voci.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: project-id" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://datacatalog.googleapis.com/v1/projects/project-id/locations/region/entryGroups?entryGroupId=entryGroupId"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://datacatalog.googleapis.com/v1/projects/project-id/locations/region/entryGroups?entryGroupId=entryGroupId" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "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 set di file all'interno del gruppo di voci

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

• project_id: l'ID del tuo progetto Google Cloud
• entryGroupId: ID di entryGroup esistente. Il set di file verrà creato in questo sntryGroup.
• entryId: EntryId del nuovo set di file. L'ID deve iniziare con una lettera o un trattino basso, contenere solo lettere dell'alfabeto latino, numeri e trattini bassi e avere una lunghezza massima di 64 caratteri.
• description: descrizione del set di file.
• displayName: il nome testuale per la voce del set di file.
• filePatterns: deve iniziare con "gs://bucket_name/". Vedi Requisiti relativi ai pattern dei file.
• schema: schema del set di file.
  Esempio di schema 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"
        }
      ]
    }
  ...
  }
  

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, espandi una delle seguenti opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti fa accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: project_id" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://datacatalog.googleapis.com/v1/projects/project_id/locations/region/entryGroups/entryGroupId/entries?entryId=entryId"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando di gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project_id" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://datacatalog.googleapis.com/v1/projects/project_id/locations/region/entryGroups/entryGroupId/entries?entryId=entryId" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

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

Ruoli, autorizzazioni e criteri IAM

Data Catalog definisce i ruoli di entry e entryGroup per facilitare la gestione delle autorizzazioni di set di file e altre risorse di Data Catalog.

Ruoli voce	Descrizione
dataCatalog.entryOwner	Proprietario di una determinata voce o gruppo di voci. Autorizzazioni: datacatalog.entries.(*) datacatalog.entryGroups.get Applicabilità: Organizzazione, progetto e entryGroup.
dataCatalog.entryViewer	Può visualizzare i dettagli di entry e entryGroup. Autorizzazioni datacatalog.entries.get datacatalog.entryGroups.get Applicabilità: Organizzazione, progetto e entryGroup.

Ruoli entryGroup	Descrizione
dataCatalog.entryGroupOwner	Proprietario di un particolare entryGroup. Autorizzazioni: datacatalog.entryGroups.(*) voci datacatalog.(*) Applicabilità: A livello di organizzazione, progetto e entryGroups.
dataCatalog.entryGroupCreator	Può creare entryGroup all'interno di un progetto. All'autore di un entryGroup viene automaticamente assegnato il ruolo dataCatalog.entryGroupOwner. Autorizzazioni datacatalog.entryGroups.(get | create) Applicabilità: A livello di organizzazione e di progetto.

Impostazione dei criteri IAM

Gli utenti con l'autorizzazione datacatalog.<resource>.setIamPolicy possono impostare criteri IAM su gruppi di voci Data Catalog e altre risorse Data Catalog (vedi Ruoli Data Catalog).

gcloud

• Imposta il criterio IAM di un gruppo di voci con gcloud data-catalog entry-groups set-iam-policy:

  gcloud data-catalog entry-groups set-iam-policy my_entrygroup \  
      --location=us-central1 \  
      policy file
  

• Ottieni il criterio IAM di un gruppo di voci con gcloud data-catalog entry-groups get-iam-policy

  gcloud data-catalog entry-groups get-iam-policy my_entrygroup \  
      --location=us-central1
  

Console

Accedi alla pagina Dettagli gruppo di voci nell'UI di Data Catalog, quindi utilizza il riquadro IAM sul lato destro per concedere o revocare le autorizzazioni.

Concessione dei ruoli del gruppo di voci

Esempio 1:

Un'azienda con contesti aziendali diversi per i suoi set di file crea gruppi di voci order-files e user-files separati:

Figura 1. Esempio di come archiviare i dati degli ordini e dei dati utente in diversi gruppi di voci.

L'azienda concede agli utenti il ruolo Visualizzatore EntryGroup per order-files, il che significa che possono cercare solo le voci contenute in quel gruppo di voci. I risultati di ricerca non restituiscono voci nel gruppo di voci user-files.

Esempio 2:

Un'azienda concede il ruolo Visualizzatore EntryGroup a un utente solo nel progetto project_entry_group. L'utente potrà solo visualizzare le voci all'interno di quel progetto.

Ricerca di set di file

Gli utenti possono limitare l'ambito della ricerca in Data Catalog utilizzando il facet type. type=entry_group limita la query di ricerca ai gruppi di voci, mentre type=fileset cerca solo i set di file. I facet type possono essere utilizzati in combinazione con altri facet, ad esempio projectid.

gcloud

• Cerca gruppi di voci in un progetto:

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

• Cerca tutti i gruppi di voci a cui puoi accedere:

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

• Cerca set di file in un progetto:

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

• Cerca set di file in un progetto con sintassi semplificata:

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

La UI di Data Catalog nella console Google Cloud offre anche un modo pratico per cercare gruppi di voci e set di file Cloud Storage.