Utiliser des ensembles de fichiers Cloud Storage

Vous pouvez créer et gérer des entrées d'ensembles de fichiers Cloud Storage (appelés "ensembles de fichiers" dans la suite de ce document) à l'aide des API Data Catalog.

Comment les ensembles de fichiers s'intègrent dans Data Catalog

Avant d'étudier les ensembles de fichiers, examinons les concepts clés de Data Catalog et comment ils s'intègrent dans Data Catalog.

Entrée
Un catalogue de données entry représente une ressource Google Cloud, telle qu'un ensemble de données ou une table BigQuery, un sujet Pub/Sub ou un ensemble de fichiers Cloud Storage. Vous pouvez créer, rechercher et gérer des entrées Data Catalog pour explorer et gérer les ressources de données Google Cloud. Une entrée d'ensemble de fichiers peut inclure un schéma facultatif de données d'ensemble de fichiers.
Groupe d'entrées

Les entrées sont contenues dans un groupe d'entrées (entry group). Un groupe d'entrées contient des entrées logiques associées à des stratégies Identity and Access Management qui spécifient les utilisateurs pouvant créer, modifier et afficher les entrées d'un groupe d'entrées.

Data Catalog crée automatiquement un groupe d'entrées pour les entrées BigQuery ("@bigquery") et les sujets Pub/Sub ("@pubsub"). Vous créez votre propre groupe d'entrées contenant vos entrées d'ensemble de fichiers Cloud Storage et les stratégies IAM associées à ces entrées. Les groupes d'entrées, comme les entrées, peuvent être recherchés.

L'illustration suivante montre comment les groupes d'entrées prédéfinis et créés par l'utilisateur s'intègrent dans le modèle de données Data Catalog.

Ensemble de fichiers Cloud Storage

Un ensemble de fichiers Cloud Storage est une entrée d'un groupe d'entrées créé par l'utilisateur. Il est défini par un ou plusieurs modèles de fichier qui spécifient un ensemble d'un ou plusieurs fichiers Cloud Storage.

Exigences concernant les modèles de fichier :

Créer des groupes d'entrées et des ensembles de fichiers

Les ensembles de fichiers doivent être placés dans un groupe d'entrées créé par l'utilisateur. Si vous n'avez pas créé de groupe d'entrées, commencez par en créer un, puis créez l'ensemble de fichiers au sein de ce groupe d'entrées. Vous pouvez définir des stratégies IAM sur le groupe d'entrées pour déterminer qui a accès aux ensembles de fichiers et aux autres entrées du groupe d'entrées.

gcloud

1. Créer un groupe d'entrées

Utilisez la commande gcloud data-catalog entry-groups create pour créer un groupe d'entrée auquel sont associés un schéma et une description.

Exemple :

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

2. Créer un ensemble de fichiers dans le groupe d'entrées

Utilisez la commande gcloud data-catalog entries create pour créer un ensemble de fichiers dans un groupe d'entrées. L'exemple de commande gcloud ci-dessous crée une entrée d'ensemble de fichiers qui inclut un schéma de données d'ensemble de fichiers.

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

