Depuis le 10 avril 2026, Dataplex Universal Catalog s'appelle désormais Knowledge Catalog. Les noms de l'API, de la bibliothèque cliente, de la CLI et d'IAM restent inchangés. Pour en savoir plus, consultez Présentation de Google Cloud Knowledge Catalog.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Importer des métadonnées à l'aide d'un pipeline personnalisé

Ce document explique comment importer des métadonnées d'un système tiers dans Knowledge Catalog (anciennement Dataplex Universal Catalog) à l'aide des méthodes de l'API d'importation de métadonnées et de votre propre pipeline. Les métadonnées Knowledge Catalog se composent d'entrées et de leurs aspects.

Si vous souhaitez plutôt utiliser un pipeline d'orchestration géré par Google Cloudpour extraire et importer des métadonnées, nous vous suggérons d'utiliser un pipeline de connectivité géré. Avec un pipeline de connectivité géré, vous apportez votre propre connecteur qui extrait les métadonnées et génère une sortie dans un format pouvant être utilisé comme entrée par les méthodes d'API d'importation de métadonnées (le fichier d'importation de métadonnées). Vous utiliserez ensuite Workflows pour orchestrer les tâches du pipeline.

Vous pouvez exécuter les types de jobs d'importation de métadonnées suivants :

Synchronisation complète des entrées avec importation incrémentielle de leurs aspects. Compatible avec les entrées personnalisées.
Importation incrémentielle des aspects uniquement. Compatible avec les aspects appartenant à des entrées personnalisées et des entrées système. Pour les entrées personnalisées, vous pouvez modifier les aspects facultatifs et obligatoires. Pour les entrées système, vous pouvez modifier les aspects facultatifs.

Étapes majeures

Pour importer des métadonnées à l'aide de l'API d'importation de métadonnées, procédez comme suit :

Déterminez le champ d'application du job.

Découvrez également comment Knowledge Catalog applique la logique de comparaison et le mode de synchronisation pour les entrées et les aspects.
Créez un ou plusieurs fichiers d'importation de métadonnées qui définissent les données à importer.
Enregistrez les fichiers d'importation de métadonnées dans un bucket Cloud Storage.
Exécuter un job d'importation de métadonnées.

Les étapes décrites sur cette page supposent que vous êtes familiarisé avec les concepts de métadonnées de Knowledge Catalog, y compris les groupes d'entrées, les types d'entrées et les types d'aspects. Pour en savoir plus, consultez À propos des métadonnées dans Knowledge Catalog.

Avant de commencer

Avant d'importer des métadonnées, effectuez les tâches décrites dans cette section.

Rôles requis

Pour vous assurer que le compte de service Knowledge Catalog dispose des autorisations nécessaires pour accéder au bucket Cloud Storage, demandez à votre administrateur d'accorder au compte de service Knowledge Catalog le rôle IAM Lecteur des objets de l'espace de stockage (roles/storage.objectViewer) et l'autorisation storage.buckets.get sur le bucket.

Pour obtenir les autorisations nécessaires pour gérer les jobs d'importation de métadonnées, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Modifier les entrées et leurs aspects dans un job de métadonnées de synchronisation complète des entrées :
- Utilisateur du type d'entrée Dataplex (roles/dataplex.entryTypeUser) sur le type d'entrée ou le projet où le type d'entrée est défini
- Utilisateur du type d'aspect Dataplex (roles/dataplex.aspectTypeUser) sur le type d'aspect ou le projet où le type d'aspect est défini
Modifiez les aspects requis dans un job de métadonnées d'aspect uniquement :
- Utilisateur du type d'entrée Dataplex (roles/dataplex.entryTypeUser) sur le type d'entrée ou le projet où le type d'entrée est défini
- Utilisateur du type d'aspect Dataplex (roles/dataplex.aspectTypeUser) sur le type d'aspect ou le projet où le type d'aspect est défini
Modifier les aspects facultatifs dans un job de métadonnées d'aspect uniquement : Utilisateur du type d'aspect Dataplex (roles/dataplex.aspectTypeUser) sur le type d'aspect ou le projet où le type d'aspect est défini. Notez que lorsque vous modifiez des aspects facultatifs dans un job de métadonnées d'aspect uniquement, vous n'avez pas besoin d'autorisations pour le type d'entrée associé.
Créer des jobs d'importation de métadonnées :
- Importateur de groupe d'entrées Dataplex (roles/dataplex.entryGroupImporter) sur le projet ou la ressource
- Propriétaire des entrées et des liens d'entrée Dataplex (roles/dataplex.entryOwner) sur le projet ou la ressource
Afficher les jobs de métadonnées : Lecteur de jobs de métadonnées Dataplex (roles/dataplex.metadataJobViewer) sur le projet
Créer, afficher et annuler des jobs de métadonnées : Propriétaire de jobs de métadonnées Dataplex (roles/dataplex.metadataJobOwner) sur le projet

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer des ressources Google Cloud

Préparez les ressources Google Cloud suivantes :

Créez des groupes d'entrées pour les entrées que vous souhaitez importer.
Créez des types d'aspects pour les aspects que vous souhaitez importer.
Créez des types d'entrées pour les entrées que vous souhaitez importer.
Si vous exécutez un job de métadonnées d'aspect uniquement, créez des entrées pour les aspects que vous souhaitez importer.
Créez un bucket Cloud Storage pour stocker vos fichiers d'importation de métadonnées.

Composants d'un job d'importation de métadonnées

Lorsque vous importez des métadonnées, tenez compte des composants suivants d'un job de métadonnées :

Champ d'application du job : groupes d'entrées, types d'entrées et types d'aspects à inclure dans le job.
Mode de synchronisation : comment les entrées et les aspects du job sont mis à jour.
Fichier d'importation de métadonnées : fichier qui définit les valeurs à définir pour les entrées et les aspects du job. Vous pouvez fournir plusieurs fichiers d'importation de métadonnées dans le même job de métadonnées. Vous enregistrez les fichiers dans Cloud Storage.
Logique de comparaison : comment Knowledge Catalog détermine les entrées et les aspects à modifier.

Champ d'application du job

Le champ d'application du job définit les groupes d'entrées, les types d'entrées et les types d'aspects que vous souhaitez inclure dans un job d'importation de métadonnées. Lorsque vous importez des métadonnées, vous modifiez les entrées et les aspects appartenant aux ressources comprises dans le champ d'application du job.

Pour définir le champ d'application du job, suivez ces consignes :

Groupes d'entrées : spécifiez un ou plusieurs groupes d'entrées à inclure dans le job. Le job ne modifie que les entrées et les aspects qui appartiennent à ces groupes d'entrées. Les groupes d'entrées et le job doivent se trouver dans la même région.
Types d'entrées : spécifiez un ou plusieurs types d'entrées à inclure dans le job. Le job ne modifie que les entrées et les aspects qui appartiennent à ces types d'entrées. L'emplacement d'un type d'entrée doit correspondre à celui du job, ou le type d'entrée doit être global.
Types d'aspects : spécifiez un ou plusieurs types d'aspects à inclure dans le job. Le job ne modifie que les aspects qui appartiennent à ces types d'aspects. L'emplacement d'un type d'aspect doit correspondre à celui du job, ou le type d'aspect doit être global.

Remarque : L'importation d'aspects de type data-rules et data-quality-rule-template n'est pas possible à partir du job de métadonnées.

Le champ d'application du job doit inclure tous les types d'entrées et d'aspects que vous spécifiez dans le fichier d'importation de métadonnées.

Vous spécifiez le champ d'application du job lorsque vous créez un job de métadonnées.

Mode de synchronisation

Le mode de synchronisation spécifie comment les entrées et les aspects d'un job d'importation de métadonnées sont mis à jour. Vous devez fournir un mode de synchronisation pour les entrées et les aspects. Selon les ressources que vous souhaitez importer, les combinaisons de modes de synchronisation suivantes sont acceptées.

Objectif Mode de synchronisation des entrées Mode de synchronisation de l'aspect Résultats

Importer des entrées et leurs aspects

Objectif	Mode de synchronisation des entrées	Mode de synchronisation de l'aspect	Résultats
Importer des entrées et leurs aspects	`FULL`	`INCREMENTAL`	Toutes les entrées du champ d'application du job sont modifiées. Si une entrée existe dans Knowledge Catalog, mais qu'elle n'est pas incluse dans le fichier d'importation de métadonnées, elle est supprimée lorsque vous exécutez le job de métadonnées. Un aspect n'est modifié que si le fichier d'importation de métadonnées inclut une référence à l'aspect dans le champ `updateMask` et le champ `aspectKeys`. Consultez la section Structure d'un élément d'importation.
Importer uniquement les aspects	`NONE`	`INCREMENTAL`	Les aspects sont modifiés s'ils font partie du champ d'application du job et si le fichier d'importation de métadonnées inclut une référence aux aspects dans le champ `aspectKeys`. Consultez la section Structure d'un élément d'importation. Les autres métadonnées appartenant aux entrées du champ d'application du job ne sont pas modifiées.

FULL

INCREMENTAL

Toutes les entrées du champ d'application du job sont modifiées.

Si une entrée existe dans Knowledge Catalog, mais qu'elle n'est pas incluse dans le fichier d'importation de métadonnées, elle est supprimée lorsque vous exécutez le job de métadonnées.

Un aspect n'est modifié que si le fichier d'importation de métadonnées inclut une référence à l'aspect dans le champ updateMask et le champ aspectKeys. Consultez la section Structure d'un élément d'importation.

Importer uniquement les aspects

NONE

INCREMENTAL

Les aspects sont modifiés s'ils font partie du champ d'application du job et si le fichier d'importation de métadonnées inclut une référence aux aspects dans le champ aspectKeys. Consultez la section Structure d'un élément d'importation.

Les autres métadonnées appartenant aux entrées du champ d'application du job ne sont pas modifiées.

Vous spécifiez le mode de synchronisation lorsque vous créez un job de métadonnées.

Fichier d'importation de métadonnées

Le fichier d'importation de métadonnées est un ensemble d'entrées et d'aspects que vous souhaitez modifier. Il définit les valeurs à définir pour tous les champs appartenant à ces entrées et aspects. Vous préparez le fichier avant d'exécuter un job d'importation de métadonnées.

Les consignes générales suivantes s'appliquent :

Vous pouvez fournir plusieurs fichiers d'importation de métadonnées dans le même job de métadonnées.
Lorsque vous exécutez un job de métadonnées de synchronisation complète des entrées, les entrées que vous fournissez dans le fichier remplacent complètement toutes les entrées existantes pour toutes les ressources comprises dans le champ d'application du job. Cela signifie que vous devez inclure des valeurs pour toutes les entrées d'un job, et pas seulement pour celles que vous souhaitez ajouter ou mettre à jour. Pour obtenir la liste des entrées actuelles de votre projet à utiliser comme point de départ, utilisez la méthode API entries.list.

Attention : Si une entrée existe dans Knowledge Catalog, mais qu'elle n'est pas incluse dans le fichier d'importation de métadonnées, elle est supprimée lorsque vous exécutez le job de métadonnées. Si le fichier d'importation de métadonnées ne contient aucune donnée, toutes les entrées et tous les aspects appartenant au champ d'application du job sont supprimés.
Vous devez fournir un fichier d'importation de métadonnées dans le cadre d'un job de métadonnées. Si vous souhaitez supprimer toutes les données existantes pour les entrées comprises dans le champ d'application du job, fournissez un fichier d'importation de métadonnées vide.
Toutes les entrées et tous les aspects que vous incluez dans le fichier doivent appartenir aux groupes d'entrées, aux types d'entrées et aux types d'aspects que vous définissez dans le champ d'application du job.

Suivez les instructions détaillées des sections suivantes pour créer un fichier d'importation de métadonnées.

Structure du fichier

Chaque ligne du fichier d'importation de métadonnées contient un objet JSON correspondant à un élément d'importation. Un élément d'importation est un objet qui décrit les valeurs à modifier pour une entrée et ses aspects associés.

Vous pouvez fournir plusieurs éléments d'importation dans un même fichier d'importation de métadonnées. Toutefois, ne fournissez pas le même élément d'importation plusieurs fois dans un job de métadonnées. Utilisez un caractère de nouvelle ligne (0x0a) pour séparer chaque élément d'importation.

Un fichier d'importation de métadonnées avec un caractère de nouvelle ligne entre chaque élément d'importation se présente comme suit :

{ "entry": { "name": "entry 1", #Information about entry 1 }
{ "entry": { "name": "entry 2", #Information about entry 2 }

Structure d'un élément d'importation

Chaque élément d'importation du fichier d'importation de métadonnées peut inclure les champs suivants (voir ImportItem). L'exemple suivant est mis en forme avec des sauts de ligne pour des raisons de lisibilité, mais lorsque vous enregistrez le fichier, n'incluez un caractère de nouvelle ligne qu'après chaque élément d'importation. N'incluez pas de sauts de ligne entre les champs d'un même élément d'importation.

{
  "entry": {
    "name": "ENTRY_NAME",
    "entryType": "ENTRY_TYPE",
    "entrySource": {
      "resource": "RESOURCE",
      "system": "SYSTEM",
      "platform": "PLATFORM",
      "displayName": "DISPLAY_NAME",
      "description": "DESCRIPTION",
      "createTime": "ENTRY_CREATE_TIMESTAMP",
      "updateTime": "ENTRY_UPDATE_TIMESTAMP"
    },
    "aspects": {
      "ASPECT": {
        "data": {
          "KEY": "VALUE"
        },
        "aspectSource": {
          "createTime": "ASPECT_CREATE_TIMESTAMP",
          "updateTime": "ASPECT_UPDATE_TIMESTAMP"
        }
      },
      # Additional aspect maps
    },
    "parentEntry": "PARENT_ENTRY",
    "fullyQualifiedName": "FULLY_QUALIFIED_NAME"
  },
  "updateMask": "UPDATE_MASK_FIELDS",
  "aspectKeys": [
    "ASPECT_KEY",
    # Additional aspect keys
  ],
}

Remplacez les éléments suivants :

entry : informations sur une entrée et ses aspects associés. Dans un job d'importation de métadonnées d'aspect uniquement, Knowledge Catalog ignore tous les champs facultatifs d'une entrée, à l'exception des mappages d'aspect.
- ENTRY_NAME : nom de ressource relatif de l'entrée, au format projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryGroups/ENTRY_GROUP_ID/entries/ENTRY_ID.
- ENTRY_TYPE : nom de ressource relatif du type d'entrée utilisé pour créer cette entrée, au format projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryTypes/ENTRY_TYPE_ID.
- entrySource : informations du système source sur la ressource de données représentée par l'entrée :
  - RESOURCE : nom de la ressource dans le système source.
  - SYSTEM : nom du système source.
  - PLATFORM : plate-forme contenant le système source.
  - DISPLAY_NAME : nom à afficher convivial.
  - DESCRIPTION : description de l'entrée.
  - ENTRY_CREATE_TIMESTAMP : heure de création de l'entrée dans le système source.
  - ENTRY_UPDATE_TIMESTAMP : heure de mise à jour de l'entrée dans le système source.
- aspects : aspects associés à l'entrée. L'objet aspect et ses données sont appelés "mappage d'aspects".
  - ASPECT : aspect associé à l'entrée. Selon la façon dont l'aspect est associé à l'entrée, utilisez l'un des formats suivants :
    - Si l'aspect est associé directement à l'entrée, indiquez le nom de ressource relatif de son type d'aspect, au format PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID.
    - Si l'aspect est associé au chemin d'accès de l'entrée, indiquez le chemin d'accès du type d'aspect au format PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID@PATH.
  - KEY et VALUE : contenu de l'aspect, selon son modèle de métadonnées de type d'aspect. Le contenu doit être encodé en UTF-8. La taille maximale du champ est de 120 Ko. Le dictionnaire data est obligatoire, même s'il est vide.
  - ASPECT_CREATE_TIMESTAMP : heure de création de l'aspect dans le système source.
  - ASPECT_UPDATE_TIMESTAMP : heure à laquelle l'aspect a été mis à jour dans le système source.
- PARENT_ENTRY : nom de ressource de l'entrée parente.
- FULLY_QUALIFIED_NAME : nom de l'entrée pouvant être référencée par un système externe. Consultez la section Noms complets.
UPDATE_MASK_FIELDS : champs à mettre à jour, dans des chemins d'accès relatifs à la ressource Entry. Séparez chaque champ par une virgule.

Dans un job de synchronisation d'entrée complet, Knowledge Catalog inclut les chemins d'accès de tous les champs d'une entrée qui peuvent être modifiés, y compris les aspects. Le champ updateMask est ignoré lorsqu'une entrée est créée ou recréée.

Dans un job de métadonnées d'aspect uniquement, définissez cette valeur sur aspects.
ASPECT_KEY : aspects à modifier. Accepte les syntaxes suivantes :
- ASPECT_TYPE_REFERENCE : correspond au type d'aspect pour les aspects directement associés à l'entrée.
- ASPECT_TYPE_REFERENCE@PATH : correspond au type d'aspect et au chemin d'accès spécifié.
- ASPECT_TYPE_REFERENCE@* : correspond au type d'aspect pour tous les chemins d'accès.
- *@PATH : correspond à tous les types d'aspects sur le chemin spécifié.
Remplacez ASPECT_TYPE_REFERENCE par une référence au type d'aspect, au format PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID.

Dans un job de synchronisation d'entrées complet, si vous laissez ce champ vide, il est considéré comme spécifiant exactement les aspects présents dans l'entrée spécifiée. Knowledge Catalog ajoute implicitement les clés pour tous les aspects requis d'une entrée.

Exigences pour les fichiers

Le fichier d'importation de métadonnées doit répondre aux exigences suivantes :

Le fichier doit être au format JSON Lines, qui est un fichier JSON délimité par un retour à la ligne. Utilisez un caractère de nouvelle ligne (0x0a) pour séparer chaque élément d'importation.
Le fichier doit utiliser l'encodage de caractères UTF-8.
Les extensions de fichier acceptées sont .jsonl et .json.
La taille de chaque fichier d'importation de métadonnées doit être inférieure à 1 Gio. La taille totale maximale de toutes les données du job de métadonnées est de 3 Go. Cela inclut tous les fichiers et métadonnées associés au job.
Les types d'entrées et d'aspects que vous spécifiez dans le fichier doivent faire partie du champ d'application du job de métadonnées.
Le fichier doit être importé dans un bucket Cloud Storage. N'enregistrez pas le fichier dans un dossier nommé CLOUD_STORAGE_URI/deletions/.

Logique de comparaison

Knowledge Catalog détermine les entrées et les aspects à modifier en comparant les valeurs et les codes temporels que vous fournissez dans le fichier d'importation de métadonnées avec les valeurs et les codes temporels existants dans votre projet.

En gros, Knowledge Catalog met à jour les valeurs de votre projet lorsqu'au moins une modification proposée dans le fichier d'importation de métadonnées modifie l'état de votre projet lors de l'exécution du job, sans introduire de données obsolètes. La modification proposée doit être référencée dans le champ du masque de mise à jour ou dans le champ des clés d'aspect du fichier d'importation des métadonnées.

La logique de comparaison varie en fonction du type de job d'importation de métadonnées que vous exécutez.

Job de synchronisation complète des entrées

Dans un job de métadonnées de synchronisation complète des entrées, pour chaque entrée faisant partie du champ d'application du job, Knowledge Catalog effectue l'une des opérations suivantes :

Crée une entrée et les aspects associés. Si le fichier d'importation de métadonnées inclut une entrée qui n'existe pas dans votre projet, Knowledge Catalog crée l'entrée et les aspects associés.
Supprimer une entrée et les aspects associés. Si une entrée existe dans votre projet, mais que le fichier d'importation de métadonnées ne l'inclut pas, Knowledge Catalog supprime l'entrée et les aspects associés de votre projet.
Mettre à jour une entrée et les aspects associés Si une entrée existe à la fois dans le fichier d'importation de métadonnées et dans votre projet, Knowledge Catalog évalue les codes temporels de la source de l'entrée et les codes temporels de la source de l'aspect associés à l'entrée pour déterminer les valeurs à modifier. Ensuite, Knowledge Catalog effectue une ou plusieurs des actions suivantes :
- Recrée l'entrée. Si le code temporel de création de la source d'entrée dans le fichier d'importation de métadonnées est plus récent que le code temporel correspondant dans votre projet, Knowledge Catalog recrée l'entrée dans votre projet.
- Mettre à jour l'entrée. Si le code temporel de mise à jour de la source de l'entrée dans le fichier d'importation des métadonnées est plus récent que le code temporel correspondant dans votre projet, Knowledge Catalog met à jour l'entrée dans votre projet.
- Créer un aspect Si un aspect n'existe pas dans votre projet et qu'il est inclus dans un mappage d'aspects, le champ de masque de mise à jour et le champ de clés d'aspect dans le fichier d'importation de métadonnées, Knowledge Catalog crée l'aspect.
- Supprime un aspect. Si un aspect existe dans votre projet et qu'il est inclus dans le champ de masque de mise à jour et le champ de clés d'aspect du fichier d'importation de métadonnées, mais qu'il n'est pas inclus dans un mappage d'aspect, Knowledge Catalog supprime l'aspect.
- Mettre à jour un aspect Si un aspect existe dans votre projet et qu'il est inclus dans un mappage d'aspects, le champ de masque de mise à jour et le champ de clés d'aspect du fichier d'importation de métadonnées, et que le code temporel de mise à jour de la source d'aspect dans le fichier d'importation de métadonnées est plus récent que le code temporel correspondant dans votre projet, Knowledge Catalog met à jour l'aspect.
  
  Si aucun code temporel de mise à jour de la source d'aspect n'est fourni dans le fichier d'importation des métadonnées, mais que l'entrée correspondante est marquée pour une mise à jour, Knowledge Catalog met également à jour l'aspect.
  
  Toutefois, si au moins un aspect du fichier d'importation de métadonnées comporte un code temporel plus ancien que le code temporel correspondant dans votre projet, Knowledge Catalog n'effectue aucune mise à jour pour l'entrée associée.

Job d'aspect uniquement

Dans un job de métadonnées d'aspect uniquement, pour chaque aspect faisant partie du champ d'application du job, Knowledge Catalog effectue l'une des opérations suivantes :

Créer un aspect Si un aspect n'existe pas dans votre projet et qu'il est inclus dans un mappage d'aspects, le champ de masque de mise à jour et le champ de clés d'aspect dans le fichier d'importation de métadonnées, Knowledge Catalog crée l'aspect.
Supprime un aspect. Pour les aspects facultatifs, si l'aspect existe dans votre projet et qu'il est inclus dans le champ de masque de mise à jour et le champ de clés d'aspect du fichier d'importation de métadonnées, mais qu'il n'est pas inclus dans un mappage d'aspects, Knowledge Catalog supprime l'aspect.

Les aspects obligatoires ne peuvent pas être supprimés.
Mettre à jour un aspect Si un aspect existe dans votre projet et qu'il est inclus dans un mappage d'aspects, le champ de masque de mise à jour et le champ de clés d'aspect du fichier d'importation de métadonnées, et que le code temporel de mise à jour de la source d'aspect dans le fichier d'importation de métadonnées est plus récent que le code temporel correspondant dans votre projet, Knowledge Catalog met à jour l'aspect.

Si aucun code temporel de mise à jour de la source d'aspect n'est fourni dans le fichier d'importation des métadonnées, Knowledge Catalog met également à jour l'aspect.

Knowledge Catalog met à jour les aspects en fonction du code temporel de mise à jour de la source de l'aspect, quel que soit le code temporel de mise à jour de la source de l'entrée correspondante.

Créer un fichier d'importation de métadonnées

Avant d'importer des métadonnées, créez un fichier d'importation de métadonnées pour votre job. Procédez comme indiqué ci-dessous.

Préparez un fichier d'importation de métadonnées en suivant les consignes décrites précédemment dans ce document.
Importez le fichier dans un bucket Cloud Storage.

Vous pouvez fournir plusieurs fichiers d'importation de métadonnées dans le même job de métadonnées. Pour fournir plusieurs fichiers, enregistrez-les dans le même bucket Cloud Storage. Lorsque vous exécutez le job, vous spécifiez un bucket, et non un fichier spécifique. Knowledge Catalog importe les métadonnées de tous les fichiers enregistrés dans le bucket, y compris ceux situés dans des sous-dossiers.

Exécuter un job d'importation de métadonnées

Après avoir créé un fichier d'importation de métadonnées, exécutez le job d'importation de métadonnées.

REST

Pour importer des métadonnées, utilisez la méthode metadataJobs.create.

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

PROJECT_NUMBER : numéro ou ID de votre projet Google Cloud .
LOCATION_ID : emplacement Google Cloud , par exemple us-central1.
METADATA_JOB_ID (facultatif) : ID du job de métadonnées.
CLOUD_STORAGE_URI : URI du bucket ou du dossier Cloud Storage contenant les fichiers d'importation de métadonnées. Pour en savoir plus sur les exigences concernant les fichiers, consultez Fichier d'importation de métadonnées.
ENTRY_GROUP : nom de ressource relatif des groupes d'entrées inclus dans le champ d'application du job, au format projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryGroups/ENTRY_GROUP_ID. Pour en savoir plus, consultez Champ d'application du job.
ENTRY_TYPE : nom de ressource relatif d'un type d'entrée inclus dans le champ d'application du job, au format projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryTypes/ENTRY_TYPE_ID. Pour en savoir plus, consultez Champ d'application d'un job.
ASPECT_TYPE : nom de ressource relatif d'un type d'aspect inclus dans le champ d'application du job, au format projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/aspectTypes/ASPECT_TYPE_ID. Facultatif lors de la création d'un job de synchronisation d'entrées complet, obligatoire lors de la création d'un job d'aspect uniquement. Pour en savoir plus, consultez Champ d'application du job.
ENTRY_SYNC_MODE : mode de synchronisation des entrées, tel que FULL ou NONE. Pour en savoir plus, consultez Mode de synchronisation.
LOG_LEVEL : niveau des journaux à capturer, par exemple INFO ou DEBUG. Pour en savoir plus, consultez Afficher les journaux de job et résoudre les problèmes.

Méthode HTTP et URL :

POST https://dataplex.googleapis.com/v1/projects/TARGET_PROJECT_NUMBER/locations/LOCATION_ID/metadataJobs?metadataJobId=METADATA_JOB_ID

Corps JSON de la requête :

{
  "type": "IMPORT",
  "import_spec": {
    "source_storage_uri": "gs://CLOUD_STORAGE_URI/",
    "scope": {
      "entryGroups": [
        "ENTRY_GROUP"
      ],
      "entry_types": [
        "ENTRY_TYPE"
      ],
      "aspect_types": [
        "ASPECT_TYPE"
      ]
    },
    "entry_sync_mode": "ENTRY_SYNC_MODE",
    "aspect_sync_mode": "INCREMENTAL",
    "log_level": "LOG_LEVEL"
  }
}

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

curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://dataplex.googleapis.com/v1/projects/TARGET_PROJECT_NUMBER/locations/LOCATION_ID/metadataJobs?metadataJobId=METADATA_JOB_ID"

PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://dataplex.googleapis.com/v1/projects/TARGET_PROJECT_NUMBER/locations/LOCATION_ID/metadataJobs?metadataJobId=METADATA_JOB_ID" | Select-Object -Expand Content

La réponse identifie une opération de longue durée.

Obtenir des informations sur un job de métadonnées

Pour obtenir des informations sur un job de métadonnées, comme son état et le nombre d'entrées modifiées, procédez comme suit. Pour en savoir plus sur la résolution des problèmes liés à un job ayant échoué, consultez la section Afficher les journaux de job et résoudre les problèmes de ce document.

C#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour C#.

Pour vous authentifier auprès de Knowledge Catalog, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for GetMetadataJob</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void GetMetadataJobRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        GetMetadataJobRequest request = new GetMetadataJobRequest
        {
            MetadataJobName = MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]"),
        };
        // Make the request
        MetadataJob response = catalogServiceClient.GetMetadataJob(request);
    }
}

Go

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Go.


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewCatalogClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.GetMetadataJobRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#GetMetadataJobRequest.
	}
	resp, err := c.GetMetadataJob(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Java.

import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.GetMetadataJobRequest;
import com.google.cloud.dataplex.v1.MetadataJob;
import com.google.cloud.dataplex.v1.MetadataJobName;

public class SyncGetMetadataJob {

  public static void main(String[] args) throws Exception {
    syncGetMetadataJob();
  }

  public static void syncGetMetadataJob() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CatalogServiceClient catalogServiceClient = CatalogServiceClient.create()) {
      GetMetadataJobRequest request =
          GetMetadataJobRequest.newBuilder()
              .setName(MetadataJobName.of("[PROJECT]", "[LOCATION]", "[METADATAJOB]").toString())
              .build();
      MetadataJob response = catalogServiceClient.getMetadataJob(request);
    }
  }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Node.js.

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The resource name of the metadata job, in the format
 *  `projects/{project_id_or_number}/locations/{location_id}/metadataJobs/{metadata_job_id}`.
 */
// const name = 'abc123'

// Imports the Dataplex library
const {CatalogServiceClient} = require('@google-cloud/dataplex').v1;

// Instantiates a client
const dataplexClient = new CatalogServiceClient();

async function callGetMetadataJob() {
  // Construct request
  const request = {
    name,
  };

  // Run request
  const response = await dataplexClient.getMetadataJob(request);
  console.log(response);
}

callGetMetadataJob();

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Python.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_get_metadata_job():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.GetMetadataJobRequest(
        name="name_value",
    )

    # Make the request
    response = client.get_metadata_job(request=request)

    # Handle the response
    print(response)

Ruby

Avant d'essayer cet exemple, suivez les instructions de configuration pour Ruby décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Ruby.

require "google/cloud/dataplex/v1"

##
# Snippet for the get_metadata_job call in the CatalogService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::CatalogService::Client#get_metadata_job.
#
def get_metadata_job
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::CatalogService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::GetMetadataJobRequest.new

  # Call the get_metadata_job method.
  result = client.get_metadata_job request

  # The returned object is of type Google::Cloud::Dataplex::V1::MetadataJob.
  p result
end

REST

Pour obtenir des informations sur un job de métadonnées, utilisez la méthode metadataJobs.get.

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

PROJECT_NUMBER : numéro ou ID de votre projet Google Cloud .
LOCATION_ID : emplacement Google Cloud , par exemple us-central1.
METADATA_JOB_ID : ID du job de métadonnées.

Méthode HTTP et URL :

GET https://dataplex.googleapis.com/v1/projects/TARGET_PROJECT_NUMBER/locations/LOCATION_ID/metadataJobs/METADATA_JOB_ID

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

curl (Linux, macOS ou Cloud Shell)

Exécutez la commande suivante :

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://dataplex.googleapis.com/v1/projects/TARGET_PROJECT_NUMBER/locations/LOCATION_ID/metadataJobs/METADATA_JOB_ID"

PowerShell (Windows)

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://dataplex.googleapis.com/v1/projects/TARGET_PROJECT_NUMBER/locations/LOCATION_ID/metadataJobs/METADATA_JOB_ID" | Select-Object -Expand Content

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

{
  "name": "projects/123456789012/locations/us-central1/metadataJobs/my-metadata-job",
  "uid": "a1b2c3d4-e5f6-7a8b-9c0d-1e2f3a4b5c6d",
  "createTime": "2026-07-17T16:30:15Z",
  "updateTime": "2026-07-17T16:35:15Z",
  "type": "IMPORT",
  "importSpec": {
    "sourceStorageUri": "gs://my-bucket/",
    "scope": {
      "entryGroups": [
        "projects/123456789012/locations/us-central1/entryGroups/my-entry-group"
      ],
      "entryTypes": [
        "projects/123456789012/locations/us-central1/entryTypes/my-entry-type"
      ],
      "aspectTypes": [
        "projects/123456789012/locations/us-central1/aspectTypes/my-aspect-type"
      ]
    },
    "entrySyncMode": "FULL",
    "aspectSyncMode": "INCREMENTAL",
    "logLevel": "INFO"
  },
  "status": {
    "state": "SUCCEEDED"
  },
  "importResult": {
    "deletedEntries": "2",
    "updatedEntries": "5",
    "createdEntries": "10",
    "unchangedEntries": "20",
    "updateTime": "2026-07-17T16:35:15Z"
  }
}

Obtenir la liste des jobs de métadonnées

Vous pouvez obtenir la liste des jobs de métadonnées les plus récents. Les jobs plus anciens qui ont atteint un état final sont régulièrement supprimés du système.

C#

using Google.Api.Gax;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dataplex.V1;
using System;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for ListMetadataJobs</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void ListMetadataJobsRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        ListMetadataJobsRequest request = new ListMetadataJobsRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            Filter = "",
            OrderBy = "",
        };
        // Make the request
        PagedEnumerable<ListMetadataJobsResponse, MetadataJob> response = catalogServiceClient.ListMetadataJobs(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (MetadataJob item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (ListMetadataJobsResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (MetadataJob item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<MetadataJob> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (MetadataJob item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

Go


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
	"google.golang.org/api/iterator"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewCatalogClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.ListMetadataJobsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#ListMetadataJobsRequest.
	}
	it := c.ListMetadataJobs(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*dataplexpb.ListMetadataJobsResponse)
	}
}

Java

import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.ListMetadataJobsRequest;
import com.google.cloud.dataplex.v1.LocationName;
import com.google.cloud.dataplex.v1.MetadataJob;

public class SyncListMetadataJobs {

  public static void main(String[] args) throws Exception {
    syncListMetadataJobs();
  }

  public static void syncListMetadataJobs() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CatalogServiceClient catalogServiceClient = CatalogServiceClient.create()) {
      ListMetadataJobsRequest request =
          ListMetadataJobsRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .setOrderBy("orderBy-1207110587")
              .build();
      for (MetadataJob element : catalogServiceClient.listMetadataJobs(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Node.js

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The resource name of the parent location, in the format
 *  `projects/{project_id_or_number}/locations/{location_id}`
 */
// const parent = 'abc123'
/**
 *  Optional. The maximum number of metadata jobs to return. The service might
 *  return fewer jobs than this value. If unspecified, at most 10 jobs are
 *  returned. The maximum value is 1,000.
 */
// const pageSize = 1234
/**
 *  Optional. The page token received from a previous `ListMetadataJobs` call.
 *  Provide this token to retrieve the subsequent page of results. When
 *  paginating, all other parameters that are provided to the
 *  `ListMetadataJobs` request must match the call that provided the page
 *  token.
 */
// const pageToken = 'abc123'
/**
 *  Optional. Filter request. Filters are case-sensitive.
 *  The service supports the following formats:
 *  * `labels.key1 = "value1"`
 *  * `labels:key1`
 *  * `name = "value"`
 *  You can combine filters with `AND`, `OR`, and `NOT` operators.
 */
// const filter = 'abc123'
/**
 *  Optional. The field to sort the results by, either `name` or `create_time`.
 *  If not specified, the ordering is undefined.
 */
// const orderBy = 'abc123'

// Imports the Dataplex library
const {CatalogServiceClient} = require('@google-cloud/dataplex').v1;

// Instantiates a client
const dataplexClient = new CatalogServiceClient();

async function callListMetadataJobs() {
  // Construct request
  const request = {
    parent,
  };

  // Run request
  const iterable = dataplexClient.listMetadataJobsAsync(request);
  for await (const response of iterable) {
      console.log(response);
  }
}

callListMetadataJobs();

Python

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_list_metadata_jobs():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.ListMetadataJobsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_metadata_jobs(request=request)

    # Handle the response
    for response in page_result:
        print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the list_metadata_jobs call in the CatalogService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::CatalogService::Client#list_metadata_jobs.
#
def list_metadata_jobs
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::CatalogService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::ListMetadataJobsRequest.new

  # Call the list_metadata_jobs method.
  result = client.list_metadata_jobs request

  # The returned object is of type Gapic::PagedEnumerable. You can iterate
  # over elements, and API calls will be issued to fetch pages as needed.
  result.each do |item|
    # Each element is of type ::Google::Cloud::Dataplex::V1::MetadataJob.
    p item
  end
end

REST

Pour obtenir la liste des jobs de métadonnées les plus récents, utilisez la méthode metadataJobs.list.

Annuler un job de métadonnées

Vous pouvez annuler un job de métadonnées que vous ne souhaitez pas exécuter.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedCatalogServiceClientSnippets
{
    /// <summary>Snippet for CancelMetadataJob</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void CancelMetadataJobRequestObject()
    {
        // Create client
        CatalogServiceClient catalogServiceClient = CatalogServiceClient.Create();
        // Initialize request argument(s)
        CancelMetadataJobRequest request = new CancelMetadataJobRequest
        {
            MetadataJobName = MetadataJobName.FromProjectLocationMetadataJob("[PROJECT]", "[LOCATION]", "[METADATAJOB]"),
        };
        // Make the request
        catalogServiceClient.CancelMetadataJob(request);
    }
}

Go


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewCatalogClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.CancelMetadataJobRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CancelMetadataJobRequest.
	}
	err = c.CancelMetadataJob(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
}

Java

import com.google.cloud.dataplex.v1.CancelMetadataJobRequest;
import com.google.cloud.dataplex.v1.CatalogServiceClient;
import com.google.cloud.dataplex.v1.MetadataJobName;
import com.google.protobuf.Empty;

public class SyncCancelMetadataJob {

  public static void main(String[] args) throws Exception {
    syncCancelMetadataJob();
  }

  public static void syncCancelMetadataJob() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (CatalogServiceClient catalogServiceClient = CatalogServiceClient.create()) {
      CancelMetadataJobRequest request =
          CancelMetadataJobRequest.newBuilder()
              .setName(MetadataJobName.of("[PROJECT]", "[LOCATION]", "[METADATAJOB]").toString())
              .build();
      catalogServiceClient.cancelMetadataJob(request);
    }
  }
}

Node.js

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The resource name of the job, in the format
 *  `projects/{project_id_or_number}/locations/{location_id}/metadataJobs/{metadata_job_id}`
 */
// const name = 'abc123'

// Imports the Dataplex library
const {CatalogServiceClient} = require('@google-cloud/dataplex').v1;

// Instantiates a client
const dataplexClient = new CatalogServiceClient();

async function callCancelMetadataJob() {
  // Construct request
  const request = {
    name,
  };

  // Run request
  const response = await dataplexClient.cancelMetadataJob(request);
  console.log(response);
}

callCancelMetadataJob();

Python

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_cancel_metadata_job():
    # Create a client
    client = dataplex_v1.CatalogServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.CancelMetadataJobRequest(
        name="name_value",
    )

    # Make the request
    client.cancel_metadata_job(request=request)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the cancel_metadata_job call in the CatalogService service
#
# This snippet has been automatically generated and should be regarded as a code
# template only. It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
# client as shown in https://cloud.google.com/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::CatalogService::Client#cancel_metadata_job.
#
def cancel_metadata_job
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::CatalogService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::CancelMetadataJobRequest.new

  # Call the cancel_metadata_job method.
  result = client.cancel_metadata_job request

  # The returned object is of type Google::Protobuf::Empty.
  p result
end

REST

Pour annuler un job de métadonnées, utilisez la méthode metadataJobs.cancel.

Afficher les journaux de jobs et résoudre les problèmes

Utilisez Cloud Logging pour afficher les journaux d'un job de métadonnées. Pour en savoir plus, consultez Surveiller les journaux Knowledge Catalog.

Vous configurez le niveau de journalisation lorsque vous créez un job de métadonnées. Les niveaux de journalisation suivants sont disponibles :

INFO : fournit des journaux au niveau global du job. Inclut des journaux agrégés sur les éléments d'importation, mais ne précise pas quel élément d'importation comporte une erreur.
DEBUG : fournit des journaux détaillés pour chaque élément d'importation. Utilisez la journalisation au niveau du débogage pour résoudre les problèmes liés à des éléments d'importation spécifiques. Par exemple, utilisez la journalisation au niveau du débogage pour identifier les ressources manquantes dans le champ d'application du job, les entrées ou les aspects qui ne sont pas conformes au type d'entrée ou d'aspect associé, ou d'autres erreurs de configuration dans le fichier d'importation de métadonnées.

Remarque : Selon la taille de votre job de métadonnées et le nombre de journaux générés, la journalisation au niveau du débogage peut entraîner des coûts supplémentaires. Pour en savoir plus, consultez les tarifs de Google Cloud Observability.

Erreurs de validation

Knowledge Catalog valide les fichiers d'importation de métadonnées par rapport aux métadonnées actuelles de votre projet. En cas de problème de validation, l'état du job peut renvoyer l'un des états suivants :

FAILED : se produit lorsque le fichier d'importation des métadonnées comporte une erreur. Knowledge Catalog n'importe aucune métadonnée et le job échoue. Voici quelques exemples d'erreurs dans le fichier d'importation de métadonnées :
- Un élément du fichier ne peut pas être analysé en tant qu'élément d'importation valide
- Une entrée ou un aspect du fichier appartient à un groupe d'entrées, un type d'entrée ou un type d'aspect qui ne fait pas partie du champ d'application du job.
- Le même nom d'entrée est spécifié plusieurs fois dans le job
- Un type d'aspect spécifié dans un mappage d'aspects ou les clés d'aspect n'utilise pas le format PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID@OPTIONAL_PATH.
- Un aspect obligatoire est marqué pour suppression
SUCCEEDED_WITH_ERRORS : se produit lorsque le fichier d'importation de métadonnées peut être analysé, mais que l'importation d'un élément du fichier entraîne un état incohérent d'une entrée de votre projet. Knowledge Catalog ignore ces entrées, mais importe le reste des métadonnées du fichier.

Utilisez les journaux de job pour résoudre l'erreur.

Importer des métadonnées à l'aide d'un pipeline personnalisé Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Étapes majeures

Avant de commencer

Rôles requis

Créer des ressources Google Cloud

Composants d'un job d'importation de métadonnées

Champ d'application du job

Mode de synchronisation

Fichier d'importation de métadonnées

Structure du fichier

Structure d'un élément d'importation

Exigences pour les fichiers

Logique de comparaison

Job de synchronisation complète des entrées

Job d'aspect uniquement

Créer un fichier d'importation de métadonnées

Exécuter un job d'importation de métadonnées

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Obtenir des informations sur un job de métadonnées

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Obtenir la liste des jobs de métadonnées

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

Annuler un job de métadonnées

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

Afficher les journaux de jobs et résoudre les problèmes

Erreurs de validation

Étapes suivantes

Importer des métadonnées à l'aide d'un pipeline personnalisé