A partir del 10 de abril de 2026, Dataplex Universal Catalog ahora se llama Knowledge Catalog. Los nombres de la API, la biblioteca cliente, la CLI y IAM no cambiaron. Para obtener más información, consulta Presentamos Google Cloud Knowledge Catalog.

Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Importa metadatos con una canalización personalizada

En este documento, se describe cómo importar metadatos de un sistema de terceros a Knowledge Catalog (anteriormente, Dataplex Universal Catalog) con los métodos de la API de importación de metadatos y tu propia canalización. Los metadatos de Knowledge Catalog constan de entradas y sus aspectos.

Si, en cambio, quieres usar una canalización de organización administrada por Google Cloud para extraer e importar metadatos, te sugerimos que uses una canalización de conectividad administrada. Con una canalización de conectividad administrada, traes tu propio conector que extrae metadatos y genera un resultado en un formato que los métodos de la API de importación de metadatos pueden usar como entrada (el archivo de importación de metadatos). Luego, usa Workflows para organizar las tareas de la canalización.

Puedes ejecutar los siguientes tipos de trabajos de importación de metadatos:

Sincronización completa de entradas con importación incremental de sus aspectos. Compatible con entradas personalizadas.
Importación incremental solo de aspectos. Se admite para los aspectos que pertenecen a entradas personalizadas y entradas del sistema. En el caso de las entradas personalizadas, puedes modificar tanto los aspectos opcionales como los obligatorios. En el caso de las entradas del sistema, puedes modificar los aspectos opcionales.

Pasos de alto nivel

Para importar metadatos con la API de importación de metadatos, sigue estos pasos de alto nivel:

Determina el alcance del trabajo.

Además, comprende cómo Knowledge Catalog aplica la lógica de comparación y el modo de sincronización para las entradas y los aspectos.
Crea uno o más archivos de importación de metadatos que definan los datos que se importarán.
Guarda los archivos de importación de metadatos en un bucket de Cloud Storage.
Ejecuta un trabajo de importación de metadatos.

En los pasos de esta página, se supone que conoces los conceptos de metadatos de Knowledge Catalog, incluidos los grupos de entradas, los tipos de entradas y los tipos de aspectos. Para obtener más información, consulta Acerca de los metadatos en Knowledge Catalog.

Antes de comenzar

Antes de importar metadatos, completa las tareas de esta sección.

Roles obligatorios

Para asegurarte de que la cuenta de servicio de Knowledge Catalog tenga los permisos necesarios para acceder al bucket de Cloud Storage, pídele a tu administrador que otorgue a la cuenta de servicio de Knowledge Catalog el rol de IAM Visualizador de objetos de Storage (roles/storage.objectViewer) y el permiso storage.buckets.get en el bucket.

Para obtener los permisos que necesitas para administrar los trabajos de importación de metadatos, pídele a tu administrador que te otorgue los siguientes roles de IAM:

Modifica las entradas y sus aspectos en un trabajo de metadatos de sincronización de entradas completo:
- Usuario de tipo de entrada de Dataplex (roles/dataplex.entryTypeUser) en el tipo de entrada o el proyecto en el que se define el tipo de entrada
- Usuario de tipos de aspecto de Dataplex (roles/dataplex.aspectTypeUser) en el tipo de aspecto o el proyecto en el que se define el tipo de aspecto
Modifica los aspectos obligatorios en un trabajo de metadatos solo de aspectos:
- Usuario de tipo de entrada de Dataplex (roles/dataplex.entryTypeUser) en el tipo de entrada o el proyecto en el que se define el tipo de entrada
- Usuario de tipo de aspecto de Dataplex (roles/dataplex.aspectTypeUser) en el tipo de aspecto o el proyecto en el que se define el tipo de aspecto
Modificar aspectos opcionales en un trabajo de metadatos solo de aspectos: Usuario de tipo de aspecto de Dataplex (roles/dataplex.aspectTypeUser) en el tipo de aspecto o el proyecto en el que se define el tipo de aspecto. Ten en cuenta que, cuando modificas aspectos opcionales en un trabajo de metadatos solo de aspectos, no necesitas permisos para el tipo de entrada asociado.
Crea trabajos de importación de metadatos:
- Importador de grupos de entradas de Dataplex (roles/dataplex.entryGroupImporter) en el proyecto o el recurso
- Propietario de entradas y vínculo de entrada de Dataplex (roles/dataplex.entryOwner) en el proyecto o el recurso
Visualiza trabajos de metadatos: Visualizador de trabajos de metadatos de Dataplex (roles/dataplex.metadataJobViewer) en el proyecto
Crea, visualiza y cancela trabajos de metadatos: Propietario de trabajos de metadatos de Dataplex (roles/dataplex.metadataJobOwner) en el proyecto

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Crea recursos de Google Cloud

