Cloud Storage-Dateisätze verwenden

Sie können Data Catalog APIs verwenden, um Cloud Storage-Dateisatzeinträge zu erstellen und zu verwalten (im Folgenden als "Dateisätze" bezeichnet).

So passen Dateisätze in den Datenkatalog ein

Bevor wir uns mit Dateisätzen befassen, sehen wir uns die wichtigsten Data Catalog-Konzepte und die Dateisätze in Data Catalog an.

Eintrag
Ein Datenkatalog-entry stellt eine Google Cloud-Ressource dar, z. B. ein BigQuery-Dataset oder eine BigQuery-Tabelle, ein Pub/Sub-Thema oder ein Cloud Storage-Dateiset. Sie erstellen, suchen in und verwalten Data Catalog-Einträge, um Google Cloud-Datenressourcen zu entdecken und zu verwalten. Ein Dateisatzeintrag kann ein optionales Schema von Dateisatzdaten enthalten.
Eintragsgruppe

Einträge sind in einem entry group enthalten. Eine Eintragsgruppe enthält logisch zusammengehörige Einträge sowie Identity and Access Management-Richtlinien, die festlegen, welche Nutzer innerhalb einer Eintragsgruppe Einträge erstellen, bearbeiten und ansehen dürfen.

Data Catalog erstellt automatisch eine Eintragsgruppe für BigQuery-Einträge ("@bigquery") und Pub/Sub-Themen ("@pubsub"). Sie erstellen eine eigene Eintragsgruppe, die Ihre Cloud Storage-Dateisatzeinträge und die mit diesen Einträgen verknüpften IAM-Richtlinien enthält. Eintragsgruppen wie Einträge können durchsucht werden.

Die folgende Abbildung zeigt, wie vordefinierte und von Nutzern erstellte Eintragsgruppen in das Data Catalog-Datenmodell passen.

Cloud Storage-Dateisatz

Ein Cloud Storage-Dateisatz ist ein Eintrag in einer vom Nutzer erstellten Eintragsgruppe. Er wird durch ein oder mehrere Dateimuster definiert, die einen Satz von einer oder mehreren Cloud Storage-Dateien angeben.

Anforderungen an Dateimuster:

Eintragsgruppen und Dateisätze erstellen

Dateisätze müssen in einer von Nutzern erstellten Eintragsgruppe platziert werden. Wenn Sie keine Eintragsgruppe erstellt haben, erstellen Sie zuerst die Eintragsgruppe und erstellen Sie dann den Dateisatz innerhalb der Eintragsgruppe. Sie können IAM-Richtlinien für die Eintragsgruppe festlegen, um festzulegen, wer Zugriff auf Dateisätze und andere Einträge innerhalb der Eintragsgruppe hat.

gcloud-Befehl

1 Eintragsgruppe erstellen

Verwenden Sie den Befehl gcloud data-catalog entry-groups create, um eine Eintragsgruppe mit einem angehängten Schema und einer Beschreibung zu erstellen.

Beispiel:

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

2. Dateisatz innerhalb der Eintragsgruppe erstellen

Erstellen Sie mit dem Befehl gcloud data-catalog entries create einen Dateisatz innerhalb einer Eintragsgruppe. Mit diesem gcloud-Befehl unten wird ein Dateisatzeintrag erstellt, der das Schema der Dateisatzdaten enthält.

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

