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.

Cómo usar la calidad de los datos automática

En este documento, se describe cómo usar las exploraciones de calidad de los datos de Knowledge Catalog (anteriormente, Dataplex Universal Catalog) para medir, supervisar y administrar la calidad de tus datos. Las exploraciones de calidad de los datos te ayudan a automatizar el proceso de validación de tus datos para garantizar su integridad, validez y coherencia.

Con las exploraciones de calidad de los datos, puedes definir reglas para verificar si faltan valores, asegurarte de que los valores coincidan con una expresión regular o pertenezcan a un conjunto, verificar la unicidad o usar SQL personalizado para validaciones más complejas, como la detección de anomalías. En este documento, se explica cómo crear y administrar análisis de calidad de los datos.

Obtén más información sobre las exploraciones de calidad de los datos. Obtén más información para reutilizar reglas de calidad de los datos en varias verificaciones.

Antes de comenzar

Habilita la API de Dataplex si aún no está habilitada.
Roles necesarios para habilitar las APIs
Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtenerlo a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén información para otorgar roles.
Habilitar la API
Opcional: Para generar recomendaciones de reglas de calidad de los datos basadas en los resultados de un análisis de perfiles de datos, crea y ejecuta el análisis de perfiles de datos.

Roles y permisos requeridos

En esta sección, se describen los roles y los permisos de IAM necesarios para usar los análisis de calidad de los datos de Knowledge Catalog.

Roles y permisos de los usuarios

Para obtener los permisos que necesitas para ejecutar y administrar análisis de calidad de los datos, pídele a tu administrador que te otorgue los siguientes roles de IAM:

Ejecuta un análisis de calidad de los datos en una tabla de BigQuery:
- Usuario de trabajo de BigQuery (roles/bigquery.jobUser) en el proyecto para ejecutar trabajos de análisis
- Visualizador de datos de BigQuery (roles/bigquery.dataViewer) en la tabla de BigQuery que se analizará
Publica los resultados de la verificación de calidad de los datos en Knowledge Catalog:
- Editor de datos de BigQuery (roles/bigquery.dataEditor) en la tabla analizada
- Editor del catálogo de Dataplex (roles/dataplex.catalogEditor) en el grupo de entradas @bigquery en la misma ubicación que la tabla
Realizar tareas específicas en recursos de DataScan:
- Administrador de DataScan de Dataplex (roles/dataplex.dataScanAdmin) en el proyecto para obtener acceso completo
- Creador de DataScan de Dataplex (roles/dataplex.dataScanCreator) en el proyecto para crear análisis
- Editor de DataScan de Dataplex (roles/dataplex.dataScanEditor) en el proyecto para obtener acceso de escritura
- Visualizador de DataScan de Dataplex (roles/dataplex.dataScanViewer) en el proyecto para leer los metadatos del análisis
- Visualizador de datos de DataScan de Dataplex (roles/dataplex.dataScanDataViewer) en el proyecto para leer los datos del análisis, incluidas las reglas y los resultados

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

Estos roles predefinidos contienen los permisos necesarios para ejecutar y administrar análisis de calidad de los datos. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para ejecutar y administrar análisis de calidad de los datos:

Ejecuta un análisis de calidad de los datos en una tabla de BigQuery:
- bigquery.jobs.create en el proyecto para ejecutar trabajos de análisis
- bigquery.tables.get en la tabla de BigQuery que se analizará
- bigquery.tables.getData en la tabla de BigQuery que se analizará
Publica los resultados de la verificación de calidad de los datos en Knowledge Catalog:
- bigquery.tables.update en la tabla analizada
- dataplex.entryGroups.useDataQualityScorecardAspect en el grupo de entradas @bigquery en la misma ubicación que la tabla
Crea un DataScan: dataplex.datascans.create en el proyecto
Borra un DataScan: dataplex.datascans.delete en el proyecto.
Visualiza los metadatos de DataScan: dataplex.datascans.get en el proyecto
Consulta los detalles de DataScan, incluidas las reglas y los resultados: dataplex.datascans.getData en el proyecto
Enumera DataScan: dataplex.datascans.list en el proyecto
Ejecuta un DataScan: dataplex.datascans.run en el proyecto
Actualiza un DataScan: dataplex.datascans.update en el proyecto
Obtén o establece la política de IAM en un DataScan:
- dataplex.datascans.getIamPolicy en el proyecto
- dataplex.datascans.setIamPolicy en el proyecto

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Si necesitas acceder a columnas protegidas por políticas de acceso a nivel de columna de BigQuery, también necesitas permisos para esas columnas.

Roles y permisos de la cuenta de servicio de Knowledge Catalog

Si no creaste ningún análisis de calidad de los datos o análisis del perfil de datos, o no tienes un lake de Knowledge Catalog en este proyecto, crea un identificador de servicio ejecutando el siguiente comando: gcloud beta services identity create --service=dataplex.googleapis.com. Este comando devuelve un identificador de servicio de Knowledge Catalog si existe.

Para garantizar que la cuenta de servicio de Knowledge Catalog del proyecto que contiene la exploración de calidad de los datos tenga los permisos necesarios para leer datos de varias fuentes y exportar resultados, pídele a tu administrador que otorgue los siguientes roles de IAM a la cuenta de servicio de Knowledge Catalog del proyecto que contiene la exploración de calidad de los datos:

Lee los datos de la tabla de BigQuery: Visualizador de datos de BigQuery (roles/bigquery.dataViewer) en las tablas que se analizarán y cualquier otra tabla a la que se haga referencia en las reglas
Lee los datos de las tablas de Lakehouse de Apache Hive, Delta Lake de SAP Business Data Cloud y el catálogo de REST de Iceberg en Google Cloud : Visualizador de BigLake (roles/biglake.viewer) en las tablas respectivas que se analizarán y cualquier otra tabla a la que se haga referencia en las reglas
Exporta los resultados del análisis a una tabla de BigQuery: Editor de datos de BigQuery (roles/bigquery.dataEditor) en el conjunto de datos y la tabla de resultados
Analiza los datos de BigQuery organizados en un lake de Knowledge Catalog:
- Lector de metadatos de Dataplex (roles/dataplex.metadataReader) en recursos de Dataplex
- Visualizador de Dataplex (roles/dataplex.viewer) en los recursos de Dataplex
Analiza una tabla externa de BigQuery desde Cloud Storage: Visualizador de objetos de almacenamiento (roles/storage.objectViewer) en el bucket de Cloud Storage

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

Estos roles predefinidos contienen los permisos necesarios para leer datos de varias fuentes y exportar resultados. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para leer datos de varias fuentes y exportar resultados:

Lee los datos de la tabla de BigQuery:
- bigquery.tables.get en tablas de BigQuery
- bigquery.tables.getData en tablas de BigQuery
Exporta los resultados del análisis a una tabla de BigQuery:
- bigquery.datasets.get en el conjunto de datos y la tabla de resultados
- bigquery.tables.create en el conjunto de datos y la tabla de resultados
- bigquery.tables.get en el conjunto de datos y la tabla de resultados
- bigquery.tables.getData en el conjunto de datos y la tabla de resultados
- bigquery.tables.update en el conjunto de datos y la tabla de resultados
- bigquery.tables.updateData en el conjunto de datos y la tabla de resultados
Analiza los datos de BigQuery organizados en un lake de Knowledge Catalog:
- dataplex.lakes.list en los recursos de Dataplex
- dataplex.lakes.get en los recursos de Dataplex
- dataplex.zones.list en los recursos de Dataplex
- dataplex.zones.get en los recursos de Dataplex
- dataplex.entities.list en los recursos de Dataplex
- dataplex.entities.get en los recursos de Dataplex
- dataplex.operations.get en los recursos de Dataplex
Analiza una tabla externa de BigQuery desde Cloud Storage:
- storage.buckets.get en el bucket de Cloud Storage
- storage.objects.get en el bucket de Cloud Storage

Es posible que tu administrador también pueda otorgar estos permisos a la cuenta de servicio de Knowledge Catalog del proyecto que contiene el análisis de calidad de los datos con roles personalizados o con otros roles predefinidos.

Si necesitas acceder a columnas protegidas por políticas de acceso a nivel de columna de BigQuery, asigna los permisos de la cuenta de servicio de Knowledge Catalog para esas columnas.

Si una tabla tiene habilitadas las políticas de acceso a nivel de fila de BigQuery, solo puedes analizar las filas visibles para la cuenta de servicio de Knowledge Catalog. Ten en cuenta que los privilegios de acceso del usuario individual no se evalúan para las políticas a nivel de fila.

Requisitos de Herramientas de redes

Para ejecutar un análisis, debes habilitar el Acceso privado a Google en la subred de VPC que usas para el análisis. Si no especificas una subred, asegúrate de que la subred predeterminada tenga habilitado el Acceso privado a Google.

Define reglas de calidad de los datos

Puedes definir reglas de calidad de los datos con lo siguiente:

Reglas integradas
Verificaciones de SQL personalizadas
Reglas reutilizables, incluidas las plantillas de reglas del sistema