Prepara los siguientes recursos de Google Cloud :

Crea grupos de entradas para las entradas que quieras importar.
Crea tipos de aspectos para los aspectos que deseas importar.
Crea tipos de entrada para las entradas que quieras importar.
Si ejecutas un trabajo de metadatos solo de aspectos, crea entradas para los aspectos que quieras importar.
Crea un bucket de Cloud Storage para almacenar tus archivos de importación de metadatos.

Componentes de un trabajo de importación de metadatos

Cuando importes metadatos, ten en cuenta los siguientes componentes de un trabajo de metadatos:

Alcance del trabajo: Son los grupos de entradas, los tipos de entradas y los tipos de aspectos que se incluirán en el trabajo.
Modo de sincronización: Cómo se actualizan las entradas y los aspectos del trabajo.
Archivo de importación de metadatos: Es un archivo que define los valores que se establecerán para las entradas y los aspectos del trabajo. Puedes proporcionar varios archivos de importación de metadatos en el mismo trabajo de metadatos. Guardas los archivos en Cloud Storage.
Lógica de comparación: cómo Knowledge Catalog determina qué entradas y aspectos modificar.

Alcance del trabajo

El alcance del trabajo define los grupos de entradas, los tipos de entradas y los tipos de aspectos que deseas incluir en un trabajo de importación de metadatos. Cuando importas metadatos, modificas las entradas y los aspectos que pertenecen a los recursos dentro del alcance del trabajo.

Para definir el alcance del trabajo, sigue estos lineamientos:

Grupos de entradas: Especifica uno o más grupos de entradas para incluir en el trabajo. El trabajo modifica solo las entradas y los aspectos que pertenecen a estos grupos de entradas. Los grupos de entradas y el trabajo deben estar en la misma región.
Tipos de entrada: Especifica uno o más tipos de entrada para incluir en el trabajo. El trabajo modifica solo las entradas y los aspectos que pertenecen a estos tipos de entrada. La ubicación de un tipo de entrada debe coincidir con la ubicación del trabajo o el tipo de entrada debe ser global.
Tipos de aspectos: Especifica uno o más tipos de aspectos para incluir en el trabajo. El trabajo modifica solo los aspectos que pertenecen a estos tipos de aspectos. La ubicación de un tipo de aspecto debe coincidir con la ubicación del trabajo o el tipo de aspecto debe ser global.

Nota: No se admite la importación de aspectos de tipo data-rules y data-quality-rule-template desde el trabajo de metadatos.

El permiso del trabajo debe incluir todos los tipos de entradas y de aspectos que especifiques en el archivo de importación de metadatos.

Especifica el permiso del trabajo cuando creas un trabajo de metadatos.

Modo de sincronización

El modo de sincronización especifica cómo se actualizan las entradas y los aspectos en un trabajo de importación de metadatos. Debes proporcionar un modo de sincronización para las entradas y los aspectos. Según los recursos que quieras importar, se admiten las siguientes combinaciones de modos de sincronización.

Objetivo Modo de sincronización de entradas Modo de sincronización de aspecto Resultados

Importa entradas y sus aspectos

Objetivo	Modo de sincronización de entradas	Modo de sincronización de aspecto	Resultados
Importa entradas y sus aspectos	`FULL`	`INCREMENTAL`	Se modifican todas las entradas en el permiso del trabajo. Si existe una entrada en Knowledge Catalog, pero no se incluye en el archivo de importación de metadatos, se borrará cuando ejecutes el trabajo de metadatos. Un aspecto se modifica solo si el archivo de importación de metadatos incluye una referencia al aspecto en el campo `updateMask` y el campo `aspectKeys`. Consulta Estructura de un elemento de importación.
Importa solo aspectos	`NONE`	`INCREMENTAL`	Los aspectos se modifican si forman parte del alcance del trabajo y si el archivo de importación de metadatos incluye una referencia a los aspectos en el campo `aspectKeys`. Consulta Estructura de un elemento de importación. No se modifican otros metadatos que pertenecen a entradas en el permiso del trabajo.