Notizen melden:

  • --gcs-file-patterns: Siehe Anforderungen an Dateimuster.
  • --schema-from-file: Das folgende Beispiel zeigt das JSON-Format der Schematextdatei, die vom Flag --schema-from-file akzeptiert wird.
    [
      {
        "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. Klicken Sie in der Drop-down-Liste Erstellen oder im Abschnitt Eintragsgruppen der Data Catalog-UI in der Google Cloud Console auf Eintragsgruppe erstellen.

  2. Füllen Sie das Formular Eintragsgruppe erstellen aus und klicken Sie dann auf Erstellen.

  3. Die Seite Eintragsgruppendetails wird geöffnet. Wählen Sie den Tab FILESETS aus und klicken Sie auf Erstellen.

  4. Füllen Sie das Formular Dateisatz erstellen aus.

    1. Klicken Sie zum Anhängen eines Schemas auf Schema definieren, um das Schemaformular zu öffnen. Klicken Sie auf + FELDER HINZUFÜGEN, um Felder einzeln hinzuzufügen, oder klicken Sie rechts oben im Formular auf Als Text bearbeiten, um die Felder im JSON-Format anzugeben.
    2. Klicken Sie auf Speichern, um das Schema zu speichern.
  5. Klicken Sie auf Erstellen, um das Dateiset zu erstellen.

Python

  1. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Code ausführen .
    """
    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. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Führen Sie den Code aus
    /*
    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. Clientbibliothek installieren
  2. Standardanmeldedaten für Anwendungen einrichten
  3. Führen Sie den Code aus.
    /**
     * 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 UND BEFEHLSZEILE

Wenn Sie keinen Zugriff auf Cloud Client-Bibliotheken für Ihre Sprache haben oder die API mit REST-Anfragen testen möchten, sehen Sie sich die folgenden Beispiele an und lesen Sie die Dokumentation zu den Data Catalog REST APIs entryGroups.create und entryGroups.entries.create.

1 Eintragsgruppe erstellen

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • project-id: mit der ID Ihres GCP-Projekts
  • entryGroupId: Die ID muss mit einem Buchstaben oder Unterstrich beginnen, darf nur lateinische Buchstaben, Zahlen und Unterstriche enthalten und darf höchstens 64 Zeichen umfassen.
  • displayName: Der Textname für die Eintragsgruppe.

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

{
  "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. Dateisatz innerhalb der Eintragsgruppe erstellen

Ersetzen Sie diese Werte in den folgenden Anweisungen:

  • project_id: Ihre GCP-Projekt-ID.
  • entryGroupId: ID der vorhandenen entryGroup. Dateisatz wird in dieser sntryGroup erstellt.
  • entryId: EntryId des neuen Dateisatzes. Die ID muss mit einem Buchstaben oder Unterstrich beginnen, darf nur lateinische Buchstaben, Zahlen und Unterstriche enthalten und darf höchstens 64 Zeichen umfassen.
  • description: Dateisatzbeschreibung.
  • displayName: Der Textname für den Dateisatzeintrag.
  • filePatterns: Muss mit "gs://bucket_name/" beginnen. Siehe Anforderungen an Dateimuster.
  • schema: Dateisatzschema.

    Beispiel für ein JSON-Schema:
    { ...
      "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"
          }
        ]
      }
    ...
    }
    

HTTP-Methode und URL:

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

JSON-Text anfordern:

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

Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

Sie sollten in etwa folgende JSON-Antwort erhalten:

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

IAM-Rollen, Berechtigungen und Richtlinien

Data Catalog definiert "entry"- und "entryGroup"-Rollen, um die Berechtigungsverwaltung für Dateisätze und andere Data Catalog-Ressourcen zu erleichtern.

Beitragsrollen Beschreibung
dataCatalog.entryOwner Inhaber eines bestimmten Eintrags oder einer Gruppe von Einträgen.
  • Berechtigungen:
    • datacatalog.entries.(*)
    • datacatalog.entryGroups.get
  • Gültigkeit:
    • Organisation, Projekt und entryGroup.
dataCatalog.entryViewer Kann Details zu Eintrag und entryGroup anzeigen.
  • Berechtigungen
    • datacatalog.entries.get
    • datacatalog.entryGroups.get
  • Gültigkeit:
    • Organisation, Projekt und entryGroup.
entryGroup-Rollen Beschreibung
dataCatalog.entryGroupOwner Inhaber einer bestimmten entryGroup.
  • Berechtigungen:
    • datacatalog.entryGroups.(*)
    • datacatalog.entries.(*)
  • Gültigkeit:
    • Organisations-, Projekt- und entryGroups-Ebene
dataCatalog.entryGroupCreator Kann entryGroups in einem Projekt erstellen. Dem Ersteller einer entryGroup wird automatisch die Rolle dataCatalog.entryGroupOwner zugewiesen.
  • Berechtigungen
    • datacatalog.entryGroups.(get | create)
  • Gültigkeit:
    • Organisations- und Projektebene.

IAM-Richtlinien festlegen

Nutzer mit der Berechtigung datacatalog.<resource>.setIamPolicy können IAM-Richtlinien für Data Catalog-Eintragsgruppen und andere Data Catalog-Ressourcen festlegen (siehe Data Catalog-Rollen).

gcloud-Befehl

Console

Rufen Sie in der Data Catalog-UI die Seite Details der Eintragsgruppe auf und verwenden Sie dann das IAM-Steuerfeld auf der rechten Seite, um Berechtigungen zu erteilen oder zu entziehen.

Rollen den Eintragsgruppen zuweisen

Beispiel 1:

Ein Unternehmen mit unterschiedlichen Geschäftskontexten für seine Dateisätze erstellt separate Eintragsgruppen order-files und user-files:

Das Unternehmen gewährt Nutzern die Rolle "Betrachter von Eintragsgruppen" für order-files, das heißt, sie können nur nach Einträgen suchen, die in dieser Eintragsgruppe enthalten sind. Ihre Suchergebnisse geben keine Einträge in der Eintragsgruppe user-files zurück.

Beispiel 2:

Ein Unternehmen gewährt nur einem Nutzer im Projekt project_entry_group die Rolle "Betrachter der Eintragsgruppe". Der Nutzer kann nur Einträge innerhalb dieses Projekts ansehen.

In Dateisätzen suchen

Nutzer können den Umfang der Suche in Data Catalog mithilfe des Attributs type einschränken. type=entry_group beschränkt die Suchanfrage auf Eintragsgruppen, während type=fileset nur nach Dateisätzen sucht. type-Attribute können in Verbindung mit anderen Attributen wie projectid verwendet werden.

gcloud-Befehl

  • Nach Eintragsgruppen in einem Projekt suchen:

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

  • Suchen Sie nach allen Beitragsgruppen, auf die Sie zugreifen können:

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

  • Nach Dateisätzen in einem Projekt suchen:

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

  • Suche nach Dateisätzen in einem Projekt – vereinfachte Syntax:

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