Si usas Google Cloud CLI, puedes definir estas reglas en un archivo JSON o YAML.

En los ejemplos de las siguientes secciones, se muestra cómo definir una variedad de reglas de calidad de los datos. Las reglas validan una tabla de muestra que contiene datos sobre las transacciones de los clientes. Supongamos que la tabla tiene el siguiente esquema:

Nombre de la columna	Tipo de columna	Descripción de la columna
transaction_timestamp	Marca de tiempo	Es la marca de tiempo de la transacción. La tabla está particionada en este campo.
customer_id	String	Un ID de cliente con el formato de 8 letras seguidas de 16 dígitos.
transaction_id	String	El ID de transacción debe ser único en toda la tabla.
currency_id	String	Es una de las monedas admitidas. El tipo de moneda debe coincidir con una de las monedas disponibles en la tabla de dimensiones `dim_currency`.
importe	float	Es el importe de la transacción.
discount_pct	float	Es el porcentaje de descuento. Este valor debe estar entre 0 y 100.

Define reglas de calidad de los datos con tipos de reglas integrados

Los siguientes ejemplos se basan en tipos de reglas integradas. Puedes crear reglas basadas en tipos de reglas integrados con la consola de Google Cloud o la API. Knowledge Catalog podría recomendar algunas de estas reglas.

Nombre de la columna	Tipo de regla	Dimensión sugerida	Parámetros de regla
`transaction_id`	Verificación de unicidad	Unicidad	Umbral: `Not Applicable`
`amount`	Verificación de valores nulos	Integridad	Umbral: `100%`
`customer_id`	Verificación de regex (expresión regular)	Validez	Expresión regular: `^[a-zA-Z]{8}[0-9]{16}$` Umbral: `100%`
`currency_id`	Verificación del valor establecido	Validez	Conjunto de: `USD,JPY,INR,GBP,CAN` Umbral: `100%`

Define reglas de calidad de los datos con reglas de SQL personalizadas

Para crear reglas de SQL personalizadas, usa el siguiente framework:

Cuando crees una regla que evalúe una fila a la vez, crea una expresión que genere la cantidad de filas exitosas cuando Knowledge Catalog evalúe la consulta SELECT COUNTIF(CUSTOM_SQL_EXPRESSION) FROM TABLE. Knowledge Catalog compara la cantidad de filas correctas con el umbral.
Cuando creas una regla que evalúa las filas o usa una condición de tabla, crea una expresión que devuelva un resultado de éxito o falla cuando Knowledge Catalog evalúe la consulta SELECT IF(CUSTOM_SQL_EXPRESSION) FROM TABLE.
Cuando crees una regla que evalúe el estado no válido de un conjunto de datos, proporciona una instrucción que devuelva filas no válidas. Si se devuelven filas, la regla falla. Omite el punto y coma final de la instrucción de SQL.
Puedes hacer referencia a una tabla de fuente de datos y a todos sus filtros de condición previa con el parámetro de referencia de datos ${data()} en una regla, en lugar de mencionar de forma explícita la tabla de origen y sus filtros. Algunos ejemplos de filtros de condiciones previas son los filtros de filas, los porcentajes de muestreo y los filtros incrementales. El parámetro ${data()} distingue mayúsculas de minúsculas.

Los siguientes ejemplos se basan en reglas de SQL personalizadas.

Tipo de regla	Descripción de la regla	Expresión SQL
Condición de fila	Verifica si el valor de `discount_pct` está entre 0 y 100.	`0` <`discount_pct` AND `discount_pct` < `100`
Condición de fila	Verificación de referencia para validar que `currency_id` sea una de las monedas admitidas.	`currency_id in (select id from my_project_id.dim_dataset.dim_currency)`
Estado de la tabla	Expresión de SQL de agregación que verifica si el promedio de `discount_pct` está entre el 30% y el 50%.	`30<avg(discount) AND avg(discount) <50`
Condición de fila	Verifica si una fecha no es futura.	`TIMESTAMP(transaction_timestamp) < CURRENT_TIMESTAMP()`
Estado de la tabla	Una función definida por el usuario (UDF) de BigQuery para verificar que el importe promedio de las transacciones sea inferior a un valor predefinido por país Crea la UDF (JavaScript) ejecutando el siguiente comando: CREATE OR REPLACE FUNCTION myProject.myDataset.average_by_country ( country STRING, average FLOAT64) RETURNS BOOL LANGUAGE js AS R""" if (country = "CAN" && average < 5000){ return 1 } else if (country = "IND" && average < 1000){ return 1 } else { return 0 } """;	Regla de ejemplo para verificar el importe promedio de las transacciones de `country=CAN`. myProject.myDataset.average_by_country( "CAN", (SELECT avg(amount) FROM myProject.myDataset.transactions_table WHERE currency_id = 'CAN' ))
Estado de la tabla	Una cláusula de predicción de BigQuery ML para identificar anomalías en `discount_pct`. Verifica si se debe aplicar un descuento en función de `customer`, `currency` y `transaction`. La regla verifica si la predicción coincide con el valor real, al menos el 99% de las veces. Suposición: El modelo de AA se crea antes de usar la regla. Crea el modelo de AA con el siguiente comando: CREATE MODEL model-project-id.dataset-id.model-name OPTIONS(model_type='logistic_reg') AS SELECT IF(discount_pct IS NULL, 0, 1) AS label, IFNULL(customer_id, "") AS customer, IFNULL(currency_id, "") AS currency, IFNULL(amount, 0.0) AS amount FROM `data-project-id.dataset-id.table-names` WHERE transaction_timestamp < '2022-01-01';	La siguiente regla verifica si la exactitud de la predicción es superior al 99%. SELECT accuracy > 0.99 FROM ML.EVALUATE (MODEL model-project-id.dataset-id.model-name, ( SELECT customer_id, currency_id, amount, discount_pct FROM data-project-id.dataset-id.table-names WHERE transaction_timestamp > '2022-01-01'; ) )
Condición de fila	Una función de predicción de BigQuery ML para identificar anomalías en `discount_pct`. La función verifica si se debe aplicar un descuento según `customer`, `currency` y `transaction`. La regla identifica todas las instancias en las que la predicción no coincidió. Suposición: El modelo de AA se crea antes de usar la regla. Crea el modelo de AA con el siguiente comando: CREATE MODEL model-project-id.dataset-id.model-name OPTIONS(model_type='logistic_reg') AS SELECT IF(discount_pct IS NULL, 0, 1) AS label, IFNULL(customer_id, "") AS customer, IFNULL(currency_id, "") AS currency, IFNULL(amount, 0.0) AS amount FROM `data-project-id.dataset-id.table-names` WHERE transaction_timestamp < '2022-01-01';	La siguiente regla verifica si la predicción de descuento coincide con el valor real para cada fila. IF(discount_pct > 0, 1, 0) =(SELECT predicted_label FROM ML.PREDICT( MODEL model-project-id.dataset-id.model-name, ( SELECT customer_id, currency_id, amount, discount_pct FROM data-project-id.dataset-id.table-names AS t WHERE t.transaction_timestamp = transaction_timestamp LIMIT 1 ) ) )
Aserción de SQL	Valida si el `discount_pct` es superior al 30% para hoy verificando si existe alguna fila con un porcentaje de descuento inferior o igual a 30.	`SELECT * FROM my_project_id.dim_dataset.dim_currency WHERE discount_pct <= 30 AND transaction_timestamp >= current_date()`
Aserción de SQL (con parámetro de referencia de datos)	Verifica si el `discount_pct` es superior al 30% para todas las monedas admitidas hoy. El filtro de fecha `transaction_timestamp >= current_date()` se aplica como un filtro de fila en la tabla de la fuente de datos. El parámetro de referencia de datos `${data()}` actúa como un marcador de posición para `my_project_id.dim_dataset.dim_currency WHERE transaction_timestamp >= current_date()` y aplica el filtro de filas.	`SELECT * FROM ${data()} WHERE discount_pct > 30`

Define reglas de calidad de los datos con gcloud CLI

En el siguiente archivo YAML de ejemplo, se usan algunas de las mismas reglas que en las reglas de ejemplo que usan tipos integrados y las reglas de SQL personalizadas de ejemplo. Este archivo YAML también contiene otras especificaciones para el análisis de calidad de los datos, como filtros y porcentaje de muestreo. Cuando usas gcloud CLI para crear o actualizar un análisis de calidad de los datos, puedes usar un archivo YAML como este como entrada para el argumento --data-quality-spec-file.

rules:
- uniquenessExpectation: {}
  column: transaction_id
  dimension: UNIQUENESS
- nonNullExpectation: {}
  column: amount
  dimension: COMPLETENESS
  threshold: 1
- regexExpectation:
    regex: '^[a-zA-Z]{8}[0-9]{16}$'
  column : customer_id
  ignoreNull : true
  dimension : VALIDITY
  threshold : 1
- setExpectation :
    values :
    - 'USD'
    - 'JPY'
    - 'INR'
    - 'GBP'
    - 'CAN'
  column : currency_id
  ignoreNull : true
  dimension : VALIDITY
  threshold : 1