FULL

INCREMENTAL

Se modifican todas las entradas en el permiso del trabajo.

Si existe una entrada en Knowledge Catalog, pero no se incluye en el archivo de importación de metadatos, se borrará cuando ejecutes el trabajo de metadatos.

Un aspecto se modifica solo si el archivo de importación de metadatos incluye una referencia al aspecto en el campo updateMask y el campo aspectKeys. Consulta Estructura de un elemento de importación.

Importa solo aspectos

NONE

INCREMENTAL

Los aspectos se modifican si forman parte del alcance del trabajo y si el archivo de importación de metadatos incluye una referencia a los aspectos en el campo aspectKeys. Consulta Estructura de un elemento de importación.

No se modifican otros metadatos que pertenecen a entradas en el permiso del trabajo.

Especificas el modo de sincronización cuando creas un trabajo de metadatos.

Archivo de importación de metadatos

El archivo de importación de metadatos es una colección de las entradas y los aspectos que deseas modificar. Define los valores que se establecerán para todos los campos que pertenecen a estas entradas y aspectos. Debes preparar el archivo antes de ejecutar un trabajo de importación de metadatos.

Se aplican estos lineamientos generales:

Puedes proporcionar varios archivos de importación de metadatos en el mismo trabajo de metadatos.
Cuando ejecutas un trabajo de metadatos de sincronización de entradas completa, las entradas que proporcionas en el archivo reemplazan por completo todas las entradas existentes para cualquier recurso que esté dentro del alcance del trabajo. Esto significa que debes incluir valores para todas las entradas de un trabajo, no solo los valores que deseas agregar o actualizar. Para obtener una lista de las entradas actuales en tu proyecto y usarlas como punto de partida, usa el método de la API entries.list.

Precaución: Si existe una entrada en Knowledge Catalog, pero no se incluye en el archivo de importación de metadatos, la entrada se borra cuando ejecutas el trabajo de metadatos. Si el archivo de importación de metadatos no contiene datos, se borran todas las entradas y los aspectos que pertenecen al alcance del trabajo.
Debes proporcionar un archivo de importación de metadatos como parte de un trabajo de metadatos. Si quieres borrar todos los datos existentes de las entradas que están dentro del alcance del trabajo, proporciona un archivo de importación de metadatos vacío.
Todas las entradas y los aspectos que incluyas en el archivo deben pertenecer a los grupos de entradas, los tipos de entradas y los tipos de aspectos que definas en el alcance del trabajo.

Usa los lineamientos detallados de las siguientes secciones para crear un archivo de importación de metadatos.

Estructura del archivo

Cada línea del archivo de importación de metadatos contiene un objeto JSON que corresponde a un elemento de importación. Un elemento de importación es un objeto que describe los valores que se modificarán para una entrada y sus aspectos adjuntos.

Puedes proporcionar varios elementos de importación en un solo archivo de importación de metadatos. Sin embargo, no proporciones el mismo elemento de importación más de una vez en un trabajo de metadatos. Usa un carácter de línea nueva (0x0a) para separar cada elemento de importación.

Un archivo de importación de metadatos con un carácter de línea nueva entre cada elemento de importación se ve como en el siguiente ejemplo:

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

Estructura de un elemento de importación

Cada elemento de importación en el archivo de importación de metadatos puede incluir los siguientes campos (consulta ImportItem). El siguiente ejemplo tiene formato con saltos de línea para facilitar la lectura, pero cuando guardes el archivo, incluye un carácter de línea nueva solo después de cada elemento de importación. No incluyas saltos de línea entre los campos de un solo elemento de importación.

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

Reemplaza lo siguiente:

entry: información sobre una entrada y sus aspectos adjuntos. En un trabajo de importación de metadatos solo de aspectos, Knowledge Catalog ignora todos los campos opcionales de una entrada, excepto los mapas de aspectos.
- ENTRY_NAME: Es el nombre del recurso relativo de la entrada, en el formato projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryGroups/ENTRY_GROUP_ID/entries/ENTRY_ID.
- ENTRY_TYPE: Es el nombre de recurso relativo del tipo de entrada que se usó para crear esta entrada, en el formato projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryTypes/ENTRY_TYPE_ID.
- entrySource: Es la información del sistema de origen sobre el recurso de datos que representa la entrada:
  - RESOURCE: Es el nombre del recurso en el sistema de origen.
  - SYSTEM: Es el nombre del sistema de origen.
  - PLATFORM: Es la plataforma que contiene el sistema de origen.
  - DISPLAY_NAME: un nombre visible fácil de usar.
  - DESCRIPTION: Es una descripción de la entrada.
  - ENTRY_CREATE_TIMESTAMP: Es la hora en que se creó la entrada en el sistema de origen.
  - ENTRY_UPDATE_TIMESTAMP: la hora en que se actualizó la entrada en el sistema de origen.
