",
transformationContext="datasource"
).getDynamicFrame()
val ruleset = """
Rules = [
(ColumnValues "age" >= 26) OR (ColumnLength "name" >= 4)
]
"""
val dq_results = EvaluateDataQuality.processRows(
frame=datasource,
ruleset=ruleset,
additionalOptions=JsonOptions("""
{
"compositeRuleEvaluation.method":"ROW"
}
"""
)
)
}
```
En Catálogo de datos de AWS Glue, puede configurar fácilmente esta opción en la interfaz de usuario, como se muestra a continuación.
![\[En la captura de pantalla se muestra una ventana de configuración de reglas compuesta en la que puede elegir entre filas y columnas para la configuración de evaluación de reglas. Si elige Fila, las reglas compuestas se comportarán como una regla única que evalúa la fila en su totalidad. Si elige Columna, las reglas compuestas evaluarán las reglas individuales en todo el conjunto de datos y combinarán los resultados.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/composite-rule-settings.png)
Una vez establecidas, las reglas compuestas se comportarán como una regla única que evalúa la fila en su totalidad. En el ejemplo a continuación se muestra este comportamiento.
```
# Row Level outcome
+------+------+------------------------------------------------------------+---------------------------+
|myCol1|myCol2|DataQualityRulesPass |DataQualityEvaluationResult|
+------+------+------------------------------------------------------------+---------------------------+
|2 |1 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed |
|0 |3 |[(ColumnValues "myCol1" > 1) OR (ColumnValues "myCol2" > 2)]|Passed |
+------+------+------------------------------------------------------------+---------------------------+
```
Algunas reglas no son compatibles con esta característica debido a que los resultados generales se basan en umbrales o proporciones. Estas regulas se enumeran a continuación.
Reglas que se basan en las proporciones:
+ Integridad
+ DataSetMatch
+ ReferentialIntegrity
+ Singularidad
Reglas que se basan en los umbrales:
Cuando las reglas que se mencionan a continuación incluyen con un umbral, no son compatibles. Sin embargo, las reglas que no incluyen `with threshold` sí mantienen la compatibilidad.
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Expresiones
Si un tipo de regla no produce una respuesta booleana, debe proporcionar una expresión como parámetro para crear una respuesta booleana. Por ejemplo, la siguiente regla compara la media (promedio) de todos los valores de una columna con una expresión para obtener un resultado true (verdadero) o false (falso).
```
Mean "colA" between 80 and 100
```
Algunos tipos de reglas, como `IsUnique` y `IsComplete` ya producen una respuesta booleana.
En la tabla siguiente, se enumeran las expresiones que puede utilizar en las reglas de DQDL.
**Expresiones de DQDL admitidas**
| Expresión | Descripción | Ejemplo |
| --- | --- | --- |
| =x | Se resuelve en true si la respuesta del tipo de regla es igual que x. | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | Se resuelve en verdadero si la respuesta del tipo de regla es igual a x. | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | Se resuelve en true si la respuesta del tipo de regla es mayor que x. | ColumnValues "colA" > 10
|
| < x | Se resuelve en true si la respuesta del tipo de regla es menor que x. | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | Se resuelve en true si la respuesta del tipo de regla es mayor o igual que x. | ColumnValues "colA" >= 10
|
| <= x | Se resuelve en true si la respuesta del tipo de regla es menor o igual que x. | ColumnValues "colA" <= 1000
|
| entre x e y | Se resuelve en true si la respuesta del tipo de regla se encuentra en un rango especificado (exclusivo). Solo debe utilizar este tipo de expresión para los tipos numéricos y de datos. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| no está entre x e y | Se resuelve en verdadero si la respuesta del tipo de regla no se encuentra en un rango especificado (inclusivo). Solo debe utilizar este tipo de expresión para los tipos numéricos y de fecha. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| en [a, b, c, ...] | Se resuelve en true si la respuesta del tipo de regla se encuentra en el conjunto especificado. | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| no está en [a, b, c,... ] | Se resuelve en true si la respuesta del tipo de regla no se encuentra en el conjunto especificado. | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| coincide con /ab\$1c/i | Se resuelve en true si la respuesta del tipo de regla coincide con una expresión regular. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| no coincide con /ab\$1c/i | Se resuelve en true si la respuesta del tipo de regla no coincide con una expresión regular. | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | Solo funciona con el tipo de regla ColumnValues para crear una expresión de fecha. | ColumnValues "load_date" > (now() - 3 days)
|
| en/coincide con [...] / no está en/no coincide con [...] with threshold | Indica el porcentaje de valores que coinciden con las condiciones de la regla. Solo funciona con los tipos de regla ColumnValues, ColumnDataType y CustomSQL. | ColumnValues "colA" in ["A", "B"] with threshold > 0.8,
ColumnValues "colA" matches "[a-zA-Z]*" with threshold between 0.2 and 0.9
ColumnDataType "colA" = "Timestamp" with threshold > 0.9
|
#### Palabras clave para NULL, EMPTY y WHITESPACES\$1ONLY
Para validar si una columna de cadenas contiene una cadena nula, vacía o solo con espacios en blanco, puede utilizar las palabras clave a continuación:
+ NULL/null: esta palabra clave se resuelve como verdadera para un valor `null` en una columna de cadenas.
`ColumnValues "colA" != NULL with threshold > 0.5` devolvería el valor verdadero si más del 50 % de los datos no tienen valores nulos.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)` devolvería el valor verdadero para todas las filas que tengan un valor nulo o una longitud superior a 5. *Tenga en cuenta que esto requiere que se utilice la opción “compositeRuleEvaluation.method” = “ROW”.*
+ EMPTY/empty: esta palabra clave se resuelve como verdadera para un valor de cadena vacío (“”) en una columna de cadenas. Algunos formatos de datos transforman los valores nulos de una columna de cadenas en cadenas vacías. Esta palabra clave ayuda a remover las cadenas vacías en los datos.
`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])` devolvería el valor verdadero si una fila está vacía, “a” o “b”. *Tenga en cuenta que esto requiere que se utilice la opción “compositeRuleEvaluation.method” = “ROW”.*
+ WHITESPACES\$1ONLY/whitespaces\$1only: esta palabra clave se resuelve como verdadera para una cadena que solo tiene un valor de espacios en blanco (“ ”) en una columna de cadenas.
`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]` devolvería el valor verdadero si una fila no es ni “a” ni “b” ni solo contiene espacios en blanco.
Reglas admitidas:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
Puede utilizar las palabras clave a continuación para validar si una columna contiene un valor nulo al trabajar con expresiones numéricas o basadas en fechas.
+ NULL/null: esta palabra clave se resuelve como verdadera para un valor nulo en una columna de cadenas.
`ColumnValues "colA" in [NULL, "2023-01-01"]` devolvería el valor verdadero si una fecha de la columna es `2023-01-01` o nula.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)` devolvería el valor verdadero para todas las filas que tengan un valor nulo o cuyos valores sean entre 1 y 9. *Tenga en cuenta que esto requiere que se utilice la opción “compositeRuleEvaluation.method” = “ROW”.*
Reglas admitidas:
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Filtrado con la cláusula Where
**nota**
La cláusula Where solo es compatible con AWS Glue 4.0.
Puede filtrar sus datos durante la creación de reglas. Esto resulta útil cuando se quieren aplicar reglas condicionales.
```
where " "
```
El filtro debe especificarse con la palabra clave `where`, seguida de una instrucción de SparkSQL válida entre comillas `("")`.
Si desea agregar la cláusula Where a una regla que tiene un umbral, la cláusula Where debe especificarse antes de la condición de umbral.
```
where "valid SparkSQL statement>" with threshold
```
Con esta sintaxis, puede escribir reglas como las siguientes.
```
Completeness "colA" > 0.5 where "colB = 10"
ColumnValues "colB" in ["A", "B"] where "colC is not null" with threshold > 0.9
ColumnLength "colC" > 10 where "colD != Concat(colE, colF)"
```
Comprobaremos si la instrucción de SparkSQL proporcionada es válida. Si no es válida, la evaluación de la regla fallará y mostrará el error `IllegalArgumentException` con el siguiente formato:
```
Rule where "" has provided an invalid where clause :
```
**Comportamiento de la cláusula Where cuando la identificación del registro de errores a nivel de la fila está activada**
Con Calidad de datos de AWS Glue, puede identificar registros específicos que fallaron. Al aplicar una cláusula Where a las reglas que admiten resultados a nivel de la fila, etiquetaremos las filas filtradas por la cláusula Where como `Passed`.
Si prefiere etiquetar por separado las filas filtradas como `SKIPPED`, puede configurar las siguientes `additionalOptions` para el trabajo de ETL.
```
object GlueApp {
val datasource = glueContext.getCatalogSource(
database="",
tableName="",
transformationContext="datasource"
).getDynamicFrame()
val ruleset = """
Rules = [
IsComplete "att2" where "att1 = 'a'"
]
"""
val dq_results = EvaluateDataQuality.processRows(
frame=datasource,
ruleset=ruleset,
additionalOptions=JsonOptions("""
{
"rowLevelConfiguration.filteredRowLabel":"SKIPPED"
}
"""
)
)
}
```
Como ejemplo, consulte la siguiente regla y el marco de datos:
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | Resultados a nivel de la fila (predeterminado) | Resultados a nivel de la fila (opción omitida) | Comentarios |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | PASSED | PASSED | |
| 2 | b | d | PASSED | SKIPPED | La fila está filtrada, ya que att1 no es "a" |
| 3 | a | null | ERROR | ERROR | |
| 4 | a | f | PASSED | PASSED | |
| 5 | b | null | PASSED | SKIPPED | La fila está filtrada, ya que att1 no es "a" |
| 6 | a | f | PASSED | PASSED | |
### Constantes
En DQDL, puede definir valores constantes y hacer referencia a ellos a lo largo de todo el script. Esto ayuda a evitar problemas relacionados con los límites de tamaño de las consultas, por ejemplo, al trabajar con instrucciones SQL de gran tamaño que podrían superar los límites permitidos. Al asignar estos valores a las constantes, puede simplificar el DQDL y evitar sobrepasar esos límites.
En el siguiente ejemplo, se muestra cómo definir y utilizar una constante:
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
En este ejemplo, la consulta SQL se asigna a la constante `mySql`, que luego se referencia en la regla mediante el prefijo `$`.
### Etiquetas
Las etiquetas ofrecen una forma eficaz de organizar y analizar los resultados de calidad de los datos. Puede consultar los resultados por etiquetas específicas para identificar reglas fallidas dentro de categorías concretas, contar los resultados de las reglas por equipo o dominio y crear informes específicos para distintas partes interesadas.
Por ejemplo, puede aplicar a todas las reglas relacionadas con el equipo de finanzas una etiqueta `"team=finance"` y generar un informe personalizado para mostrar métricas de calidad específicas del equipo de finanzas. Puede etiquetar las reglas de alta prioridad con `"criticality=high"` para priorizar las tareas de remediación. Las etiquetas se pueden crear como parte del DQDL. Puede consultar las etiquetas como parte de los resultados de las reglas, los resultados a nivel de fila y las respuestas de la API, lo que facilita la integración con sus flujos de trabajo existentes de supervisión y generación de informes.
**nota**
Las etiquetas solo están disponibles en ETL de AWS Glue y no están disponibles en la calidad de datos basada en el catálogo de datos de AWS Glue.
#### Sintaxis de las etiquetas de DQDL
DQDL admite tanto etiquetas predeterminadas como etiquetas específicas de las reglas. Las etiquetas predeterminadas se definen a nivel del conjunto de reglas y se aplican automáticamente a todas las reglas incluidas en ese conjunto. Las reglas individuales también pueden tener sus propias etiquetas y, dado que las etiquetas se implementan como pares clave-valor, las etiquetas específicas de una regla pueden sustituir a las etiquetas predeterminadas cuando se utiliza la misma clave.
En el siguiente ejemplo, se muestra cómo utilizar etiquetas predeterminadas y específicas de una regla:
```
DefaultLabels=["frequency"="monthly"]
Rules = [
// Auto includes the default label ["frequency"="monthly"]
ColumnValues "col" > 21,
// Add ["foo"="bar"] to default label. Labels for this rule would be ["frequency"="monthly", "foo"="bar"]
Rule 1 with threshold > 0.8 labels=["foo"="bar"],
// Override default label. Labels for this rule would be ["frequency"="daily", "foo"="bar"]
Rule 2 with threshold > 0.8 labels=["foo"="bar", "frequency"="daily"]
// Labels must be applied to the entire composite rule (parentheses required)
(Rule 1 AND Rule 2) labels=["foo"="bar]
]
```
##### Restricciones del etiquetado
Las etiquetas tienen las siguientes restricciones:
+ Un máximo de 10 etiquetas por regla de DQDL.
+ Las etiquetas se especifican como una lista de pares clave-valor.
+ La clave de la etiqueta y el valor de la etiqueta distinguen entre mayúsculas y minúsculas.
+ La longitud máxima de la clave de la etiqueta es de 128 caracteres. La clave de la etiqueta no debe estar vacía ni ser nula.
+ La longitud máxima del valor de la etiqueta es de 256 caracteres. El valor de la etiqueta puede estar vacío o ser nulo.
#### Recuperación de etiquetas de DQDL
Puede recuperar las etiquetas de DQDL a partir de los resultados de las reglas, los resultados a nivel de fila y las respuestas de la API.
##### Resultados de la regla
Las etiquetas de DQDL siempre son visibles en los resultados de las reglas. No se necesita ninguna configuración adicional para habilitarlas.
##### Resultados a nivel de fila
Las etiquetas de DQDL están desactivadas de forma predeterminada en los resultados a nivel de fila, pero pueden habilitarse mediante `AdditionalOptions` en `EvaluateDataQuality`.
En el siguiente ejemplo, se muestra cómo habilitar etiquetas en resultados a nivel de fila:
```
val evaluateResult = EvaluateDataQuality.processRows(
frame=AmazonS3_node1754591511068,
ruleset=example_ruleset,
publishingOptions=JsonOptions("""{
"dataQualityEvaluationContext": "evaluateResult",
"enableDataQualityCloudWatchMetrics": "true",
"enableDataQualityResultsPublishing": "true"
}"""),
additionalOptions=JsonOptions("""{
"performanceTuning.caching":"CACHE_NOTHING",
"observations.scope":"ALL",
"rowLevelConfiguration.ruleWithLabels":"ENABLED"
}""")
)
```
Cuando están habilitadas, el marco de datos de resultados a nivel de fila incluye las etiquetas de cada regla en las columnas `DataQualityRulesPass`, `DataQualityRulesFail` y `DataQualityRulesSkip`.
##### Respuesta de la API
Las etiquetas de DQDL siempre son visibles en las respuestas de la API, en un nuevo campo `Labels` dentro del objeto `RuleResults`.
En el siguiente ejemplo, se muestran las etiquetas en una respuesta de la API:
```
{
"ResultId": "dqresult-example",
"ProfileId": "dqprofile-example",
"Score": 0.6666666666666666,
"RulesetName": "EvaluateDataQuality_node1754591514205",
"EvaluationContext": "EvaluateDataQuality_node1754591514205",
"StartedOn": "2025-08-22T19:36:10.448000+00:00",
"CompletedOn": "2025-08-22T19:36:16.368000+00:00",
"JobName": "anniezc-test-labels",
"JobRunId": "jr_068f6d7a45074d9105d14e4dee09db12c3b95664b45f6ee44fa29ed7e5619ba8",
"RuleResults": [
{
"Name": "Rule_0",
"Description": "IsComplete colA",
"EvaluationMessage": "Input data does not include column colA!",
"Result": "FAIL",
"EvaluatedMetrics": {},
"EvaluatedRule": "IsComplete colA",
"Labels": {
"frequency": "monthly"
}
},
{
"Name": "Rule_1",
"Description": "Rule 1 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 1 with threshold > 0.8",
"Labels": {
"frequency": "monthly",
"foo": "bar"
}
},
{
"Name": "Rule_3",
"Description": "Rule 2 with threshold > 0.8",
"Result": "PASS",
"EvaluatedMetrics": {},
"EvaluatedRule": "Rule 2 with threshold > 0.8",
"Labels": {
"frequency": "daily",
"foo": "bar"
}
}
]
}
```
### Reglas dinámicas
**nota**
Las reglas dinámicas solo se admiten en la ETL de AWS Glue y no en el Catálogo de datos de AWS Glue.
Ahora puede crear reglas dinámicas para comparar las métricas actuales generadas por sus reglas con sus valores históricos. Estas comparaciones históricas se habilitan usando el operador `last()` en las expresiones. Por ejemplo, la regla `RowCount > last()` se aplicará correctamente cuando el número de filas de la ejecución actual sea superior al recuento de filas anterior más reciente del mismo conjunto de datos. `last()` utiliza un argumento numérico natural opcional que describe cuántas métricas anteriores se deben tener en cuenta; `last(k)` donde `k >= 1` hará referencia a las últimas métricas `k`.
+ Si no hay puntos de datos disponibles, `last(k)` devolverá el valor predeterminado, 0,0.
+ Si hay menos de las métricas `k` disponibles, `last(k)` devolverá todas las métricas anteriores.
Para formar expresiones válidas utilice `last(k)`, donde `k > 1` requiera una función de agregación para reducir varios resultados históricos a un solo número. Por ejemplo, `RowCount > avg(last(5))` comprobará si el recuento de filas del conjunto de datos actual es estrictamente mayor que el promedio de los últimos cinco recuentos de filas del mismo conjunto de datos. `RowCount > last(5)` producirá un error, porque el recuento de filas del conjunto de datos actual no se puede comparar de forma significativa con una lista.
Funciones de agregación admitidas:
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std` (desviación estándar)
+ `abs` (valor absoluto)
+ `index(last(k), i)` permitirá seleccionar el valor en la posición `i` de los más recientes del último `k`. `i` está indexado a cero, por lo que `index(last(3), 0)` devolverá el punto de datos más reciente y `index(last(3), 3)` generará un error, ya que solo hay tres puntos de datos e intentaremos indexar el cuarto más reciente.
**Ejemplos de expresiones**
**ColumnCorrelation**
+ `ColumnCorrelation "colA" "colB" < avg(last(10))`
**DistinctValuesCount**
+ `DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1`
La mayoría de los tipos de reglas con condiciones o umbrales numéricos admiten reglas dinámicas; consulte la tabla dada, [Analizadores y reglas](#dqdl-analyzers-table), para determinar si las reglas dinámicas son compatibles con su tipo de regla.
**Exclusión de las estadísticas de las reglas dinámicas**
En ocasiones, tendrá que excluir las estadísticas de datos de los cálculos de las reglas dinámicas. Supongamos que ha efectuado una carga de datos históricos y no quiere que eso afecte a sus promedios. Para ello, abra el trabajo en la ETL de AWS Glue y seleccione la pestaña **Calidad de los datos**; a continuación, seleccione **Estadísticas** y seleccione las estadísticas que desee excluir. Podrá ver un gráfico de tendencias junto con una tabla de estadísticas. Seleccione los valores que desee excluir y elija **Excluir estadísticas**. Ahora las estadísticas que estén excluidas no se incluirán en los cálculos de las reglas dinámicas.
![\[La captura de pantalla muestra la opción de excluir o incluir estadísticas del menú desplegable después de seleccionar una estadística.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### Analizadores
**nota**
El Catálogo de datos de AWS Glue no es compatible con los analizadores.
Las reglas de DQDL usan funciones denominadas *analizadores* para recopilar información sobre los datos. La expresión booleana de una regla hace uso de esta información para determinar si la regla debe funcionar correctamente o no. Por ejemplo, la regla RowCount `RowCount > 5 ` usará un analizador de recuento de filas para descubrir el número de filas del conjunto de datos y compararlo con la expresión `> 5`, para comprobar si existen más de cinco filas en el conjunto de datos actual.
A veces, en lugar de crear reglas, recomendamos crear analizadores y luego hacer que generen estadísticas que puedan usarse para detectar anomalías. Para estos casos, puede crear analizadores. Los analizadores se diferencian de las reglas en estas formas.
| Característica | Analizadores | Reglas |
| --- | --- | --- |
| Parte del conjunto de reglas | Sí | Sí |
| Genera estadísticas | Sí | Sí |
| Genera observaciones | Sí | Sí |
| Puede evaluar y hacer valer una condición | No | Sí |
| Puede configurar acciones como detener los trabajos por fallas o continuar procesando el trabajo | No | Sí |
Los analizadores pueden existir de forma independiente sin reglas, por lo que es posible configurarlos rápidamente y crear progresivamente reglas de calidad de datos.
Algunos tipos de reglas se pueden introducir en el bloque `Analyzers` del conjunto de reglas para ejecutar las reglas necesarias para los analizadores y recopilar información sin comprobar ninguna condición. Algunos analizadores no están asociados a las reglas y solo se pueden introducir en el bloque `Analyzers`. La siguiente tabla indica si cada elemento se admite como regla o como analizador independiente, junto con información adicional para cada tipo de regla.
**Ejemplos de conjunto de reglas con el analizador**
El siguiente conjunto de reglas usa:
+ una regla dinámica para comprobar si un conjunto de datos está creciendo por arriba de su media final en las últimas tres ejecuciones de tareas,
+ un analizador `DistinctValuesCount` para registrar la cantidad de valores distintos de la columna del conjunto de datos de `Name`,
+ un analizador `ColumnLength` para rastrear el tamaño mínimo y máximo de `Name` a lo largo del tiempo.
Los resultados de las métricas del analizador pueden verse en la pestaña Calidad de los datos durante la ejecución del trabajo.
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
Calidad de datos de AWS Glue es compatible con los siguientes analizadores.
| Nombre del analizador | Funcionalidad |
| --- | --- |
| RowCount | Calcula los recuentos de filas de un conjunto de datos |
| Completeness | Calcula el porcentaje de integridad de una columna |
| Uniqueness | Calcula el porcentaje de exclusividad de una columna |
| Mean | Calcula la media de una columna numérica |
| Sum | Calcula la suma de una columna numérica |
| StandardDeviation | Calcula la desviación estándar de una columna numérica |
| Entropy | Calcula la entropía de una columna numérica |
| DistinctValuesCount | Calcula el número de valores distintos de una columna |
| UniqueValueRatio | Calcula la relación de valores únicos de una columna |
| ColumnCount | Calcula el número de columnas de un conjunto de datos |
| ColumnLength | Calcula la longitud de una columna |
| ColumnValues | Calcula el mínimo y el máximo para las columnas numéricas Calcula la longitud mínima de la columna y la longitud máxima de la columna para las columnas no numéricas |
| ColumnCorrelation | Calcula las correlaciones de columnas para las columnas dadas |
| CustomSql | Calcula las estadísticas que devuelve CustomSQL |
| AllStatistics | Calcula las siguientes estadísticas: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/dqdl.html) |
### Comentarios
Puede utilizar el carácter “\$1” para agregar un comentario al documento DQDL. DQDL ignorará todo lo que figure a continuación del “\$1” hasta el final de la línea.
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# Referencia de tipo de regla de DQDL
En esta sección, se proporciona una referencia para cada tipo de regla que admite Calidad de datos de AWS Glue.
**nota**
En la actualidad, DQDL no admite datos de columnas anidadas o de tipo lista.
Los valores entre corchetes de la siguiente tabla se sustituirán por la información dada en los argumentos de la regla.
Por lo general, las reglas requieren un argumento adicional para la expresión.
| RuleType | Descripción | Argumentos | Métricas informadas | ¿Se admite como regla? | ¿Se admite como analizador? | ¿Devuelve los resultados de nivel de fila? | ¿Soporte para reglas dinámicas? | Genera observaciones | ¿Admite la cláusula Where? |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AggregateMatch | Comprueba si dos conjuntos de datos coinciden mediante la comparación de métricas resumidas, como el importe total de ventas. Es útil para que las instituciones financieras comparen si todos los datos provienen de los sistemas de origen. | Una o más agregaciones | Cuando los nombres de la primera y la segunda columna de agregación son los mismos: `Column.[Column].AggregateMatch` Cuando los nombres de la primera y la segunda columna de agregación son distintos: `Column.[Column1,Column2].AggregateMatch` | Sí | No | No | No | No | No |
| AllStatistics | Analizador independiente que recopila varias métricas para la columna dada de un conjunto de datos. | El nombre de una sola columna | Para las columnas de todos los tipos: `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Métricas adicionales para columnas con valores de cadena: `ColumnLength metrics` Métricas adicionales para columnas con valores numéricos: `ColumnValues metrics` | No | Sí | No | No | No | No |
| ColumnCorrelation | Compruebe lo bien que se correlacionan dos columnas. | Exactamente dos columnas de nombres | Multicolumn.[Column1,Column2].ColumnCorrelation | Sí | Sí | No | Sí | No | Sí |
| ColumnCount | Comprueba si se ha eliminado alguna columna. | Ninguno | Dataset.\$1.ColumnCount | Sí | Sí | No | Sí | Sí | No |
| ColumnDataType | Comprueba si una columna es compatible con un tipo de datos. | Exactamente un nombre de columna | Column.[Column].ColumnDataType.Compliance | Sí | No | No | Sí, en la expresión de umbral a nivel de fila | No | Sí |
| ColumnExists | Comprueba si existen columnas en un conjunto de datos. Esto les permite a los clientes crear plataformas de datos de autoservicio para garantizar que determinadas columnas estén disponibles. | Exactamente un nombre de columna | N/A | Sí | No | No | No | No | No |
| ColumnLength | Comprueba si la longitud de los datos es coherente. | Exactamente un nombre de columna | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Métrica adicional cuando se da un umbral a nivel de fila: `Column.[Column].ColumnValues.Compliance` | Sí | Sí | Sí, cuando se da un umbral a nivel de fila | No | Sí. Solo genera observaciones analizando la longitud mínima y máxima | Sí |
| ColumnNamesMatchPattern | Comprueba si los nombres de las columnas coinciden con patrones definidos. Es útil para que los equipos de gobierno refuercen la coherencia de los nombres de las columnas. | Una expresión regular para los nombres de las columnas | Dataset.\$1.ColumnNamesPatternMatchRatio | Sí | No | No | No | No | No |
| ColumnValues | Comprueba si los datos son coherentes según los valores definidos. Esta regla admite expresiones regulares. | Exactamente un nombre de columna | `Column.[Column].Maximum` `Column.[Column].Minimum` Métrica adicional cuando se da un umbral a nivel de fila: `Column.[Column].ColumnValues.Compliance` | Sí | Sí | Sí, cuando se da un umbral a nivel de fila | No | Sí. Solo genera observaciones analizando los valores mínimo y máximo | Sí |
| Integridad | Comprueba si hay espacios en blanco o CEROS en los datos. | Exactamente un nombre de columna | `Column.[Column].Completeness` | Sí | Sí | Sí | Sí | Sí | Sí |
| CustomSql | Los clientes pueden implementar prácticamente cualquier tipo de control de calidad de datos en SQL. | Una instrucción SQL (Opcional) Un umbral a nivel de fila | `Dataset.*.CustomSQL` Métrica adicional cuando se da un umbral a nivel de fila: `Dataset.*.CustomSQL.Compliance` | Sí | No | Sí, cuando se da un umbral a nivel de fila | Sí | No | No |
| DataFreshness | Comprueba si los datos están actualizados. | Exactamente un nombre de columna | Column.[Column].DataFreshness.Compliance | Sí | No | Sí | No | No | Sí |
| DataSetMatch | Compara dos conjuntos de datos e identifica si están sincronizados. | Nombre de un conjunto de datos de referencia Un mapeo de columnas (Opcional) Columnas para comprobar si hay coincidencias | Dataset.[ReferenceDatasetAlias].DatasetMatch | Sí | No | Sí | Sí | No | No |
| DistinctValuesCount | Comprueba si hay valores duplicados. | Exactamente un nombre de columna | Column.[Column].DistinctValuesCount | Sí | Sí | Sí | Sí | Sí | Sí |
| DetectAnomalies | Comprueba la presencia de anomalías en las métricas notificadas por otro tipo de regla. | Un tipo de regla | Métricas informadas por el argumento del tipo de regla | Sí | No | No | No | No | No |
| Entropía | Comprueba la entropía de los datos. | Exactamente un nombre de columna | Column.[Column].Entropy | Sí | Sí | No | Sí | No | Sí |
| IsComplete | Comprueba si el 100 % de los datos está completos. | Exactamente un nombre de columna | Column.[Column].Completeness | Sí | No | Sí | No | No | Sí |
| IsPrimaryKey | Comprueba si una columna es una clave principal (no NULA y única). | Exactamente un nombre de columna | Para una sola columna: `Column.[Column].Uniqueness` Para múltiples columnas: `Multicolumn.[CommaDelimitedColumns].Uniqueness` | Sí | No | Sí | No | No | Sí |
| IsUnique | Comprueba si el 100 % de los datos es único. | Exactamente un nombre de columna | Column.[Column].Uniqueness | Sí | No | Sí | No | No | Sí |
| Media | Comprueba si la media coincide con el umbral establecido. | Exactamente un nombre de columna | Column.[Column].Mean | Sí | Sí | Sí | Sí | No | Sí |
| ReferentialIntegrity | Comprueba si dos conjuntos de datos tienen integridad referencial. | Una o más columnas del conjunto de datos Uno o más nombres de columnas del conjunto de datos de referencia | Column.[ReferenceDatasetAlias].ReferentialIntegrity | Sí | No | Sí | Sí | No | No |
| RowCount | Comprueba si los recuentos de registros coinciden con un umbral. | Ninguno | Dataset.\$1.RowCount | Sí | Sí | No | Sí | Sí | Sí |
| RowCountMatch | Comprueba si los recuentos de registros entre dos conjuntos de datos coinciden. | Alias del conjunto de datos de referencia | Dataset.[ReferenceDatasetAlias].RowCountMatch | Sí | No | No | Sí | No | No |
| StandardDeviation | Comprueba si la desviación estándar coincide con el umbral. | Exactamente un nombre de columna | Column.[Column].StandardDeviation | Sí | Sí | Sí | Sí | No | Sí |
| SchemaMatch | Comprueba si el esquema entre dos conjuntos de datos coincide. | Alias del conjunto de datos de referencia | Dataset.[ReferenceDatasetAlias].SchemaMatch | Sí | No | No | Sí | No | No |
| Sum | Comprueba si la suma coincide con un umbral establecido. | Exactamente un nombre de columna | Column.[Column].Sum | Sí | Sí | No | Sí | No | Sí |
| Singularidad | Comprueba si la unicidad del conjunto de datos coincide con el umbral. | Exactamente un nombre de columna | Column.[Column].Uniqueness | Sí | Sí | Sí | Sí | No | Sí |
| UniqueValueRatio | Comprueba si la relación de valores únicos coincide con el umbral. | Exactamente un nombre de columna | Column.[Column].UniqueValueRatio | Sí | Sí | Sí | Sí | No | Sí |
| FileFreshness | Comprueba si los archivos de Amazon S3 están actualizados. | Ruta del archivo o carpeta y un umbral. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Sí | No | No | No | No | No |
| FileMatch | Comprueba si el contenido del archivo coincide con una suma de comprobación o con otro archivo. Esta regla usa sumas de comprobación para validar si dos archivos son iguales. | Ruta del archivo o carpeta de origen y ruta del archivo o carpeta de destino. | No se genera ninguna estadística. | Sí | No | No | No | No | No |
| FileSize | Comprueba si el tamaño de un archivo coincide con una condición especificada. | Ruta del archivo o carpeta y umbral. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Sí | No | No | No | No | No |
| FileUniqueness | Comprueba si los archivos son únicos mediante sumas de comprobación. | Ruta del archivo o carpeta y umbral. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Sí | No | No | No | No | No |
**Topics**
+ [AggregateMatch](dqdl-rule-types-AggregateMatch.md)
+ [ColumnCorrelation](dqdl-rule-types-ColumnCorrelation.md)
+ [ColumnCount](dqdl-rule-types-ColumnCount.md)
+ [ColumnDataType](dqdl-rule-types-ColumnDataType.md)
+ [ColumnExists](dqdl-rule-types-ColumnExists.md)
+ [ColumnLength](dqdl-rule-types-ColumnLength.md)
+ [ColumnNamesMatchPattern](dqdl-rule-types-ColumnNamesMatchPattern.md)
+ [ColumnValues](dqdl-rule-types-ColumnValues.md)
+ [Integridad](dqdl-rule-types-Completeness.md)
+ [CustomSQL](dqdl-rule-types-CustomSql.md)
+ [DataFreshness](dqdl-rule-types-DataFreshness.md)
+ [DataSetMatch](dqdl-rule-types-DatasetMatch.md)
+ [DistinctValuesCount](dqdl-rule-types-DistinctValuesCount.md)
+ [Entropía](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [Media](dqdl-rule-types-Mean.md)
+ [ReferentialIntegrity](dqdl-rule-types-ReferentialIntegrity.md)
+ [RowCount](dqdl-rule-types-RowCount.md)
+ [RowCountMatch](dqdl-rule-types-RowCountMatch.md)
+ [StandardDeviation](dqdl-rule-types-StandardDeviation.md)
+ [Sum](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [Singularidad](dqdl-rule-types-Uniqueness.md)
+ [UniqueValueRatio](dqdl-rule-types-UniqueValueRatio.md)
+ [DetectAnomalies](dqdl-rule-types-DetectAnomalies.md)
+ [FileFreshness](dqdl-rule-types-FileFreshness.md)
+ [FileMatch](dqdl-rule-types-FileMatch.md)
+ [FileUniqueness](dqdl-rule-types-FileUniqueness.md)
+ [FileSize](dqdl-rule-types-FileSize.md)
# AggregateMatch
Comprueba la relación de dos agregaciones de columnas con respecto a una expresión determinada. Este tipo de regla funciona en varios conjuntos de datos. Se evalúan las agregaciones de dos columnas y se obtiene una relación al dividir el resultado de la agregación de la primera columna por el resultado de la agregación de la segunda columna. La relación se comprueba con la expresión proporcionada para producir una respuesta booleana.
**Sintaxis**
**Agregación de columnas**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION**: la operación que se debe utilizar para la agregación. `sum` y `avg` se admiten en la actualidad.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **OPTIONAL\$1REFERENCE\$1ALIAS**: este parámetro debe proporcionarse si la columna proviene de un conjunto de datos de referencia y no del conjunto de datos principal. Si utiliza esta regla en el Catálogo de datos de AWS Glue, su alias de referencia debe tener el formato "..
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **COL\$1NAME**: el nombre de la columna que se va a agregar.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
**Ejemplo: promedio**
```
"avg(rating)"
```
**Ejemplo: suma**
```
"sum(amount)"
```
**Ejemplo: promedio de la columna en el conjunto de datos de referencia**
```
"avg(reference.rating)"
```
**Regla**
```
AggregateMatch
```
+ **AGG\$1EXP\$11**: la agregación de la primera columna.
Tipos de columnas compatibles: byte, decimal, doble, flotante, entero, largo, corto
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **AGG\$1EXP\$12**: la agregación de la segunda columna.
Tipos de columnas compatibles: byte, decimal, doble, flotante, entero, largo, corto
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: coincidencia agregada mediante suma**
La siguiente regla de ejemplo comprueba si la suma de los valores en la columna `amount` es exactamente igual a la suma de los valores en la columna `total_amount`.
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**Ejemplo: coincidencia agregada mediante promedio**
La siguiente regla de ejemplo comprueba si el promedio de los valores en la columna `ratings` es igual al 90 %, como mínimo, del promedio de los valores en la columna `ratings` en el conjunto de datos `reference`. El conjunto de datos de referencia se proporciona como origen de datos adicional en la experiencia ETL o el Catálogo de datos.
En AWS Glue ETL, puede usar:
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
En el Catálogo de datos de AWS Glue, puede usar:
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**Comportamiento nulo**
La regla `AggregateMatch` ignorará las filas con valores nulos al momento de calcular los métodos de agregación (suma/media). Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La media de la columna `units` será (0 \$1 20 \$1 40) / 3 = 20. Las filas 101 y 103 no se tienen en cuenta para este cálculo.
# ColumnCorrelation
Comprueba la *correlación* entre dos columnas con una expresión dada. AWS Calidad de datos de Glue utiliza el coeficiente de correlación de Pearson para medir la correlación lineal entre dos columnas. El resultado es un número entre -1 y 1 que mide la fuerza y la dirección de la relación.
**Sintaxis**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME**: el nombre de la primera columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **COL\$12\$1NAME**: el nombre de la segunda columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: correlación de columnas**
La siguiente regla de ejemplo comprueba si el coeficiente de correlación entre las columnas `height` y `weight` tiene una correlación positiva fuerte (un valor de coeficiente superior a 0,8).
```
ColumnCorrelation "height" "weight" > 0.8
```
```
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
```
**Muestra de reglas dinámicas**
+ `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))`
+ `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))`
**Comportamiento nulo**
La regla `ColumnCorrelation` ignorará las filas con los valores `NULL` al momento de calcular la correlación. Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Las filas 101 y 103 se ignorarán y la `ColumnCorrelation` será 1.0.
# ColumnCount
Comprueba el recuento de columnas del conjunto de datos principal con respecto a una expresión determinada. En la expresión, puede indicar el número de columnas o un rango de columnas mediante operadores como `>` y `<`.
**Sintaxis**
```
ColumnCount
```
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: comprobación numérica del recuento de columnas**
La siguiente regla de ejemplo comprueba si el recuento de columnas se encuentra dentro de un rango determinado.
```
ColumnCount between 10 and 20
```
**Muestra de reglas dinámicas**
+ `ColumnCount >= avg(last(10))`
+ `ColumnCount between min(last(10))-1 and max(last(10))+1`
# ColumnDataType
Comprueba si los valores de una columna determinada se pueden convertir en Apache Spark al tipo proporcionado. Acepta una expresión `with threshold` para comprobar si hay un subconjunto de los valores en la columna.
**Sintaxis**
```
ColumnDataType =
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
Tipos de columnas compatibles: tipo cadena
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPECTED\$1TYPE**: el tipo esperado de los valores en la columna.
Valores admitidos: booleano, fecha, marca de tiempo, entero, doble, flotante, largo
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESIÓN**: una expresión opcional para especificar el porcentaje de valores que deben ser del tipo esperado.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
**Ejemplo: números enteros del tipo de datos de columna como cadenas**
La siguiente regla de ejemplo comprueba si los valores de la columna dada, que es de tipo cadena, pueden convertirse a enteros.
```
ColumnDataType "colA" = "INTEGER"
```
**Ejemplo: los números enteros del tipo de datos de las columnas como cadenas comprueban un subconjunto de los valores**
La siguiente regla de ejemplo comprueba si más del 90 % de los valores de la columna dada, que es de tipo cadena, pueden convertirse a enteros.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
Comprueba si existe una columna.
**Sintaxis**
```
ColumnExists
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplo: la columna existe**
La siguiente regla de ejemplo comprueba si existe la columna denominada `Middle_Name`.
```
ColumnExists "Middle_Name"
```
# ColumnLength
Comprueba si la longitud de cada fila de una columna se ajusta a una expresión dada.
**Sintaxis**
```
ColumnLength
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cadena
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: longitud de la fila de la columna**
La siguiente regla de ejemplo comprueba si el valor de cada fila de la columna denominada `Postal_Code` tiene 5 caracteres.
```
ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
```
**Comportamiento nulo**
La regla `ColumnLength` considera a los valores `NULL` como cadenas con una longitud de 0. Para una fila `NULL`:
```
ColumnLength "Postal_Code" > 4 # this will fail
```
```
ColumnLength "Postal_Code" < 6 # this will succeed
```
El ejemplo de regla compuesta a continuación presenta una manera de fallar de manera explícita un valor `NULL`:
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
Comprueba si los nombres de todas las columnas del conjunto de datos principal coinciden con la expresión regular dada.
**Sintaxis**
```
ColumnNamesMatchPattern
```
+ **PATRÓN**: el patrón contra el que desea evaluar la regla de calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
**Ejemplo: los nombres de las columnas coinciden con el patrón**
La siguiente regla de ejemplo comprueba si todas las columnas comienzan con el prefijo “aws\$1”
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
Ejecuta una expresión con los valores de una columna.
**Sintaxis**
```
ColumnValues
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: valores permitidos**
El ejemplo de regla a continuación controla que cada valor en la columna específica se encuentre en un conjunto de valores permitidos (incluidos los valores nulos y las cadenas que solo contienen espacios en blanco).
```
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
```
**Ejemplo: expresión regular**
La siguiente regla de ejemplo compara los valores de una columna con una expresión regular.
```
ColumnValues "First_Name" matches "[a-zA-Z]*"
```
**Ejemplo: valores de fecha**
La siguiente regla de ejemplo compara los valores de una columna de fecha con una expresión de fecha.
```
ColumnValues "Load_Date" > (now() - 3 days)
```
**Ejemplo: valores numéricos**
La siguiente regla de ejemplo comprueba si los valores de las columnas coinciden con una restricción numérica determinada.
```
ColumnValues "Customer_ID" between 1 and 2000
```
**Comportamiento nulo**
Para todas las reglas `ColumnValues` (además de `!=` y `NOT IN`), las filas `NULL` fallarán la regla. Si la regla falla debido a un valor nulo, la razón de la falla se mostrará de la siguiente manera:
```
Value: NULL does not meet the constraint requirement!
```
El ejemplo de regla compuesta a continuación presenta una manera de permitir de manera explícita los valores `NULL`:
```
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
```
Las reglas ColumnValues negadas que utilicen la sintaxis `!=` y `not in` se considerarán filas `NULL`. Por ejemplo:
```
ColumnValues "Age" != 21
```
```
ColumnValues "Age" not in [21, 22, 23]
```
Los ejemplos a continuación presentan una manera de fallar de manera explícita los valores `NULL`
```
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
```
```
ColumnValues "Age" not in [21, 22, 23, NULL]
```
# Integridad
Comprueba el porcentaje de valores completos (no nulos) de una columna con respecto a una expresión determinada.
**Sintaxis**
```
Completeness
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: porcentaje de valor nulo**
Las siguientes reglas de ejemplo comprueban si más del 95 % de los valores de una columna están completos.
```
Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"
```
**Muestra de reglas dinámicas**
+ `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**Comportamiento nulo**
Nota sobre los formatos de datos CSV: las filas en blanco en las columnas de CSV pueden demostrar distintos comportamientos.
+ Si una columna es del tipo `String`, la fila en blanco se reconocerá como una cadena vacía y no fallará la regla `Completeness`.
+ Si una columna es de otro tipo de dato, como `Int`, la fila en blanco se reconocerá como `NULL` y fallará la regla `Completeness`.
# CustomSQL
Este tipo de regla se ha ampliado para admitir dos casos de uso:
+ Ejecutar una instrucción SQL personalizada contra un conjunto de datos y comprobar el valor que se produce con respecto a una expresión dada.
+ Ejecutar una instrucción SQL personalizada en la que especifique un nombre de columna en la instrucción SELECT contra el que compararlo con alguna condición para obtener resultados a nivel de fila.
**Sintaxis**
```
CustomSql
```
+ **SQL\$1STATEMENT**: una instrucción SQL que devuelve un solo valor numérico, entre comillas dobles.
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: SQL personalizado para recuperar el resultado general de una regla**
Esta regla de ejemplo usa una instrucción SQL para recuperar el recuento de registros de un conjunto de datos. A continuación, la regla comprueba que el recuento de registros esté comprendido entre 10 y 20.
```
CustomSql "select count(*) from primary" between 10 and 20
```
**Ejemplo: SQL personalizado para recuperar los resultados a nivel de fila**
Esta regla de ejemplo utiliza una instrucción SQL en la que se especifica un nombre de columna en la instrucción SELECT con el que se compara con alguna condición para obtener resultados a nivel de fila. Una expresión de condición de umbral define un umbral del número de registros que deben fallar para que falle toda la regla. Tenga en cuenta que una regla no puede contener una condición y una palabra clave juntas.
```
CustomSql "select Name from primary where Age > 18"
```
o
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**importante**
El alias `primary` representa el nombre del conjunto de datos que quiere evaluar. Al trabajar con trabajos de ETL visuales en la consola, `primary` siempre representa el elemento `DynamicFrame` que se pasa a la transformación de `EvaluateDataQuality.apply()`. Cuando se utiliza el Catálogo de datos de AWS Glue para ejecutar tareas de calidad de datos en una tabla, `primary` representa la tabla.
Si está en el Catálogo de datos de AWS Glue, también puede usar los nombres reales de las tablas:
```
CustomSql "select count(*) from database.table" between 10 and 20
```
También puede combinar varias tablas para comparar diferentes elementos de datos:
```
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
```
En ETL de AWS Glue, CustomSQL puede identificar los registros que no superaron las comprobaciones de calidad de datos. Para que esto funcione, debe devolver los registros que forman parte de la tabla principal para la que evalúa la calidad de los datos. Los registros que se producen como parte de la consulta se consideran correctos y aquellos que no se producen se consideran fallidos. Esto funciona uniendo el resultado de la consulta CustomSQL con el conjunto de datos original. Puede haber implicaciones de rendimiento en función de la complejidad de su consulta SQL.
Para ello:
+ Debe seleccionar al menos una columna de la tabla principal.
+ `select count(*) from primary` es una consulta válida para la regla OVERALL de CustomSQL DQ, pero no para el SQL personalizado a nivel de fila.
+ Esta regla generará un error durante la evaluación: `The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but the columns from the SQL result are not present in the Input Dataset. Ensure that matching columns are returned from the SQL.`
+ En su consulta SQL, seleccione una `Clave principal` de su tabla o seleccione un conjunto de columnas que formen una clave compuesta. No hacerlo puede generar resultados inconsistentes debido a la coincidencia de filas duplicadas y en un rendimiento degradado.
+ Seleccione claves SOLO de su tabla principal y no de sus tablas de referencia.
La siguiente regla garantizará que los registros con una antigüedad inferior a 100 años se identifiquen como correctos y que aquellos anteriores se marquen como fallidos.
```
CustomSql "select id from primary where age < 100"
```
Esta regla CustomSQL se aprobará cuando el 50 % de los registros tengan más 10 años de antigüedad y también identificará los registros que fallaron. Los registros que este CustomSQL produce se considerarán aprobados, mientras que los que no se producen se considerarán fallidos.
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
Nota: La regla CustomSQL fallará si usted produce registros que no están disponibles en el conjunto de datos.
# DataFreshness
Comprueba la actualización de los datos de una columna mediante la evaluación de la diferencia entre la hora actual y los valores de una columna de fecha. Puede indicar una expresión basada en el tiempo para este tipo de regla para asegurarse de que los valores de las columnas estén actualizados.
**Sintaxis**
```
DataFreshness
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: fecha
+ **EXPRESSION**: una expresión numérica en horas o días. Debe indicar la unidad de tiempo en la expresión.
**Ejemplo: actualización de los datos**
Las siguientes reglas de ejemplo comprueban la actualización de los datos.
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**Comportamiento nulo**
Las reglas `DataFreshness` fallarán para las filas con valores `NULL`. Si la regla falla debido a un valor nulo, la razón de la falla se mostrará de la siguiente manera:
```
80.00 % of rows passed the threshold
```
donde el 20 % de las filas que fallaron incluyen las filas con valores `NULL`.
El ejemplo de regla compuesta a continuación presenta una manera de permitir de manera explícita los valores `NULL`:
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Actualización de datos para objetos de Amazon S3**
En ocasiones, tendrá que validar la actualización de los datos en función del tiempo de creación del archivo de Amazon S3. Para ello, puede usar el siguiente código para obtener la marca temporal y añadirla a su marco de datos y, a continuación, aplicar las comprobaciones de actualización de los datos.
```
df = glueContext.create_data_frame.from_catalog(database = "default", table_name = "mytable")
df = df.withColumn("file_ts", df["_metadata.file_modification_time"])
Rules = [
DataFreshness "file_ts" < 24 hours
]
```
# DataSetMatch
Compruebe si los datos del conjunto de datos principal coinciden con los datos de un conjunto de datos de referencia. Los dos conjuntos de datos se combinan mediante las asignaciones de columnas clave proporcionadas. Se pueden proporcionar asignaciones de columnas adicionales si desea comprobar la igualdad de los datos solo en esas columnas. Tenga en cuenta que para que **DataSetMatch** funcione, sus claves de unión deben ser únicas y no NULA (debe ser una clave principal). Si no cumple estas condiciones, recibirá el siguiente mensaje de error: “La asignación de teclas proporcionada no es adecuada para determinados marcos de datos”. En los casos en los que no pueda contar con claves combinadas que sean únicas, considere usar otros tipos de reglas, como **AggregateMatch**, para que coincidan en los datos resumidos.
**Sintaxis**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS**: el alias del conjunto de datos de referencia con el que se comparan los datos del conjunto de datos principal.
+ **KEY\$1COLUMN\$1MAPPINGS**: una lista de nombres de columnas separados por comas que forman una clave en los conjuntos de datos. Si los nombres de las columnas no son los mismos en ambos conjuntos de datos, debe separarlos con un `->`
+ **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS**: puede proporcionar este parámetro si desea comprobar si hay datos coincidentes solo en determinadas columnas. Utiliza la misma sintaxis que las asignaciones de columnas clave. Si no se proporciona este parámetro, haremos coincidir los datos en todas las columnas restantes. Las columnas restantes, que no son clave, deben tener los mismos nombres en ambos conjuntos de datos.
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: haga coincidir los conjuntos de datos mediante la columna de ID**
La siguiente regla de ejemplo comprueba que más del 90 % del conjunto de datos principal coincide con el conjunto de datos de referencia, mediante el uso de la columna “ID” para unir los dos conjuntos de datos. En este caso, compara todas las columnas.
```
DatasetMatch "reference" "ID" >= 0.9
```
**Ejemplo: haga coincidir conjuntos de datos mediante varias columnas clave**
En el siguiente ejemplo, el conjunto de datos principal y el conjunto de datos de referencia tienen nombres diferentes para las columnas clave. `ID_1` y `ID_2` juntos forman una clave compuesta en el conjunto de datos principal. `ID_ref1` y `ID_ref2` juntos forman una clave compuesta en el conjunto de datos de referencia. En este escenario, puede usar la sintaxis especial para proporcionar los nombres de las columnas.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9
```
**Ejemplo: haga coincidir conjuntos de datos mediante varias columnas clave y compruebe que una columna específica coincida**
Este ejemplo se basa en el ejemplo anterior. Queremos comprobar que solo coincide la columna que contiene los importes. Esta columna se denomina `Amount1` en el conjunto de datos principal y `Amount2` en el conjunto de datos de referencia. Quiere una coincidencia exacta.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9
```
# DistinctValuesCount
Compara la cantidad de valores distintos de una columna con una expresión dada.
**Sintaxis**
```
DistinctValuesCount
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: recuento de valores distintos de columnas**
La siguiente regla de ejemplo comprueba que la columna denominada `State` contenga más de 3 valores distintos.
```
DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1`
+ `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))`
# Entropía
Comprueba si el valor de *entropía* de una columna coincide con una expresión dada. La entropía mide el nivel de información que contiene un mensaje. Dada la distribución de probabilidad entre los valores de una columna, la entropía describe cuántos bits se necesitan para identificar un valor.
**Sintaxis**
```
Entropy
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: entropía de columna**
La siguiente regla de ejemplo comprueba que la columna denominada `Feedback` tiene un valor de entropía superior a uno.
```
Entropy "Star_Rating" > 1
Entropy "First_Name" > 1 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `Entropy "colA" < max(last(10))`
+ `Entropy "colA" between min(last(10)) and max(last(10))`
# IsComplete
Comprueba si todos los valores de una columna están completos (no nulos).
**Sintaxis**
```
IsComplete
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplo: valores nulos**
El siguiente ejemplo comprueba si todos los valores de una columna denominada `email` no son nulos.
```
IsComplete "email"
IsComplete "Email" where "Customer_ID between 1 and 50"
IsComplete "Customer_ID" where "Customer_ID < 16 and Customer_ID != 12"
IsComplete "passenger_count" where "payment_type<>0"
```
**Comportamiento nulo**
Nota sobre los formatos de datos CSV: las filas en blanco en las columnas de CSV pueden demostrar distintos comportamientos.
+ Si una columna es del tipo `String`, la fila en blanco se reconocerá como una cadena vacía y no fallará la regla `Completeness`.
+ Si una columna es de otro tipo de dato, como `Int`, la fila en blanco se reconocerá como `NULL` y fallará la regla `Completeness`.
# IsPrimaryKey
Comprueba si una columna contiene una clave principal. Una columna contiene una clave principal si todos los valores de la columna son únicos y completos (no nulos). También puede comprobar las claves principales con varias columnas.
**Sintaxis**
```
IsPrimaryKey
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplo: clave principal**
La siguiente regla de ejemplo comprueba si la columna denominada `Customer_ID` contiene una clave principal.
```
IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
```
**Ejemplo: clave principal con múltiples columnas. Cualquiera de los ejemplos siguientes son válidos.**
```
IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
```
# IsUnique
Comprueba si todos los valores de una columna son únicos y devuelve un valor booleano.
**Sintaxis**
```
IsUnique
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
**Ejemplos**
La siguiente regla de ejemplo comprueba si todos los valores de una columna denominada `email` son únicos.
```
IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]
```
La siguiente regla de ejemplo verifica varias columnas.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Media
Comprueba si la media (promedio) de todos los valores de una columna coincide con una expresión dada.
**Sintaxis**
```
Mean
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: valor promedio**
La siguiente regla de ejemplo comprueba si el promedio de todos los valores de una columna supera un umbral.
```
Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `Mean "colA" > avg(last(10)) + std(last(2))`
+ `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1`
**Comportamiento nulo**
La regla `Mean` ignorará las filas con valores `NULL` al momento de calcular la media. Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La media de la columna `units` será (0 \$1 20 \$1 40) / 3 = 20. Las filas 101 y 103 no se tienen en cuenta para este cálculo.
# ReferentialIntegrity
Comprueba en qué medida los valores de un conjunto de columnas en el conjunto de datos principal son un subconjunto de los valores de un conjunto de columnas en un conjunto de datos de referencia.
**Sintaxis**
```
ReferentialIntegrity
```
+ **PRIMARY\$1COLS**: una lista de nombres de columnas separados por comas en el conjunto de datos principal.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **REFERENCE\$1DATASET\$1COLS**: este parámetro contiene dos partes separadas por un punto. La primera parte es el alias del conjunto de datos de referencia. La segunda parte es la lista de nombres de columnas separados por comas en el conjunto de datos de referencia entre corchetes.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: compruebe la integridad referencial de una columna de código postal**
La siguiente regla de ejemplo comprueba que más del 90 % de los valores en la columna `zipcode` en el conjunto de datos principal estén presentes en la columna `zipcode` en el conjunto de datos de `reference`.
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**Ejemplo: compruebe la integridad referencial de las columnas de ciudad y estado**
En el siguiente ejemplo, las columnas que contienen información sobre la ciudad y el estado existen en el conjunto de datos principal y en el conjunto de datos de referencia. Los nombres de las columnas son diferentes en ambos conjuntos de datos. La regla comprueba si el conjunto de valores de las columnas en el conjunto de datos principal es exactamente igual al conjunto de valores de las columnas en el conjunto de datos de referencia.
```
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
```
**Muestra de reglas dinámicas**
+ `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" > avg(last(10))`
+ `ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" between min(last(10)) - 1 and max(last(10)) + 1`
# RowCount
Compara el recuento de filas de un conjunto de datos con una expresión determinada. En la expresión, puede indicar el número de filas o un rango de filas mediante operadores como `>` y `<`.
**Sintaxis**
```
RowCount
```
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: comprobación numérica del recuento de filas**
La siguiente regla de ejemplo comprueba si el recuento de filas se encuentra dentro de un rango determinado.
```
RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
```
RowCount > avg(last(10)) *0.8
```
# RowCountMatch
Comprueba la relación entre el recuento de filas del conjunto de datos principal y el recuento de filas de un conjunto de datos de referencia con respecto a la expresión dada.
**Sintaxis**
```
RowCountMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS**: el alias del conjunto de datos de referencia con el que se comparan los recuentos de filas.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: comparación del recuento de filas con un conjunto de datos de referencia**
La siguiente regla de ejemplo comprueba si el recuento de filas del conjunto de datos principal es al menos el 90 % del recuento de filas del conjunto de datos de referencia.
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
Comprueba la desviación estándar de todos los valores de una columna con respecto a una expresión determinada.
**Sintaxis**
```
StandardDeviation
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: desviación estándar**
La siguiente regla de ejemplo comprueba si la desviación estándar de los valores de una columna denominada `colA` es inferior a un valor especificado.
```
StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `StandardDeviation "colA" > avg(last(10) + 0.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Comportamiento nulo**
La regla `StandardDeviation` ignorará las filas con valores `NULL` al momento de calcular la desviación estándar. Por ejemplo:
```
+---+-----------+-----------+
|id |units1 |units2 |
+---+-----------+-----------+
|100|0 |0 |
|101|null |0 |
|102|20 |20 |
|103|null |0 |
|104|40 |40 |
+---+-----------+-----------+
```
La desviación estándar de la columna `units1` no tendrá en cuenta las filas 101 y 103 y su resultado será 16.33. La desviación estándar de la columna `units2` dará como resultado 16.
# Sum
Comprueba la suma de todos los valores de una columna con respecto a una expresión determinada.
**Sintaxis**
```
Sum
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: suma**
La siguiente regla de ejemplo comprueba si la suma de todos los valores de una columna supera un umbral dado.
```
Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `Sum "ColA" > avg(last(10))`
+ `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Comportamiento nulo**
La regla `Sum` ignorará las filas con valores `NULL` al momento de calcular la suma. Por ejemplo:
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La suma de la columna `units` no considerará las filas 101 y 103 y su resultado será (0 \$1 20 \$1 40) = 60.
# SchemaMatch
Comprueba si el esquema del conjunto de datos principal coincide con el esquema de un conjunto de datos de referencia. La verificación del esquema se realiza columna por columna. El esquema de dos columnas coincide si los nombres son idénticos y los tipos son idénticos. El orden de las columnas del archivo no importa.
**Sintaxis**
```
SchemaMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS**: el alias del conjunto de datos de referencia con el que se comparan los esquemas.
**Tipos de columnas compatibles**: byte, decimal, doble, flotante, entero, largo, corto
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: SchemaMatch**
La siguiente regla de ejemplo comprueba si el esquema del conjunto de datos principal coincide exactamente con el esquema de un conjunto de datos de referencia.
```
SchemaMatch "reference" = 1.0
```
# Singularidad
Comprueba el porcentaje de valores únicos de una columna con respecto a una expresión determinada. Los valores únicos aparecen exactamente una vez.
**Sintaxis**
```
Uniqueness
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo**
La siguiente regla de ejemplo comprueba si el porcentaje de valores únicos de una columna coincide con ciertos criterios numéricos.
```
Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
```
La siguiente regla de ejemplo verifica varias columnas.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**Muestra de reglas dinámicas**
+ `Uniqueness "colA" between min(last(10)) and max(last(10))`
+ `Uniqueness "colA" >= avg(last(10))`
# UniqueValueRatio
Comprueba la *relación de valores únicos* de una columna con respecto a una expresión determinada. Una relación de valores únicos es la fracción de valores únicos dividida entre el número de todos los valores distintos de una columna. Los valores únicos aparecen exactamente una vez, mientras que los valores distintos aparecen *al menos* una vez.
Por ejemplo, el conjunto `[a, a, b]` contiene un valor único (`b`) y dos valores distintos (`a` y `b`). Por lo tanto, la relación de valores únicos del conjunto es ½ = 0,5.
**Sintaxis**
```
UniqueValueRatio
```
+ **COL\$1NAME**: el nombre de la columna con la que quiere evaluar la regla de la calidad de los datos.
**Tipos de columnas compatibles**: cualquier tipo de columna
+ **EXPRESSION**: una expresión que se ejecuta en función de la respuesta del tipo de regla para producir un valor booleano. Para obtener más información, consulte [Expresiones](dqdl.md#dqdl-syntax-rule-expressions).
**Ejemplo: relación de valores únicos**
En este ejemplo, se comprueba la relación de valores única de una columna frente a un rango de valores.
```
UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
```
**Muestra de reglas dinámicas**
+ `UniqueValueRatio "colA" > avg(last(10))`
+ `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))`
# DetectAnomalies
Detecta anomalías en una regla de calidad de datos determinada. Cada ejecución de la regla DetectAnomalies permite guardar el valor evaluado de la regla dada. Al recopilar suficientes datos, el algoritmo de detección de anomalías toma todos los datos históricos de esa regla determinada y ejecuta la detección de anomalías. La regla DetectAnomalies falla al momento de detectar una anomalía. Puede obtener más información sobre qué anomalía se detectó en Observaciones.
**Sintaxis**
```
DetectAnomalies
```
`RULE_NAME`: nombre de la regla que quiere evaluar y detectar anomalías. Reglas admitidas:
+ “RowCount”
+ “Completeness”
+ “Uniqueness”
+ “Mean”
+ “Sum”
+ “StandardDeviation”
+ “Entropy”
+ “DistinctValuesCount”
+ “UniqueValueRatio”
+ “ColumnLength”
+ “ColumnValues”
+ “ColumnCorrelation”
+ "CustomSQL"
+ "ColumnCount"
`RULE_PARAMETERS`: algunas reglas requieren parámetros adicionales para poder ejecutarse. Consulte la documentación de reglas dada para ver los parámetros necesarios.
**Ejemplo: Anomalías de RowCount**
Por ejemplo, si queremos detectar anomalías en RowCount, damos RowCount como nombre de regla.
```
DetectAnomalies "RowCount"
```
**Ejemplo: Anomalías para ColumnLength**
Por ejemplo, si queremos detectar anomalías en la longitud de la columna, daremos la longitud de columna como nombre de la regla y el nombre de la columna.
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
FileFreshness garantiza que sus archivos de datos estén actualizados en función de la condición que proporcione. Utiliza la hora de la última modificación de los archivos para garantizar que los archivos de datos o toda la carpeta estén actualizados.
Esta regla recopila dos métricas:
+ El cumplimiento de FileFreshness se basa en la regla que haya configurado
+ El número de archivos que ha analizado la regla
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
La detección de anomalías no tiene en cuenta estas métricas.
**Cómo comprobar si los archivos están actualizados**
La siguiente regla garantiza que tickets.parquet se haya creado en las últimas 24 horas.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**Cómo comprobar si la carpeta está actualizada**
La siguiente regla se aplica si todos los archivos de la carpeta se crearon o modificaron en las últimas 24 horas.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**Cómo comprobar si una carpeta o un archivo está actualizado (con umbral)**
La siguiente regla se aplica si el 10 % de los archivos de la carpeta “tickets” se crearon o modificaron en los últimos 10 días.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**Cómo comprobar archivos o carpetas con fechas específicas**
Puede comprobar si los archivos se actualizaron en días específicos.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2020-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2023-01-01" and "2024-01-01"
```
**Cómo comprobar archivos o carpetas con fechas y horas**
Puede usar FileFreshness para asegurarse de que los archivos lleguen dentro de las horas previstas.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between now() and (now() - 45 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "9:30 PM"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > (now() - 10 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > now()
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 2 hours) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between (now() - 3 days) and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "2001-02-07" and (now() + 15 minutes)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45""
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "2024-01-01"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "02:30" and "04:30"
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" between "9:30 AM" and "22:15"
```
Consideraciones clave:
+ FileFreshness puede evaluar los archivos utilizando unidades de días, horas y minutos
+ Es compatible con los formatos de tiempo AM/PM y 24 horas
+ Los horarios se calculan en UTC, a menos que se especifique una anulación
+ Las fechas se calculan en UTC a las 00:00 h
El análisis de FileFreshness basado en la fecha y la hora funciona de la siguiente manera:
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ En primer lugar, la hora “21:45” se combina con la fecha de hoy en formato UTC para crear un campo de fecha y hora
+ A continuación, la fecha y la hora se convierten en la zona horaria que haya especificado
+ Por último, se evalúa la regla
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# Match only files with a .csv extension
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "\.csv$"
# Match Parquet files that contain "orders_" in the path
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = ".*orders_.*\.parquet"
# Exclude files ending in .tmp using a negative lookahead
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**nota**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
En el ejemplo anterior, el filtro `uriRegex` se aplica primero para seleccionar únicamente los archivos que coinciden con “inventory\$1”, y luego `recentFiles = 1` toma el archivo más reciente de ese conjunto filtrado. Sin `filterOrder`, el comportamiento predeterminado tomaría primero el archivo más reciente y luego aplicaría la expresión regular, lo que podría dar como resultado que no haya archivos coincidentes si el archivo más reciente no coincide con el patrón.
**nota**
Todos los valores de la lista `filterOrder` deben hacer referencia a otras etiquetas de filtro (`recentFiles` o `uriRegex`) que también estén presentes en la misma regla. Las etiquetas que no son de filtro, como `timeZone` o `failFast`, no son válidas en `filterOrder`.
**failFast**
Cuando se establece en `"true"`, la regla devuelve un error de inmediato en el primer archivo que no cumple la condición de vigencia, en lugar de evaluar todos los archivos y calcular una tasa de cumplimiento.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**timeZone**
Indica las anulaciones de zonas horaria aceptadas; consulte [Allowed Time Zones](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) para ver las zonas horarias admitidas.
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/New_York"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "America/Chicago"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Europe/Paris"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Asia/Shanghai"
```
```
FileFreshness "s3://path/" > "21:45" with timeZone = "Australia/Darwin"
```
**Cómo inferir los nombres de los archivos directamente de los marcos de datos**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el catálogo de datos de AWS Glue, puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos y puede detectar si están actualizados.
**nota**
Esta característica solo funcionará cuando los archivos se lean correctamente en DynamicFrame o DataFrame.
```
FileFreshness > (now() - 24 hours)
```
Esta regla encontrará la ruta de la carpeta o los archivos que se usan para rellenar el marco dinámico o el marco de datos. Esto funciona para las rutas de Amazon S3 o las tablas de Catálogo de datos de AWS Glue basadas en Amazon S3. Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación **EvaluateDataQuality** inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos de AWS Glue.
![\[La instantánea muestra un nodo de evaluación de Calidad de datos conectado a un nodo de Amazon S3.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-file-freshness.png)
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.
Si lo intenta en ambos casos, o si AWS Glue no encuentra los archivos, AWS Glue devolverá el siguiente error: `“Unable to parse file path from DataFrame”`
# FileMatch
La regla FileMatch le permite comparar archivos con otros archivos o sumas de comprobación. Esto puede ser útil en algunas situaciones:
1. Validación de archivos recibidos de fuentes externas: puede usar FileMatch para asegurarse de que haya recibido los archivos correctos de orígenes externos mediante su comparación con sumas de comprobación. Esto ayuda a validar la integridad de los datos que está ingiriendo.
1. Comparación de datos en dos carpetas diferentes: FileMatch se puede utilizar para comparar archivos entre dos carpetas.
Esta regla recopila una métrica: el número de archivos que ha analizado la regla.
```
{"Dataset.*.FileCount":1}
```
**Validación de un archivo con una suma de comprobación:**
FileMatch acepta un archivo y un conjunto de sumas de comprobación para garantizar que al menos una suma de comprobación coincida con el archivo.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac041793154713e5ef8f319"]
```
Los siguientes algoritmos estándar son compatibles:
+ MD5
+ SHA-1
+ SHA-256
Si no proporciona ningún algoritmo, el valor predeterminado es SHA-256.
**Validación de todos los archivos de una carpeta con el conjunto de sumas de comprobación:**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**Comparación de archivos en diferentes carpetas**
```
# Compare all files across two buckets
FileMatch "s3://original_bucket/" "s3://archive_bucket/"
# Compare files within specific subfolders
FileMatch "s3://original_bucket/internal-folder/" "s3://original_bucket/other-folder/"
# Compare only .json files across two folders
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with uriRegex = "\.json$"
# Compare only the 5 most recent .csv files
FileMatch "s3://original_bucket/" "s3://archive_bucket/" with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
FileMatch comprobará el contenido de los archivos en `original_bucket` y se asegurará de que coincidan con lo que contiene `archive_bucket`. La regla fallará si no coinciden exactamente. También puede comprobar el contenido de las carpetas internas o de los archivos individuales.
FileMatch también puede comparar archivos individuales entre sí.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**Cómo inferir los nombres de los archivos directamente de los marcos de datos**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el Catálogo de datos de AWS Glue (respaldado por Amazon S3), puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos.
**nota**
Esta característica solo funcionará cuando los archivos se lean correctamente en DynamicFrame o DataFrame.
```
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-1"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"] with hashAlgorithm = "SHA-256"
FileMatch in ["3ee0d8617ac041793154713e5ef8f319"]
```
Si la suma de comprobación proporcionada es diferente de la calculada, FileMatch le avisará de la diferencia.
![\[La instantánea muestra una regla con el estado Regla fallida de Calidad de datos. FileMatch explica el error.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-file-match.png)
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# Match only files with a .json extension
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "\.json$"
# Exclude files ending in .tmp using a negative lookahead
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**nota**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Esta etiqueta garantiza que los archivos no tengan nombres duplicados. El comportamiento predeterminado es false.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación **EvaluateDataQuality** inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos de AWS Glue.
![\[La instantánea muestra una regla con el estado Regla fallida de Calidad de datos. FileMatch explica el error.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-file-match-transform.png)
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.
# FileUniqueness
FileUniqueness permite asegurarse de que no haya archivos duplicados en los datos que ha recibido de sus productores de datos.
Recopila las siguientes estadísticas de datos:
1. El número de archivos que ha analizado la regla
1. La relación de singularidad de los archivos
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**Cómo encontrar archivos duplicados en una carpeta:**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**Cómo inferir los nombres de las carpetas directamente de los marcos de datos para detectar duplicados:**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el catálogo de datos de AWS Glue, puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos.
**nota**
Cuando se utiliza la inferencia, las reglas basadas en archivos solo pueden detectar los archivos leídos correctamente en DynamicFrame o DataFrame.
```
FileUniqueness > 0.5
```
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# Match only files with a .csv extension
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "\.csv$"
# Exclude files ending in .tmp using a negative lookahead
FileUniqueness "s3://bucket/" > 0.5 with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**nota**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Esta etiqueta garantiza que los archivos no tengan nombres duplicados. El comportamiento predeterminado es false.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación **EvaluateDataQuality** inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos de AWS Glue.
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.
# FileSize
El tipo de regla FileSize le permite asegurarse de que los archivos cumplan ciertos criterios de tamaño de archivo. Esto resulta útil para los siguientes casos de uso:
1. Asegurarse de que los productores no envíen archivos vacíos o sustancialmente más pequeños para su procesamiento.
1. Asegurarse de que sus buckets de destino no tengan archivos más pequeños, lo que podría provocar problemas de rendimiento.
FileSize recopila las siguientes métricas:
1. Conformidad: devuelve el porcentaje (%) de archivos que cumplen el umbral de la regla que ha establecido
1. Recuento de archivos: el número de archivos que ha analizado la regla
1. Tamaño mínimo de archivo en bytes
1. Tamaño máximo de archivo en bytes
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
Estas métricas no admiten la detección de anomalías.
**Validación del tamaño de los archivos**
Esta regla se aplicará cuando el archivo file.dat ocupe más de 2 MB.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
Las unidades compatibles incluyen B (bytes), MB (megabytes), GB (gigabytes) y TB (terabytes).
**Validación del tamaño de los archivos en las carpetas**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
Esta regla se aplicará si el 70 % de los archivos de s3://amzn-s3-demo-bucket tienen entre 2 GB y 1 TB.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**Cómo inferir los nombres de los archivos directamente de los marcos de datos**
No siempre tiene que proporcionar una ruta de archivo. Por ejemplo, al crear la regla en el Catálogo de datos, puede resultar difícil encontrar qué carpetas usan las tablas del catálogo. AWS Calidad de datos de Glue puede encontrar las carpetas o archivos específicos que se usan para rellenar su marco de datos.
**nota**
Esta característica solo funcionará cuando los archivos se lean correctamente en DynamicFrame o DataFrame.
```
FileSize < 10 MB with threshold > 0.7
```
**Etiquetas de reglas opcionales basadas en archivos:**
Las etiquetas permiten controlar el comportamiento de las reglas.
**recentFiles**
Esta etiqueta limita el número de archivos procesados dejando primero el archivo más reciente.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**uriRegex**
**nota**
La etiqueta AWS está disponible en `uriRegex` Glue 5.0 y versiones posteriores.
Esta etiqueta filtra los archivos mediante la aplicación de un patrón de expresión regular a la ruta del archivo. Solo se procesan los archivos cuyas rutas coinciden con el patrón. También puede usar una anticipación negativa para excluir los archivos que coinciden con un patrón.
```
# Match only files with a .dat extension
FileSize "s3://bucket/" > 5 B with uriRegex = "\.dat$"
# Exclude files ending in .tmp using a negative lookahead
FileSize "s3://bucket/" > 5 B with uriRegex = "(?!.*\.tmp$).*"
```
**filterOrder**
**nota**
La etiqueta AWS está disponible en `filterOrder` Glue 5.0 y versiones posteriores.
Cuando utiliza varias etiquetas de filtro, como `recentFiles` y `uriRegex`, en conjunto, la etiqueta `filterOrder` controla el orden en que se aplican. El orden predeterminado es primero `recentFiles` y luego `uriRegex`.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**failFast**
Cuando se establece en `"true"`, la regla devuelve un error de inmediato en el primer archivo que no cumple la condición de tamaño, en lugar de evaluar todos los archivos y calcular una tasa de cumplimiento.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
Existen algunas consideraciones:
1. En la ETL de AWS Glue, debe tener la transformación EvaluateDataQuality inmediatamente después de una transformación de Amazon S3 o del Catálogo de datos.
1. Esta regla no funcionará en las sesiones interactivas de AWS Glue.
# Uso de las API para medir y gestionar la calidad de los datos
En este tema, se describe cómo utilizar las API para medir y gestionar la calidad de los datos.
**Contents**
+ [Requisitos previos](#using-apis-prerequisites)
+ [Cómo trabajar con las recomendaciones de Calidad de datos de AWS Glue](#using-apis-recommendations)
+ [Trabajar con los conjuntos de reglas de Calidad de datos de AWS Glue](#using-apis-rulesets)
+ [Cómo trabajar con ejecuciones de Calidad de datos de AWS Glue](#using-apis-runs)
+ [Cómo trabajar con los resultados de Calidad de datos de AWS Glue](#using-apis-results)
## Requisitos previos
+ Asegúrese de que su versión de boto3 esté actualizada para que incluya la última API de Calidad de datos de AWS Glue.
+ Asegúrese de que la versión de AWS CLI esté actualizada para incluir la CLI más reciente.
Si utiliza un trabajo de AWS Glue para ejecutar estas API, puede usar la siguiente opción para actualizar la biblioteca boto3 a la última versión:
```
—additional-python-modules boto3==
```
## Cómo trabajar con las recomendaciones de Calidad de datos de AWS Glue
**Para iniciar una recomendación de Calidad de datos de AWS Glue, ejecute lo siguiente:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_rule_recommendation_run(self, database_name, table_name, role_arn):
"""
Starts a recommendation run that is used to generate rules when you don't know what rules to write. AWS Glue Data Quality
analyzes the data and comes up with recommendations for a potential ruleset. You can then triage the ruleset
and modify the generated ruleset to your liking.
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want a recommendation
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
"""
try:
response = self.client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_arn
)
except ClientError as err:
logger.error(
"Couldn't start data quality recommendation run %s. Here's why: %s: %s", name,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
Para una ejecución de recomendaciones, puede utilizar sus recomendaciones `pushDownPredicates` o `catalogPartitionPredicates` para mejorar el rendimiento y ejecutar las recomendaciones solo en particiones específicas de los orígenes de su catálogo.
```
client.start_data_quality_rule_recommendation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name,
'AdditionalOptions': {
'pushDownPredicate': "year=2022"
}
}
},
Role=role_arn,
NumberOfWorkers=2,
CreatedRulesetName=''
)
```
**Para obtener los resultados de una recomendación de Calidad de datos de AWS Glue, ejecute:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_rule_recommendation_run(self, run_id):
"""
Gets the specified recommendation run that was used to generate rules.
:param run_id: The id of the data quality recommendation run
"""
try:
response = self.client.get_data_quality_rule_recommendation_run(RunId=run_id)
except ClientError as err:
logger.error(
"Couldn't get data quality recommendation run %. Here's why: %s: %s", run_id,
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
Del objeto de respuesta anterior, puede extraer el conjunto de reglas recomendado por la ejecución para usarlo en los siguientes pasos:
```
print(response['RecommendedRuleset'])
Rules = [
RowCount between 2000 and 8000,
IsComplete "col1",
IsComplete "col2",
StandardDeviation "col3" between 58138330.8 and 64258155.09,
ColumnValues "col4" between 1000042965 and 1214474826,
IsComplete "col5"
]
```
**Para obtener una lista de todas las ejecuciones de recomendación que se puedan filtrar y enumerar:**
```
response = client.list_data_quality_rule_recommendation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': '',
'TableName': ''
}
}
)
```
**Para cancelar las tareas de recomendación de Calidad de datos de AWS Glue existentes:**
```
response = client.cancel_data_quality_rule_recommendation_run(
RunId='dqrun-d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
```
## Trabajar con los conjuntos de reglas de Calidad de datos de AWS Glue
**Para crear un conjunto de reglas de Calidad de datos de AWS Glue:**
```
response = client.create_data_quality_ruleset(
Name='',
Ruleset='Rules = [IsComplete "col1", IsPrimaryKey "col2", RowCount between 2000 and 8000]',
TargetTable={
'TableName': '',
'DatabaseName': ''
}
)
```
**Para obtener un conjunto de reglas de calidad de datos:**
```
response = client.get_data_quality_ruleset(
Name=''
)
print(response)
```
Puede utilizar esta API para, a continuación, extraer el conjunto de reglas:
```
print(response['Ruleset'])
```
**Para enumerar todos los conjuntos de reglas de calidad de datos de una tabla:**
```
response = client.list_data_quality_rulesets()
```
Puedes usar la condición de filtro de la API para filtrar todos los conjuntos de reglas adjuntos a una base de datos o tabla específica:
```
response = client.list_data_quality_rulesets(
Filter={
'TargetTable': {
'TableName': '',
'DatabaseName': ''
}
},
)
```
**Para actualizar un conjunto de reglas de calidad de datos:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def update_data_quality_ruleset(self, ruleset_name, ruleset_string):
"""
Update an AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to update
:param ruleset_string: The DQDL ruleset string to update the ruleset with
"""
try:
response = self.client.update_data_quality_ruleset(
Name=ruleset_name,
Ruleset=ruleset_string
)
except ClientError as err:
logger.error(
"Couldn't update the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Para eliminar un conjunto de reglas de la calidad de los datos:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def delete_data_quality_ruleset(self, ruleset_name):
"""
Delete a AWS Glue Data Quality Ruleset
:param ruleset_name: The name of the AWS Glue Data Quality ruleset to delete
"""
try:
response = self.client.delete_data_quality_ruleset(
Name=ruleset_name
)
except ClientError as err:
logger.error(
"Couldn't delete the AWS Glue Data Quality ruleset. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## Cómo trabajar con ejecuciones de Calidad de datos de AWS Glue
**Para iniciar una ejecución de Calidad de datos de AWS Glue:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def start_data_quality_ruleset_evaluation_run(self, database_name, table_name, role_name, ruleset_list):
"""
Start an AWS Glue Data Quality evaluation run
:param database_name: The name of the AWS Glue database which contains the dataset.
:param table_name: The name of the AWS Glue table against which we want to evaluate.
:param role_arn: The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that grants permission to let AWS Glue access the resources it needs.
:param ruleset_list: The list of AWS Glue Data Quality ruleset names to evaluate.
"""
try:
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
},
Role=role_name,
RulesetNames=ruleset_list
)
except ClientError as err:
logger.error(
"Couldn't start the AWS Glue Data Quality Run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response['RunId']
```
Recuerde que puede pasar un parámetro `pushDownPredicate` o `catalogPartitionPredicate` para garantizar que la ejecución de calidad de los datos solo se dirija a un conjunto específico de particiones de la tabla de catálogo. Por ejemplo:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CloudWatchMetricsEnabled': False
},
RulesetNames=[
'',
]
)
```
También puede configurar cómo se evalúan las reglas compuestas de su conjunto de reglas, ya sea en el nivel de la FILA o de la COLUMNA. Para obtener más información sobre cómo funcionan las reglas compuestas, consulte [Cómo funcionan las reglas compuestas](dqdl.md#dqdl-syntax-composite-rules) en la documentación.
Ejemplo de cómo configurar el método de evaluación de reglas compuestas en su solicitud:
```
response = client.start_data_quality_ruleset_evaluation_run(
DataSource={
'GlueTable': {
'DatabaseName': '',
'TableName': '',
'AdditionalOptions': {
'pushDownPredicate': 'year=2023'
}
}
},
Role='',
NumberOfWorkers=5,
Timeout=123,
AdditionalRunOptions={
'CompositeRuleEvaluationMethod':ROW
},
RulesetNames=[
'',
]
)
```
**Para obtener información sobre una ejecución de Calidad de datos de AWS Glue:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_ruleset_evaluation_run(self, run_id):
"""
Get details about an AWS Glue Data Quality Run
:param run_id: The AWS Glue Data Quality run ID to look up
"""
try:
response = self.client.get_data_quality_ruleset_evaluation_run(
RunId=run_id
)
except ClientError as err:
logger.error(
"Couldn't look up the AWS Glue Data Quality run ID. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Para obtener los resultados de una ejecución de Calidad de datos de AWS Glue:**
Para una ejecución de Calidad de datos de AWS Glue determinada, puede extraer los resultados de la evaluación de la ejecución mediante el siguiente método:
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(response['RuleResults'])
```
**Para ver una lista de todas sus ejecuciones de Calidad de datos de AWS Glue:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def list_data_quality_ruleset_evaluation_runs(self, database_name, table_name):
"""
Lists all the AWS Glue Data Quality runs against a given table
:param database_name: The name of the database where the data quality runs
:param table_name: The name of the table against which the data quality runs were created
"""
try:
response = self.client.list_data_quality_ruleset_evaluation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': database_name,
'TableName': table_name
}
}
}
)
except ClientError as err:
logger.error(
"Couldn't list the AWS Glue Quality runs. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
Puede modificar la cláusula de filtro para que solo muestre los resultados entre tiempos específicos o si se ejecutan en tablas específicas.
**Para detener una ejecución continua de Calidad de datos de AWS Glue:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def cancel_data_quality_ruleset_evaluation_run(self, result_id):
"""
Cancels a given AWS Glue Data Quality run
:param result_id: The result id of a AWS Glue Data Quality run to cancel
"""
try:
response = self.client.cancel_data_quality_ruleset_evaluation_run(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't cancel the AWS Glue Data Quality run. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
## Cómo trabajar con los resultados de Calidad de datos de AWS Glue
**Para obtener los resultados de ejecución de Calidad de datos de AWS Glue:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_data_quality_result(self, result_id):
"""
Outputs the result of an AWS Glue Data Quality Result
:param result_id: The result id of an AWS Glue Data Quality run
"""
try:
response = self.client.get_data_quality_result(
ResultId=result_id
)
except ClientError as err:
logger.error(
"Couldn't get the AWS Glue Data Quality result. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
else:
return response
```
**Para ver las estadísticas recopiladas para un resultado de calidad de datos determinado:**
```
import boto3
from botocore.exceptions import ClientError
import logging
logger = logging.getLogger(__name__)
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_profile_for_data_quality_result(self, result_id):
"""
Outputs the statistic profile for a AWS Glue Data Quality Result
:param result_id: The result id of a AWS Glue Data Quality run
"""
try:
response = self.glue_client.get_data_quality_result(
ResultId=result_id
)
# the profile contains all statistics gathered for the result
profile_id = response['ProfileId']
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
return profile
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality profile. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para ver las series temporales de una estadística recopilada en varias ejecuciones de calidad de datos:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_statistics_for_data_quality_result(self, profile_id):
"""
Outputs an array of datapoints for each statistic in the input result.
:param result_id: The profile id of a AWS Glue Data Quality run
"""
try:
profile = self.glue_client.list_data_quality_statistics(
ProfileId = profile_id
)
statistics = [self.glue_client.list_data_quality_statistics(
StatisticId = s['StatisticId']
) for s in profile['Statistics']]
return statistics
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para ver el modelo de detección de anomalías de una estadística específica:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_result_for_statistic(self, statistic_id, profile_id):
"""
Outputs the details (bounds) of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model_result(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality model results. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para excluir un punto de datos de la referencia de la detección de anomalías de su modelo estadístico:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_statistic(self, statistic_id, profile_ids):
"""
Annotate some points along a given statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param statistic_id the statistic timeseries to annotate
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.batch_put_data_quality_statistic_annotation(
InclusionAnnotations = [
{'ProfileId': prof_id,
'StatisticId': statistic_id,
'InclusionAnnotation': 'EXCLUDE'} for prof_id in profile_ids
]
)
return response['FailedInclusionAnnotations']
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para ver el estado del entrenamiento del modelo de detección de anomalías de una estadística específica:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def get_model_training_status_for_statistic(self, statistic_id, profile_id):
"""
Outputs the status of anomaly detection training for the given statistic at the given profile.
:param statistic_id the model's statistic (the timeseries it is tracking)
:param profile_id the profile associated with the model (a point in the timeseries)
"""
try:
model = self.glue_client.get_data_quality_model(
ProfileId = profile_id, StatisticId = statistic_id
)
return model
except ClientError as err:
logger.error(
"Couldn't retrieve Data Quality statistics. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para excluir todos los resultados de una ejecución de calidad de datos específica a partir de las referencias de la detección de anomalías:**
```
class GlueWrapper:
"""Encapsulates AWS Glue actions."""
def __init__(self, glue_client):
"""
:param glue_client: A Boto3 AWS Glue client.
"""
self.glue_client = glue_client
def apply_exclusions_to_profile(self, profile_id):
"""
Exclude datapoints produced by a run across statistic timeseries.
This example excludes the provided values; INCLUDE can also be used to undo this action.
:param profile_id the profiles we want to exclude (points in the timeseries)
"""
try:
response = self.glue_client.put_data_quality_profile_annotation(
ProfileId = profile_id,
InclusionAnnotation = "EXCLUDE"
)
return response
except ClientError as err:
logger.error(
"Couldn't store Data Quality annotations. Here's why: %s: %s",
err.response['Error']['Code'], err.response['Error']['Message'])
raise
```
**Para obtener los resultados de una ejecución de calidad de datos determinada y mostrarlos:**
Con un `runID` de Calidad de datos de AWS Glue, puede extraer el `resultID` para obtener los resultados reales, tal y como se muestra a continuación:
```
response = client.get_data_quality_ruleset_evaluation_run(
RunId='dqrun-abca77ee126abe1378c1da1ae0750d7dxxxx'
)
resultID = response['ResultIds'][0]
response = client.get_data_quality_result(
ResultId=resultID
)
print(resp['RuleResults'])
```
# Configuración de alertas, implementaciones y programación
En este tema se describe cómo configurar alertas, implementaciones y programación para Calidad de datos de Glue de AWS Glue.
**Contents**
+ [Configuración de alertas y notificaciones en la integración de Amazon EventBridge](#data-quality-alerts-eventbridge)
+ [Opciones de configuración adicionales para el patrón de eventos](#data-quality-alerts-eventbridge-config-options)
+ [Formatación de notificaciones como correos electrónicos](#data-quality-alerts-eventbridge-format-notifications)
+ [Configuración de alertas y notificaciones en la integración de CloudWatch](#data-quality-alerts-cloudwatch)
+ [Cómo consultar los resultados de calidad de los datos para crear paneles](#data-quality-alerts-querying-results)
+ [Implementación de reglas de calidad de datos mediante AWS CloudFormation](#data-quality-deploy-cfn)
+ [Programación de reglas de calidad de datos](#data-quality-scheduling-rules)
## Configuración de alertas y notificaciones en la integración de Amazon EventBridge
Calidad de datos de AWS Glue es compatible con la publicación de eventos de EventBridge, que se emiten al completar una evaluación del conjunto de reglas de calidad de datos. De este modo, puede configurar fácilmente alertas cuando fallen las reglas de calidad de datos.
Este es un ejemplo de un evento al evaluar los conjuntos de reglas de calidad de los datos en el Data Catalog. Con esta información, puede revisar los datos que están disponibles con Amazon EventBridge. Puede realizar llamadas a la API adicionales para obtener más información. Por ejemplo, llama a la API `get_data_quality_result` con el ID de resultado para obtener los detalles de una ejecución concreta.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_DATA_CATALOG",
"runId":"dqrun-12334567890",
"databaseName": "db-123",
"tableName": "table-123",
"catalogId": "123456789012"
},
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00,
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
Este es un ejemplo de evento que se publica al evaluar los conjuntos de reglas de calidad de los datos en los blocs de notas ETL de AWS Glue o AWS Glue Studio.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Data Quality Evaluation Results Available",
"source":"aws.glue-dataquality",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":[],
"detail":{
"context": {
"contextType": "GLUE_JOB",
"jobId": "jr-12334567890",
"jobName": "dq-eval-job-1234",
"evaluationContext": "",
}
"resultID": "dqresult-12334567890",
"rulesetNames": ["rulset1"],
"state":"SUCCEEDED",
"score": 1.00
"rulesSucceeded": 100,
"rulesFailed": 0,
"rulesSkipped": 0
}
}
```
Para que la evaluación de la calidad de los datos se ejecute tanto en el Catálogo de datos como en los trabajos de ETL, la opción **Publicar métricas en Amazon CloudWatch**, que está seleccionada de forma predeterminada, debe permanecer seleccionada para que la publicación de EventBridge funcione.
**Configuración de notificaciones de EventBridge**
![\[Propiedades de calidad de datos en AWS CloudFormation\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-properties-cfn.png)
Para recibir los eventos emitidos y definir los objetivos, debe configurar las reglas de Amazon EventBridge. Para crear reglas:
1. Abra la consola de Amazon EventBridge.
1. Elija **Reglas** en la sección **Buses** de la barra de navegación.
1. Elija **Create Rule**.
1. En **Definir los detalles de las reglas**:
1. En Nombre, escriba `myDQRule`.
1. Ingrese la descripción (opcional).
1. Para el bus de eventos, seleccione su bus de eventos. Si no tiene uno, déjelo como predeterminado.
1. En Tipo de regla, seleccione **Regla con un patrón de evento** y luego elija **Siguiente**.
1. En **Construir patrón de evento**:
1. En el origen del evento, seleccione **Eventos de AWS o eventos de socios de EventBridge**.
1. Omita la sección de eventos de muestra.
1. Para el método de creación, seleccione **Usar forma de patrón**.
1. Para el patrón de eventos:
1. Seleccione **Servicios de AWS** para el origen del evento.
1. Seleccione **Calidad de datos de Glue** para servicio de AWS.
1. Seleccione **Resultados de la evaluación de la calidad de los datos disponibles** para el tipo de evento.
1. Seleccione **FALLA** para estado(s) específico(s). A continuación, puede ver un patrón de eventos similar al siguiente:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"state": ["FAILED"]
}
}
```
1. Para más opciones de configuración, consulte [Opciones de configuración adicionales para el patrón de eventos](#data-quality-alerts-eventbridge-config-options).
1. En **Objetivo(s) seleccionado(s)**:
1. Para **Tipos de objetivos**, seleccione el **Servicio de AWS**.
1. Utilice el menú desplegable **Seleccionar objetivo** para elegir el servicio de AWS al que desee conectarse (SNS, Lambda, SQS, etc.) y, a continuación, seleccione **Siguiente.**
1. En **Configurar etiqueta(s)**, haga clic en **Agregar nuevas etiquetas** para agregar etiquetas opcionales y, a continuación, seleccione **Siguiente**.
1. Aparecerá una página de resumen de todas las selecciones. Selecciona **Crear regla** en la parte inferior.
### Opciones de configuración adicionales para el patrón de eventos
Además de filtrar el evento en función del éxito o el fracaso, puede que desee filtrar más los eventos según distintos parámetros.
Para ello, vaya a la sección Patrón de eventos y seleccione **Editar patrón** para especificar parámetros adicionales. Tenga en cuenta que los campos del patrón de eventos distinguen entre mayúsculas y minúsculas. A continuación, se muestran ejemplos de cómo configurar el patrón de eventos.
Para capturar eventos de una tabla en particular que evalúe conjuntos de reglas específicos, utilice este tipo de patrón:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_DATA_CATALOG"],
"databaseName": "db-123",
"tableName": "table-123",
},
"rulesetNames": ["ruleset1", "ruleset2"]
"state": ["FAILED"]
}
}
```
Para capturar eventos de trabajos específicos de la experiencia ETL, utilice este tipo de patrón:
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"context": {
"contextType": ["GLUE_JOB"],
"jobName": ["dq_evaluation_job1", "dq_evaluation_job2"]
},
"state": ["FAILED"]
}
}
```
Para capturar eventos con una puntuación inferior a un umbral específico (por ejemplo, 70 %):
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"score": [{
"numeric": ["<=", 0.7]
}]
}
}
```
### Formatación de notificaciones como correos electrónicos
A veces es necesario enviar una notificación por correo electrónico con un formato adecuado a los equipos de la empresa. Puede utilizar Amazon EventBridge y AWS Lambda para conseguirlo.
![\[Notificación de calidad de datos con formato de correo electrónico\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data_quality_sample_email.png)
El siguiente código de ejemplo se puede utilizar para formatear las notificaciones de calidad de los datos a fin de generar correos electrónicos.
```
import boto3
import json
from datetime import datetime
sns_client = boto3.client('sns')
glue_client = boto3.client('glue')
sns_topic_arn = 'arn:aws:sns:::'
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
sns_client.publish(
TopicArn=sns_topic_arn,
Message=message_text,
Subject=subject_text
)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
## Configuración de alertas y notificaciones en la integración de CloudWatch
Nuestro enfoque recomendado es configurar alertas de calidad de datos mediante Amazon EventBridge, ya que Amazon EventBridge requiere una configuración única para alertar a los clientes. Sin embargo, algunos clientes prefieren Amazon CloudWatch por estar más familiarizados. Para estos clientes, ofrecemos la integración con Amazon CloudWatch.
Cada evaluación de Calidad de datos de AWS Glue emite un par de métricas nombradas `glue.data.quality.rules.passed` (que indican el número de reglas que se han aprobado) y `glue.data.quality.rules.failed` (que indican el número de reglas no aprobadas) por ejecución de calidad de datos. Puede usar esta métrica emitida para crear alarmas que alerten a los usuarios si una determinada cantidad de calidad de datos cae por debajo de un umbral. Para empezar a configurar una alarma que envíe un correo electrónico a través de una notificación de Amazon SNS, siga los pasos que se indican a continuación:
Para empezar a configurar una alarma que envíe un correo electrónico a través de una notificación de Amazon SNS, siga los pasos que se indican a continuación:
1. Abra la consola de Amazon CloudWatch.
1. Seleccione **Todas las métricas** en **Métricas**. Verá un espacio de nombres adicional en Espacios de nombres personalizados denominado Calidad de datos de Glue.
**nota**
Al iniciar una ejecución de Calidad de datos de AWS Glue, asegúrese de que la casilla **Publicar métricas en Amazon CloudWatch** esté habilitada. De lo contrario, las métricas de esa ejecución concreta no se publicarán en Amazon CloudWatch.
En el espacio de nombres `Glue Data Quality`, puede ver las métricas que se emiten por tabla y por conjunto de reglas. Para este tema, utilizaremos la `glue.data.quality.rules.failed` regla y la alarma si este valor supera 1 (lo que indica que, si vemos un número de evaluaciones de reglas fallidas superior a 1, queremos que se nos notifique).
1. Para crear la alarma, seleccione **Todas las alarmas** en **Alarmas**.
1. Elija **Crear alarma**.
1. Elija **Seleccionar métrica**.
1. Seleccione la métrica `glue.data.quality.rules.failed` correspondiente a la tabla que creó y, a continuación, elija **Seleccionar métrica**.
1. En la pestaña **Especificar métrica y condiciones**, en la sección **Métricas**:
1. En **Statistic** (Estadística), elija **Sum** (Suma).
1. Para **Periodo**, seleccione **1 minuto**.
1. En la sección **Condiciones**:
1. En **Threshold type (Tipo de umbral)**, elija **Static (Estático)**.
1. Para **Siempre que glue.data.quality.rules.failed sea…**, seleccione **Mayor que/Igual a**.
1. Para **que...**, ingrese **1** como valor umbral.
Estas selecciones implican que si la métrica `glue.data.quality.rules.failed` emite un valor mayor o igual a 1, activaremos una alarma. Sin embargo, si no hay datos, los consideraremos aceptables.
1. Elija **Siguiente**.
1. En **Acciones de configuración**:
1. Para la sección **Desencadenador de estado de alarma**, elija **En alarma**.
1. Para la sección **Enviar una notificación al siguiente tema de SNS**, seleccione **Crear un tema nuevo para enviar una notificación a través de un nuevo tema de SNS**.
1. En **Puntos de conexión de correo electrónico que recibirán la notificación**, ingrese una dirección de correo electrónico. Luego haga clic en **Crear tema**.
1. Elija **Siguiente**.
1. En **Nombre de la alarma**, ingrese `myFirstDQAlarm` y, a continuación, seleccione **Siguiente**.
1. Aparecerá una página de resumen de todas las selecciones. Seleccione **Crear alarma** en la parte inferior.
Ahora puede ver la alarma que se crea desde el panel de alarmas de Amazon CloudWatch.
## Cómo consultar los resultados de calidad de los datos para crear paneles
Es posible que desee crear un panel para mostrar los resultados de calidad de sus datos. Hay dos formas de hacer esto:
**Configure Amazon EventBridge con el siguiente código para escribir los datos en Amazon S3:**
```
import boto3
import json
from datetime import datetime
s3_client = boto3.client('s3')
glue_client = boto3.client('glue')
s3_bucket = 's3-bucket-name'
def write_logs(log_metadata):
try:
filename = datetime.now().strftime("%m%d%Y%H%M%S") + ".json"
key_opts = {
'year': datetime.now().year,
'month': "{:02d}".format(datetime.now().month),
'day': "{:02d}".format(datetime.now().day),
'filename': filename
}
s3key = "gluedataqualitylogs/year={year}/month={month}/day={day}/{filename}".format(**key_opts)
s3_client.put_object(Bucket=s3_bucket, Key=s3key, Body=json.dumps(log_metadata))
except Exception as e:
print(f'Error writing logs to S3: {e}')
def lambda_handler(event, context):
log_metadata = {}
message_text = ""
subject_text = ""
if event['detail']['context']['contextType'] == 'GLUE_DATA_CATALOG':
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['tableName'] = str(event['detail']['context']['tableName'])
log_metadata['databaseName'] = str(event['detail']['context']['databaseName'])
log_metadata['runId'] = str(event['detail']['context']['runId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_table_name: {}\n".format(log_metadata['tableName'])
message_text += "glue_database_name: {}\n".format(log_metadata['databaseName'])
message_text += "run_id: {}\n".format(log_metadata['runId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
else:
log_metadata['ruleset_name'] = str(event['detail']['rulesetNames'][0])
log_metadata['jobName'] = str(event['detail']['context']['jobName'])
log_metadata['jobId'] = str(event['detail']['context']['jobId'])
log_metadata['resultId'] = str(event['detail']['resultId'])
log_metadata['state'] = str(event['detail']['state'])
log_metadata['score'] = str(event['detail']['score'])
log_metadata['numRulesSucceeded'] = str(event['detail']['numRulesSucceeded'])
log_metadata['numRulesFailed'] = str(event['detail']['numRulesFailed'])
log_metadata['numRulesSkipped'] = str(event['detail']['numRulesSkipped'])
message_text += "Glue Data Quality run details:\n"
message_text += "ruleset_name: {}\n".format(log_metadata['ruleset_name'])
message_text += "glue_job_name: {}\n".format(log_metadata['jobName'])
message_text += "job_id: {}\n".format(log_metadata['jobId'])
message_text += "result_id: {}\n".format(log_metadata['resultId'])
message_text += "state: {}\n".format(log_metadata['state'])
message_text += "score: {}\n".format(log_metadata['score'])
message_text += "numRulesSucceeded: {}\n".format(log_metadata['numRulesSucceeded'])
message_text += "numRulesFailed: {}\n".format(log_metadata['numRulesFailed'])
message_text += "numRulesSkipped: {}\n".format(log_metadata['numRulesSkipped'])
subject_text = "Glue Data Quality ruleset {} run details".format(log_metadata['ruleset_name'])
resultID = str(event['detail']['resultId'])
response = glue_client.get_data_quality_result(ResultId=resultID)
RuleResults = response['RuleResults']
message_text += "\n\nruleset details evaluation steps results:\n\n"
subresult_info = []
for dic in RuleResults:
subresult = "Name: {}\t\tResult: {}\t\tDescription: \t{}".format(dic['Name'], dic['Result'], dic['Description'])
if 'EvaluationMessage' in dic:
subresult += "\t\tEvaluationMessage: {}".format(dic['EvaluationMessage'])
subresult_info.append({
'Name': dic['Name'],
'Result': dic['Result'],
'Description': dic['Description'],
'EvaluationMessage': dic.get('EvaluationMessage', '')
})
message_text += "\n" + subresult
log_metadata['resultrun'] = subresult_info
write_logs(log_metadata)
return {
'statusCode': 200,
'body': json.dumps('Message published to SNS topic')
}
```
Después de escribir en Amazon S3, puede utilizar los rastreadores de AWS Glue para registrarse en Athena y consultar las tablas.
**Configure una ubicación de Amazon S3 durante una evaluación de la calidad de los datos:**
Al ejecutar tareas de calidad de datos en el Data Catalog de AWS Glue o en la ETL de AWS Glue, puede proporcionar una ubicación de Amazon S3 para escribir los resultados de calidad de los datos en Amazon S3. Puede usar la siguiente sintaxis para crear una tabla que haga referencia al objetivo para leer los resultados de calidad de los datos.
Tenga en cuenta que debe ejecutar las consultas `CREATE EXTERNAL TABLE` y `MSCK REPAIR TABLE` por separado.
```
CREATE EXTERNAL TABLE (
catalogid string,
databasename string,
tablename string,
dqrunid string,
evaluationstartedon timestamp,
evaluationcompletedon timestamp,
rule string,
outcome string,
failurereason string,
evaluatedmetrics string)
PARTITIONED BY (
`year` string,
`month` string,
`day` string)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES (
'paths'='catalogId,databaseName,dqRunId,evaluatedMetrics,evaluationCompletedOn,evaluationStartedOn,failureReason,outcome,rule,tableName')
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://glue-s3-dq-bucket-us-east-2-results/'
TBLPROPERTIES (
'classification'='json',
'compressionType'='none',
'typeOfData'='file');
```
```
MSCK REPAIR TABLE ;
```
Una vez que haya creado la tabla anterior, podrá ejecutar consultas analíticas con Amazon Athena.
## Implementación de reglas de calidad de datos mediante AWS CloudFormation
Puede usar AWS CloudFormation para crear reglas de calidad de datos. Para obtener más información, consulte [Pilas de AWS CloudFormation para AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/populate-with-cloudformation-templates.html).
## Programación de reglas de calidad de datos
Puede programar las reglas de calidad de los datos mediante los métodos siguientes:
+ Programe las reglas de calidad de los datos desde el Data Catalog: los usuarios sin código pueden utilizar esta opción para programar fácilmente los escaneos de calidad de datos. AWS Calidad de datos de Glue creará la programación en Amazon EventBridge. Para programar las reglas de calidad de los datos:
+ Navegue hasta el conjunto de reglas y haga clic en **Ejecutar**.
+ En la **Frecuencia de ejecución**, seleccione la programación deseada y proporcione un **Nombre de tarea**. Este nombre de tarea es el nombre de su programación en EventBridge.
+ Utilice Amazon EventBridge y AWS Step Functions para organizar las evaluaciones y recomendaciones de las normas de calidad de los datos.
# Cifrado de datos en reposo para Calidad de datos de AWS Glue
AWS Glue Data Quality proporciona cifrado de forma predeterminada para proteger los datos en reposo confidenciales de los clientes mediante claves de cifrado propiedad de AWS.
## Claves propiedad de AWS
Calidad de datos de AWS Glue utiliza estas claves para cifrar automáticamente los activos de Calidad de datos de los clientes. No puede ver, administrar ni usar las claves propiedad de AWS ni auditar su uso. Sin embargo, no necesita realizar ninguna acción ni cambiar ningún programa para proteger las claves que cifran los datos. Para obtener más información, consulte las [claves propias de AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk) en la Guía para desarrolladores de AWS KMS.
El cifrado de los datos en reposo de forma predeterminada ayuda a reducir la sobrecarga operativa y la complejidad que implica la protección de los datos confidenciales. Al mismo tiempo, le permite crear aplicaciones seguras que cumplen con los estrictos requisitos normativos y de conformidad con el cifrado.
Si bien no puede deshabilitar esta capa de cifrado ni seleccionar un tipo de cifrado alternativo, puede agregar una segunda capa de cifrado sobre las claves de cifrado propias de AWS. Para ello, elija una clave administrada por el cliente al crear sus recursos de Calidad de datos.
## Claves administradas por el cliente
**Claves administradas por el cliente**: Calidad de datos de AWS Glue admite el uso de una clave simétrica administrada por el cliente que usted crea, posee y administra. Esto agrega una segunda capa de cifrado sobre el cifrado propio existente de AWS. Como usted tiene el control total de esta capa de cifrado, puede realizar tareas como las siguientes:
+ Establecer y mantener políticas de claves
+ Establecer y mantener concesiones y políticas de IAM
+ Habilitar y deshabilitar políticas de claves
+ Rotar el material criptográfico
+ Agregar etiquetas.
+ Crear alias de clave
+ Programar la eliminación de claves
Para más información, consulte las [Claves administradas por el cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) en la Guía para desarrolladores de AWS KMS.
En la siguiente tabla se resume cómo Calidad de datos de AWS Glue cifra los diferentes activos de Calidad de datos.
| Tipo de datos | Cifrado de AWS de clave propia | Clave de cifrado administrada por el cliente |
| --- | --- | --- |
| **Conjunto de reglas de calidad de datos** Cadena de conjunto de reglas de DQDL a la que hace referencia el conjunto de reglas de DQ persistente. Por ahora, estos conjuntos de reglas persistentes solo se utilizan en la experiencia del Catálogo de datos de AWS Glue. | Habilitado | Habilitado |
| **Resultados del analizador o de la regla de calidad de los datos** Artefactos de resultados que contienen el estado de superado o no superado de cada regla en un conjunto de reglas, así como las métricas recopiladas tanto por las reglas como por los analizadores. | Habilitado | Habilitado |
| **Observaciones** Las observaciones se generan cuando se detecta una anomalía en los datos. Contiene información sobre los límites superior e inferior esperados, y una regla sugerida basada en estos límites. Si se generan, se muestran junto con los resultados de calidad de datos. | Habilitado | Habilitado |
| **Statistics** Contiene información sobre las métricas recopiladas después de evaluar los datos según un conjunto de reglas, como el valor de la métrica (p. ej., RowCount o integridad), los nombres de las columnas y otros metadatos. | Habilitado | Habilitado |
| **Modelos estadísticos de detección de anomalías** Los modelos estadísticos contienen la serie temporal de los límites superior e inferior de una métrica determinada generada a partir de evaluaciones anteriores de los datos de los clientes. | Habilitado | Habilitado |
**nota**
Calidad de datos de AWS habilita automáticamente el cifrado en reposo utilizando claves propias de AWS para proteger los datos de identificación personal sin cargo alguno. Sin embargo, se aplicarán cargos de AWS KMS por el uso de una clave administrada por el cliente. Para obtener más información sobre los precios, consulte [Precios de AWS KMS](https://aws.amazon.com/kms/pricing/).
Para obtener más información sobre AWS KMS, consulte [AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
## Crear una clave administrada por el cliente
Puede crear una clave simétrica administrada por el cliente a través de la Consola de administración de AWS o las API de AWS KMS.
**Para crear una clave simétrica administrada por el cliente:**
+ Siga los pasos para [Crear claves AWS KMS de cifrado simétrico](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) descritos en la Guía para desarrolladores de AWS Key Management Service.
### Política de claves
Las políticas de clave controlan el acceso a la clave administrada por el cliente. Cada clave administrada por el cliente debe tener exactamente una política de clave, que contiene instrucciones que determinan quién puede usar la clave y cómo puede utilizarla. Cuando crea la clave administrada por el cliente, puede especificar una política de clave. Para obtener más información, consulte [Políticas de claves de AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) en la Guía para desarrolladores de AWS Key Management Service.
Para utilizar su clave administrada por el cliente con sus recursos de Calidad de datos, en la política de claves deben permitirse las siguientes operaciones de API:
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html): descifra el texto cifrado que se cifró con una clave AWS KMS mediante `GenerateDataKeyWithoutPlaintext`.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html) – proporciona los detalles de la clave administrada por el cliente para permitir que Amazon Location valide la clave.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html): devuelve una clave de datos simétrica única para usarla fuera de AWS KMS. Esta operación devuelve una clave de datos que se cifra bajo una clave KMS de cifrado simétrica especificada. Los bytes de la clave son aleatorios; no están relacionados con el intermediario ni con la clave KMS. Se utiliza para reducir las llamadas a KMS que debe realizar el cliente.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html): descifra el texto cifrado y lo vuelve a cifrar por completo en AWS KMS. Puede utilizar esta operación para cambiar la clave KMS con la que se cifran los datos, por ejemplo, cuando [rota manualmente](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html#rotate-keys-manually) una clave KMS o cambia la clave KMS que protege un texto cifrado. También puede usarla para volver a cifrar el texto cifrado con la misma clave KMS, por ejemplo, para cambiar el [contexto de cifrado](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) de un texto cifrado.
Los siguientes son ejemplos de declaraciones de política que puede agregar para Amazon Location:
```
"Statement" : [
{
"Sid" : "Allow access to principals authorized to use AWS Glue Data Quality",
"Effect" : "Allow",
"Principal" : {
"AWS": "arn:aws:iam:::role/ExampleRole"
},
"Action" : [
"kms:Decrypt",
"kms:DescribeKey",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:ReEncrypt*"
],
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"kms:ViaService" : "glue.amazonaws.com",
"kms:CallerAccount" : "111122223333"
}
},
{
"Sid": "Allow access for key administrators",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:*"
],
"Resource": "arn:aws:kms:region:111122223333:key/key_ID"
},
{
"Sid" : "Allow read-only access to key metadata to the account",
"Effect" : "Allow",
"Principal" : {
"AWS" : "arn:aws:iam::111122223333:root"
},
"Action" : [
"kms:Describe*",
"kms:Get*",
"kms:List*",
],
"Resource" : "*"
}
]
```
### Notas sobre el uso de claves KMS en Calidad de datos de AWS Glue
Calidad de datos de AWS Glue no admite transiciones de clave. Esto significa que si cifra sus activos de Calidad de datos con la clave A y decide pasarse a la clave B, no volveremos a cifrar los datos cifrados con la clave A para usar la clave B. Puede cambiar a la clave B, pero tendrá que mantener el acceso a la clave A para acceder a los datos previamente cifrados con la clave A.
Para obtener más información sobre la especificación de permisos en una política, consulte [Permisos para los servicios de AWS en políticas de claves](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-services.html) en la Guía para desarrolladores de AWS Key Management Service.
Para obtener más información sobre la solución de problemas de acceso a las claves, consulte [Solución de problemas de acceso a las claves](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html) en la Guía para desarrolladores de AWS Key Management Service.
## Creación de una configuración de seguridad
En AWS Glue, el [recurso Configuraciones de seguridad](encryption-security-configuration.md) contiene las propiedades que se necesitan cuando se escriben datos cifrados.
**Para cifrar sus activos de calidad de datos:**
1. En **Configuración de cifrado**, vaya a **Configuración avanzada** y elija **Habilitar el cifrado de calidad de datos**
1. Seleccione su clave KMS o elija **Crear una clave AWS KMS**
![\[La captura de pantalla muestra la página Agregar configuración de seguridad. Se selecciona la opción Habilitar el cifrado de calidad de datos.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/data-quality-add-security-configuration.png)
## Contexto de cifrado de Calidad de datos de AWS Glue
Un [contexto de cifrado](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) es un conjunto opcional de pares clave-valor que pueden contener información contextual adicional sobre los datos.
AWS KMS utiliza el contexto de cifrado como [datos autenticados adicionales](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad) para admitir el [cifrado autenticado](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad). Cuando se incluye un contexto de cifrado en una solicitud para cifrar datos, AWS KMS vincula el contexto de cifrado a los datos cifrados. Para descifrar los datos, debe incluir el mismo contexto de cifrado en la solicitud.
### Ejemplo de contexto de cifrado de Calidad de datos de AWS Glue
```
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "beacon:ACTIVE"
}
```
### Uso del contexto de cifrado para la supervisión
Si utiliza una clave simétrica gestionada por el cliente para cifrar su rastreador o su colección de geocercas, también puede utilizar el contexto de cifrado en los registros y registros de auditoría para identificar cómo se utiliza la clave gestionada por el cliente. El contexto de cifrado también aparece en los registros generados por AWS CloudTrail o Amazon CloudWatch Logs.
## Monitoreo de las claves de cifrado para Calidad de datos de AWS Glue
Cuando utiliza una clave AWS KMS administrada por el cliente con sus recursos de Calidad de datos de AWS Glue, puede utilizar AWS CloudTrail o Amazon CloudWatch Logs para realizar un seguimiento de las solicitudes que Calidad de datos de AWS Glue envía a AWS KMS.
Los siguientes ejemplos son eventos de AWS CloudTrail para que `GenerateDataKeyWithoutPlainText` y `Decrypt` monitoreen las operaciones de KMS solicitadas por Calidad de datos de AWS para acceder a los datos que se cifraron con su clave administrada por el cliente.
**Decrypt**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "Decrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE",
"version": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**GenerateDataKeyWithoutPlaintext**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-02T20:03:10Z",
"eventSource": "kms.amazonaws.com",
"eventName": "GenerateDataKeyWithoutPlaintext",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"keyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"encryptionAlgorithm": "SYMMETRIC_DEFAULT",
"encryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
}
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
**ReencyRPT**
```
{
"eventVersion": "1.09",
"userIdentity": {
"type": "AssumedRole",
"arn": "arn:aws:sts::111122223333:role/CustomerRole",
"accountId": "111122223333",
"invokedBy": "glue.amazonaws.com"
},
"eventTime": "2024-07-17T21:34:41Z",
"eventSource": "kms.amazonaws.com",
"eventName": "ReEncrypt",
"awsRegion": "us-east-1",
"sourceIPAddress": "glue.amazonaws.com",
"userAgent": "glue.amazonaws.com",
"requestParameters": {
"destinationEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:ACTIVE"
"version": "branch:version:12345678-SAMPLE"
},
"destinationKeyId": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"sourceAAD": "1234567890-SAMPLE+Z+lqoYOHj7VtWxJLrvh+biUFbliYDAQkobM=",
"sourceKeyId": "arn:aws:kms:ap-southeast-2:585824196334:key/17ca05ca-a8c1-40d7-b7fd-30abb569a53a",
"destinationEncryptionAlgorithm": "SYMMETRIC_DEFAULT",
"sourceEncryptionContext": {
"kms-arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"branch-key-id": "111122223333+arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE",
"hierarchy-version": "1",
"aws-crypto-ec:aws:glue:securityConfiguration": "111122223333:customer-security-configuration-name",
"create-time": "2024-06-07T13:47:23:000861Z",
"tablename": "AwsGlueMlEncryptionKeyStore",
"type": "branch:version:ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE"
},
"destinationAAD": "1234567890-SAMPLE",
"sourceEncryptionAlgorithm": "SYMMETRIC_DEFAULT"
},
"responseElements": null,
"requestID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"eventID": "ff000af-00eb-00ce-0e00-ea000fb0fba0SAMPLE",
"readOnly": true,
"resources": [
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
},
{
"accountId": "111122223333",
"type": "AWS::KMS::Key",
"ARN": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-123456SAMPLE"
}
],
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "111122223333",
"eventCategory": "Management"
}
```
## Más información
Los siguientes recursos proporcionan más información sobre cifrado de datos en reposo.
+ Para obtener más información acerca de los [conceptos básicos de AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html), consulte la Guía para desarrolladores de AWS Key Management Service.
+ Para obtener más información sobre las [prácticas recomendadas de seguridad de AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/best-practices.html), consulte la Guía para desarrolladores de AWS Key Management Service.
# Solución de problemas de calidad de datos de AWS Glue
Si detecta errores en la Calidad de datos de AWS Glue, utilice las siguientes soluciones como ayuda para encontrar el origen de los problemas y corregirlos.
**Contents**
+ [Error: falta el módulo Calidad de datos de AWS Glue](#data-quality-trouble-error-1)
+ [Error: permisos de AWS Lake Formation insuficientes](#data-quality-trouble-error-2)
+ [Error: los conjuntos de reglas no disponen de un nombre único](#data-quality-trouble-error-3)
+ [Error: tablas con caracteres especiales](#data-quality-trouble-error-4)
+ [Error: error de desbordamiento con un conjunto de reglas grande](#data-quality-trouble-error-5)
+ [Error: el estado general de la regla falló](#data-quality-trouble-error-6)
+ [AnalysisException: no es posible verificar la existencia de la base de datos predeterminada](#data-quality-trouble-error-7)
+ [Mensaje de error: el mapa de teclas proporcionado no es adecuado para determinados marcos de datos](#data-quality-trouble-error-8)
+ [Excepción en la clase de usuario: java.lang.RuntimeException: no fue posible recuperar los datos. Para obtener más información, consulte los registros en CloudWatch](#data-quality-trouble-error-9)
+ [ERROR DE INICIO: error al descargar desde S3 para bucket](#data-quality-trouble-error-10)
+ [InvalidInputException (estado: 400): las reglas de calidad de datos no se pueden analizar](#data-quality-trouble-error-11)
+ [Error: EventBridge no activa los trabajos de calidad de datos de Glue según la programación que configuré](#data-quality-trouble-error-12)
+ [Errores de CustomSQL](#data-quality-trouble-error-13)
+ [Reglas dinámicas](#data-quality-trouble-error-14)
+ [Excepción en la Clase de usuario: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException](#data-quality-trouble-error-15)
+ [UNCLASSIFIED\$1ERROR; IllegalArgumentException: Error de análisis: no se proporcionaron reglas ni analizadores, no hay una alternativa viable en la entrada](#data-quality-trouble-error-16)
## Error: falta el módulo Calidad de datos de AWS Glue
**Mensaje de error**: ningún módulo se llama “awsgluedq”.
**Solución**: este error se produce al ejecutar Calidad de datos de AWS Glue en una versión no compatible. AWS Calidad de datos de Glue solo es compatible con la versión 3.0 de Glue y versiones posteriores.
## Error: permisos de AWS Lake Formation insuficientes
**Mensaje de error**: excepción en la clase de usuario: `com.amazonaws.services.glue.model.AccessDeniedException`: permisos de Lake Formation insuficientes en impact\$1sdg\$1involvement (servicio: AWS Glue; código de estado: 400; código de error: AccessDeniedException; ID de solicitud: 465ae693-b7ba-4df0-a4e4-6b17xxxxxxxx; proxy: nulo).
**Solución**: es necesario que dé permisos suficientes en AWS Lake Formation.
## Error: los conjuntos de reglas no disponen de un nombre único
**Mensaje de error**: excepción en la clase de usuario: ...services.glue.model.AlreadyExistsException: ya hay otro conjunto de reglas con el mismo nombre.
**Solución**: los conjuntos de reglas son globales y es necesario que sean únicos.
## Error: tablas con caracteres especiales
**Mensaje de error**: excepción en la clase de usuario: org.apache.spark.sql.AnalysisException: no se puede resolver “C” dado el conjunto de columnas de entrada: [primary.data\$1end\$1time, primary.data\$1start\$1time, primary.end\$1time, primary.last\$1updated, primary.message, primary.process\$1date, primary.rowhash, primary.run\$1by, primary.run\$1id, primary.start\$1time, primary.status]; línea 1 posición 44;.
**Solución**: actualmente existe una limitación que impide que Calidad de datos de AWS Glue se ejecute en tablas con caracteres especiales como “.”.
## Error: error de desbordamiento con un conjunto de reglas grande
**Mensaje de error**: excepción en la clase de usuario: java.lang.StackOverflowError.
**Solución**: si tiene un conjunto de reglas grande de más de 2000 reglas, es posible que se produzca este problema. Divida sus reglas en varios conjuntos de reglas.
## Error: el estado general de la regla falló
**Condición de error**: mi conjunto de reglas es correcto, pero el estado general de mi regla tiene errores.
**Solución**: lo más probable es que este error sea porque eligió la opción de publicar las métricas en Amazon CloudWatch mientras publicaba. Si su conjunto de datos está en una VPC, es posible que su VPC no permita que AWS Glue publique métricas en Amazon CloudWatch. En este caso, debe configurar un punto de conexión para que la VPC pueda acceder a Amazon CloudWatch.
## AnalysisException: no es posible verificar la existencia de la base de datos predeterminada
**Condición de error**: AnalysisException: no se puede verificar la existencia de la base de datos predeterminada: com.amazonaws.services.glue.model.AccessDeniedException: permiso(s) de Lake Formation insuficiente(s) por defecto (servicio: AWS Glue; código de estado: 400; código de error: AccessDeniedException; ID de solicitud: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX; proxy: nulo)
**Solución**: en la integración del catálogo del trabajo de AWS Glue, AWS Glue siempre intenta comprobar si la base de datos predeterminada existe o no utiliza AWS Glue `GetDatabase API`. Cuando no se concede el permiso `DESCRIBE` de Lake Formation o se concede el permiso `GetDatabase IAM`, el trabajo falla al verificar la existencia de la base de datos predeterminada.
Para resolverlo:
1. Agregue el permiso `DESCRIBE` en Lake Formation para la base de datos predeterminada.
1. Configure el rol de IAM asociado al trabajo de AWS Glue como creador de bases de datos en Lake Formation. Esto creará automáticamente una base de datos predeterminada y otorgará los permisos de Lake Formation necesarios para el rol.
1. Deshabilite la opción `--enable-data-catalog`. (Se muestra como **Usar Data Catalog como metaalmacén de Hive** en AWS Glue Studio).
Si no necesita la integración Data Catalog de Spark SQL en el trabajo, puede desactivarlo.
## Mensaje de error: el mapa de teclas proporcionado no es adecuado para determinados marcos de datos
**Condición de error**: el mapa de teclas dado no es adecuado para determinados marcos de datos.
**Solución**: utiliza el tipo de regla **DataSetMatch** y las claves de unión están duplicadas. Las claves de unión deben ser únicas y no deben ser NULAS. En los casos en los que no pueda tener claves de unión que sean únicas, considere la posibilidad de usar otros tipos de reglas, como **AggregateMatch**, para hacer coincidir los datos de resumen.
## Excepción en la clase de usuario: java.lang.RuntimeException: no fue posible recuperar los datos. Para obtener más información, consulte los registros en CloudWatch
**Condición de error**: excepción en la clase de usuario: java.lang.RuntimeException: no fue posible recuperar los datos. Para obtener más información, consulte los registros de CloudWatch.
**Solución**: esto sucede cuando crea reglas de calidad de datos en una tabla basada en Amazon S3 que se compara con Amazon RDS o Amazon Redshift. En estos casos, AWS Glue no puede cargar la conexión. En cambio, intente configurar la regla de calidad de datos en el conjunto de datos de Amazon Redshift o de Amazon RDS. Este es un error conocido.
## ERROR DE INICIO: error al descargar desde S3 para bucket
**Condición de error**: ERROR DE INICIO: error durante la descarga desde S3 para bucket: `aws-glue-ml-data-quality-assets-us-east-1, key: jars/aws-glue-ml-data-quality-etl.jar.Access Denied (Service: Amazon S3; Status Code: 403; Please refer logs for details) `.
**Solución**: los permisos en el rol transferidos a Calidad de datos de AWS Glue deben permitir la lectura desde la ubicación de Amazon S3 previa. Esta política de IAM debe estar asociada con la función:
```
{
"Sid": "allowS3",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::aws-glue-ml-data-quality-assets-/*"
}
```
Consulte la [autorización de calidad de los datos](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html) para obtener información detallada sobre los permisos. Estas bibliotecas son necesarias para evaluar la calidad de los datos de sus conjuntos de datos.
## InvalidInputException (estado: 400): las reglas de calidad de datos no se pueden analizar
**Condición de error**: InvalidInputException (estado: 400): las reglas de calidad de datos no se pueden analizar.
**Solución**: hay muchas posibilidades de que se produzca este error. Una posibilidad es que las reglas contengan comillas simples. Revise que sean comillas dobles. Por ejemplo:
```
Rules = [
ColumnValues "tipo_vinculo" in ["CODO", "DOCO", "COCO", "DODO"] AND "categoria" = 'ES"
AND "cod_bandera" = 'CEP'
```
Cambie esto a:
```
Rules = [
(ColumnValues "tipovinculo" in [ "CODO", "DOCO", "COCO", "DODO"]) AND (ColumnValues "categoria" = "ES")
AND (ColumnValues "codbandera" = "CEP")
]
```
## Error: EventBridge no activa los trabajos de calidad de datos de Glue según la programación que configuré
**Condición de error**: EventBridge no activa trabajos de AWS Glue Data Quality según la programación que configuré.
**Solución**: es posible que el rol que activa el trabajo no tenga los permisos necesarios. Asegúrese de que el rol que usa para activar los trabajos tenga los permisos necesarios mencionados en la [configuración de IAM necesaria para programar las ejecuciones de evaluación](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html#data-quality-iam-setup-evaluation-runs).
## Errores de CustomSQL
**Condición de error**:` The output from CustomSQL must contain at least one column that matches the input dataset for AWS Glue Data Quality to provide row level results. The SQL query is a valid query but no columns from the SQL result are present in the Input Dataset. Ensure that matching columns are returned from the SQL`.
**Solución**: la consulta SQL es válida, pero asegúrese de seleccionar únicamente las columnas de la tabla principal. Se puede producir este error cuando selecciona funciones de agregación como sumar o contar en las columnas de la tabla principal.
**Condición de error**:` There was a problem when executing your SQL statement: cannot resolve "Col"`.
**Solución**: esta columna no está presente en la tabla principal.
**Condición de error**:` The columns that are returned from the SQL statement should only belong to the primary table. "In this case, some columns ( Col ) belong to reference table"`.
**Solución**: en las consultas SQL, cuando una la tabla principal con otras tablas de referencia, asegúrese de que la instrucción de selección solo contenga los nombres de las columnas de la tabla principal para generar resultados a nivel de fila para la tabla principal.
## Reglas dinámicas
**Condición de error**`: Dynamic rules require job context, and cannot be evaluated in interactive session or data preview.`.
**Causa:** es posible que este mensaje de error aparezca en los resultados de la vista previa de datos o en otras sesiones interactivas cuando hay reglas de calidad de datos dinámicas en el conjunto de reglas. Las reglas dinámicas hacen referencia a métricas históricas asociadas con un nombre de trabajo y un contexto de evaluación determinados, por lo que no se pueden evaluar en sesiones interactivas.
**Solución**: Al ejecutar el trabajo de AWS Glue se generarán métricas históricas, a las que se podrá hacer referencia en futuras ejecuciones del mismo trabajo.
**Condición de error**:
+ ` [RuleType] rule only supports simple atomic operands in thresholds.`.
+ `Function last not yet implemented for [RuleType] rule.`
**Resolución**: Por lo general, se aceptan reglas dinámicas para todos los tipos de reglas de DQDL en expresiones numéricas (consulte la referencia sobre [DQDL](dqdl.md)). Sin embargo, algunas reglas que producen diversas métricas, como ColumnValues y ColumnLength, aún no se aceptan.
**Condición de error**:` Binary expression operands must resolve to a single number.`.
**Causa**: las reglas dinámicas aceptan expresiones binarias, como `RowCount > avg(last(5)) * 0.9`. En este caso, la expresión binaria es `avg(last(5)) * 0.9`. Esta regla es válida ya que ambos operandos, `avg(last(5))` y `0.9`, se resuelven en un solo número. Un ejemplo incorrecto es `RowCount > last(5) * 0.9`, ya que `last(5)` generará una lista que no se puede comparar de manera significativa con el recuento de filas actual.
**Solución**: use las funciones de agregación para reducir un operando con valores de lista a un solo número.
**Condición de error**:
+ `Rule threshold results in list, and a single value is expected. Use aggregation functions to produce a single value. Valid example: sum(last(10)), avg(last(10)).`
+ `Rule threshold results in empty list, and a single value is expected.`
**Causa**: es posible usar las reglas dinámicas para comparar alguna característica del conjunto de datos con sus valores históricos. La última función permite recuperar varios valores históricos, siempre que se dé un argumento entero positivo. Por ejemplo, `last(5)` recuperará los cinco últimos valores que se observaron en las ejecuciones de tareas de su regla.
**Solución**: es necesario utilizar una función de agregación para reducir estos valores a un solo número, para poder realizar una comparación significativa con el valor observado en la ejecución de tareas actual.
Ejemplos válidos:
+ `RowCount >= avg(last(5))`
+ `RowCount > last(1)`
+ `RowCount < last()`
Ejemplo no válido: `RowCount > last(5)`.
**Condición de error**:
+ `Function index used in threshold requires positive integer argument.`
+ `Index argument must be an integer. Valid syntax example: RowCount > index(last(10, 2)), which means RowCount must be greater than third most recent execution from last 10 job runs.`
**Solución**: al crear reglas dinámicas, puede usar la función de agregación `index` para seleccionar un valor histórico de una lista. Por ejemplo, `RowCount > index(last(5)`: 1) comprobará si el recuento de filas observado en el trabajo actual es estrictamente superior al segundo recuento de filas más reciente observado en su trabajo. `index` está indexado a cero.
**Condición de error**:` IllegalArgumentException: Parsing Error: Rule Type: DetectAnomalies is not valid`.
**Resolución**: la detección de anomalías solo está disponible en la versión 4.0. de AWS Glue.
**Condición de error**:` IllegalArgumentException: Parsing Error: Unexpected condition for rule of type ... no viable alternative at input ...`.
Nota: `...` es dinámico. Ejemplo: : `IllegalArgumentException: Parsing Error: Unexpected condition for rule of type RowCount with number return type, line 4:19 no viable alternative at input '>last'`.
**Resolución**: la detección de anomalías solo está disponible en la versión 4.0. de AWS Glue.
## Excepción en la Clase de usuario: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException
**Condición del error**`: Exception in User Class: org.apache.spark.sql.AnalysisException: org.apache.hadoop.hive.ql.metadata.HiveException: Unable to fetch table mailpiece_submitted. StorageDescriptor#InputFormat cannot be null for table: mailpiece_submitted (Service: null; Status Code: 0; Error Code: null; Request ID: null; Proxy: null)`
**Causa:** Apache Iceberg se utiliza en el Catálogo de datos de AWS Glue y el atributo de formato de entrada en el Catálogo de datos de AWS Glue está vació.
**Solución**: este problema se produce cuando se utiliza el tipo de regla CustomSQL en la regla de calidad de datos. Una forma de solucionarlo es utilizar “primario” o agregar el nombre del catálogo `glue_catalog.` a `. in Custom ruletype`.
## UNCLASSIFIED\$1ERROR; IllegalArgumentException: Error de análisis: no se proporcionaron reglas ni analizadores, no hay una alternativa viable en la entrada
**Condición del error**`: UNCLASSIFIED_ERROR; IllegalArgumentException: Parsing Error: No rules or analyzers provided., no viable alternative at input`
**Resolución**: el DQDL no se puede analizar. Hay algunos casos en los que esto puede ocurrir. Si utiliza reglas compuestas, asegúrese de que estén entre paréntesis.
```
(RowCount >= avg(last(10)) * 0.6) and (RowCount <= avg(last(10)) * 1.4) instead of
RowCount >= avg(last(10)) * 0.6 and RowCount <= avg(last(10)) * 1.4
```