- rangeExpectation:
    minValue : '0'
    maxValue : '100'
  column : discount_pct
  ignoreNull : true
  dimension : VALIDITY
  threshold : 1
- rowConditionExpectation:
    sqlExpression : 0 < `discount_pct` AND `discount_pct` < 100
  column: discount_pct
  dimension: VALIDITY
  threshold: 1
- rowConditionExpectation:
    sqlExpression : currency_id in (select id from `my_project_id.dim_dataset.dim_currency`)
  column: currency_id
  dimension: VALIDITY
  threshold: 1
- tableConditionExpectation:
    sqlExpression : 30 < avg(discount_pct) AND avg(discount_pct) < 50
  dimension: VALIDITY
- rowConditionExpectation:
    sqlExpression : TIMESTAMP(transaction_timestamp) < CURRENT_TIMESTAMP()
  column: transaction_timestamp
  dimension: VALIDITY
  threshold: 1
- sqlAssertion:
    sqlStatement : SELECT * FROM `my_project_id.dim_dataset.dim_currency` WHERE discount_pct > 100
  dimension: VALIDITY
  debugQueries:
  - sqlStatement: SELECT MAX(discount_pct) FROM `my_project_id.dim_dataset.dim_currency`
samplingPercent: 50
rowFilter: discount_pct > 100
postScanActions:
  bigqueryExport:
    resultsTable: projects/my_project_id/datasets/dim_dataset/tables/dim_currency
  notificationReport:
    recipients:
      emails:
      - '222larabrown@gmail.com'
      - 'cloudysanfrancisco@gmail.com'
    scoreThresholdTrigger:
      scoreThreshold: 50
    jobFailureTrigger: {}
    jobEndTrigger: {}
catalogPublishingEnabled: true

Configura la identidad de ejecución

De forma predeterminada, los análisis de calidad de los datos se ejecutan con la cuenta de servicio de Knowledge Catalog. Puedes anular esto para usar una cuenta de servicio personalizada o tus propias credenciales de usuario final (EUC).

Si usas una identidad de ejecución personalizada, cambiará la forma en que se te factura por el análisis. Cuando especificas una identidad de ejecución personalizada, los costos de procesamiento y almacenamiento asociados con el análisis se facturan directamente a tu proyecto de BigQuery, lo que omite los SKU premium estándar de Knowledge Catalog.

Permisos necesarios para las identidades de ejecución personalizadas

Para configurar una cuenta de servicio personalizada o usar credenciales de usuario final, debes tener los siguientes permisos adicionales de Identity and Access Management (IAM):

Para usar una cuenta de servicio personalizada, necesitas lo siguiente:
- El permiso iam.serviceAccounts.actAs otorgado para el proyecto que contiene la cuenta de servicio (por ejemplo, roles/iam.serviceAccountUser).
- El agente de servicio de tu proyecto (service-PROJECT_NUMBER@gcp-sa-dataplex.iam.gserviceaccount.com) necesita el permiso iam.serviceAccounts.getAccessToken en la cuenta de servicio personalizada (por ejemplo, con el rol roles/iam.serviceAccountTokenCreator).
- La cuenta de servicio personalizada necesita bigquery.tables.getData en la tabla para analizar, bigquery.jobs.insert en el proyecto de análisis y bigquery.dataEditor en el conjunto de datos de exportación (si se usa la exportación).
Para usar las credenciales del usuario final, necesitas lo siguiente:
- bigquery.tables.getData en la tabla que se analizará.
- bigquery.jobs.insert en el proyecto de análisis.
- bigquery.dataEditor en el conjunto de datos de exportación (si se usa la exportación).

Para configurar la identidad de ejecución, selecciona una de las siguientes opciones:

Console

Para configurar la identidad de ejecución en la consola de Google Cloud , selecciona la identidad cuando crees tu análisis de calidad de los datos.

En la sección Identidad de ejecución, selecciona una de las siguientes opciones:

Agente de servicio de Dataplex: Es el comportamiento predeterminado.
Cuenta de servicio: Ingresa la dirección de correo electrónico de la cuenta de servicio que quieres usar.
Credencial de usuario: Usa tus propias credenciales para ejecutar el análisis.

REST

Para usar una cuenta de servicio personalizada, agrega el objeto executionIdentity a la definición del recurso DataScan durante la solicitud create:

"executionIdentity": {
  "serviceAccount": {
     "email": "YOUR_SERVICE_ACCOUNT_EMAIL"
  }
}

Reemplaza lo siguiente:

YOUR_SERVICE_ACCOUNT_EMAIL: Es la dirección de correo electrónico de la cuenta de servicio que deseas usar.

Para usar las credenciales de usuario final, especifica el objeto userCredential en su lugar:

"executionIdentity": {
  "userCredential": {}
}

Crea un análisis de calidad de los datos

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en Crear análisis de calidad de los datos.
En la ventana Define el análisis, completa los siguientes campos:
1. Ingresa un nombre visible (opcional).
2. Ingresa un ID. Consulta las convenciones de nomenclatura de recursos.
3. Escribe una descripción (opcional).
4. En el campo Tabla, haz clic en Explorar. Elige la tabla que quieres analizar y, luego, haz clic en Seleccionar. Solo se admiten las tablas de BigQuery estándar, Iceberg REST Catalog, SAP BDC Delta y Hive en Google Cloud Lakehouse.
  
  En el caso de las tablas de conjuntos de datos multirregionales, elige una región en la que se creará el análisis de datos.
  
  Para explorar las tablas organizadas en los lakes de Knowledge Catalog, haz clic en Explorar dentro de los lakes de Knowledge Catalog.
5. En el campo Alcance, elige Incremental o Datos completos.
  - Si eliges Incremental, en el campo Columna de marca de tiempo, selecciona una columna de tipo DATE o TIMESTAMP de tu tabla de BigQuery que aumente a medida que se agreguen registros nuevos y que se pueda usar para identificar registros nuevos. Puede ser una columna que particiona la tabla.
6. Opcional: Para filtrar tus datos, selecciona la casilla de verificación Filtrar filas. Proporciona un filtro de fila que consista en una expresión de SQL válida que se pueda usar como parte de una cláusula WHERE en la sintaxis de GoogleSQL. Por ejemplo, col1 >= 0. El filtro puede ser una combinación de varias condiciones de columna. Por ejemplo, col1 >= 0 AND col2 < 10.
7. Para muestrear tus datos, en la lista Tamaño de muestreo, selecciona un porcentaje de muestreo. Elige un valor de porcentaje que varíe entre 0.0% y 100.0% con hasta 3 dígitos decimales. Para conjuntos de datos más grandes, elige un porcentaje de muestreo más bajo. Por ejemplo, para una tabla de 1 PB, si ingresas un valor entre 0.1% y 1.0%, el análisis de calidad de los datos muestra entre 1 y 10 TB de datos. En el caso de los análisis de datos incrementales, el análisis de calidad de los datos aplica el muestreo al incremento más reciente.
8. Opcional: Para publicar los resultados del análisis de calidad de los datos como metadatos de Knowledge Catalog, selecciona la casilla de verificación Publicar resultados en Knowledge Catalog.
  
  Puedes ver los resultados del análisis más reciente en la pestaña Calidad de los datos de las páginas de BigQuery y Knowledge Catalog de la tabla de origen. Para permitir que los usuarios accedan a los resultados del análisis publicados, consulta la sección Otorga acceso a los resultados del análisis de calidad de los datos de este documento.
9. Para Tipo de credencial, consulta Configura la identidad de ejecución.
10. Para crear un análisis de calidad de los datos con reglas, selecciona Tipo de regla > Crear con regla basada en entradas.
11. En la sección Programación, elige una de las siguientes opciones:
  - Repetir: Ejecuta el análisis de calidad de los datos según un programa: cada hora, todos los días, todas las semanas, todos los meses o de forma personalizada. Especifica la frecuencia con la que se ejecuta el análisis y en qué momento. Si eliges la opción personalizada, usa el formato cron para especificar el programa.
  - A pedido: Ejecuta el análisis de calidad de los datos a pedido.
  - Ejecución única: Ejecuta el análisis de calidad de los datos una vez ahora y quítalo después del tiempo de eliminación automática. Esta función está en vista previa.
    - Establece la eliminación automática de los resultados posteriores al análisis: El tiempo de eliminación automática es el intervalo entre el momento en que se ejecuta el análisis y el momento en que se borra. Un análisis de calidad de los datos sin un tiempo de eliminación automática especificado se borra automáticamente 24 horas después de su ejecución. El tiempo de eliminación automática puede variar entre 0 segundos (eliminación inmediata) y 365 días.