- aspects: Son los aspectos que se adjuntan a la entrada. El objeto aspect y sus datos se denominan mapa de aspectos.
  - ASPECT: un aspecto que se adjunta a la entrada. Según cómo se adjunte el aspecto a la entrada, usa uno de los siguientes formatos:
    - Si el aspecto se adjunta directamente a la entrada, proporciona el nombre del recurso relativo de su tipo de aspecto, en el formato PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID.
    - Si el aspecto se adjunta a la ruta de acceso de la entrada, proporciona la ruta de acceso del tipo de aspecto, en el formato PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID@PATH.
  - KEY y VALUE: Es el contenido del aspecto, según su plantilla de metadatos de tipo de aspecto. El contenido debe estar codificado en UTF-8. El tamaño máximo del campo es de 120 KB. El diccionario data es obligatorio, incluso si está vacío.
  - ASPECT_CREATE_TIMESTAMP: Es la hora en la que se creó el aspecto en el sistema de origen.
  - ASPECT_UPDATE_TIMESTAMP: Es la hora en que se actualizó el aspecto en el sistema de origen.
- PARENT_ENTRY: Es el nombre del recurso de la entrada superior.
- FULLY_QUALIFIED_NAME: un nombre para la entrada al que puede hacer referencia un sistema externo. Consulta Nombres completamente calificados.
UPDATE_MASK_FIELDS: Son los campos que se actualizarán, en rutas de acceso relativas al recurso Entry. Separa cada campo con una coma.

En un trabajo de sincronización de entrada completa, Knowledge Catalog incluye las rutas de acceso de todos los campos de una entrada que se pueden modificar, incluidos los aspectos. El campo updateMask se ignora cuando se crea o se vuelve a crear una entrada.

En un trabajo de metadatos de solo aspecto, establece este valor en aspects.
ASPECT_KEY: Son los aspectos que se modificarán. Admite las siguientes sintaxis:
- ASPECT_TYPE_REFERENCE: coincide con el tipo de aspecto para los aspectos que se adjuntan directamente a la entrada.
- ASPECT_TYPE_REFERENCE@PATH: coincide con el tipo de aspecto y la ruta de acceso especificada.
- ASPECT_TYPE_REFERENCE@*: Coincide con el tipo de aspecto para todas las rutas de acceso.
- *@PATH: Coincide con todos los tipos de aspectos en la ruta de acceso especificada.
Reemplaza ASPECT_TYPE_REFERENCE por una referencia al tipo de aspecto, en el formato PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID.

En un trabajo de sincronización de entradas completo, si dejas este campo vacío, se trata como si se especificaran exactamente los aspectos que están presentes en la entrada especificada. Knowledge Catalog agrega de forma implícita las claves para todos los aspectos obligatorios de una entrada.

Requisitos de los archivos

El archivo de importación de metadatos tiene los siguientes requisitos:

El archivo debe tener el formato de un archivo de líneas JSON, que es un archivo JSON delimitado por saltos de línea. Usa un carácter de línea nueva (0x0a) para separar cada elemento de importación.
El archivo debe usar la codificación de caracteres UTF-8.
Las extensiones de archivo admitidas son .jsonl y .json.
El tamaño de cada archivo de importación de metadatos debe ser inferior a 1 GiB. El tamaño total máximo de todos los datos en el trabajo de metadatos es de 3 GB. Esto incluye todos los archivos y metadatos asociados al trabajo.
Los tipos de entrada y de aspecto que especifiques en el archivo deben formar parte del permiso del trabajo de metadatos.
El archivo se debe subir a un bucket de Cloud Storage. No guardes el archivo en una carpeta llamada CLOUD_STORAGE_URI/deletions/.

Lógica de comparación