Notes sur les options :

  • --gcs-file-patterns : consultez la section Exigences concernant les modèles de fichier.
  • --schema-from-file : l'exemple suivant montre le format JSON du fichier texte de schéma accepté par l'option --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. Sélectionnez Create entry group (Créer un groupe d'entrées) dans la liste déroulante CREATE (Créer) ou dans la section Entry Groups (Groupes d'entrées) de l'Interface utilisateur de Data Catalog dans Google Cloud Console.

  2. Remplissez le formulaire Create Entry Group (Créer un groupe d'entrées), puis cliquez sur CREATE (Créer).

  3. La page Détails du groupe d'entrées s'affiche. Après avoir sélectionné l'onglet ENTRIES (Entrées), cliquez sur CREATE (Créer).

  4. Remplissez le formulaire Create Fileset (Créer un ensemble de fichiers).

    1. Pour associer un schéma, cliquez sur Define Schema (Définir un schéma) pour ouvrir le formulaire correspondant. Cliquez sur + ADD FIELDS (AJOUTER DES CHAMPS) pour ajouter des champs individuellement ou activez l'option Edit as text (Modifier sous forme de texte) en haut à droite du formulaire pour les spécifier au format JSON.
    2. Cliquez sur Save (Enregistrer) pour enregistrer le schéma.
  5. Cliquez sur Create (Créer) pour créer l'ensemble de fichiers.

Python

  1. Installer la bibliothèque cliente
  2. Configurer les identifiants par défaut de l'application
  3. Exécuter le code
    """
    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. Installer la bibliothèque cliente
  2. Configurer les identifiants par défaut de l'application
  3. Exécuter le code
    /*
    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. Installer la bibliothèque cliente
  2. Configurer les identifiants par défaut de l'application
  3. Exécuter le code
    /**
     * 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));
    

API REST et ligne de commande

Si vous n'avez pas accès aux bibliothèques clientes Cloud pour votre langage ou si vous souhaitez tester l'API à l'aide de requêtes REST, consultez les exemples suivants et reportez-vous aux API REST Data Catalog entryGroups.create et entryGroups.entries.create.

1. Créer un groupe d'entrées

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • project-id : votre ID de projet GCP.
  • entryGroupId : l'ID doit commencer par une lettre ou un trait de soulignement, ne doit contenir que des lettres en alphabet latin, des chiffres et des traits de soulignement, et ne doit pas contenir plus de 64 caractères.
  • displayName : nom textuel du groupe d'entrées.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "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. Créer un ensemble de fichiers dans le groupe d'entrées

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • project_id : votre ID de projet GCP.
  • entryGroupId : ID du groupe d'entrées existant. L'ensemble de fichiers sera créé dans ce groupe d'entrées.
  • entryId : ID d'entrée du nouvel ensemble de fichiers. L'ID doit commencer par une lettre ou un trait de soulignement, ne doit contenir que des lettres en alphabet latin, des chiffres et des traits de soulignement, et ne doit pas contenir plus de 64 caractères.
  • description : description de l'ensemble de fichiers.
  • displayName : nom textuel de l'entrée d'ensemble de fichiers.
  • filePatterns : doit commencer par "gs://bucket_name/". Consultez la section Exigences concernant les modèles de fichier.
  • schema : schéma de l'ensemble de fichiers.

    Exemple de schéma 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éthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

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

Rôles, autorisations et stratégies IAM

Data Catalog définit les rôles d'entrée et de groupe d'entrée pour faciliter la gestion des autorisations des ensembles de fichiers et des autres ressources Data Catalog.

Rôles d'entrée Description
dataCatalog.entryOwner Propriétaire d'une entrée ou d'un groupe d'entrées spécifique.
  • Autorisations :
    • datacatalog.entries.(*)
    • datacatalog.entryGroups.get
  • Applicabilité :
    • Organisation, projet et groupe d'entrées.
dataCatalog.entryViewer Peut consulter les détails de l'entrée et du groupe d'entrées.
  • Autorisations
    • datacatalog.entries.get
    • datacatalog.entryGroups.get
  • Applicabilité :
    • Organisation, projet et groupe d'entrées.
Rôles de groupe d'entrées Description
dataCatalog.entryGroupOwner Propriétaire d'un groupe d'entrées particulier.
  • Autorisations :
    • datacatalog.entryGroups.(*)
    • datacatalog entries.(*)
  • Applicabilité :
    • Au niveau de l'organisation, du projet et du groupe d'entrées.
dataCatalog.entryGroupCreator Peut créer des groupes d'entrées dans un projet. Le créateur d'un groupe d'entrées reçoit automatiquement le rôle dataCatalog.entryGroupOwner.
  • Autorisations
    • datacatalog.entryGroups.(get | create)
  • Applicabilité :
    • Au niveau de l'organisation et du projet.

Définir des stratégies IAM

Les utilisateurs disposant de l'autorisation datacatalog.<resource>.setIamPolicy peuvent définir des stratégies IAM sur des groupes d'entrées Data Catalog et d'autres ressources Data Catalog (consultez la section Rôles Data Catalog).

gcloud

Console

Accédez à la page Détails du groupe d'entrées dans l'UI de Data Catalog, puis utilisez le panneau IAM situé à droite pour accorder ou révoquer des autorisations.

Attribuer des rôles de groupe d'entrées

Exemple 1 :

Une entreprise dont les ensembles de fichiers ont des contextes commerciaux différents crée des groupes d'entrées order-files et user-files distincts :

L'entreprise attribue aux utilisateurs le rôle Lecteur de groupes d'entrées pour order-files, ce qui signifie qu'ils ne peuvent rechercher que les entrées contenues dans ce groupe d'entrées. Leurs résultats de recherche ne renvoient pas d'entrées dans le groupe d'entrées user-files.

Exemple 2 :

Une entreprise attribue le rôle Lecteur de groupes d'entrées à un utilisateur dans le projet project_entry_group seulement. L'utilisateur ne pourra afficher que les entrées de ce projet.

Effectuer des recherches dans des ensembles de fichiers

Les utilisateurs peuvent restreindre la portée de la recherche dans Data Catalog à l'aide de l'attribut type. type=entry_group limite la requête de recherche aux groupes d'entrées tandis que type=fileset ne recherche que les ensembles de fichiers. Les attributs type peuvent être utilisés conjointement avec d'autres attributs, tels que projectid.

gcloud

  • Rechercher des groupes d'entrées dans un projet :

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

  • Rechercher tous les groupes d'entrées auxquels vous pouvez accéder :

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

  • Rechercher des ensembles de fichiers dans un projet :

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

  • Rechercher des ensembles de fichiers dans un projet (syntaxe simplifiée) :

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