12. Haz clic en Continuar.
En la ventana Reglas de calidad de los datos, define las reglas que se configurarán para esta verificación de calidad de los datos.
1. Haz clic en Agregar reglas y, luego, elige una de las siguientes opciones.
  - Recomendaciones basadas en perfiles: Crea reglas a partir de las recomendaciones basadas en un análisis de generación de perfiles de datos existente.
    1. Elige columnas: Selecciona las columnas para las que deseas obtener reglas recomendadas.
    2. Elegir proyecto para analizar: Si el análisis del perfil de datos se encuentra en un proyecto diferente del proyecto en el que creas el análisis de calidad de los datos, selecciona el proyecto del que deseas extraer los análisis del perfil.
    3. Elegir resultados de perfil: Selecciona uno o más resultados de perfil y, luego, haz clic en Aceptar. Esto propaga una lista de reglas sugeridas que puedes usar como punto de partida.
    4. Selecciona la casilla de verificación de las reglas que deseas agregar y, luego, haz clic en Seleccionar. Una vez seleccionadas, las reglas se agregan a tu lista de reglas actual. Luego, puedes editar las reglas.
  - Tipos de reglas integradas: Crea reglas a partir de reglas predefinidas. Consulta la lista de reglas predefinidas.
    1. Elegir columnas: Selecciona las columnas para las que quieres elegir reglas.
    2. Elegir tipos de reglas: Selecciona los tipos de reglas que deseas elegir y, luego, haz clic en Aceptar. Los tipos de reglas que aparecen dependen de las columnas que seleccionaste.
    3. Selecciona la casilla de verificación de las reglas que deseas agregar y, luego, haz clic en Seleccionar. Una vez seleccionadas, las reglas se agregan a tu lista de reglas actual. Luego, puedes editar las reglas.
  - Regla de verificación de fila de SQL: Crea una regla de SQL personalizada para aplicarla a cada fila.
    1. En Dimensión, elige una dimensión.
    2. En Umbral de aprobación, elige un porcentaje de registros que deben aprobar la verificación.
    3. En Nombre de la columna, elige una columna.
    4. En el campo Proporciona una expresión en SQL, ingresa una expresión en SQL que se evalúe como un valor booleano true (aprobado) o false (reprobado). Para obtener más información, consulta Tipos de reglas de SQL personalizadas compatibles y los ejemplos en Define reglas de calidad de los datos.
    5. Haz clic en Agregar.
  - Regla de verificación de agregación de SQL: Crea una regla de condición de tabla de SQL personalizada.
    1. En Dimensión, elige una dimensión.
    2. En Nombre de la columna, elige una columna.
    3. En el campo Proporciona una expresión en SQL, ingresa una expresión en SQL que se evalúe como un valor booleano true (aprobado) o false (reprobado). Para obtener más información, consulta Tipos de reglas de SQL personalizadas compatibles y los ejemplos en Define reglas de calidad de los datos.
    4. Haz clic en Agregar.
  - Regla de aserción de SQL: Crea una regla de aserción de SQL personalizada para verificar si hay un estado no válido de los datos.
    1. En Dimensión, elige una dimensión.
    2. Opcional: En Nombre de la columna, elige una columna.
    3. En el campo Proporciona una sentencia de SQL, ingresa una instrucción de SQL que devuelva filas que coincidan con el estado no válido. Si se devuelven filas, esta regla falla. Omite el punto y coma final de la sentencia de SQL. Para obtener más información, consulta Tipos de reglas de SQL personalizadas compatibles y los ejemplos en Define reglas de calidad de los datos.
    4. Haz clic en Agregar.
2. Opcional: Para cualquier regla de calidad de los datos, puedes asignar un nombre de regla personalizado que se usará para la supervisión y las alertas, y una descripción. Para ello, edita una regla y especifica los siguientes detalles:
  - Nombre de la regla: Ingresa un nombre de regla personalizado de hasta 63 caracteres. El nombre de la regla puede incluir letras (a-z, A-Z), dígitos (0-9) y guiones (-), y debe comenzar con una letra y terminar con un número o una letra.
  - Descripción: Ingresa una descripción de la regla con una longitud máxima de 1,024 caracteres.
3. Repite los pasos anteriores para agregar reglas adicionales a la exploración de calidad de los datos. Cuando termines, haz clic en Continuar.
Opcional: Exporta los resultados del análisis a una tabla estándar de BigQuery. En la sección Exporta los resultados del análisis a una tabla de BigQuery, haz lo siguiente:
1. En el campo Selecciona un conjunto de datos de BigQuery, haz clic en Explorar. Selecciona un conjunto de datos de BigQuery para almacenar los resultados del análisis de calidad de los datos.
2. En el campo Tabla de BigQuery, especifica la tabla para almacenar los resultados del análisis de calidad de los datos. Si usas una tabla existente, asegúrate de que sea compatible con el esquema de la tabla de exportación. Si la tabla especificada no existe, Knowledge Catalog la crea por ti.
  
  Nota: Puedes usar la misma tabla de resultados para varias verificaciones de calidad de los datos.
Opcional: Agrega etiquetas. Las etiquetas son pares clave-valor que te permiten agrupar objetos relacionados entre sí o con otros recursos de Google Cloud .
Opcional: Configura informes de notificaciones por correo electrónico para alertar a las personas sobre el estado y los resultados de un trabajo de análisis de calidad de los datos. En la sección Informe de notificaciones, haz clic en Agregar ID de correo electrónico y, luego, ingresa hasta cinco direcciones de correo electrónico. Luego, selecciona las situaciones para las que deseas enviar informes:
- Nivel de calidad (<=): Envía un informe cuando un trabajo se completa correctamente con un nivel de calidad de los datos inferior al nivel objetivo especificado. Ingresa una puntuación de calidad objetivo entre 0 y 100.
- Fallas del trabajo: Envía un informe cuando el trabajo falla, independientemente de los resultados de la calidad de los datos.
- Finalización del trabajo (éxito o fracaso): Envía un informe cuando finaliza el trabajo, independientemente de los resultados de la calidad de los datos.
Haz clic en Crear.

Después de crear el análisis, puedes ejecutarlo en cualquier momento haciendo clic en Ejecutar ahora.

gcloud

Para crear un análisis de calidad de los datos, usa el comando gcloud dataplex datascans create data-quality.

Si los datos de origen se organizan en un lake de Knowledge Catalog, incluye la marca --data-source-entity:

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-entity=DATA_SOURCE_ENTITY

Si los datos de origen no están organizados en un lake de Knowledge Catalog, incluye la marca --data-source-resource:

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-resource=DATA_SOURCE_RESOURCE

Reemplaza las siguientes variables:

DATASCAN: Es el nombre de la exploración de calidad de los datos.
LOCATION: Es la región de Google Cloud en la que se creará la exploración de calidad de los datos.
DATA_QUALITY_SPEC_FILE: Es la ruta de acceso al archivo JSON o YAML que contiene las especificaciones para la exploración de calidad de los datos. El archivo puede ser un archivo local o una ruta de acceso de Cloud Storage con el prefijo gs://. Usa este archivo para especificar las reglas de calidad de los datos para el análisis. También puedes especificar detalles adicionales en este archivo, como filtros, porcentaje de muestreo y acciones posteriores al análisis, como exportar a BigQuery o enviar informes de notificaciones por correo electrónico. Consulta la documentación para la representación JSON y el ejemplo de representación YAML.
DATA_SOURCE_ENTITY: Es la entidad de Knowledge Catalog que contiene los datos para el análisis de calidad de los datos. Por ejemplo, projects/test-project/locations/test-location/lakes/test-lake/zones/test-zone/entities/test-entity.
DATA_SOURCE_RESOURCE: Es el nombre del recurso que contiene los datos para la exploración de calidad de los datos. Por ejemplo, //bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table.

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.Api.Gax.ResourceNames;
using Google.Cloud.Dataplex.V1;
using Google.LongRunning;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for CreateDataScan</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 CreateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        CreateDataScanRequest request = new CreateDataScanRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            DataScan = new DataScan(),
            DataScanId = "",
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.CreateDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<DataScan, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataScan result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataScan, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceCreateDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataScan retrievedResult = retrievedResponse.Result;
        }
    }
}

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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

	resp, err := op.Wait(ctx)
	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.CreateDataScanRequest;
import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.LocationName;

public class SyncCreateDataScan {

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

  public static void syncCreateDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      CreateDataScanRequest request =
          CreateDataScanRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setDataScan(DataScan.newBuilder().build())
              .setDataScanId("dataScanId1260787906")
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.createDataScanAsync(request).get();
    }
  }
}

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.

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **



'use strict';