Knowledge Catalog determina qué entradas y aspectos modificar comparando los valores y las marcas de tiempo que proporcionas en el archivo de importación de metadatos con los valores y las marcas de tiempo que existen en tu proyecto.

En un nivel alto, Knowledge Catalog actualiza los valores de tu proyecto cuando al menos un cambio propuesto en el archivo de importación de metadatos cambie el estado de tu proyecto cuando se ejecute el trabajo, sin introducir datos desactualizados. Se debe hacer referencia al cambio propuesto en el campo de máscara de actualización o en el campo de claves de aspecto en el archivo de importación de metadatos.

La lógica de comparación varía según el tipo de trabajo de importación de metadatos que ejecutes.

Trabajo de sincronización de entradas completo

En un trabajo de metadatos de sincronización de entradas completo, para cada entrada que forma parte del alcance del trabajo, Knowledge Catalog hace una de las siguientes acciones:

Crea una entrada y aspectos adjuntos. Si el archivo de importación de metadatos incluye una entrada que no existe en tu proyecto, Knowledge Catalog crea la entrada y los aspectos adjuntos.
Borra una entrada y los aspectos adjuntos. Si existe una entrada en tu proyecto, pero el archivo de importación de metadatos no la incluye, Knowledge Catalog borra la entrada y sus aspectos adjuntos de tu proyecto.
Actualiza una entrada y los aspectos adjuntos. Si existe una entrada tanto en el archivo de importación de metadatos como en tu proyecto, Knowledge Catalog evalúa las marcas de tiempo de origen de la entrada y las marcas de tiempo de origen del aspecto que están asociadas con la entrada para determinar qué valores modificar. Luego, Knowledge Catalog realiza una o más de las siguientes acciones:
- Vuelve a crear la entrada. Si la marca de tiempo de creación de la fuente de entrada en el archivo de importación de metadatos es más reciente que la marca de tiempo correspondiente en tu proyecto, Knowledge Catalog vuelve a crear la entrada en tu proyecto.
- Actualiza la entrada. Si la marca de tiempo de actualización de la fuente de la entrada en el archivo de importación de metadatos es más reciente que la marca de tiempo correspondiente en tu proyecto, Knowledge Catalog actualiza la entrada en tu proyecto.
- Crea un aspecto. Si un aspecto no existe en tu proyecto y se incluye en un mapa de aspectos, el campo de máscara de actualización y el campo de claves de aspecto en el archivo de importación de metadatos, Knowledge Catalog crea el aspecto.
- Borra un aspecto. Si existe un aspecto en tu proyecto y se incluye en el campo de máscara de actualización y en el campo de claves de aspecto del archivo de importación de metadatos, pero no se incluye en un mapa de aspectos, Knowledge Catalog borra el aspecto.
- Actualiza un aspecto. Si existe un aspecto en tu proyecto y se incluye en un mapa de aspectos, el campo de máscara de actualización y el campo de claves de aspecto en el archivo de importación de metadatos, y la marca de tiempo de actualización de la fuente del aspecto en el archivo de importación de metadatos es más reciente que la marca de tiempo correspondiente en tu proyecto, Knowledge Catalog actualiza el aspecto.
  
  Si no se proporciona una marca de tiempo de actualización de la fuente del aspecto en el archivo de importación de metadatos, pero la entrada correspondiente está marcada para una actualización, Knowledge Catalog también actualiza el aspecto.
  
  Sin embargo, si al menos un aspecto del archivo de importación de metadatos tiene una marca de tiempo anterior a la correspondiente en tu proyecto, Knowledge Catalog no realiza ninguna actualización para la entrada adjunta.

Trabajo solo de aspecto

En un trabajo de metadatos solo de aspectos, para cada aspecto que forma parte del alcance del trabajo, Knowledge Catalog hace una de las siguientes acciones:

Crea un aspecto. Si un aspecto no existe en tu proyecto y se incluye en un mapa de aspectos, el campo de máscara de actualización y el campo de claves de aspecto en el archivo de importación de metadatos, Knowledge Catalog crea el aspecto.
Borra un aspecto. En el caso de los aspectos opcionales, si el aspecto existe en tu proyecto y se incluye en el campo de máscara de actualización y en el campo de claves de aspecto en el archivo de importación de metadatos, pero no se incluye en un mapa de aspectos, Knowledge Catalog borra el aspecto.