function main(parent, dataScan) {
  /**
   * 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:
   *  `projects/{project}/locations/{location_id}`
   *  where `project` refers to a *project_id* or *project_number* and
   *  `location_id` refers to a Google Cloud region.
   */
  // const parent = 'abc123'
  /**
   *  Required. DataScan resource.
   */
  // const dataScan = {}
  /**
   *  Optional. DataScan identifier. If not provided, a unique ID will be
   *  generated with the prefix "data-scan-".
   *  * Must contain only lowercase letters, numbers and hyphens.
   *  * Must start with a letter.
   *  * Must end with a number or a letter.
   *  * Must be between 1-63 characters.
   *  * Must be unique within the customer project / location.
   */
  // const dataScanId = 'abc123'
  /**
   *  Optional. Only validate the request, but do not perform mutations.
   *  The default is `false`.
   */
  // const validateOnly = true

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

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

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

    // Run request
    const [operation] = await dataplexClient.createDataScan(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateDataScan();
}

process.on('unhandledRejection', err => {
  console.error(err.message);
  process.exitCode = 1;
});
main(...process.argv.slice(2));

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.

# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import google.api_core.exceptions
from google.cloud import dataplex_v1


def create_data_quality_scan_global(
    project_id: str,
    dataset_id: str,
    table_id: str,
    location: str,
    column_id_1: str,
    column_id_2: str,
) -> None:
    """Creates a Dataplex Data Quality Scan using global API endpoint routing.

    Args:
        project_id (str): Google Cloud project ID where the scan is created.
        dataset_id (str): Target BigQuery dataset ID.
        table_id (str): Target BigQuery table ID to scan.
        location (str): Google Cloud region where serverless compute runs.
        column_id_1 (str): Name of the first column to evaluate.
        column_id_2 (str): Name of the second column to evaluate.
    """
    client = dataplex_v1.DataScanServiceClient()

    parent = client.common_location_path(project=project_id, location=location)

    # A bigquery table with at least 2 columns is assumed.
    bigquery_table = (
        f"//bigquery.googleapis.com/projects/{project_id}"
        f"/datasets/{dataset_id}/tables/{table_id}"
    )

    data_quality_spec = dataplex_v1.DataQualitySpec(
        rules=[
            dataplex_v1.DataQualityRule(
                name="global-null-assertion",
                dimension="COMPLETENESS",
                description="Fails if any row contains a null value",
                sql_assertion=dataplex_v1.DataQualityRule.SqlAssertion(
                    # Use ${data()} as the placeholder for the table Dataplex is scanning
                    sql_statement=(
                        "SELECT * FROM ${data()} "
                        f"WHERE {column_id_1} IS NULL OR {column_id_2} IS NULL"
                    )
                ),
            )
        ]
    )

    data_scan = dataplex_v1.DataScan(
        display_name="Global Data Quality Scan",
        data=dataplex_v1.DataSource(resource=bigquery_table),
        data_quality_spec=data_quality_spec,
    )

    request = dataplex_v1.CreateDataScanRequest(parent=parent, data_scan=data_scan)

    try:
        operation = client.create_data_scan(request=request)
        print(operation.result())
    except google.api_core.exceptions.AlreadyExists:
        print("A scan with this ID already exists.")
    except google.api_core.exceptions.InvalidArgument as e:
        print(f"Your scan configuration is invalid: {e}")
    except google.api_core.exceptions.GoogleAPIError as e:
        print(f"Unexpected exception: {e}")

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 create_data_scan call in the DataScanService 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::DataScanService::Client#create_data_scan.
#
def create_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

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

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

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Para crear una verificación de calidad de los datos, usa el método dataScans.create.

Con la siguiente solicitud, se crea un análisis único de la calidad de los datos:

POST https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataScans?data_scan_id=DATASCAN_ID

{
"data": {
  "resource": "//bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID"
},
"type": "DATA_QUALITY",
"executionSpec": {
  "trigger": {
    "oneTime": {
      "ttl_after_scan_completion": "120s"
    }
  }
},
"dataQualitySpec": {
  "rules": [
    {
      "nonNullExpectation": {},
      "column": "COLUMN_NAME",
      "dimension": "DIMENSION",
      "threshold": 1
    }
  ],
  "filter": "FILTER_CONDITION"
}
}

Reemplaza lo siguiente:

PROJECT_ID: ID del proyecto
LOCATION: Es la región en la que se creará el análisis de calidad de los datos.
DATASCAN_ID: Es el ID de la exploración de calidad de los datos.
DATASET_ID: Es el ID del conjunto de datos de BigQuery.
TABLE_ID: Es el ID de la tabla de BigQuery.
COLUMN_NAME: Es el nombre de la columna de la regla.
DIMENSION: Es la dimensión de la regla, por ejemplo, VALIDITY.
FILTER_CONDITION: Es una cadena de filtro AIP-160 opcional para ejecutar reglas de forma selectiva (por ejemplo, name = \"RULE_NAME\").

Si quieres crear reglas para el análisis de calidad de los datos con recomendaciones de reglas que se basen en los resultados de un análisis del perfil de datos, obtén las recomendaciones llamando al método dataScans.jobs.generateDataQualityRules en el análisis del perfil de datos.

Nota: Si tu tabla de BigQuery está configurada con el Filtro de partición obligatorio establecido en true, usa la columna de partición de BigQuery como el filtro de filas de análisis de calidad de los datos o la columna de marca de tiempo.

Esquema de la tabla de exportación

Para exportar los resultados del análisis de calidad de los datos a una tabla de BigQuery existente, asegúrate de que sea compatible con el siguiente esquema de tabla:

Nombre de la columna	Tipo de datos de la columna	Nombre del subcampo (si corresponde)	Tipo de datos del subcampo	Modo	Ejemplo
data_quality_scan	`struct/record`	`resource_name`	`string`	nullable	`//dataplex.googleapis.com/projects/test-project/locations/europe-west2/datascans/test-datascan`
		`project_id`	`string`	nullable	`dataplex-back-end-dev-project`
		`location`	`string`	nullable	`us-central1`
		`data_scan_id`	`string`	nullable	`test-datascan`
		`display_name`	`string`	nullable	`datascan-display-name`
data_source	`struct/record`	`resource_name`	`string`	nullable	Caso de entidad: `//dataplex.googleapis.com/projects/dataplex-back-end-dev-project/locations/europe-west2/lakes/a0-datascan-test-lake/zones/a0-datascan-test-zone/entities/table1` Caso de tabla: `//bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table`
		`dataplex_entity_project_id`	`string`	nullable	`dataplex-back-end-dev-project`
		`dataplex_entity_project_number`	`integer`	nullable	`123456789`
		`dataplex_lake_id`	`string`	nullable	(solo es válido si la fuente es una entidad) `test-lake`
		`dataplex_zone_id`	`string`	nullable	(solo es válido si la fuente es una entidad) `test-zone`
		`dataplex_entity_id`	`string`	nullable	(solo es válido si la fuente es una entidad) `test-entity`
		`table_project_id`	`string`	nullable	`test-project`
		`table_project_number`	`integer`	nullable	`987654321`
		`dataset_id`	`string`	nullable	(Solo es válido si la fuente es una tabla) `test-dataset`
		`table_id`	`string`	nullable	(Solo es válido si la fuente es una tabla) `test-table`
data_quality_job_id	`string`			nullable	`caeba234-cfde-4fca-9e5b-fe02a9812e38`
data_quality_job_configuration	`json`			nullable	`{"trigger": "ondemand", "incremental": true}`
job_labels	`json`			nullable	`{"key1":value1}`
job_start_time	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
job_end_time	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
job_quality_result	`struct/record`	`passed`	`boolean`	nullable	`true`/`false`
		`score`	`float`	nullable	`90.8`
		`incremental_start`	`string`	nullable	`2023-01-01T00:00:00`
		`incremental_end`	`string`	nullable	`2024-01-01T00:00:00`
job_dimension_result	`json`			nullable	`{"ACCURACY":{"passed":true,"score":100},"CONSISTENCY":{"passed":false,"score":60}}`
job_rows_scanned	`integer`			nullable	`7500`
rule_name	`string`			nullable	`test-rule`
rule_description	`string`			nullable	`Test rule description`
rule_type	`string`			nullable	`Range Check`
rule_evaluation_type	`string`			nullable	`Per row`
rule_column	`string`			nullable	`Rule only attached to a certain column`
rule_dimension	`string`			nullable	`UNIQUENESS`
rule_threshold_percent	`float`			nullable	(0.0-100.0) `Rule-threshold-pct in API * 100`
rule_parameters	`json`			nullable	`{min: 24, max:5345}`
rule_passed	`boolean`			nullable	`true`
rule_rows_evaluated	`integer`			nullable	`7400`
rule_rows_passed	`integer`			nullable	`3`
rule_rows_passed_percent	`float`			nullable	(0.0-100.0) `80.0` (indica 80%)
rule_rows_null	`integer`			nullable	`4`
rule_failed_records_query	`string`			nullable	"SELECT * FROM `test-project.test-dataset.test-table` WHERE (NOT((`cTime` >= '15:31:38.776361' and `cTime` <= '19:23:53.754823') IS TRUE));"
created_on	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
last_updated	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
rule_assertion_row_count	`integer`			nullable	`10`
debug_queries	`struct/record`	`description`	`string`	nullable	`Test debug query description`
		`sql_statement`	`string`	nullable	`SELECT MIN(col1) AS min_col1, AVG(col1) FROM ${data()}`
		`debug_query_results`	`struct/record`	repeated	`[{"name": "min_col1", "type": "INTEGER", "value": "5"}, {"type": "FLOAT", "value": "7"}]`
		↳ `name`	`string`	nullable	Es el nombre de la columna de resultados de la consulta, como `min_col1`.
		↳ `type`	`string`	nullable	Es el tipo de columna de resultado de la consulta, como `INTEGER`.
		↳ `value`	`string`	nullable	El valor de la columna de resultados de la consulta, como `5`
rule_attributes	`json`			nullable	`{"key": "value"}`
rule_source	`struct/record`	`rule_path_elements`	`struct/record`	repeated	`[{"entry_source": {"entry_type": "bigquery_table"}}]`
		↳ `entry_source`	`struct/record`	nullable	`{"entry_type": "bigquery_table"}`
		↳ `entry_type`	`string`	nullable	`bigquery_table`
		↳ `entry`	`string`	nullable	`projects/test-project/locations/us/entryGroups/@bigquery/entries/test-table`
		↳ `display_name`	`string`	nullable	`test-table`
		↳ `entry_link_source`	`struct/record`	nullable	`{"entry_link_type": "table_spec"}`
		↳ `entry_link_type`	`string`	nullable	`table_spec`
		↳ `entry_link`	`string`	nullable	`projects/test-project/locations/us/entryLinks/test-link`

Cuando configures BigQueryExport para un trabajo de análisis de calidad de los datos, sigue estos lineamientos:

Para el campo resultsTable, usa el siguiente formato: //bigquery.googleapis.com/projects/{project-id}/datasets/{dataset-id}/tables/{table-id}.
Usa una tabla estándar de BigQuery.
Si la tabla no existe cuando se crea o actualiza el análisis, Knowledge Catalog la crea por ti.
De forma predeterminada, la tabla se particiona en la columna job_start_time diariamente.
Si deseas que la tabla se particione en otras configuraciones o si no deseas la partición, vuelve a crear la tabla con el esquema y las configuraciones necesarios y, luego, proporciona la tabla creada previamente como la tabla de resultados.
Asegúrate de que la tabla de resultados esté en la misma ubicación que la tabla de origen.
Si se configuran los Controles del servicio de VPC en el proyecto, la tabla de resultados debe estar en el mismo perímetro de los Controles del servicio de VPC que la tabla de origen.
Si la tabla se modifica durante la etapa de ejecución del análisis, el trabajo en ejecución actual se exporta a la tabla de resultados anterior y el cambio de tabla se aplica a partir del siguiente trabajo de análisis.
No modifiques el esquema de la tabla. Si necesitas columnas personalizadas, crea una vista sobre la tabla.
Para reducir los costos, establece un vencimiento en la partición según tu caso de uso. Para obtener más información, consulta cómo configurar el vencimiento de la partición.

Ejecuta un análisis de calidad de los datos

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en el análisis de calidad de los datos que quieras ejecutar.
Haz clic en Ejecutar ahora.

gcloud

Para ejecutar un análisis de calidad de los datos, usa el comando gcloud dataplex datascans run:

gcloud dataplex datascans run DATASCAN \
--location=LOCATION \

Reemplaza las siguientes variables:

LOCATION: Es la región de Google Cloud en la que se creó la exploración de calidad de los datos.
DATASCAN: Es el nombre de la exploración de calidad de los datos.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for RunDataScan</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 RunDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        RunDataScanRequest request = new RunDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
        };
        // Make the request
        RunDataScanResponse response = dataScanServiceClient.RunDataScan(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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

Java

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.RunDataScanRequest;
import com.google.cloud.dataplex.v1.RunDataScanResponse;

public class SyncRunDataScan {

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

  public static void syncRunDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      RunDataScanRequest request =
          RunDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      RunDataScanResponse response = dataScanServiceClient.runDataScan(request);
    }
  }
}

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_run_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

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

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

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the run_data_scan call in the DataScanService 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::DataScanService::Client#run_data_scan.
#
def run_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

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

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

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