No se pueden borrar los aspectos obligatorios.
Actualiza un aspecto. Si existe un aspecto en tu proyecto y se incluye en un mapa de aspectos, el campo de máscara de actualización y el campo de claves de aspecto en el archivo de importación de metadatos, y la marca de tiempo de actualización de la fuente del aspecto en el archivo de importación de metadatos es más reciente que la marca de tiempo correspondiente en tu proyecto, Knowledge Catalog actualiza el aspecto.

Si no se proporciona una marca de tiempo de actualización de la fuente del aspecto en el archivo de importación de metadatos, Knowledge Catalog también actualiza el aspecto.

Knowledge Catalog actualiza los aspectos según la marca de tiempo de actualización de la fuente del aspecto, independientemente de la marca de tiempo de actualización de la fuente de la entrada correspondiente.

Crea un archivo de importación de metadatos

Antes de importar metadatos, crea un archivo de importación de metadatos para tu trabajo. Sigue estos pasos:

Prepara un archivo de importación de metadatos siguiendo los lineamientos que se describen anteriormente en este documento.
Sube el archivo a un bucket de Cloud Storage.

Puedes proporcionar varios archivos de importación de metadatos en el mismo trabajo de metadatos. Para proporcionar varios archivos, guárdalos en el mismo bucket de Cloud Storage. Cuando ejecutas el trabajo, especificas un bucket, no un archivo específico. Knowledge Catalog importa metadatos de todos los archivos que se guardan en el bucket, incluidos los archivos que se encuentran en subcarpetas.

Ejecuta un trabajo de importación de metadatos

Después de crear un archivo de importación de metadatos, ejecuta el trabajo de importación de metadatos.

REST

Para importar metadatos, usa el método metadataJobs.create.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_NUMBER: Es el número o el ID del proyecto de Google Cloud .
LOCATION_ID: Es la ubicación de Google Cloud , como us-central1.
METADATA_JOB_ID: es opcional. Es el ID del trabajo de metadatos.
CLOUD_STORAGE_URI: Es el URI del bucket o la carpeta de Cloud Storage que contiene los archivos de importación de metadatos. Para obtener más información sobre los requisitos de los archivos, consulta Archivo de importación de metadatos.
ENTRY_GROUP: Es el nombre de recurso relativo de los grupos de entradas que están dentro del alcance del trabajo, en el formato projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryGroups/ENTRY_GROUP_ID. Para obtener más información, consulta Alcance del trabajo.
ENTRY_TYPE: Es el nombre de recurso relativo de un tipo de entrada que está dentro del alcance del trabajo, en el formato projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/entryTypes/ENTRY_TYPE_ID. Para obtener más información, consulta Alcance del trabajo.
ASPECT_TYPE: Es el nombre de recurso relativo de un tipo de aspecto que está dentro del alcance del trabajo, con el formato projects/PROJECT_ID_OR_NUMBER/locations/LOCATION_ID/aspectTypes/ASPECT_TYPE_ID. Es opcional cuando se crea un trabajo de sincronización de entradas completo y obligatorio cuando se crea un trabajo solo de aspectos. Para obtener más información, consulta Alcance del trabajo.
ENTRY_SYNC_MODE: Es el modo de sincronización de entradas, como FULL o NONE. Para obtener más información, consulta Modo de sincronización.
LOG_LEVEL: Es el nivel de registros que se capturarán, como INFO o DEBUG. Para obtener más información, consulta Visualiza los registros de trabajos y soluciona problemas.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

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

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: Con el siguiente comando, se supone que accediste a gcloud CLI con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login , o a través del uso de Cloud Shell, que accede de forma automática a gcloud CLI . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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)

Nota: El siguiente comando supone que accediste a gcloud CLI con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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 respuesta identifica una operación de larga duración.

Obtén detalles sobre un trabajo de metadatos

Para obtener información sobre un trabajo de metadatos, como el estado del trabajo y la cantidad de entradas que se modificaron, sigue estos pasos. Para obtener más información sobre cómo solucionar problemas de un trabajo con errores, consulta la sección Visualiza los registros de trabajos y soluciona problemas de este documento.

C#

Antes de probar este ejemplo, sigue las instrucciones de configuración para C# que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para C#.

Para autenticarte en Knowledge Catalog, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Go que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para 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

Antes de probar este ejemplo, sigue las instrucciones de configuración para Ruby que encontrarás en la guía de inicio rápido de Knowledge Catalog sobre las bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Knowledge Catalog para 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