REST

Para ejecutar un análisis de calidad de los datos, usa el método dataScans.run.

Airflow

Para ejecutar un análisis de calidad de los datos con un grafo acíclico dirigido (DAG) en Managed Service para Apache Airflow (Cloud Composer), usa el DataplexRunDataQualityScanOperator:

from datetime import datetime
from airflow import DAG
from airflow.providers.google.cloud.operators.dataplex import DataplexRunDataQualityScanOperator

with DAG(
  "dataplex_auto_dq_scan",
  start_date=datetime(2026, 1, 1),
  schedule_interval="@daily",
  catchup=False,
) as dag:

  run_dq_scan = DataplexRunDataQualityScanOperator(
      task_id="run_dataplex_dq_scan",
      project_id="PROJECT_ID",
      region="REGION",
      data_scan_id="DATASCAN_ID",
  )

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto de Google Cloud .
REGION: Es la región de Google Cloud en la que se creó el análisis de calidad de los datos.
DATASCAN_ID: Es el ID de tu análisis de calidad de los datos.

Cancela un trabajo de análisis de calidad de los datos

Si un trabajo de análisis de calidad de los datos se ejecuta durante más tiempo del esperado o se inició con una configuración incorrecta, puedes cancelarlo. Esta es una operación de mejor esfuerzo. Si el trabajo ya está en un estado terminal (como SUCCEEDED o FAILED), se ignora la solicitud de cancelación.

Roles y permisos requeridos

Para obtener los permisos que necesitas para cancelar un trabajo de análisis de calidad de los datos, pídele a tu administrador que te otorgue el rol de IAM de editor de Dataplex (roles/dataplex.editor) o administrador de DataScan de Dataplex (roles/dataplex.dataScanAdmin) en tu proyecto.

Cancelar un trabajo

Puedes cancelar un trabajo de análisis de calidad de los datos en ejecución o pendiente con la API de REST.

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos.

Ir a Creación de perfiles de datos y calidad
Haz clic en el nombre de la exploración de calidad de los datos que contiene el trabajo que deseas cancelar.
En la pestaña Historial de trabajos, busca el trabajo con el estado En ejecución o Pendiente.
Haz clic en Cancelar junto al trabajo.

REST

Usa el método projects.locations.dataScans.jobs.cancel.

POST https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataScans/DATASCAN_ID/jobs/JOB_ID:cancel

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto.
LOCATION: Es la región en la que se encuentra el análisis de datos.
DATASCAN_ID: Es el ID del análisis de datos.
JOB_ID: Es el ID del trabajo que se cancelará.

Visualiza los resultados del análisis de calidad de los datos

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en el nombre de un análisis de calidad de los datos.
- En la sección Descripción general, se muestra información sobre los trabajos más recientes, incluido cuándo se ejecutó el análisis, la cantidad de registros analizados en cada trabajo, si se aprobaron todas las verificaciones de calidad de los datos y, si hubo fallas, la cantidad de verificaciones de calidad de los datos que fallaron.
- En la sección Configuración del análisis de la calidad de los datos, se muestran detalles sobre el análisis.
Para ver información detallada sobre un trabajo, como las puntuaciones de calidad de los datos que indican el porcentaje de reglas que se aprobaron, qué reglas fallaron y los registros de trabajos, haz clic en la pestaña Historial de trabajos. Luego, haz clic en un ID de tarea.

gcloud

Para ver los resultados de un trabajo de análisis de calidad de los datos, usa el comando gcloud dataplex datascans jobs describe:

gcloud dataplex datascans jobs describe JOB \
--location=LOCATION \
--datascan=DATASCAN \
--view=FULL

Reemplaza las siguientes variables:

JOB: Es el ID del trabajo de análisis de calidad de los datos.
LOCATION: Es la región de Google Cloud en la que se creó el análisis de calidad de los datos.
DATASCAN: Es el nombre de la exploración de calidad de los datos a la que pertenece el trabajo.
--view=FULL: Para ver el resultado del trabajo de análisis, especifica FULL.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for GetDataScan</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 GetDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        GetDataScanRequest request = new GetDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            View = GetDataScanRequest.Types.DataScanView.Unspecified,
        };
        // Make the request
        DataScan response = dataScanServiceClient.GetDataScan(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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

Java

import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.GetDataScanRequest;

public class SyncGetDataScan {

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

  public static void syncGetDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      GetDataScanRequest request =
          GetDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      DataScan response = dataScanServiceClient.getDataScan(request);
    }
  }
}

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_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

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

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

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the get_data_scan call in the DataScanService 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::DataScanService::Client#get_data_scan.
#
def get_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

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

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

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

REST

Para ver los resultados de un análisis de calidad de los datos, usa el método dataScans.get.

Visualiza los resultados publicados

Si los resultados del análisis de calidad de los datos se publican como metadatos de Knowledge Catalog, puedes ver los resultados más recientes en las páginas de BigQuery y Knowledge Catalog en la consola deGoogle Cloud , en la pestaña Calidad de los datos de la tabla de origen.

En la consola de Google Cloud , ve a la página Búsqueda de Knowledge Catalog.

Ir a Búsqueda
Busca la tabla y, luego, selecciónala.
Haz clic en la pestaña Calidad de los datos.

Se muestran los resultados publicados más recientes.

Nota: Es posible que los resultados publicados no estén disponibles si se ejecuta un análisis por primera vez.

Visualiza los resultados del análisis histórico

Knowledge Catalog guarda el historial de análisis de calidad de los datos de los últimos 300 trabajos o del último año, lo que ocurra primero.

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en el nombre de un análisis de calidad de los datos.
Haz clic en la pestaña Historial de trabajos.

En la pestaña Historial de trabajos, se proporciona información sobre los trabajos anteriores, como la cantidad de registros analizados en cada trabajo, el estado del trabajo, la hora en que se ejecutó el trabajo y si cada regla se aprobó o falló.
Para ver información detallada sobre un trabajo, haz clic en cualquiera de los trabajos de la columna ID de trabajo.

gcloud

Para ver los trabajos históricos de análisis de calidad de los datos, usa el comando gcloud dataplex datascans jobs list:

gcloud dataplex datascans jobs list \
--location=LOCATION \
--datascan=DATASCAN \

Reemplaza las siguientes variables:

LOCATION: Es la región de Google Cloud en la que se creó el análisis de calidad de los datos.
DATASCAN: Es el nombre de la exploración de calidad de los datos para la que deseas ver los trabajos históricos.

C#

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

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for ListDataScanJobs</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 ListDataScanJobsRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        ListDataScanJobsRequest request = new ListDataScanJobsRequest
        {
            ParentAsDataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Filter = "",
        };
        // Make the request
        PagedEnumerable<ListDataScanJobsResponse, DataScanJob> response = dataScanServiceClient.ListDataScanJobs(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (DataScanJob 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 (ListDataScanJobsResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (DataScanJob 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<DataScanJob> 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 (DataScanJob 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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.ListDataScanJobsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#ListDataScanJobsRequest.
	}
	it := c.ListDataScanJobs(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.ListDataScanJobsResponse)
	}
}

Java

import com.google.cloud.dataplex.v1.DataScanJob;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.ListDataScanJobsRequest;

public class SyncListDataScanJobs {

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

  public static void syncListDataScanJobs() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      ListDataScanJobsRequest request =
          ListDataScanJobsRequest.newBuilder()
              .setParent(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      for (DataScanJob element : dataScanServiceClient.listDataScanJobs(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

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_data_scan_jobs():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

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

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

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

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the list_data_scan_jobs call in the DataScanService 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::DataScanService::Client#list_data_scan_jobs.
#
def list_data_scan_jobs
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

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

  # Call the list_data_scan_jobs method.
  result = client.list_data_scan_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::DataScanJob.
    p item
  end
end

REST

Para ver los trabajos históricos de análisis de calidad de los datos, usa el método dataScans.jobs.list.

Estados de los trabajos

Los trabajos de análisis de datos pueden tener los siguientes estados:

PENDING: El trabajo se creó, pero aún no se comenzó a ejecutar. En este estado, el análisis configura de forma activa la infraestructura o adquiere ranuras. Esta fase puede tardar entre 10 y 20 segundos o más, según la complejidad del esquema y la contención de recursos.
RUNNING: El trabajo se está ejecutando.
CANCELING: El trabajo se está cancelando.
CANCELLED: El trabajo se canceló correctamente.
SUCCEEDED: El trabajo se completa correctamente. El estado de finalización puede retrasarse hasta 60 segundos con respecto a la finalización real de la consulta debido a los pasos de procesamiento posterior, como la agregación y la sincronización de metadatos.
FAILED: El trabajo falla debido a un error. El estado de finalización puede retrasarse hasta 60 segundos con respecto a la finalización real de la consulta debido a los pasos de procesamiento posterior, como la agregación y la sincronización de metadatos.
SUCCEEDED_WITH_ERRORS: El trabajo se completa correctamente, pero se producen algunos errores durante la ejecución.

Prácticas recomendadas para la supervisión

Cuando supervises tus trabajos de análisis de datos, ten en cuenta las siguientes prácticas recomendadas:

Evita el sondeo agresivo: Evita el sondeo agresivo (por ejemplo, llamar a GetJob o un equivalente cada 1 a 5 segundos). El sondeo agresivo desperdicia la cuota de la API y no acelera las transiciones de estado.
Usa la retirada exponencial: Si el sondeo repetitivo es inevitable, usa la retirada exponencial a partir de los 10 a 15 segundos.
Usa el desacoplamiento asíncrono controlado por eventos (recomendado): En lugar del sondeo de API síncrono, usa activadores de Eventarc que escuchen los registros de auditoría de Cloud (cloudaudit.googleapis.com). Puedes usar estos activadores para iniciar flujos de trabajo descendentes de inmediato después de los eventos de finalización de trabajos de DataScan. Este enfoque omite los límites de sondeo de la API, conserva la cuota y reduce la latencia percibida.

Para permitir que los usuarios de tu organización vean los resultados del análisis, haz lo siguiente:

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en la exploración de calidad de los datos cuyos resultados quieras compartir.
Haz clic en la pestaña Permisos.
Haz lo siguiente:
- Para otorgar acceso a una principal, haz clic en Otorgar acceso. Otorga el rol Visualizador de datos de DataScan de Dataplex a la principal asociada.
- Para quitar el acceso de una principal, selecciona la principal de la que quieres quitar el rol de Visualizador de datos de DataScan de Dataplex. Haz clic en Quitar acceso y, luego, confirma cuando se te solicite.

Configura alertas en Logging

Para configurar alertas de fallas en la calidad de los datos con los registros de Cloud Logging, sigue estos pasos:

Console

En la consola de Google Cloud , ve al Explorador de registros de Logging.

Ve al Explorador de registros
En la ventana Consulta, ingresa tu consulta. Consulta las consultas de muestra.
Haz clic en Ejecutar consulta.
Haz clic en Crear alerta. Se abrirá un panel lateral.
Ingresa el nombre de la política de alertas y haz clic en Siguiente.
Revisa la consulta.
1. Haz clic en Obtener vista previa de los registros para probar tu consulta. Esto muestra los registros con las condiciones que coinciden.
2. Haz clic en Siguiente.
Establece el tiempo entre notificaciones y haz clic en Siguiente.
Define quién debe recibir la notificación de la alerta y haz clic en Guardar para crear la política de alertas.

Como alternativa, puedes configurar y editar tus alertas navegando en la consola deGoogle Cloud a Monitoring > Alertas.

gcloud

No compatible.

REST

Obtén información para configurar alertas en Logging.

Consultas de muestra para configurar alertas a nivel de trabajo o de dimensión

Una consulta de ejemplo para configurar alertas sobre fallas generales de calidad de los datos en un análisis de calidad de los datos:

resource.type="dataplex.googleapis.com/DataScan"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND resource.labels.datascan_id="a0-test-dec6-dq-3"
AND NOT jsonPayload.dataQuality.passed=true

A continuación, se muestra una consulta de ejemplo para configurar alertas sobre fallas de calidad de los datos en una dimensión (por ejemplo, unicidad) de un análisis de calidad de los datos determinado:

resource.type="dataplex.googleapis.com/DataScan"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND resource.labels.datascan_id="a0-test-dec6-dq-3"
AND jsonPayload.dataQuality.dimensionPassed.UNIQUENESS=false

Es una consulta de ejemplo para configurar alertas sobre fallas en la calidad de los datos de una tabla.

Establece alertas sobre fallas en la calidad de los datos para una tabla de BigQuery que no esté organizada en un lake de Knowledge Catalog:

resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.dataSource="//bigquery.googleapis.com/projects/test-project/datasets/testdataset/table/chicago_taxi_trips"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND NOT jsonPayload.dataQuality.passed=true

Establece alertas sobre fallas en la calidad de los datos para una tabla de BigQuery que esté organizada en un lake de Knowledge Catalog:

resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.dataSource="projects/test-project/datasets/testdataset/table/chicago_taxi_trips"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND NOT jsonPayload.dataQuality.passed=true

Consultas de muestra para configurar alertas por regla

A continuación, se muestra una consulta de ejemplo para configurar alertas en todas las reglas de calidad de los datos con errores con el nombre de regla personalizado especificado para un análisis de calidad de los datos:
```
resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.ruleName="custom-name"
AND jsonPayload.result="FAILED"
```
A continuación, se muestra una consulta de ejemplo para configurar alertas en todas las reglas de calidad de los datos con errores de un tipo de evaluación específico para un análisis de calidad de los datos:
```
resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.evalutionType="PER_ROW"
AND jsonPayload.result="FAILED"
```
Una consulta de ejemplo para configurar alertas en todas las reglas de calidad de los datos con errores de una columna en la tabla que se usa para un análisis de calidad de los datos:
```
resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.column="CInteger"
AND jsonPayload.result="FAILED"
```

Soluciona un problema de calidad de los datos

Para cada trabajo con reglas a nivel de fila que fallan, Knowledge Catalog proporciona una consulta para obtener los registros con errores. Ejecuta esta consulta para ver los registros que no coincidieron con tu regla.

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en el nombre de la exploración de calidad de los datos cuyos registros deseas solucionar.
Haz clic en la pestaña Historial de trabajos.
Haz clic en el ID del trabajo que identificó las fallas de calidad de los datos.
En la ventana de resultados del trabajo que se abre, en la sección Reglas, busca la columna Consulta para obtener registros con errores. Haz clic en Copiar la consulta en el portapapeles para la regla que falló.
Ejecuta la consulta en BigQuery para ver los registros que causaron el error en el trabajo.

gcloud

No compatible.

REST

Para obtener el trabajo que identificó las fallas de calidad de los datos, usa el método dataScans.get.

En el objeto de respuesta, el campo failingRowsQuery muestra la consulta.
Ejecuta la consulta en BigQuery para ver los registros que causaron el error en el trabajo.

Knowledge Catalog también ejecuta la consulta de depuración, siempre que se haya incluido durante la creación de la regla. Los resultados de la consulta de depuración se incluyen en el resultado de cada regla. Esta función está en vista previa.

Console

No compatible.

gcloud

No compatible.

REST

Para obtener el trabajo que identificó las fallas de calidad de los datos, usa el método dataScans.get. En el objeto de respuesta, el campo debugQueriesResultSets muestra los resultados de las consultas de depuración.

Administra los análisis de calidad de los datos de una tabla específica

En los pasos de este documento, se muestra cómo administrar los análisis de perfiles de datos en tu proyecto con la página Calidad y creación de perfiles de datos de Knowledge Catalog en la consola de Google Cloud .

También puedes crear y administrar análisis de perfiles de datos cuando trabajas con una tabla específica. En la consola de Google Cloud , en la página de Knowledge Catalog de la tabla, usa la pestaña Calidad de los datos. Haz lo siguiente:

En la consola de Google Cloud , ve a la página Búsqueda de Knowledge Catalog.

Ir a Búsqueda

Busca la tabla y, luego, selecciónala.
Haz clic en la pestaña Calidad de los datos.
Según si la tabla tiene un análisis de calidad de los datos cuyos resultados se publican como metadatos de Knowledge Catalog, puedes trabajar con los análisis de calidad de los datos de la tabla de las siguientes maneras:
- Se publican los resultados del análisis de calidad de los datos: Los resultados del análisis más reciente se muestran en la página.
  
  Para administrar los análisis de calidad de los datos de esta tabla, haz clic en Análisis de calidad de los datos y, luego, selecciona una de las siguientes opciones:
  - Crear análisis nuevo: Crea un análisis de calidad de los datos nuevo. Para obtener más información, consulta la sección Crea un análisis de calidad de los datos de este documento. Cuando creas un análisis desde la página de detalles de una tabla, esta se preselecciona.
  - Ejecutar ahora: Ejecuta el análisis.
  - Editar configuración de análisis: Edita la configuración, incluidos el nombre visible, los filtros y la programación.
    
    Para editar las reglas de calidad de los datos, en la pestaña Calidad de los datos, haz clic en la pestaña Reglas. Haz clic en Modificar reglas. Actualiza las reglas y, luego, haz clic en Guardar.
  - Administrar permisos del análisis: Controla quién puede acceder a los resultados del análisis. Para obtener más información, consulta la sección Otorga acceso a los resultados del análisis de calidad de los datos de este documento.
  - Ver resultados históricos: Consulta información detallada sobre los trabajos de análisis de calidad de los datos anteriores. Para obtener más información, consulta las secciones Visualiza los resultados del análisis de calidad de los datos y Visualiza los resultados del análisis histórico de este documento.
  - Ver todos los análisis: Consulta una lista de los análisis de calidad de los datos que se aplican a esta tabla.
- Los resultados del análisis de calidad de los datos no se publican: selecciona una de las siguientes opciones:
  - Crear análisis de calidad de los datos: Crea un análisis de calidad de los datos nuevo. Para obtener más información, consulta la sección Crea un análisis de calidad de los datos de este documento. Cuando creas un análisis desde la página de detalles de una tabla, esta se preselecciona.
  - Ver análisis existentes: Consulta una lista de análisis de calidad de los datos que se aplican a esta tabla.

Actualiza un análisis de calidad de los datos

Puedes editar varios parámetros de configuración de un análisis de calidad de los datos existente, como el nombre visible, los filtros, el programa y las reglas de calidad de los datos.

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en el nombre de un análisis de calidad de los datos.
Para editar la configuración, incluidos el nombre visible, los filtros y el programa, haz clic en Editar. Edita los valores y, luego, haz clic en Guardar.
Para editar las reglas de calidad de los datos, en la página de detalles del análisis, haz clic en la pestaña Reglas actuales. Haz clic en Modificar reglas. Actualiza las reglas y, luego, haz clic en Guardar.

gcloud

Para actualizar la descripción de un análisis de calidad de los datos, usa el comando gcloud dataplex datascans update data-quality:

gcloud dataplex datascans update data-quality DATASCAN \
--location=LOCATION \
--description=DESCRIPTION

Reemplaza lo siguiente:

DATASCAN: Es el nombre del análisis de calidad de los datos que se actualizará.
LOCATION: Es la región de Google Cloud en la que se creó el análisis de calidad de los datos.
DESCRIPTION: Es la descripción nueva de la verificación de la calidad de los datos.

C#

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataScan</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 UpdateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataScanRequest request = new UpdateDataScanRequest
        {
            DataScan = new DataScan(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.UpdateDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<DataScan, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataScan result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataScan, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceUpdateDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataScan retrievedResult = retrievedResponse.Result;
        }
    }
}

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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.UpdateDataScanRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateDataScan {

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

  public static void syncUpdateDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      UpdateDataScanRequest request =
          UpdateDataScanRequest.newBuilder()
              .setDataScan(DataScan.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.updateDataScanAsync(request).get();
    }
  }
}

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_update_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    data_scan = dataplex_v1.DataScan()
    data_scan.data.entity = "entity_value"

    request = dataplex_v1.UpdateDataScanRequest(
        data_scan=data_scan,
    )

    # Make the request
    operation = client.update_data_scan(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the update_data_scan call in the DataScanService 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::DataScanService::Client#update_data_scan.
#
def update_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

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

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

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Para editar un análisis de calidad de los datos, usa el método dataScans.patch.

Borra un análisis de calidad de los datos

Console

En la consola de Google Cloud , ve a la página Calidad y creación de perfiles de datos de Knowledge Catalog.

Ir a Creación de perfiles de datos y calidad
Haz clic en el escaneo que quieres borrar.
Haz clic en Borrar y, luego, confirma la acción cuando se te solicite.

gcloud

Para borrar una verificación de calidad de los datos, usa el comando gcloud dataplex datascans delete:

gcloud dataplex datascans delete DATASCAN \
--location=LOCATION \
--async

Reemplaza las siguientes variables:

DATASCAN: Es el nombre de la exploración de calidad de los datos que se borrará.
LOCATION: Es la región de Google Cloud en la que se creó el análisis de calidad de los datos.

C#

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for DeleteDataScan</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 DeleteDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        DeleteDataScanRequest request = new DeleteDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Force = false,
        };
        // Make the request
        Operation<Empty, OperationMetadata> response = dataScanServiceClient.DeleteDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        Empty result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<Empty, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceDeleteDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Empty retrievedResult = retrievedResponse.Result;
        }
    }
}

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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

	err = op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
}