Para obtener información sobre un trabajo de metadatos, usa el método metadataJobs.get.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

PROJECT_NUMBER: Es el número o el ID del proyecto de Google Cloud .
LOCATION_ID: Es la ubicación de Google Cloud , como us-central1.
METADATA_JOB_ID: Es el ID del trabajo de metadatos.

Método HTTP y URL:

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

Para enviar tu solicitud, expande una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el siguiente comando:

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)

Ejecuta el siguiente comando:

$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

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

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

Obtén una lista de trabajos de metadatos

Puedes obtener una lista de los trabajos de metadatos más recientes. Los trabajos más antiguos que alcanzaron un estado terminal se borran de forma periódica del sistema.

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

Para obtener una lista de los trabajos de metadatos más recientes, usa el método metadataJobs.list.

Cancela un trabajo de metadatos

Puedes cancelar un trabajo de metadatos que no quieras ejecutar.

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

Para cancelar un trabajo de metadatos, usa el método metadataJobs.cancel.

Visualiza los registros de trabajos y soluciona problemas

Usa Cloud Logging para ver los registros de un trabajo de metadatos. Para obtener más información, consulta Supervisa los registros de Knowledge Catalog.

Configura el nivel de registro cuando creas un trabajo de metadatos. Están disponibles los siguientes niveles de registro:

INFO: Proporciona registros a nivel general del trabajo. Incluye registros agregados sobre los elementos de importación, pero no especifica cuál de ellos tiene un error.
DEBUG: Proporciona registros detallados de cada elemento de importación. Usa el registro de nivel de depuración para solucionar problemas con elementos de importación específicos. Por ejemplo, usa el registro de nivel de depuración para identificar los recursos que faltan en el alcance del trabajo, las entradas o los aspectos que no se ajustan al tipo de entrada o aspecto asociado, o bien otros errores de configuración con el archivo de importación de metadatos.

Nota: Según el tamaño de tu trabajo de metadatos y la cantidad de registros que se generen, el registro de nivel de depuración puede generar costos adicionales. Para obtener más información, consulta los precios de Google Cloud Observability.

Errores de validación

Knowledge Catalog valida los archivos de importación de metadatos con los metadatos actuales de tu proyecto. Si hay un problema de validación, el estado del trabajo puede devolver uno de los siguientes estados:

FAILED: Se produce cuando el archivo de importación de metadatos tiene un error. Knowledge Catalog no importa ningún metadato y el trabajo falla. Estos son algunos ejemplos de errores en el archivo de importación de metadatos:
- No se puede analizar un elemento del archivo para convertirlo en un elemento de importación válido
- Una entrada o un aspecto del archivo pertenece a un grupo de entradas, un tipo de entrada o un tipo de aspecto que no forma parte del alcance del trabajo.
- Se especificó el mismo nombre de entrada más de una vez en el trabajo
- Un tipo de aspecto que se especifica en un mapa de aspectos o las claves de aspecto no usa el formato PROJECT_ID_OR_NUMBER.LOCATION_ID.ASPECT_TYPE_ID@OPTIONAL_PATH
- Se marcó un aspecto obligatorio para su eliminación
SUCCEEDED_WITH_ERRORS: Ocurre cuando el archivo de importación de metadatos se puede analizar correctamente, pero importar un elemento en el archivo haría que una entrada en tu proyecto esté en un estado incoherente. Knowledge Catalog ignora esas entradas, pero importa el resto de los metadatos del archivo.

Usa los registros de trabajos para solucionar el error.

Importa metadatos con una canalización personalizada Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Pasos de alto nivel

Antes de comenzar

Roles obligatorios

Crea recursos de Google Cloud

Componentes de un trabajo de importación de metadatos

Alcance del trabajo

Modo de sincronización

Archivo de importación de metadatos

Estructura del archivo

Estructura de un elemento de importación

Requisitos de los archivos

Lógica de comparación

Trabajo de sincronización de entradas completo

Trabajo solo de aspecto

Crea un archivo de importación de metadatos

Ejecuta un trabajo de importación de metadatos

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Obtén detalles sobre un trabajo de metadatos

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Obtén una lista de trabajos de metadatos

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

Cancela un trabajo de metadatos

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

Visualiza los registros de trabajos y soluciona problemas

Errores de validación

¿Qué sigue?

Importa metadatos con una canalización personalizada