Java

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.DeleteDataScanRequest;
import com.google.protobuf.Empty;

public class SyncDeleteDataScan {

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

  public static void syncDeleteDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      DeleteDataScanRequest request =
          DeleteDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setForce(true)
              .build();
      dataScanServiceClient.deleteDataScanAsync(request).get();
    }
  }
}

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_delete_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

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

    # Make the request
    operation = client.delete_data_scan(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the delete_data_scan call in the DataScanService 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::DataScanService::Client#delete_data_scan.
#
def delete_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

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

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

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Para borrar una verificación de calidad de los datos, usa el método dataScans.delete.

¿Qué sigue?

Sigue un instructivo para crear un flujo de trabajo de calidad de los datos de política como código.
Sigue un instructivo para administrar reglas de calidad de los datos como código con Terraform.
Obtén más información sobre la generación de perfiles de datos.
Obtén más información para usar la generación de perfiles de datos.

Cómo usar la calidad de los datos automática Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Antes de comenzar

Roles y permisos requeridos

Roles y permisos de los usuarios

Permisos necesarios

Roles y permisos de la cuenta de servicio de Knowledge Catalog

Permisos necesarios

Requisitos de Herramientas de redes

Define reglas de calidad de los datos

Define reglas de calidad de los datos con tipos de reglas integrados

Define reglas de calidad de los datos con reglas de SQL personalizadas

Define reglas de calidad de los datos con gcloud CLI

Configura la identidad de ejecución

Permisos necesarios para las identidades de ejecución personalizadas

Console

REST

Crea un análisis de calidad de los datos

Console

gcloud

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

Esquema de la tabla de exportación

Ejecuta un análisis de calidad de los datos

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Airflow

Cancela un trabajo de análisis de calidad de los datos

Roles y permisos requeridos

Cancelar un trabajo

Console

REST

Visualiza los resultados del análisis de calidad de los datos

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Visualiza los resultados publicados

Visualiza los resultados del análisis histórico

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Cómo usar la calidad de los datos automática