",
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"
}
"""
)
)
}
```
Dans AWS Glue Data Catalog, vous pouvez facilement configurer cette option dans l'interface utilisateur, comme indiqué ci-dessous.
![\[La capture d’écran montre une fenêtre de paramètres de règles composites dans laquelle vous pouvez choisir la configuration d’évaluation des règles entre ligne et colonne. Si vous choisissez Row, les règles composites se comporteront comme une règle unique évaluant la ligne entière. Si vous choisissez Column, les règles composites évalueront les règles individuelles dans l’ensemble du jeu de données et combineront les résultats.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/composite-rule-settings.png)
Une fois définies, les règles composites se comporteront comme une règle unique évaluant la ligne entière. L’exemple suivant illustre ce comportement.
```
# 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 |
+------+------+------------------------------------------------------------+---------------------------+
```
Certaines règles ne peuvent pas être prises en charge dans cette fonctionnalité, car leur résultat global repose sur des seuils ou des ratios. Elles sont répertoriées ci-dessous.
Règles basées sur des ratios :
+ Exhaustivité
+ DatasetMatch
+ ReferentialIntegrity
+ Unicité
Règles dépendantes de seuils :
Lorsque les règles suivantes sont incluses dans un seuil, elles ne sont pas prises en charge. Cependant, les règles qui n’impliquent pas `with threshold` restent prises en charge.
+ ColumnDataType
+ ColumnValues
+ CustomSQL
### Expressions
Si un type de règle ne produit pas de réponse booléenne, vous devez fournir une expression en tant que paramètre afin de créer une réponse booléenne. Par exemple, la règle suivante vérifie la moyenne de toutes les valeurs d’une colonne par rapport à une expression afin de renvoyer un résultat vrai ou faux.
```
Mean "colA" between 80 and 100
```
Certains types de règles tels que `IsUnique` et `IsComplete` renvoient déjà une réponse booléenne.
Le tableau suivant répertorie les expressions pouvant être utilisées dans les règles DQDL.
**Expressions DQDL prises en charge**
| Expression | Description | Exemple |
| --- | --- | --- |
| =x | Correspond à true si la réponse du type de règle est égale àx. | Completeness "colA" = "1.0",
ColumnValues "colA" = "2022-06-30"
|
| \$1=x | x devient vrai si la réponse du type de règle n'est pas égale àx. | ColumnValues "colA" != "a",
ColumnValues "colA" != "2022-06-30"
|
| > x | Correspond à true si la réponse du type de règle est supérieure àx. | ColumnValues "colA" > 10
|
| < x | Correspond à true si la réponse du type de règle est inférieure àx. | ColumnValues "colA" < 1000,
ColumnValues "colA" < "2022-06-30"
|
| >= x | Permet de déterminer true si la réponse du type de règle est supérieure ou égale àx. | ColumnValues "colA" >= 10
|
| <= x | Permet de déterminer true si la réponse du type de règle est inférieure ou égale àx. | ColumnValues "colA" <= 1000
|
| entre x et y | Se traduit par true si la réponse du type de règle se situe dans une plage spécifiée (exclusif). Utilisez ce type d’expression uniquement pour les types numériques et date. | Mean "colA" between 8 and 100,
ColumnValues "colA" between "2022-05-31" and "2022-06-30"
|
| pas entre x et y | Se traduit par true si la réponse du type de règle ne se situe pas dans une plage spécifiée (inclusif). Vous ne devez utiliser ce type d’expression que pour les types numériques et les dates. | ColumnValues "colA" not between "2022-05-31" and "2022-06-30"
|
| dans [a, b, c, ...] | Se traduit par true si la réponse du type de règle se trouve dans le jeu spécifié. | ColumnValues "colA" in [ 1, 2, 3 ],
ColumnValues "colA" in [ "a", "b", "c" ]
|
| pas dans [a, b, c, ...] | Se traduit par true si la réponse du type de règle ne se trouve pas dans le jeu spécifié. | ColumnValues "colA" not in [ 1, 2, 3 ],
ColumnValues "colA" not in [ "a", "b", "c" ]
|
| allumettes /ab\$1c/i | Se traduit par true si la réponse du type de règle correspond à une expression régulière. | ColumnValues "colA" matches "[a-zA-Z]*"
|
| ne correspond pas /ab\$1c/i | Se traduit par true si la réponse du type de règle ne correspond pas à une expression régulière. | ColumnValues "colA" not matches "[a-zA-Z]*"
|
| now() | Fonctionne uniquement avec le type de règle ColumnValues pour créer une expression de date. | ColumnValues "load_date" > (now() - 3 days)
|
| matches/in […]/not matches/notdans [...] with threshold | Spécifie le pourcentage de valeurs qui correspondent aux conditions de la règle. Fonctionne uniquement avec les types de règles ColumnValues, ColumnDataType et 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
|
#### Mots-clés pour NULL, EMPTY et WHITESPACES\$1ONLY
Si vous souhaitez vérifier si une colonne de chaîne contient une valeur nulle, vide ou une chaîne contenant uniquement des espaces blancs, vous pouvez utiliser les mots clés suivants :
+ NULL/null : ce mot clé se traduit par true pour une valeur `null` d’une colonne de chaîne.
`ColumnValues "colA" != NULL with threshold > 0.5` renverrait true si plus de 50 % de vos données ne contiennent pas de valeurs nulles.
`(ColumnValues "colA" = NULL) or (ColumnLength "colA" > 5)` renverrait true pour toutes les lignes qui ont une valeur nulle ou dont la longueur est supérieure à 5. *Notez que cela nécessitera l'utilisation de l'option « compositeRuleEvaluation .method » = « ROW ».*
+ EMPTY/empty : ce mot clé se traduit par true pour une valeur de chaîne vide (“”) dans une colonne de chaîne. Certains formats de données transforment les valeurs nulles d’une colonne de chaînes en chaînes vides. Ce mot clé permet de filtrer les chaînes vides dans vos données.
`(ColumnValues "colA" = EMPTY) or (ColumnValues "colA" in ["a", "b"])` renverrait true si une ligne est vide, « a » ou « b ». *Notez que cela nécessite l'utilisation de l'option « compositeRuleEvaluation .method » = « ROW ».*
+ WHITESPACES\$1ONLY/whitespaces\$1only : ce mot clé prend la valeur true pour une chaîne contenant uniquement des espaces blancs (« ») dans une colonne de chaîne.
`ColumnValues "colA" not in ["a", "b", WHITESPACES_ONLY]` renverrait true si une ligne n’est ni « a » ni « b », ni de simples espaces blancs.
Règles prises en charge :
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
Pour une expression numérique ou basée sur une date, si vous souhaitez vérifier si une colonne contient une valeur nulle, vous pouvez utiliser les mots clés suivants.
+ NULL/null : ce mot clé se traduit par true pour une valeur nulle d’une colonne de chaîne.
`ColumnValues "colA" in [NULL, "2023-01-01"]` renverrait true si une date de votre colonne est `2023-01-01` ou nulle.
`(ColumnValues "colA" = NULL) or (ColumnValues "colA" between 1 and 9)` renverrait true pour toutes les lignes qui ont une valeur nulle ou dont les valeurs sont comprises entre 1 et 9. *Notez que cela nécessitera l'utilisation de l'option « compositeRuleEvaluation .method » = « ROW ».*
Règles prises en charge :
+ [ColumnValues](https://docs.aws.amazon.com/glue/latest/dg/dqdl.html#dqdl-rule-types-ColumnValues)
#### Filtrage avec la clause Where
**Note**
La clause Where n'est prise en charge que dans AWS Glue 4.0.
Vous pouvez filtrer vos données lorsque vous créez des règles. Cela s’avère utile lorsque vous souhaitez appliquer des règles conditionnelles.
```
where " "
```
Le filtre doit être spécifié avec le mot clé `where`, suivi d’une instruction SparkSQL valide placée entre guillemets `("")`.
Si vous souhaitez ajouter la clause Where à une règle avec un seuil, elle doit être spécifiée avant la condition de seuil.
```
where "valid SparkSQL statement>" with threshold
```
Avec cette syntaxe, vous pouvez écrire des règles comme les suivantes.
```
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)"
```
Nous allons vérifier que l’instruction SparkSQL fournie est valide. Si elle n’est pas valide, l’évaluation des règles échouera et nous lancerons un `IllegalArgumentException` au format suivant :
```
Rule where "" has provided an invalid where clause :
```
**Comportement de la clause Where lorsque l’identification des enregistrements d’erreur au niveau des lignes est activée**
Avec AWS Glue Data Quality, vous pouvez identifier les enregistrements spécifiques qui ont échoué. Lorsque vous appliquez une clause Where à des règles qui prennent en charge les résultats au niveau des lignes, nous étiquetons les lignes filtrées par la clause Where en tant que `Passed`.
Si vous préférez étiqueter séparément les lignes filtrées en tant que `SKIPPED`, vous pouvez définir les paramètres `additionalOptions` suivants pour la tâche 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"
}
"""
)
)
}
```
À titre d’exemple, reportez-vous à la règle et à la trame de données suivantes :
```
IsComplete att2 where "att1 = 'a'"
```
| id | att1 | att2 | Résultats au niveau des lignes (par défaut) | Résultats au niveau des lignes (option ignorée) | Commentaires |
| --- | --- | --- | --- | --- | --- |
| 1 | a | f | PASSED | PASSED | |
| 2 | b | d | PASSED | SKIPPED | La ligne est filtrée, car att1 n’est pas "a". |
| 3 | a | null | ÉCHEC | ÉCHEC | |
| 4 | a | f | PASSED | PASSED | |
| 5 | b | null | PASSED | SKIPPED | La ligne est filtrée, car att1 n’est pas "a". |
| 6 | a | f | PASSED | PASSED | |
### Constantes
Dans DQDL, vous pouvez définir des valeurs constantes et les référencer tout au long de votre script. Cela permet d'éviter les problèmes liés aux limites de taille des requêtes, par exemple lorsque vous travaillez avec des instructions SQL volumineuses susceptibles de dépasser les limites autorisées. En affectant ces valeurs aux constantes, vous pouvez simplifier votre DQDL et éviter d'atteindre ces limites.
L'exemple suivant montre comment définir et utiliser une constante :
```
mySql = "select count(*) from primary"
Rules = [
CustomSql $mySql between 0 and 100
]
```
Dans cet exemple, la requête SQL est affectée à la constante`mySql`, qui est ensuite référencée dans la règle à l'aide du `$` préfixe.
### Étiquettes
Les étiquettes constituent un moyen efficace d'organiser et d'analyser les résultats relatifs à la qualité des données. Vous pouvez interroger les résultats à l'aide d'étiquettes spécifiques pour identifier les règles défaillantes au sein de catégories particulières, compter les résultats des règles par équipe ou par domaine et créer des rapports ciblés pour les différentes parties prenantes.
Par exemple, vous pouvez appliquer toutes les règles relatives à l'équipe financière à l'aide d'une étiquette `"team=finance"` et générer un rapport personnalisé pour présenter les indicateurs de qualité spécifiques à l'équipe financière. Vous pouvez étiqueter les règles de haute priorité avec `"criticality=high"` pour hiérarchiser les efforts de correction. Les étiquettes peuvent être créées dans le cadre du DQDL. Vous pouvez interroger les étiquettes dans le cadre des résultats des règles, des résultats au niveau des lignes et des réponses des API, ce qui facilite l'intégration à vos flux de travail de surveillance et de reporting existants.
**Note**
Les étiquettes ne sont disponibles que dans AWS Glue ETL et ne sont pas disponibles dans le Data Quality basé sur le catalogue de données AWS Glue.
#### Syntaxe pour les étiquettes DQDL
Le DQDL prend en charge les étiquettes par défaut et spécifiques aux règles. Les libellés par défaut sont définis au niveau de l'ensemble de règles et s'appliquent automatiquement à toutes les règles de cet ensemble de règles. Les règles individuelles peuvent également avoir leurs propres étiquettes, et comme les étiquettes sont implémentées sous forme de paires clé-valeur, les étiquettes spécifiques aux règles peuvent remplacer les étiquettes par défaut lorsque vous utilisez la même clé.
L'exemple suivant montre comment utiliser les libellés par défaut et spécifiques aux règles :
```
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]
]
```
##### Contraintes liées aux étiquettes
Les étiquettes sont soumises aux contraintes suivantes :
+ Un maximum de 10 étiquettes par règle DQDL.
+ Les étiquettes sont spécifiées sous forme de liste de paires clé-valeur.
+ La clé et la valeur de l'étiquette distinguent les majuscules et minuscules.
+ La longueur maximale de la clé d'étiquette est de 128 caractères. La clé d'étiquette ne doit pas être vide ou nulle.
+ La longueur maximale de la valeur d'étiquette est de 256 caractères. La valeur de l'étiquette peut être vide ou nulle.
#### Récupération d'étiquettes DQDL
Vous pouvez récupérer des étiquettes DQDL à partir des résultats des règles, des résultats au niveau des lignes et des réponses d'API.
##### Résultats des règles
Les étiquettes DQDL sont toujours visibles dans les résultats des règles. Aucune configuration supplémentaire n'est nécessaire pour les activer.
##### Résultats au niveau des lignes
Les étiquettes DQDL sont désactivées par défaut dans les résultats au niveau des lignes, mais elles peuvent être activées dans. `AdditionalOptions` `EvaluateDataQuality`
L'exemple suivant montre comment activer les étiquettes dans les résultats au niveau des lignes :
```
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"
}""")
)
```
Lorsqu'elle est activée, la trame de données de résultats au niveau des lignes inclut des étiquettes pour chaque règle dans les colonnes`DataQualityRulesPass`, et`DataQualityRulesFail`. `DataQualityRulesSkip`
##### Réponse de l'API
Les étiquettes DQDL sont toujours visibles dans les réponses de l'API sous un nouveau champ `Labels` de l'`RuleResults`objet.
L'exemple suivant montre des libellés dans une réponse d'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"
}
}
]
}
```
### Règles dynamiques
**Note**
Les règles dynamiques ne sont prises en charge que dans AWS Glue ETL et ne le sont pas dans AWS Glue Data Catalog.
Vous pouvez désormais créer des règles dynamiques pour comparer les métriques actuelles produites par vos règles avec leurs valeurs historiques. Ces comparaisons historiques sont rendues possibles en utilisant l’opérateur `last()` dans les expressions. Par exemple, la règle `RowCount > last()` fonctionne lorsque le nombre de lignes de l’exécution en cours est supérieur au nombre de lignes précédent le plus récent pour le même jeu de données. `last()` prend un argument de nombre naturel facultatif décrivant le nombre de métriques précédentes à prendre en compte ; `last(k)` où `k >= 1` renvoyera aux dernières métriques `k`.
+ Si aucun point de données n’est disponible, `last(k)` renverra la valeur par défaut 0,0.
+ Si moins de `k` métriques sont disponibles, `last(k)` renverra toutes les métriques précédentes.
Pour former des expressions valides, utilisez `last(k)`, où `k > 1` nécessite une fonction d’agrégation pour réduire plusieurs résultats historiques en un seul nombre. Par exemple, `RowCount > avg(last(5))` vérifiera si le nombre de lignes du jeu de données actuel est strictement supérieur à la moyenne des cinq dernières lignes du même jeu de données. `RowCount > last(5)` générera une erreur, car le nombre de lignes du jeu de données actuel ne peut pas être comparé de manière significative à une liste.
Fonctions d’agrégation prises en charge :
+ `avg`
+ `median`
+ `max`
+ `min`
+ `sum`
+ `std` (écart-type)
+ `abs` (valeur absolue)
+ `index(last(k), i)` permet de sélectionner la `i`e valeur la plus récente parmi les dernières `k`. `i` est indexé à partir de zéro, donc `index(last(3), 0)` renverra le point de données le plus récent et `index(last(3), 3)` générera une erreur, car il n’y a que trois points de données et nous essayons d’indexer le 4e le plus récent.
**Exemples d'expressions**
**ColumnCorrelation**
+ `ColumnCorrelation "colA" "colB" < avg(last(10))`
**DistinctValuesCount**
+ `DistinctValuesCount "colA" between min(last(10))-1 and max(last(10))+1`
La plupart des types de règles comportant des conditions ou des seuils numériques prennent en charge les règles dynamiques. Consultez le tableau fourni, [Analyseurs et règles](#dqdl-analyzers-table) pour vérifier si les règles dynamiques sont disponibles pour le type de règle que vous utilisez.
**Exclure les statistiques des règles dynamiques**
Vous devrez parfois exclure les statistiques de données de vos calculs de règles dynamiques. Supposons que vous ayez effectué un chargement de données historiques et que vous ne vouliez pas que cela ait un impact sur vos moyennes. Pour ce faire, ouvrez le job dans AWS Glue ETL et choisissez l'onglet **Data Quality**, puis sélectionnez **Statistics** et sélectionnez les statistiques que vous souhaitez exclure. Vous pourrez voir un graphique de tendance ainsi qu’un tableau de statistiques. Sélectionnez les valeurs que vous souhaitez exclure, puis choisissez **Exclure les statistiques**. Les statistiques exclues ne seront désormais pas incluses dans les calculs de règles dynamiques.
![\[La capture d’écran affiche l’option permettant d’exclure ou d’inclure des statistiques dans le menu déroulant après avoir sélectionné une statistique.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-excluding-statistics-from-dynamic-rules.png)
### Analyseurs
**Note**
Les analyseurs ne sont pas pris en charge dans AWS Glue Data Catalog.
Les règles DQDL utilisent des fonctions appelées *analyseurs* pour rassembler des informations sur vos données. Ces informations sont utilisées par l’expression booléenne d’une règle afin de décider si cette dernière doit être considérée comme réussie ou échouée. Par exemple, la RowCount règle `RowCount > 5 ` utilisera un analyseur de nombre de lignes pour découvrir le nombre de lignes de votre ensemble de données et comparer ce nombre à l'expression `> 5` pour vérifier s'il existe plus de cinq lignes dans le jeu de données actuel.
Il est parfois préférable, plutôt que de créer des règles, de créer des analyseurs et de les configurer pour qu’ils génèrent des statistiques utiles à la détection d’anomalies. Dans de tels cas, vous pouvez créer des analyseurs. Les analyseurs se distinguent des règles de la manière suivante.
| Caractéristiques | Analyseurs | Rules |
| --- | --- | --- |
| Partie du jeu de règles | Oui | Oui |
| Génère des statistiques | Oui | Oui |
| Génère des observations | Oui | Oui |
| Peut évaluer et affirmer une condition | Non | Oui |
| Vous pouvez configurer des actions telles que l’arrêt des tâches en cas d’échec ou la poursuite du traitement des tâches | Non | Oui |
Les analyseurs peuvent exister indépendamment sans règles, vous offrant ainsi la possibilité de les configurer rapidement et de créer progressivement des règles de qualité des données.
Certains types de règles peuvent être saisis dans le bloc `Analyzers` de votre jeu de règles afin d’exécuter les règles nécessaires aux analyseurs et rassembler des informations sans avoir à valider une quelconque condition. Certains analyseurs ne sont pas associés à des règles et ne peuvent être saisis que dans le bloc `Analyzers`. Le tableau ci-dessous précise pour chaque élément s’il est pris en charge en tant que règle ou en tant qu’analyseur autonome, avec des informations supplémentaires pour chaque type de règle.
**Exemple d'ensemble de règles avec analyseur**
Le jeu de règles suivant utilise :
+ une règle dynamique permettant de vérifier si la croissance d’un jeu de données est supérieure à sa moyenne mobile au cours des trois dernières exécutions de tâches
+ un analyseur `DistinctValuesCount` permettant d’enregistrer le nombre de valeurs distinctes dans la colonne `Name` du jeu de données
+ un analyseur `ColumnLength` permettant de suivre la taille `Name` minimale et maximale au fil du temps
Les résultats des métriques de l’analyseur peuvent être consultés dans l’onglet Qualité des données de votre exécution de tâche.
```
Rules = [
RowCount > avg(last(3))
]
Analyzers = [
DistinctValuesCount "Name",
ColumnLength "Name"
]
```
AWS Glue Data Quality prend en charge les analyseurs suivants.
| Nom de l’analyseur | Fonctionnalité |
| --- | --- |
| RowCount | Calcule le nombre de lignes pour un jeu de données |
| Completeness | Calcule le pourcentage de complétude d’une colonne |
| Uniqueness | Calcule le pourcentage d’unicité d’une colonne |
| Mean | Calcule la moyenne d’une colonne numérique |
| Sum | Calcule la somme d’une colonne numérique |
| StandardDeviation | Calcule l’écart type d’une colonne numérique |
| Entropy | Calcule l’entropie d’une colonne numérique |
| DistinctValuesCount | Calcule le nombre de valeurs distinctes dans une colonne |
| UniqueValueRatio | Calcule le ratio de valeurs uniques dans une colonne |
| ColumnCount | Calcule le nombre de colonnes d’un jeu de données |
| ColumnLength | Calcule la longueur d’une colonne |
| ColumnValues | Calcule le minimum et le maximum pour les colonnes numériques Calcule le minimum ColumnLength et le maximum ColumnLength pour les colonnes non numériques |
| ColumnCorrelation | Calcule les corrélations de colonnes pour des colonnes données |
| CustomSql | Calcule les statistiques renvoyées par le CustomSQL |
| AllStatistics | Calcule les statistiques suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/dqdl.html) |
### Commentaires
Vous pouvez utiliser le caractère « \$1 » pour ajouter un commentaire à votre document DQDL. Tout ce qui se trouve après le caractère « \$1 » et jusqu’à la fin de la ligne est ignoré par DQDL.
```
Rules = [
# More items should generally mean a higher price, so correlation should be positive
ColumnCorrelation "price" "num_items" > 0
]
```
# Référence du type de règle DQDL
Cette section fournit une référence pour chaque type de règle pris en charge par AWS Glue Data Quality.
**Note**
Le langage DQDL ne prend actuellement pas en charge les données de colonnes imbriquées ou de type liste.
Les valeurs entre crochets dans le tableau ci-dessous seront remplacées par les informations fournies dans les arguments des règles.
Les règles nécessitent généralement un argument supplémentaire pour l’expression.
| Ruletype | Description | Arguments | Métriques rapportées | Prise en charge en tant que règle ? | Prise en charge en tant qu’analyseur ? | Renvoie des résultats au niveau des lignes ? | Prise en charge des règles dynamiques ? | Génère des observations | Prise en charge de la syntaxe de clause Where ? |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| AggregateMatch | Vérifie si deux jeux de données correspondent en comparant des métriques récapitulatives telles que le montant total des ventes. Utile pour permettre aux institutions financières de vérifier si toutes les données sont ingérées à partir de systèmes sources. | Une ou plusieurs agrégations | Lorsque les noms de la première et de la deuxième colonne d’agrégation correspondent : `Column.[Column].AggregateMatch` Lorsque les noms de la première et de la deuxième colonne d’agrégation sont différents : `Column.[Column1,Column2].AggregateMatch` | Oui | Non | Non | Non | Non | Non |
| AllStatistics | Analyseur autonome permettant de rassembler plusieurs métriques pour la colonne fournie d’un jeu de données. | Un seul nom de colonne | Pour les colonnes de tous types : `Dataset.*.RowCount` `Column.[Column].Completeness` `Column.[Column].Uniqueness` Métriques supplémentaires pour les colonnes à valeur de chaîne : `ColumnLength metrics` Métriques supplémentaires pour les colonnes à valeur numérique : `ColumnValues metrics` | Non | Oui | Non | Non | Non | Non |
| ColumnCorrelation | Vérifie dans quelle mesure deux colonnes sont corrélées. | Exactement deux noms de colonne | Multicolumn.[Column1,Column2].ColumnCorrelation | Oui | Oui | Non | Oui | Non | Oui |
| ColumnCount | Vérifie si des colonnes sont supprimées. | Aucune | Dataset.\$1.ColumnCount | Oui | Oui | Non | Oui | Oui | Non |
| ColumnDataType | Vérifie si une colonne est conforme à un type de données. | Exactement un nom de colonne | Column.[Column].ColumnDataType.Compliance | Oui | Non | Non | Oui, dans l’expression de seuil au niveau de la ligne | Non | Oui |
| ColumnExists | Vérifie si des colonnes existent dans un jeu de données. Cela permet aux clients de créer des plateformes de données en libre-service pour s'assurer que certaines colonnes sont disponibles. | Exactement un nom de colonne | N/A | Oui | Non | Non | Non | Non | Non |
| ColumnLength | Vérifie si la longueur des données est cohérente. | Exactement un nom de colonne | `Column.[Column].MaximumLength` `Column.[Column].MinimumLength` Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni : `Column.[Column].ColumnValues.Compliance` | Oui | Oui | Oui, lorsque le seuil au niveau de la ligne est fourni | Non | Oui. Génère uniquement des observations en analysant les longueurs minimale et maximale | Oui |
| ColumnNamesMatchPattern | Vérifie si les noms de colonnes correspondent aux modèles définis. Utile pour les équipes de gouvernance afin d'assurer la cohérence des noms de colonnes. | Une expression régulière pour les noms de colonne | Dataset.\$1.ColumnNamesPatternMatchRatio | Oui | Non | Non | Non | Non | Non |
| ColumnValues | Vérifie si les données sont cohérentes par rapport aux valeurs définies. Cette règle prend en charge les expressions régulières. | Exactement un nom de colonne | `Column.[Column].Maximum` `Column.[Column].Minimum` Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni : `Column.[Column].ColumnValues.Compliance` | Oui | Oui | Oui, lorsque le seuil au niveau de la ligne est fourni | Non | Oui. Génère uniquement des observations en analysant les valeurs minimales et maximales | Oui |
| Exhaustivité | Vérifie la présence de données vides ou NULLs incomplètes. | Exactement un nom de colonne | `Column.[Column].Completeness` | Oui | Oui | Oui | Oui | Oui | Oui |
| CustomSql | Les clients peuvent implémenter presque tous les types de contrôles de qualité des données dans SQL. | Une instruction SQL (Facultatif) Un seuil au niveau de la ligne | `Dataset.*.CustomSQL` Métrique supplémentaire lorsque le seuil au niveau de la ligne est fourni : `Dataset.*.CustomSQL.Compliance` | Oui | Non | Oui, lorsque le seuil au niveau de la ligne est fourni | Oui | Non | Non |
| DataFreshness | Vérifie si les données sont récentes. | Exactement un nom de colonne | Column.[Column].DataFreshness.Compliance | Oui | Non | Oui | Non | Non | Oui |
| DatasetMatch | Compare deux jeux de données et détermine s'ils sont synchronisés. | Nom d’un jeu de données de référence Un mappage de colonnes (Facultatif) Colonnes pour vérifier les correspondances | Dataset.[ReferenceDatasetAlias].DatasetMatch | Oui | Non | Oui | Oui | Non | Non |
| DistinctValuesCount | Vérifie la présence de valeurs dupliquées. | Exactement un nom de colonne | Column.[Column].DistinctValuesCount | Oui | Oui | Oui | Oui | Oui | Oui |
| DetectAnomalies | Vérifie la présence d’anomalies dans les métriques rapportées par un autre type de règle. | Un type de règle | Métrique(s) rapportée(s) par l’argument du type de règle | Oui | Non | Non | Non | Non | Non |
| Entropie | Vérifie l'entropie des données. | Exactement un nom de colonne | Column.[Column].Entropy | Oui | Oui | Non | Oui | Non | Oui |
| IsComplete | Vérifie si 100 % des données sont complètes. | Exactement un nom de colonne | Column.[Column].Completeness | Oui | Non | Oui | Non | Non | Oui |
| IsPrimaryKey | Vérifie si une colonne est une clé primaire (non NULL et unique). | Exactement un nom de colonne | Pour une seule colonne : `Column.[Column].Uniqueness` Pour plusieurs colonnes : `Multicolumn.[CommaDelimitedColumns].Uniqueness` | Oui | Non | Oui | Non | Non | Oui |
| IsUnique | Vérifie si 100 % des données sont uniques. | Exactement un nom de colonne | Column.[Column].Uniqueness | Oui | Non | Oui | Non | Non | Oui |
| Mean | Vérifie si la moyenne correspond au seuil défini. | Exactement un nom de colonne | Column.[Column].Mean | Oui | Oui | Oui | Oui | Non | Oui |
| ReferentialIntegrity | Vérifie si deux jeux de données ont une intégrité référentielle. | Un ou plusieurs noms de colonne provenant du jeu de données Un ou plusieurs noms de colonne provenant du jeu de données de référence | Column.[ReferenceDatasetAlias].ReferentialIntegrity | Oui | Non | Oui | Oui | Non | Non |
| RowCount | Vérifie si le nombre d'enregistrements correspond à un seuil. | Aucune | Dataset.\$1.RowCount | Oui | Oui | Non | Oui | Oui | Oui |
| RowCountMatch | Vérifie si le nombre d'enregistrements entre deux jeux de données correspond. | Alias de jeu de données de référence | Dataset.[ReferenceDatasetAlias].RowCountMatch | Oui | Non | Non | Oui | Non | Non |
| StandardDeviation | Vérifie si l'écart type correspond au seuil. | Exactement un nom de colonne | Column.[Column].StandardDeviation | Oui | Oui | Oui | Oui | Non | Oui |
| SchemaMatch | Vérifie si le schéma entre deux jeux de données correspond. | Alias de jeu de données de référence | Dataset.[ReferenceDatasetAlias].SchemaMatch | Oui | Non | Non | Oui | Non | Non |
| Somme | Vérifie si la somme correspond à un seuil défini. | Exactement un nom de colonne | Column.[Column].Sum | Oui | Oui | Non | Oui | Non | Oui |
| Unicité | Vérifie si l'unicité du jeu de données correspond au seuil. | Exactement un nom de colonne | Column.[Column].Uniqueness | Oui | Oui | Oui | Oui | Non | Oui |
| UniqueValueRatio | Vérifie si le ratio de valeur unique correspond au seuil. | Exactement un nom de colonne | Column.[Column].UniqueValueRatio | Oui | Oui | Oui | Oui | Non | Oui |
| FileFreshness | Vérifie si les fichiers dans Amazon S3 sont récents. | Chemin d’accès au fichier ou au dossier et seuil. | `Dataset.*.FileFreshness.Compliance` `Dataset.*.FileCount` | Oui | Non | Non | Non | Non | Non |
| FileMatch | Vérifie si le contenu du fichier correspond à une somme de contrôle ou à un autre fichier. Cette règle utilise des sommes de contrôle pour s’assurer que deux fichiers sont identiques. | Chemin d’accès au fichier ou au dossier source et chemin d’accès au fichier ou au dossier cible. | Aucune statistique n’est générée. | Oui | Non | Non | Non | Non | Non |
| FileSize | Vérifie si la taille d’un fichier correspond à une condition spécifiée. | Chemin d’accès au fichier ou au dossier et seuil. | `Dataset.*.FileSize.Compliance` `Dataset.*.FileCount` `Dataset.*.MaximumFileSize` `Dataset.*.MinimumFileSize` | Oui | Non | Non | Non | Non | Non |
| FileUniqueness | Vérifie si les fichiers sont uniques à l’aide de sommes de contrôle. | Chemin d’accès au fichier ou au dossier et seuil. | `Dataset.*.FileUniquenessRatio` `Dataset.*.FileCount` | Oui | Non | Non | Non | Non | Non |
**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)
+ [Intégralité](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)
+ [Entropie](dqdl-rule-types-Entropy.md)
+ [IsComplete](dqdl-rule-types-IsComplete.md)
+ [IsPrimaryKey](dqdl-rule-types-IsPrimaryKey.md)
+ [IsUnique](dqdl-rule-types-IsUnique.md)
+ [Mean](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)
+ [Somme](dqdl-rule-types-Sum.md)
+ [SchemaMatch](dqdl-rule-types-SchemaMatch.md)
+ [Unicité](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
Vérifie le ratio de deux agrégations de colonnes par rapport à une expression donnée. Ce type de règle fonctionne sur plusieurs jeux de données. Les deux agrégations de colonnes sont évaluées et un ratio est produit en divisant le résultat de la première agrégation de colonnes par le résultat de la seconde agrégation de colonnes. Le ratio est vérifié par rapport à l'expression fournie pour produire une réponse booléenne.
**Syntaxe**
**Agrégation de colonnes**
```
AggregateMatch (.)
```
+ **AGG\$1OPERATION** : l'opération à utiliser pour l'agrégation. À l'heure actuelle, `sum` et `avg` sont pris en charge.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **OPTIONAL\$1REFERENCE\$1ALIAS** : ce paramètre doit être fourni si la colonne provient d'un jeu de données de référence et non du jeu de données principal. Si vous utilisez cette règle dans le catalogue de données AWS Glue, votre alias de référence doit suivre le format « ». .
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **COL\$1NAME** : le nom de la colonne à agréger.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
**Exemple : moyenne**
```
"avg(rating)"
```
**Exemple : somme**
```
"sum(amount)"
```
**Exemple : moyenne de la colonne dans le jeu de données de référence**
```
"avg(reference.rating)"
```
**Règle**
```
AggregateMatch
```
+ **AGG\$1EXP\$11** : la première agrégation de colonnes.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **AGG\$1EXP\$12** : la deuxième agrégation de colonnes.
Types de colonnes pris en charge : octet, décimal, double, virgule flottante, entier, long, court
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : correspondance agrégée à l'aide de la somme**
L'exemple de règle suivant vérifie si la somme des valeurs de la colonne `amount` est exactement égale à la somme des valeurs de la colonne `total_amount`.
```
AggregateMatch "sum(amount)" "sum(total_amount)" = 1.0
```
**Exemple : correspondance agrégée à l'aide de la moyenne**
L'exemple de règle suivant vérifie si la moyenne des valeurs de la colonne `ratings` est égale à au moins 90 % de la moyenne des valeurs de la colonne `ratings` dans le jeu de données `reference`. Le jeu de données de référence est fourni en tant que source de données supplémentaire dans l'expérience ETL ou le catalogue de données.
Dans AWS Glue ETL, vous pouvez utiliser :
```
AggregateMatch "avg(ratings)" "avg(reference.ratings)" >= 0.9
```
Dans le catalogue de données AWS Glue, vous pouvez utiliser :
```
AggregateMatch "avg(ratings)" "avg(database_name.tablename.ratings)" >= 0.9
```
**Comportement null**
La règle `AggregateMatch` ignorera les lignes contenant des valeurs NULL dans le calcul des méthodes d’agrégation (somme/moyenne). Par exemple :
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La moyenne de la colonne `units` sera (0 \$1 20 \$1 40) / 3 = 20. Les lignes 101 et 103 ne sont pas prises en compte dans ce calcul.
# ColumnCorrelation
Vérifie la *corrélation* entre deux colonnes par rapport à une expression donnée. AWS Glue Data Quality utilise le coefficient de corrélation de Pearson pour mesurer la corrélation linéaire entre deux colonnes. Le résultat est un nombre compris entre -1 et 1 qui mesure la force et la direction de la relation.
**Syntaxe**
```
ColumnCorrelation
```
+ **COL\$11\$1NAME** – Nom de la première colonne par rapport à laquelle vous souhaitez évaluer la règle de qualité des données.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **COL\$12\$1NAME** – Nom de la deuxième colonne par rapport à laquelle vous souhaitez évaluer la règle de qualité des données.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : corrélation de colonnes**
L'exemple de règle suivant vérifie si le coefficient de corrélation entre les colonnes `height` et `weight` présente une forte corrélation positive (valeur de coefficient supérieure à 0,8).
```
ColumnCorrelation "height" "weight" > 0.8
```
```
ColumnCorrelation "weightinkgs" "Salary" > 0.8 where "weightinkgs > 40"
```
**Exemples de règles dynamiques**
+ `ColumnCorrelation "colA" "colB" between min(last(10)) and max(last(10))`
+ `ColumnCorrelation "colA" "colB" < avg(last(5)) + std(last(5))`
**Comportement null**
La règle `ColumnCorrelation` ignorera les lignes contenant des valeurs `NULL` dans le calcul de la corrélation. Par exemple :
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
Les lignes 101 et 103 seront ignorées, et la valeur `ColumnCorrelation` sera 1.0.
# ColumnCount
Vérifie le nombre de colonnes du jeu de données principal par rapport à une expression donnée. Dans l'expression, vous pouvez spécifier le nombre de colonnes ou une plage de colonnes à l'aide d'opérateurs tels que `>` et `<`.
**Syntaxe**
```
ColumnCount
```
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : vérification numérique du nombre de colonnes**
L'exemple de règle suivant vérifie si le nombre de colonnes est compris dans une plage donnée.
```
ColumnCount between 10 and 20
```
**Exemples de règles dynamiques**
+ `ColumnCount >= avg(last(10))`
+ `ColumnCount between min(last(10))-1 and max(last(10))+1`
# ColumnDataType
Vérifie si les valeurs d’une colonne donnée peuvent être converties vers le type fourni dans Apache Spark. Accepte une expression `with threshold` pour vérifier la présence d'un sous-ensemble des valeurs de la colonne.
**Syntaxe**
```
ColumnDataType =
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
Types de colonnes pris en charge : type de chaîne
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPECTED\$1TYPE** : le type attendu des valeurs de la colonne.
Valeurs prises en charge : booléen, date, horodatage, entier, double, flottant, long
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** : une expression facultative pour spécifier le pourcentage de valeurs qui doivent être du type attendu.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
**Exemple : les entiers de type colonne en tant que chaînes**
L’exemple de règle suivant vérifie si les valeurs de la colonne donnée, qui est de type chaîne, peuvent être converties en entiers.
```
ColumnDataType "colA" = "INTEGER"
```
**Exemple : les entiers de type colonne en tant que chaînes de caractères vérifient un sous-ensemble de valeurs.**
L’exemple de règle suivant vérifie si plus de 90 % des valeurs de la colonne donnée, qui est de type chaîne, peuvent être converties en entiers.
```
ColumnDataType "colA" = "INTEGER" with threshold > 0.9
```
# ColumnExists
Vérifie si une colonne existe.
**Syntaxe**
```
ColumnExists
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n'importe quel type de colonne
**Exemple : une colonne existe**
L'exemple de règle suivant vérifie si la colonne nommée `Middle_Name` existe.
```
ColumnExists "Middle_Name"
```
# ColumnLength
Vérifie si la longueur de chaque ligne d'une colonne est conforme à une expression donnée.
**Syntaxe**
```
ColumnLength
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : chaîne
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : longueur de ligne de colonne**
L'exemple de règle suivant vérifie si la valeur de chaque ligne de la colonne nommée `Postal_Code` est constituée de 5 caractères.
```
ColumnLength "Postal_Code" = 5
ColumnLength "weightinkgs" = 2 where "weightinkgs > 10"
```
**Comportement null**
La règle `ColumnLength` traite les `NULL` comme des chaînes de longueur 0. Pour une ligne `NULL` :
```
ColumnLength "Postal_Code" > 4 # this will fail
```
```
ColumnLength "Postal_Code" < 6 # this will succeed
```
L’exemple de règle composée suivant fournit un moyen d’annuler explicitement des valeurs `NULL` :
```
(ColumnLength "Postal_Code" > 4) AND (ColumnValues "Postal_Code" != NULL)
```
# ColumnNamesMatchPattern
Vérifie si les noms de toutes les colonnes du jeu de données principal correspondent à l'expression régulière donnée.
**Syntaxe**
```
ColumnNamesMatchPattern
```
+ **PATTERN** : le modèle par rapport auquel vous souhaitez évaluer la règle de qualité des données.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
**Exemple : les noms de colonnes correspondent au modèle**
L'exemple de règle suivant vérifie si toutes les colonnes commencent par le préfixe « aws\$1 »
```
ColumnNamesMatchPattern "aws_.*"
ColumnNamesMatchPattern "aws_.*" where "weightinkgs > 10"
```
# ColumnValues
Exécute une expression en fonction des valeurs d’une colonne.
**Syntaxe**
```
ColumnValues
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n’importe quel type de colonne
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d’informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : valeurs autorisées**
L’exemple de règle suivant vérifie si chaque valeur de la colonne spécifiée fait partie d’un ensemble de valeurs autorisées (dont null, empty, et strings uniquement avec des espaces blancs).
```
ColumnValues "Country" in [ "US", "CA", "UK", NULL, EMPTY, WHITESPACES_ONLY ]
ColumnValues "gender" in ["F", "M"] where "weightinkgs < 10"
```
**Exemple : expression régulière**
L’exemple de règle suivant compare les valeurs d’une colonne à une expression régulière.
```
ColumnValues "First_Name" matches "[a-zA-Z]*"
```
**Exemple : valeurs de date**
L’exemple de règle suivant compare les valeurs d’une colonne de date à une expression de date.
```
ColumnValues "Load_Date" > (now() - 3 days)
```
**Exemple : valeurs numériques**
L’exemple de règle suivant vérifie si les valeurs des colonnes correspondent à une certaine contrainte numérique.
```
ColumnValues "Customer_ID" between 1 and 2000
```
**Comportement null**
Pour toutes les règles `ColumnValues` (à l’exception de `!=` et de `NOT IN`), les lignes `NULL` dérogent à la règle. Si la règle échoue en raison d’une valeur null, la raison de l’échec s’affichera comme suit :
```
Value: NULL does not meet the constraint requirement!
```
L’exemple de règle composée suivant fournit un moyen d’autoriser explicitement des valeurs `NULL` :
```
(ColumnValues "Age" > 21) OR (ColumnValues "Age" = NULL)
```
ColumnValues Les règles annulées utilisant la `not in` syntaxe `!=` et seront transmises aux `NULL` lignes. Par exemple :
```
ColumnValues "Age" != 21
```
```
ColumnValues "Age" not in [21, 22, 23]
```
Les exemples suivants fournissent un moyen de déroger explicitement aux valeurs `NULL`.
```
(ColumnValues "Age" != 21) AND (ColumnValues "Age" != NULL)
```
```
ColumnValues "Age" not in [21, 22, 23, NULL]
```
# Intégralité
Compare le pourcentage de valeurs complètes (non nulles) d’une colonne à une expression donnée.
**Syntaxe**
```
Completeness
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n’importe quel type de colonne
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : pourcentage de valeur nulle**
Les exemples de règles suivants vérifient si plus de 95 % des valeurs d’une colonne sont complètes.
```
Completeness "First_Name" > 0.95
Completeness "First_Name" > 0.95 where "weightinkgs > 10"
```
**Exemples de règles dynamiques**
+ `Completeness "colA" between min(last(5)) - 1 and max(last(5)) + 1`
+ `Completeness "colA" <= avg(last(10))`
**Comportement null**
Remarque sur les formats de données CSV : les lignes vides des colonnes CSV peuvent afficher plusieurs comportements.
+ Si une colonne est de type `String`, la ligne vide sera reconnue comme une chaîne vide et ne dérogera pas à la règle `Completeness`.
+ Si une colonne est d’un autre type de données, comme `Int`, la ligne vide sera reconnue comme `NULL` et dérogera à la règle `Completeness`.
# CustomSQL
Ce type de règle a été étendu pour prendre en charge deux cas d’utilisation :
+ Exécutez une instruction SQL personnalisée sur un jeu de données et compare la valeur renvoyée à une expression donnée.
+ Exécutez une instruction SQL personnalisée dans laquelle vous spécifiez un nom de colonne dans votre instruction SELECT, que vous comparez à une certaine condition pour obtenir des résultats au niveau des lignes.
**Syntaxe**
```
CustomSql
```
+ **SQL\$1STATEMENT** – Instruction SQL qui renvoie une valeur numérique unique, entourée de guillemets doubles.
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : SQL personnalisé pour récupérer le résultat global d’une règle**
Cet exemple de règle utilise une instruction SQL pour récupérer le nombre d’enregistrements d’un jeu de données. La règle vérifie ensuite que le nombre d’enregistrements est compris entre 10 et 20.
```
CustomSql "select count(*) from primary" between 10 and 20
```
**Exemple : SQL personnalisé pour récupérer les résultats au niveau des lignes**
Cet exemple de règle utilise une instruction SQL dans laquelle vous spécifiez un nom de colonne dans votre instruction SELECT, que vous comparez à une certaine condition pour obtenir des résultats au niveau des lignes. Une expression de condition de seuil définit le nombre d’enregistrements qui doivent échouer pour que l’ensemble de la règle échoue. Notez qu’une règle ne peut pas contenir à la fois une condition et un mot clé.
```
CustomSql "select Name from primary where Age > 18"
```
or
```
CustomSql "select Name from primary where Age > 18" with threshold > 3
```
**Important**
L’alias `primary` est le nom du jeu de données que vous souhaitez évaluer. Lorsque vous utilisez des tâches ETL visuelles sur la console, `primary` représente toujours le `DynamicFrame` qui est transmis à la transformation `EvaluateDataQuality.apply()`. Lorsque vous utilisez le catalogue de données AWS Glue pour exécuter des tâches de qualité des données sur une table, `primary` représente la table.
Si vous êtes dans le catalogue AWS Glue, vous pouvez également utiliser les noms de table réels :
```
CustomSql "select count(*) from database.table" between 10 and 20
```
Vous pouvez également joindre plusieurs tables pour comparer différents éléments de données :
```
CustomSql "select count(*) from database.table inner join database.table2 on id1 = id2" between 10 and 20
```
Dans AWS Glue ETL, l’utilisation de CustomSQL permet d’identifier les enregistrements qui ont échoué aux contrôles de qualité des données. Pour que cela fonctionne, vous devez renvoyer les enregistrements qui font partie de la table principale pour laquelle vous évaluez la qualité des données. Les enregistrements renvoyés dans le cadre de la requête sont considérés comme réussis et les enregistrements non renvoyés sont considérés comme ayant échoué. Cela fonctionne en joignant le résultat de votre requête CustomSQL au jeu de données d’origine. La complexité de votre requête SQL peut avoir des répercussions sur les performances.
Pour cela :
+ Vous devez sélectionner au moins une colonne dans votre table principale.
+ `select count(*) from primary` est une requête valide pour la règle OVERALL CustomSQL DQ, mais pas pour le SQL personnalisé au niveau des lignes.
+ Cette règle va générer une erreur lors de l’évaluation : `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.`
+ Dans votre requête SQL, sélectionnez une « clé primaire » dans votre table ou sélectionnez un ensemble de colonnes qui forment une clé composite. À défaut, vous risquez d’obtenir des résultats incohérents en raison de la correspondance de lignes dupliquées et d’une dégradation des performances.
+ Sélectionnez les clés UNIQUEMENT dans votre table principale et non dans vos tables de référence.
La règle suivante permet de s’assurer que les enregistrements dont l’âge est inférieur à 100 sont identifiés comme réussis et que les enregistrements dont l’âge est supérieur sont marqués comme échoués.
```
CustomSql "select id from primary where age < 100"
```
Cette règle CustomSQL sera validée si 50 % des enregistrements ont un âge supérieur à 10 et identifiera également les enregistrements qui ont échoué. Les enregistrements renvoyés par cette règle CustomSQL seront considérés comme réussis, tandis que ceux non renvoyés seront considérés comme ayant échoué.
```
CustomSQL "select ID, CustomerID from primary where age > 10" with threshold > 0.5
```
Remarque : la règle CustomSQL échoue si vous renvoyez des enregistrements qui ne sont pas disponibles dans le jeu de données.
# DataFreshness
Vérifie l’actualisation des données d’une colonne en évaluant la différence entre l’heure actuelle et les valeurs d’une colonne de date. Pour ce type de règle, vous pouvez spécifier une expression temporelle afin de vérifier que les valeurs des colonnes sont à jour.
**Syntaxe**
```
DataFreshness
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonne pris en charge** : Date
+ **EXPRESSION** – Expression numérique exprimée en heures ou en jours. Vous devez spécifier l’unité de temps dans votre expression.
**Exemple : actualisation des données**
Les exemples de règles suivants vérifient l’actualisation des données.
```
DataFreshness "Order_Date" <= 24 hours
DataFreshness "Order_Date" between 2 days and 5 days
```
**Comportement null**
Les règles `DataFreshness` échoueront pour les lignes contenant des valeurs `NULL`. Si la règle échoue en raison d’une valeur null, la raison de l’échec s’affichera comme suit :
```
80.00 % of rows passed the threshold
```
où 20 % des lignes qui ont échoué incluent les lignes avec `NULL`.
L’exemple de règle composée suivant fournit un moyen d’autoriser explicitement des valeurs `NULL` :
```
(DataFreshness "Order_Date" <= 24 hours) OR (ColumnValues "Order_Date" = NULL)
```
**Actualité des données pour les objets Amazon S3**
Vous devrez parfois valider l’actualité des données en fonction de l’heure de création du fichier Amazon S3. Pour ce faire, vous pouvez utiliser le code suivant pour obtenir l’horodatage et l’ajouter à votre trame de données, puis appliquer des contrôles d’actualité des données.
```
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
Vérifie si les données du jeu de données principal correspondent aux données d'un jeu de données de référence. Les deux jeux de données sont joints à l'aide des mappages de colonnes clés fournis. Des mappages de colonnes supplémentaires peuvent être fournis si vous souhaitez vérifier l'égalité des données uniquement dans ces colonnes. Notez que **DataSetMatch**pour fonctionner, vos clés de jointure doivent être uniques et ne pas être NULL (elles doivent être une clé primaire). Si vous ne remplissez pas ces conditions, le message d'erreur suivant affiche : « La clé de distribution fournie ne convient pas à des cadres de données donnés ». Dans les cas où vous ne pouvez pas avoir de clés jointes uniques, envisagez d'utiliser d'autres types de règles, par exemple **AggregateMatch**pour établir une correspondance sur des données récapitulatives.
**Syntaxe**
```
DatasetMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** : l'alias du jeu de données de référence avec lequel vous comparez les données du jeu de données principal.
+ **KEY\$1COLUMN\$1MAPPINGS** : une liste de noms de colonnes séparés par des virgules qui forment une clé dans les jeux de données. Si les noms de colonnes ne sont pas identiques dans les deux jeux de données, vous devez les séparer par `->`
+ **OPTIONAL\$1MATCH\$1COLUMN\$1MAPPINGS** : vous pouvez fournir ce paramètre si vous souhaitez vérifier les données correspondantes uniquement dans certaines colonnes. Il utilise la même syntaxe que les mappages de colonnes clés. Si ce paramètre n'est pas fourni, la correspondance portera sur les données de toutes les autres colonnes. Les autres colonnes non-clés doivent porter le même nom dans les deux jeux de données.
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : faire correspondre des jeux de données à l'aide de la colonne ID**
L'exemple de règle suivant vérifie que plus de 90 % du jeu de données principal correspond au jeu de données de référence, en utilisant la colonne « ID » pour joindre les deux jeux de données. Dans ce cas, toutes les colonnes sont comparées.
```
DatasetMatch "reference" "ID" >= 0.9
```
**Exemple : faire correspondre des jeux de données en utilisant plusieurs colonnes clés**
Dans l'exemple suivant, le jeu de données principal et le jeu de données de référence portent des noms différents pour les colonnes clés. `ID_1` et `ID_2` forment ensemble une clé composite dans le jeu de données principal. `ID_ref1` et `ID_ref2` forment ensemble une clé composite dans le jeu de données de référence. Dans ce scénario, vous pouvez utiliser la syntaxe spéciale pour fournir les noms des colonnes.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" >= 0.9
```
**Exemple : faire correspondre des jeux de données à l'aide de plusieurs colonnes clés et vérifie qu'une colonne spécifique correspond**
Cet exemple s'appuie sur l'exemple précédent. Nous voulons vérifier que seule la colonne contenant les montants correspond. Cette colonne est nommée `Amount1` dans le jeu de données principal et `Amount2` dans le jeu de données de référence. Une correspondance exacte est désirée.
```
DatasetMatch "reference" "ID_1->ID_ref1,ID_2->ID_ref2" "Amount1->Amount2" >= 0.9
```
# DistinctValuesCount
Vérifie le nombre de valeurs distinctes dans une colonne par rapport à une expression donnée.
**Syntaxe**
```
DistinctValuesCount
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n’importe quel type de colonne
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : nombre de valeurs de colonne distinctes**
L'exemple de règle suivant vérifie que la colonne nommée `State` contient plus de 3 valeurs distinctes.
```
DistinctValuesCount "State" > 3
DistinctValuesCount "Customer_ID" < 6 where "Customer_ID < 10"
```
**Exemples de règles dynamiques**
+ `DistinctValuesCount "colA" between avg(last(10))-1 and avg(last(10))+1`
+ `DistinctValuesCount "colA" <= index(last(10),2) + std(last(5))`
# Entropie
Vérifie si la valeur d'*entropie* d'une colonne correspond à une expression donnée. L'entropie mesure le niveau d'information contenu dans un message. Compte tenu de la distribution de probabilité des valeurs d'une colonne, l'entropie décrit le nombre de bits nécessaires pour identifier une valeur.
**Syntaxe**
```
Entropy
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n’importe quel type de colonne
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : entropie de colonne**
L'exemple de règle suivant vérifie que la colonne nommée `Feedback` possède une valeur d'entropie supérieure à un.
```
Entropy "Star_Rating" > 1
Entropy "First_Name" > 1 where "Customer_ID < 10"
```
**Exemples de règles dynamiques**
+ `Entropy "colA" < max(last(10))`
+ `Entropy "colA" between min(last(10)) and max(last(10))`
# IsComplete
Vérifie si toutes les valeurs d’une colonne sont complètes (non nulles).
**Syntaxe**
```
IsComplete
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n'importe quel type de colonne
**Exemple : valeurs nulles**
L’exemple suivant vérifie si toutes les valeurs d’une colonne nommée `email` ne sont pas nulles.
```
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"
```
**Comportement null**
Remarque sur les formats de données CSV : les lignes vides des colonnes CSV peuvent afficher plusieurs comportements.
+ Si une colonne est de type `String`, la ligne vide sera reconnue comme une chaîne vide et ne dérogera pas à la règle `Completeness`.
+ Si une colonne est d’un autre type de données, comme `Int`, la ligne vide sera reconnue comme `NULL` et dérogera à la règle `Completeness`.
# IsPrimaryKey
Vérifie si une colonne contient une clé primaire. Une colonne contient une clé primaire si toutes les valeurs de la colonne sont uniques et complètes (non nulles). Vous pouvez également vérifier la présence de clés primaires comportant plusieurs colonnes.
**Syntaxe**
```
IsPrimaryKey
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n'importe quel type de colonne
**Exemple : clé primaire**
L'exemple de règle suivant vérifie si la colonne nommée `Customer_ID` contient une clé primaire.
```
IsPrimaryKey "Customer_ID"
IsPrimaryKey "Customer_ID" where "Customer_ID < 10"
```
**Exemple : clé primaire avec plusieurs colonnes. Tous les exemples suivants sont valides.**
```
IsPrimaryKey "colA" "colB"
IsPrimaryKey "colA" "colB" "colC"
IsPrimaryKey colA "colB" "colC"
```
# IsUnique
Vérifie si toutes les valeurs d'une colonne sont uniques et renvoie une valeur booléenne.
**Syntaxe**
```
IsUnique
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n’importe quel type de colonne
**Exemples**
L'exemple de règle suivant vérifie si toutes les valeurs d'une colonne nommée `email` sont uniques.
```
IsUnique "email"
IsUnique "Customer_ID" where "Customer_ID < 10"]
```
L’exemple de règle suivant vérifie plusieurs colonnes.
```
IsUnique "vendorid" "tpep_pickup_datetime"
```
# Mean
Vérifie si la moyenne de toutes les valeurs d’une colonne correspond à une expression donnée.
**Syntaxe**
```
Mean
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : valeur moyenne**
L’exemple de règle suivant vérifie si la moyenne de toutes les valeurs d’une colonne dépasse un seuil.
```
Mean "Star_Rating" > 3
Mean "Salary" < 6200 where "Customer_ID < 10"
```
**Exemples de règles dynamiques**
+ `Mean "colA" > avg(last(10)) + std(last(2))`
+ `Mean "colA" between min(last(5)) - 1 and max(last(5)) + 1`
**Comportement null**
La règle `Mean` ignorera les lignes contenant des valeurs `NULL` dans le calcul de la moyenne. Par exemple :
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La moyenne de la colonne `units` sera (0 \$1 20 \$1 40) / 3 = 20. Les lignes 101 et 103 ne sont pas prises en compte dans ce calcul.
# ReferentialIntegrity
Vérifie dans quelle mesure les valeurs d'un ensemble de colonnes du jeu de données principal sont un sous-ensemble des valeurs d'un ensemble de colonnes d'un jeu de données de référence.
**Syntaxe**
```
ReferentialIntegrity
```
+ **PRIMARY\$1COLS** : une liste de noms de colonnes séparés par des virgules dans le jeu de données principal.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **REFERENCE\$1DATASET\$1COLS** : ce paramètre contient deux parties séparées par un point. La première partie est l'alias du jeu de données de référence. La deuxième partie est la liste des noms de colonnes du jeu de données de référence, séparés par des virgules et placés entre accolades.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : vérifier l'intégrité référentielle d'une colonne de code postal**
L'exemple de règle suivant vérifie que plus de 90 % des valeurs de la colonne `zipcode` du jeu de données principal sont présentes dans la colonne `zipcode` du jeu de données `reference`.
```
ReferentialIntegrity "zipcode" "reference.zipcode" >= 0.9
```
**Exemple : vérifier l'intégrité référentielle des colonnes de ville et d'État**
Dans l'exemple suivant, des colonnes contenant des informations sur la ville et l'État existent dans le jeu de données principal et dans le jeu de données de référence. Les noms des colonnes sont différents dans les deux jeux de données. La règle vérifie si l'ensemble de valeurs des colonnes du jeu de données principal est exactement égal à l'ensemble de valeurs des colonnes du jeu de données de référence.
```
ReferentialIntegrity "city,state" "reference.{ref_city,ref_state}" = 1.0
```
**Exemples de règles dynamiques**
+ `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
Vérifie le nombre de lignes d'un jeu de données par rapport à une expression donnée. Dans l'expression, vous pouvez spécifier le nombre de lignes ou une plage de lignes à l'aide d'opérateurs tels que `>` et `<`.
**Syntaxe**
```
RowCount
```
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : vérification numérique du nombre de lignes**
L'exemple de règle suivant vérifie si le nombre de lignes est compris dans une plage donnée.
```
RowCount between 10 and 100
RowCount between 1 and 50 where "Customer_ID < 10"
```
**Exemples de règles dynamiques**
```
RowCount > avg(last(10)) *0.8
```
# RowCountMatch
Vérifie le rapport entre le nombre de lignes du jeu de données principal et le nombre de lignes d'un jeu de données de référence par rapport à l'expression donnée.
**Syntaxe**
```
RowCountMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** : alias du jeu de données de référence par rapport auquel comparer le nombre de lignes.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : vérification du nombre de lignes par rapport à un jeu de données de référence**
L'exemple de règle suivant vérifie si le nombre de lignes du jeu de données principal est au moins égal à 90 % du nombre de lignes du jeu de données de référence.
```
RowCountMatch "reference" >= 0.9
```
# StandardDeviation
Vérifie l’écart type de toutes les valeurs d’une colonne par rapport à une expression donnée.
**Syntaxe**
```
StandardDeviation
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : écart type**
L’exemple de règle suivant vérifie si l’écart type des valeurs d’une colonne nommée `colA` est inférieur à une valeur spécifiée.
```
StandardDeviation "Star_Rating" < 1.5
StandardDeviation "Salary" < 3500 where "Customer_ID < 10"
```
**Exemples de règles dynamiques**
+ `StandardDeviation "colA" > avg(last(10) + 0.1`
+ `StandardDeviation "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Comportement null**
La règle `StandardDeviation` ignorera les lignes contenant des valeurs `NULL` dans le calcul de l’écart type. Par exemple :
```
+---+-----------+-----------+
|id |units1 |units2 |
+---+-----------+-----------+
|100|0 |0 |
|101|null |0 |
|102|20 |20 |
|103|null |0 |
|104|40 |40 |
+---+-----------+-----------+
```
L’écart type de la colonne `units1` ne tiendra pas compte des lignes 101 et 103 et donnera 16,33. L’écart type pour la colonne `units2` sera de 16.
# Somme
Vérifie la somme de toutes les valeurs d’une colonne par rapport à une expression donnée.
**Syntaxe**
```
Sum
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour plus d'informations, consultez [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : somme**
L’exemple de règle suivant vérifie si la somme de toutes les valeurs d’une colonne dépasse un seuil donné.
```
Sum "transaction_total" > 500000
Sum "Salary" < 55600 where "Customer_ID < 10"
```
**Exemples de règles dynamiques**
+ `Sum "ColA" > avg(last(10))`
+ `Sum "colA" between min(last(10)) - 1 and max(last(10)) + 1`
**Comportement null**
La règle `Sum` ignorera les lignes contenant des valeurs `NULL` dans le calcul de la somme. Par exemple :
```
+---+-----------+
|id |units |
+---+-----------+
|100|0 |
|101|null |
|102|20 |
|103|null |
|104|40 |
+---+-----------+
```
La somme des colonnes `units` ne tiendra pas compte des lignes 101 et 103 et donnera (0 \$1 20 \$1 40) = 60.
# SchemaMatch
Vérifie si le schéma du jeu de données principal correspond au schéma d'un jeu de données de référence. La vérification du schéma s'effectue colonne par colonne. Le schéma de deux colonnes correspond si les noms et les types sont identiques. L'ordre des colonnes n'importe pas.
**Syntaxe**
```
SchemaMatch
```
+ **REFERENCE\$1DATASET\$1ALIAS** : alias du jeu de données de référence par rapport auquel comparer les schémas.
**Types de colonnes pris en charge** : octet, décimal, double, virgule flottante, entier, long, court
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : SchemaMatch**
L'exemple de règle suivant vérifie si le schéma du jeu de données principal correspond exactement au schéma d'un jeu de données de référence.
```
SchemaMatch "reference" = 1.0
```
# Unicité
Vérifie le pourcentage de valeurs uniques dans une colonne par rapport à une expression donnée. Les valeurs uniques n'apparaissent qu'une seule fois.
**Syntaxe**
```
Uniqueness
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n’importe quel type de colonne
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple**
L'exemple de règle suivant vérifie si le pourcentage de valeurs uniques d'une colonne correspond à certains critères numériques.
```
Uniqueness "email" = 1.0
Uniqueness "Customer_ID" != 1.0 where "Customer_ID < 10"
```
L’exemple de règle suivant vérifie plusieurs colonnes.
```
Uniqueness "vendorid" "tpep_pickup_datetime" = 1
```
**Exemples de règles dynamiques**
+ `Uniqueness "colA" between min(last(10)) and max(last(10))`
+ `Uniqueness "colA" >= avg(last(10))`
# UniqueValueRatio
Vérifie le *ratio de valeurs uniques* d'une colonne par rapport à une expression donnée. Un ratio de valeurs uniques correspond à la fraction de valeurs uniques divisée par le nombre de toutes les valeurs distinctes d'une colonne. Les valeurs uniques n'apparaissent qu'une seule fois, alors que les valeurs distinctes apparaissent *au moins* une fois.
Par exemple, le jeu `[a, a, b]` contient une valeur unique (`b`) et deux valeurs distinctes (`a` et `b`). Le ratio de valeurs uniques du jeu est donc ½ = 0,5.
**Syntaxe**
```
UniqueValueRatio
```
+ **COL\$1NAME** – Nom de la colonne par rapport à laquelle la règle de qualité des données doit être évaluée.
**Types de colonnes pris en charge** : n’importe quel type de colonne
+ **EXPRESSION** – Expression à exécuter en fonction de la réponse du type de règle afin de produire une valeur booléenne. Pour de plus amples informations, veuillez consulter [Expressions](dqdl.md#dqdl-syntax-rule-expressions).
**Exemple : ratio de valeurs uniques**
Cet exemple vérifie le ratio de valeurs uniques d'une colonne par rapport à une plage de valeurs.
```
UniqueValueRatio "test_score" between 0 and 0.5
UniqueValueRatio "Customer_ID" between 0 and 0.9 where "Customer_ID < 10"
```
**Exemples de règles dynamiques**
+ `UniqueValueRatio "colA" > avg(last(10))`
+ `UniqueValueRatio "colA" <= index(last(10),2) + std(last(5))`
# DetectAnomalies
Détecte les anomalies pour une règle de qualité des données donnée. Chaque exécution d'une DetectAnomalies règle entraîne l'enregistrement de la valeur évaluée pour la règle donnée. Lorsque suffisamment de données sont collectées, l'algorithme de détection des anomalies prend toutes les données historiques pour cette règle donnée et exécute la détection des anomalies. DetectAnomalies la règle échoue lorsqu'une anomalie est détectée. Plus d’informations sur l’anomalie détectée peuvent être obtenues à partir des observations.
**Syntaxe**
```
DetectAnomalies
```
`RULE_NAME` : le nom de la règle pour laquelle vous souhaitez évaluer et détecter des anomalies. Règles prises en charge :
+ "RowCount"
+ "Completeness"
+ "Uniqueness"
+ "Mean"
+ "Sum"
+ "StandardDeviation"
+ "Entropy"
+ "DistinctValuesCount"
+ "UniqueValueRatio"
+ "ColumnLength"
+ "ColumnValues"
+ "ColumnCorrelation"
+ "CustomSQL"
+ "ColumnCount"
`RULE_PARAMETERS` : certaines règles nécessitent des paramètres supplémentaires pour s’exécuter. Reportez-vous à la documentation de la règle concernée pour connaître les paramètres requis.
**Exemple : Anomalies pour RowCount**
Par exemple, si nous voulons détecter des RowCount anomalies, nous indiquons RowCount le nom de la règle.
```
DetectAnomalies "RowCount"
```
**Exemple : Anomalies pour ColumnLength**
Par exemple, si nous voulons détecter des ColumnLength anomalies, nous indiquons le nom de la ColumnLength règle et le nom de la colonne.
```
DetectAnomalies "ColumnLength" "id"
```
# FileFreshness
FileFreshness garantit que vos fichiers de données sont à jour en fonction de l'état que vous fournissez. Il utilise l'heure de dernière modification de vos fichiers pour s'assurer que les fichiers de données ou l'ensemble du dossier le sont up-to-date.
Cette règle regroupe deux métriques :
+ FileFreshness conformité en fonction de la règle que vous avez définie
+ Nombre de fichiers analysés par la règle.
```
{"Dataset.*.FileFreshness.Compliance":1,"Dataset.*.FileCount":1}
```
La détection des anomalies ne prend pas en compte ces métriques.
**Vérification de l’actualité des fichiers**
La règle suivante garantit que tickets.parquet a été créé au cours des dernières 24 heures.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/tickets.parquet" > (now() - 24 hours)
```
**Vérification de l’actualité du dossier**
La règle suivante s’applique si tous les fichiers du dossier ont été créés ou modifiés au cours des dernières 24 heures.
```
FileFreshness "s3://bucket/" >= (now() -1 days)
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" >= (now() - 24 hours)
```
**Vérification de l’actualité d’un dossier ou d’un fichier avec un seuil**
La règle suivante s’applique si 10 % des fichiers du dossier « tickets » ont été créés ou modifiés au cours des 10 derniers jours.
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" < (now() - 10 days) with threshold > 0.1
```
**Vérification de fichiers ou de dossiers avec des dates spécifiques**
Vous pouvez vérifier l’actualité des fichiers pour des jours spécifiques.
```
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"
```
**Vérification de fichiers ou de dossiers avec l’heure**
Vous pouvez l'utiliser FileFreshness pour vous assurer que les fichiers sont arrivés à certaines heures.
```
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"
```
Considérations clés :
+ FileFreshness peut évaluer les fichiers en utilisant des unités de jours, d'heures et de minutes
+ Parfois, elle prend en charge le format matins/après-midi et 24 heures
+ Les heures sont calculées en UTC, sauf si une dérogation est spécifiée.
+ Les dates sont calculées en UTC à 00:00.
FileFreshness qui sont basés sur le temps fonctionnent comme suit :
```
FileFreshness "s3://amzn-s3-demo-bucket/artifacts/file/tickets/" > "21:45"
```
+ Tout d’abord, l’heure « 21:45 » est combinée à la date du jour au format UTC pour créer un champ date-heure.
+ Ensuite, le champ date-heure est converti en un fuseau horaire que vous avez spécifié.
+ Enfin, la règle est évaluée.
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileFreshness "s3://amzn-s3-demo-bucket/" between (now() - 100 minutes) and (now() + 10 minutes) with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# 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$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre, telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with recentFiles = 1 with uriRegex = "inventory_" with filterOrder = ["uriRegex","recentFiles"]
```
Dans l'exemple ci-dessus, le `uriRegex` filtre est d'abord appliqué pour sélectionner uniquement les fichiers correspondant à « inventory\$1 », puis `recentFiles = 1` prend le fichier le plus récent de cet ensemble filtré. Dans le cas contraire`filterOrder`, le comportement par défaut prendrait d'abord le fichier le plus récent, puis appliquerait l'expression régulière, ce qui pourrait entraîner l'absence de correspondance de fichiers si le fichier le plus récent ne correspond pas au modèle.
**Note**
Toutes les valeurs de la `filterOrder` liste doivent faire référence à d'autres balises de filtre (`recentFiles`ou`uriRegex`) également présentes sur la même règle. Les balises non filtrantes telles que `timeZone` ou ne `failFast` sont pas valides dans`filterOrder`.
**Fail-vite**
Lorsqu'elle est définie sur`"true"`, la règle renvoie un échec immédiatement au premier fichier qui ne répond pas à la condition de fraîcheur, au lieu d'évaluer tous les fichiers et de calculer un ratio de conformité.
```
FileFreshness "s3://amzn-s3-demo-bucket/" > (now() - 24 hours) with failFast = "true"
```
**timeZone**
Dérogations de fuseau horaire acceptées, consultez [Allowed Time Zones](https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html) pour connaître les fuseaux horaires pris en charge.
```
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"
```
**Déduction des noms de fichiers directement à partir de trames de données**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données AWS Glue, il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre dataframe et détecter s'ils sont récents.
**Note**
Cette fonctionnalité ne fonctionne que lorsque les fichiers sont correctement lus dans le DynamicFrame ou DataFrame.
```
FileFreshness > (now() - 24 hours)
```
Cette règle permet de trouver le chemin d’accès au dossier ou aux fichiers utilisés pour renseigner l’image dynamique ou la trame de données. Cela fonctionne pour les chemins Amazon S3 ou les tables AWS Glue Data Catalog basées sur Amazon S3. Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer de la **EvaluateDataQuality**transformation immédiatement après une transformation d'Amazon S3 ou de AWS Glue Data Catalog.
![\[La capture d’écran montre un nœud Evaluate Data Quality connecté à un nœud Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-file-freshness.png)
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.
Si vous essayez de le faire dans les deux cas, ou si AWS Glue ne trouve pas les fichiers, AWS Glue générera le message d'erreur suivant : `“Unable to parse file path from DataFrame”`
# FileMatch
La FileMatch règle vous permet de comparer des fichiers à d'autres fichiers ou à des checksums. Elle peut être utile dans certains scénarios :
1. Validation des fichiers reçus de sources externes : vous pouvez vous FileMatch assurer que vous avez reçu les bons fichiers provenant de sources externes en les comparant aux sommes de contrôle. Cela permet de valider l’intégrité des données que vous ingérez.
1. Comparaison de données dans deux dossiers différents : FileMatch peut être utilisé pour comparer des fichiers entre deux dossiers.
Cette règle regroupe une métrique : le nombre de fichiers analysés par la règle.
```
{"Dataset.*.FileCount":1}
```
**Valider le fichier avec une somme de contrôle :**
FileMatch accepte un fichier et une somme de contrôle définie pour s'assurer qu'au moins une somme de contrôle correspond au fichier.
```
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"]
```
Les algorithmes standard suivants sont pris en charge :
+ MD5
+ SHA-1
+ SHA-256
Si vous ne fournissez aucun algorithme, la valeur par défaut est SHA-256.
**Valider tous les fichiers d’un dossier avec un ensemble de sommes de contrôle :**
```
FileMatch "s3://amzn-s3-demo-bucket /" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"] with hashAlgorithm = "MD5"
FileMatch "s3://amzn-s3-demo-bucket /internal-folder/" in ["3ee0d8617ac041793154713e5ef8f319", "7e8617ac041793154713e5ef8f319"]
```
**Comparer des fichiers dans différents dossiers**
```
# 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 vérifiera le contenu des fichiers `original_bucket` et s'assurera qu'ils correspondent à ce qu'ils contiennent`archive_bucket`. La règle échouera s’ils ne correspondent pas exactement. Elle peut également vérifier le contenu de dossiers internes ou de fichiers individuels.
FileMatch peut également vérifier les fichiers individuels les uns par rapport aux autres.
```
FileMatch "s3://amzn-s3-demo-bucket /file_old.json" "s3://amzn-s3-demo-bucket /file_new.json"
```
**Déduction des noms de fichiers directement à partir de trames de données**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données AWS Glue (soutenu par Amazon S3), il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre bloc de données.
**Note**
Cette fonctionnalité ne fonctionne que lorsque les fichiers sont correctement lus dans le DynamicFrame ou 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 somme de contrôle fournie est différente de celle calculée, elle vous FileMatch avertira de la différence.
![\[La capture d'écran montre une règle dont le statut DQ est Rule failed. FileMatch explique l'échec.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-file-match.png)
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# 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$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre, telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileMatch "s3://bucket/" in ["3ee0d8617ac04179sam4713e5ef8f319"] with recentFiles = 1 with uriRegex = "\.json$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Cette balise garantit que les fichiers ne comportent pas de noms en double. Le comportement par défaut est false.
```
FileMatch "s3://amzn-s3-demo-bucket/file.json" in ["3ee0d8617ac04179sam4713e5ef8f319"] with matchFileName = "true"
```
Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer de la **EvaluateDataQuality**transformation immédiatement après une transformation d'Amazon S3 ou de AWS Glue Data Catalog.
![\[La capture d'écran montre une règle dont le statut DQ est Rule failed. FileMatch explique l'échec.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-file-match-transform.png)
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.
# FileUniqueness
L’unicité des fichiers vous permet de vous assurer qu’il n’y a pas de doublons dans les données que vous avez reçues de vos producteurs de données.
Elle rassemble les statistiques de données suivantes :
1. Nombre de fichiers analysés par la règle.
1. Le taux d’unicité des fichiers
```
Dataset.*.FileUniquenessRatio: 1.00, Dataset.*.FileCount: 8.00
```
**Rechercher des fichiers en double dans un dossier :**
```
FileUniqueness "s3://bucket/" > 0.5
FileUniqueness "s3://bucket/folder/" = 1
```
**Déduire les noms de dossiers directement à partir des trames de données pour détecter les doublons :**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données AWS Glue, il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre bloc de données.
**Note**
Lors de l'utilisation de l'inférence, les règles basées sur les fichiers peuvent uniquement détecter les fichiers lus avec succès dans le DynamicFrame ou. DataFrame
```
FileUniqueness > 0.5
```
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# 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$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre, telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileUniqueness "s3://bucket/" > 0.5 with recentFiles = 5 with uriRegex = "\.csv$" with filterOrder = ["uriRegex","recentFiles"]
```
**matchFileName**
Cette balise garantit que les fichiers ne comportent pas de noms en double. Le comportement par défaut est false.
```
FileUniqueness "s3://amzn-s3-demo-bucket/" > 0.5 with matchFileName = "true"
```
Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer de la **EvaluateDataQuality**transformation immédiatement après une transformation d'Amazon S3 ou de AWS Glue Data Catalog.
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.
# FileSize
Le FileSize type de règle vous permet de vous assurer que les fichiers répondent à certains critères de taille de fichier. Cela s’avère utile dans les cas d’utilisation suivants :
1. Assurez-vous que les producteurs n’envoient pas de fichiers vides ou nettement plus petits en traitement.
1. Assurez-vous que vos compartiments cible ne contiennent pas de fichiers plus petits, ce qui pourrait entraîner des problèmes de performances.
FileSize rassemble les métriques suivantes :
1. Compliance : renvoie le pourcentage de fichiers qui atteignent le seuil de règle que vous avez établi
1. File Count : nombre de fichiers analysés par la règle
1. Taille minimale du fichier en octets
1. Taille maximale du fichier en octets
```
Dataset.*.FileSize.Compliance: 1.00,
Dataset.*.FileCount: 8.00,
Dataset.*.MaximumFileSize: 327413121.00,
Dataset.*.MinimumFileSize: 204558920.00
```
La détection des anomalies n’est pas prise en charge pour ces métriques.
**Valider la taille des fichiers**
Cette règle est acceptée lorsque l’élément file.dat est supérieur à 2 Mo.
```
FileSize "s3://amzn-s3-demo-bucket/file.dat" > 2 MB
```
Les unités prises en charge sont les suivantes : o (octets), Mo (mégaoctets), Go (gigaoctets) et To (téraoctets).
**Valider la taille des fichiers dans les dossiers**
```
FileSize "s3://bucket/" > 5 B
FileSize "s3://bucket/" < 2 GB
```
Cette règle sera acceptée si 70 % des fichiers dans s3://amzn-s3-demo-bucket ont une taille comprise entre 2 Go et 1 To.
```
FileSize "s3://amzn-s3-demo-bucket/" between 2 GB and 1 TB with threshold > 0.7
```
**Déduction des noms de fichiers directement à partir de trames de données**
Il n’est pas toujours nécessaire de fournir un chemin d’accès au fichier. Par exemple, lorsque vous créez la règle dans le catalogue de données, il peut être difficile de trouver les dossiers utilisés par les tables du catalogue. AWS Glue Data Quality peut trouver les dossiers ou fichiers spécifiques utilisés pour remplir votre bloc de données.
**Note**
Cette fonctionnalité ne fonctionne que lorsque les fichiers sont correctement lus dans le DynamicFrame ou DataFrame.
```
FileSize < 10 MB with threshold > 0.7
```
**Balises de règles facultatives basées sur des fichiers :**
Les balises vous permettent de contrôler le comportement des règles.
**recentFiles**
Cette balise limite le nombre de fichiers traités en conservant le fichier le plus récent en premier.
```
FileSize "s3://amzn-s3-demo-bucket/" > 5 B with recentFiles = 1
```
**URI Regex**
**Note**
Le `uriRegex` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Cette balise filtre les fichiers en appliquant un modèle regex au chemin du fichier. Seuls les fichiers dont le chemin correspond au modèle sont traités. Vous pouvez également utiliser une prévision négative pour exclure les fichiers qui correspondent à un modèle.
```
# 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$).*"
```
**Ordre du filtre**
**Note**
Le `filterOrder` tag est disponible dans AWS Glue 5.0 et versions ultérieures.
Lorsque vous utilisez plusieurs balises de filtre telles que `recentFiles` et `uriRegex` ensemble, la `filterOrder` balise contrôle l'ordre dans lequel elles sont appliquées. L'ordre par défaut est `recentFiles` le premier, puis`uriRegex`.
```
FileSize "s3://bucket/" > 5 B with recentFiles = 5 with uriRegex = "\.dat$" with filterOrder = ["uriRegex","recentFiles"]
```
**FailFast**
Lorsqu'elle est définie sur`"true"`, la règle renvoie l'échec immédiatement au premier fichier qui ne répond pas à la condition de taille, au lieu d'évaluer tous les fichiers et de calculer un ratio de conformité.
```
FileSize "s3://bucket/" > 2 MB with failFast = "true"
```
Voici quelques considérations à prendre en compte :
1. Dans AWS Glue ETL, vous devez disposer d' DataQuality Evaluate Transform immédiatement après la transformation d'Amazon S3 ou de Data Catalog.
1. Cette règle ne fonctionnera pas dans les sessions AWS Glue Interactive.
# Utilisation APIs pour mesurer et gérer la qualité des données
Cette rubrique décrit comment l'utiliser APIs pour mesurer et gérer la qualité des données.
**Contents**
+ [Conditions préalables](#using-apis-prerequisites)
+ [Utilisation des recommandations relatives à AWS la qualité des données de Glue](#using-apis-recommendations)
+ [Travailler avec les ensembles de règles de qualité des données de AWS Glue](#using-apis-rulesets)
+ [Travailler avec AWS Glue Data Quality s'exécute](#using-apis-runs)
+ [Utilisation des résultats AWS de Glue Data Quality](#using-apis-results)
## Conditions préalables
+ Assurez-vous que votre version de boto3 est à jour afin d'inclure la dernière API AWS Glue Data Quality.
+ Assurez-vous que la version de votre AWS CLI est à jour, afin d'inclure la dernière version de la CLI.
Si vous utilisez une tâche AWS Glue pour les exécuter APIs, vous pouvez utiliser l'option suivante pour mettre à jour la dernière version de la bibliothèque boto3 :
```
—additional-python-modules boto3==
```
## Utilisation des recommandations relatives à AWS la qualité des données de Glue
**Pour démarrer une recommandation de AWS Glue Data Quality, exécutez :**
```
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']
```
Pour une exécution de recommandation, vous pouvez utiliser vos `pushDownPredicates` ou vos `catalogPartitionPredicates` pour améliorer les performances et exécuter des recommandations uniquement sur des partitions spécifiques de vos sources de catalogue.
```
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=''
)
```
**Pour obtenir les résultats d'une recommandation de AWS Glue Data Quality, exécutez :**
```
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
```
À partir de l'objet de réponse ci-dessus, vous pouvez extraire celui RuleSet qui a été recommandé par l'exécution, pour l'utiliser dans les étapes suivantes :
```
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"
]
```
**Pour obtenir une liste de toutes vos exécutions de recommandation qui peuvent être filtrées et répertoriées :**
```
response = client.list_data_quality_rule_recommendation_runs(
Filter={
'DataSource': {
'GlueTable': {
'DatabaseName': '',
'TableName': ''
}
}
)
```
**Pour annuler les tâches de recommandation de AWS Glue Data Quality existantes, procédez comme suit :**
```
response = client.cancel_data_quality_rule_recommendation_run(
RunId='dqrun-d4b6b01957fdd79e59866365bf9cb0e40fxxxxxxx'
)
```
## Travailler avec les ensembles de règles de qualité des données de AWS Glue
**Pour créer un ensemble de règles AWS Glue Data Quality, procédez comme suit :**
```
response = client.create_data_quality_ruleset(
Name='',
Ruleset='Rules = [IsComplete "col1", IsPrimaryKey "col2", RowCount between 2000 and 8000]',
TargetTable={
'TableName': '',
'DatabaseName': ''
}
)
```
**Pour obtenir un ensemble de règles de qualité des données :**
```
response = client.get_data_quality_ruleset(
Name=''
)
print(response)
```
Vous pouvez utiliser cette API pour ensuite extraire l'ensemble de règles :
```
print(response['Ruleset'])
```
**Pour répertorier tous les ensembles de règles de qualité des données pour une table :**
```
response = client.list_data_quality_rulesets()
```
Vous pouvez utiliser la condition de filtrage dans l'API pour filtrer tous les ensembles de règles attachés à une base de données ou à une table spécifique :
```
response = client.list_data_quality_rulesets(
Filter={
'TargetTable': {
'TableName': '',
'DatabaseName': ''
}
},
)
```
**Pour mettre à jour un ensemble de règles de qualité des données :**
```
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
```
**Pour supprimer un ensemble de règles de qualité des données :**
```
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
```
## Travailler avec AWS Glue Data Quality s'exécute
**Pour démarrer une exécution de AWS Glue Data Quality, procédez comme suit :**
```
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']
```
N'oubliez pas que vous pouvez transmettre un paramètre `pushDownPredicate` ou `catalogPartitionPredicate` pour garantir que votre exécution de qualité des données ne cible qu'un ensemble spécifique de partitions dans votre table de catalogue. Par exemple :
```
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=[
'',
]
)
```
Vous pouvez également configurer la manière dont les règles composites de votre ensemble de règles sont évaluées, au niveau de la LIGNE ou de la COLONNE. Pour plus d’informations sur le fonctionnement des règles composites, reportez-vous à [How composite rules work](dqdl.md#dqdl-syntax-composite-rules) dans la documentation.
Exemple expliquant comment définir la méthode d’évaluation des règles composites dans votre demande :
```
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=[
'',
]
)
```
**Pour obtenir des informations sur un AWS Glue Data Quality, exécutez :**
```
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
```
**Pour obtenir les résultats d'une exécution de AWS Glue Data Quality :**
Pour une exécution de AWS Glue Data Quality donnée, vous pouvez extraire les résultats de l'évaluation de l'exécution à l'aide de la méthode suivante :
```
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'])
```
**Pour répertorier toutes vos exécutions de AWS Glue Data Quality, procédez comme suit :**
```
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
```
Vous pouvez modifier la clause de filtrage pour n'afficher que les résultats obtenus à des moments précis ou concernant des tables spécifiques.
**Pour arrêter une exécution de AWS Glue Data Quality en cours, procédez comme suit :**
```
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
```
## Utilisation des résultats AWS de Glue Data Quality
**Pour obtenir les résultats de votre exécution avec AWS Glue Data Quality, procédez comme suit :**
```
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
```
**Pour consulter les statistiques recueillies pour un résultat de qualité des données donné :**
```
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
```
**Pour consulter les séries temporelles d’une statistique collectée au cours de plusieurs cycles de qualité des données :**
```
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
```
**Pour afficher le modèle de détection d’anomalies pour une statistique spécifique :**
```
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
```
**Pour exclure un point de données de la ligne de base de détection des anomalies de son modèle statistique :**
```
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
```
**Pour consulter l’état de l’entraînement des modèles de détection des anomalies pour une statistique spécifique :**
```
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
```
**Pour exclure tous les résultats d’une analyse de qualité des données spécifique des références de détection des anomalies :**
```
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
```
**Pour obtenir les résultats d’une exécution de la qualité des données et afficher les résultats :**
Avec une AWS Glue Data Quality`runID`, vous pouvez les extraire `resultID` pour obtenir les résultats réels, comme indiqué ci-dessous :
```
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'])
```
# Configuration des alertes, des déploiements et de la planification
Cette rubrique explique comment configurer les alertes, les déploiements et la planification pour AWS Glue Data Quality.
**Contents**
+ [Configuration des alertes et des notifications dans le cadre de EventBridge l'intégration Amazon](#data-quality-alerts-eventbridge)
+ [Options de configuration supplémentaires pour le modèle d'événement](#data-quality-alerts-eventbridge-config-options)
+ [Formatage des notifications sous forme d'e-mails](#data-quality-alerts-eventbridge-format-notifications)
+ [Configurer des alertes et des notifications lors de l' CloudWatch intégration](#data-quality-alerts-cloudwatch)
+ [Interrogation des résultats de la qualité des données pour créer des tableaux de bord](#data-quality-alerts-querying-results)
+ [Déploiement de règles de qualité des données en utilisant AWS CloudFormation](#data-quality-deploy-cfn)
+ [Planification de règles de qualité des données](#data-quality-scheduling-rules)
## Configuration des alertes et des notifications dans le cadre de EventBridge l'intégration Amazon
AWS Glue Data Quality prend en charge la publication d' EventBridge événements, qui sont émis à la fin d'une évaluation d'un ensemble de règles de qualité des données. Vous pouvez ainsi facilement configurer des alertes en cas d'échec des règles de qualité des données.
Voici un exemple d'événement lorsque vous évaluez des ensembles de règles de qualité des données dans le catalogue de données. Grâce à ces informations, vous pouvez consulter les données mises à disposition par Amazon EventBridge. Vous pouvez lancer des appels d'API supplémentaires pour obtenir plus de détails. Par exemple, appelez l'API `get_data_quality_result` avec l'ID du résultat pour obtenir les détails d'une exécution particulière.
```
{
"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
}
}
```
Voici un exemple d'événement publié lorsque vous évaluez des ensembles de règles de qualité des données dans les blocs-notes AWS Glue ETL ou 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
}
}
```
Pour que l'évaluation de la qualité des données soit exécutée à la fois dans le catalogue de données et dans les tâches ETL, l' Amazon CloudWatch option **Publier les métriques** sur, sélectionnée par défaut, doit rester sélectionnée pour que la EventBridge publication fonctionne.
**Configuration des EventBridge notifications**
![\[Propriétés de qualité des données dans AWS CloudFormation\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-properties-cfn.png)
Pour recevoir les événements émis et définir des cibles, vous devez configurer les EventBridge règles Amazon. Pour créer des règles :
1. Ouvrez la EventBridge console Amazon.
1. Choisissez **Règles** dans la section **Bus** de la barre de navigation.
1. Choisissez **Create Rule (Créer une règle)**.
1. Sous **Définir les détails de la règle** :
1. Pour le nom, saisissez `myDQRule`.
1. Saisissez une description (facultatif).
1. Pour le bus d'événements, sélectionnez votre bus d'événements. Si vous n'en avez pas, laissez le bus par défaut.
1. Pour Type de règle, sélectionnez **Règle avec un modèle d'événement**, puis choisissez **Suivant**.
1. Sous **Créer un modèle d'événement** :
1. Pour la source de l'événement, sélectionnez **AWS les événements ou les événements EventBridge partenaires**.
1. Ignorez la section de l'exemple d'événement.
1. Pour la méthode de création, sélectionnez **Utiliser le formulaire de modèle**.
1. Pour le modèle d'événement :
1. Sélectionnez **Services AWS ** pour Source de l'événement.
1. Sélectionnez **Glue Data Quality** pour le AWS service.
1. Sélectionnez **Résultats de l'évaluation de la qualité des données disponibles** pour Type d'événement.
1. Sélectionnez **FAILED** pour Statuts spécifiques. Vous voyez alors un modèle d'événement similaire à celui présenté ci-dessous :
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"state": ["FAILED"]
}
}
```
1. Pour plus d'options de configuration, consultez [Options de configuration supplémentaires pour le modèle d'événement](#data-quality-alerts-eventbridge-config-options).
1. Sous **Cibles sélectionnées** :
1. Pour **Types de cibles**, sélectionnez **Service AWS **.
1. **Utilisez le menu déroulant **Sélectionnez une cible** pour choisir le AWS service auquel vous souhaitez vous connecter (SNS, Lambda, SQS, etc.), puis choisissez Next.**
1. Sous **Configurer les balises**, cliquez sur **Ajouter de nouvelles balises** pour ajouter des balises facultatives, puis choisissez **Suivant**.
1. Une page récapitulative de toutes les sélections s'affiche. Choisissez **Créer une règle** en bas de la page.
### Options de configuration supplémentaires pour le modèle d'événement
En plus de filtrer de votre événement en fonction de sa réussite ou de son échec, vous pouvez également filtrer les événements en fonction de différents paramètres.
Pour ce faire, accédez à la section Modèle d'événement et sélectionnez **Modifier le modèle** pour spécifier des paramètres supplémentaires. Notez que les champs du modèle d'événements sont sensibles à la casse. Voici des exemples de configuration de modèle d'événement.
Pour capturer les événements d'une table particulière évaluant des ensembles de règles spécifiques, utilisez ce type de modèle :
```
{
"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"]
}
}
```
Pour capturer des événements à partir de tâches spécifiques dans l'expérience ETL, utilisez ce type de modèle :
```
{
"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"]
}
}
```
Pour capturer les événements dont le score est inférieur à un seuil spécifique (par exemple 70 %) :
```
{
"source": ["aws.glue-dataquality"],
"detail-type": ["Data Quality Evaluation Results Available"],
"detail": {
"score": [{
"numeric": ["<=", 0.7]
}]
}
}
```
### Formatage des notifications sous forme d'e-mails
Vous devez parfois envoyer une notification par e-mail correctement formatée à vos équipes métier. Vous pouvez utiliser Amazon EventBridge et AWS Lambda pour y parvenir.
![\[Notification de la qualité des données sous forme d'e-mail\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data_quality_sample_email.png)
L'exemple de code suivant peut être utilisé pour formater vos notifications de qualité des données afin de générer des e-mails.
```
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')
}
```
## Configurer des alertes et des notifications lors de l' CloudWatch intégration
Notre approche recommandée consiste à configurer des alertes relatives à la qualité des données à l'aide d'Amazon EventBridge, car Amazon EventBridge nécessite une configuration unique pour alerter les clients. Cependant, certains clients préfèrent Amazon pour des CloudWatch raisons de familiarité. Pour ces clients, nous proposons une intégration avec Amazon CloudWatch.
Chaque évaluation de la qualité des données de AWS Glue émet une paire de métriques nommées `glue.data.quality.rules.passed` (indiquant le nombre de règles passées) et `glue.data.quality.rules.failed` (indiquant le nombre de règles ayant échoué) par cycle de qualité des données. Vous pouvez utiliser cette métrique émise pour créer des alarmes afin d'avertir les utilisateurs lorsqu'une exécution d'évaluation de la qualité des données se situe en dessous du seuil. Pour commencer à configurer une alarme qui enverrait un e-mail via une notification Amazon SNS, suivez les étapes ci-dessous :
Pour commencer à configurer une alarme qui enverrait un e-mail via une notification Amazon SNS, suivez les étapes ci-dessous :
1. Ouvrez la CloudWatch console Amazon.
1. Choisissez **Toutes les métriques** sous **Métriques**. Vous verrez un espace de noms supplémentaire sous Espaces de noms personnalisés nommé qualité des données Glue.
**Note**
Lorsque vous lancez une AWS analyse de Glue Data Quality, assurez-vous que la CloudWatch case **Publish metrics to Amazon** est cochée. Dans le cas contraire, les statistiques relatives à cette course en particulier ne seront pas publiées sur Amazon CloudWatch.
Sous l'espace de noms `Glue Data Quality`, vous pouvez voir les métriques émises par table, par ensemble de règles. Dans le cadre de cette rubrique, nous utiliserons la règle `glue.data.quality.rules.failed` et l'alarme si cette valeur est supérieure à 1 (ce qui signifie que si le nombre d'échecs d'évaluation de la règle est supérieur à 1, nous voulons en être informés).
1. Pour créer l'alarme, sélectionnez **Toutes les alarmes** sous **Alarmes**.
1. Choisissez **Create alarm (Créer une alerte)**.
1. Choisissez **Sélectionner une métrique**.
1. Sélectionnez la métrique `glue.data.quality.rules.failed` correspondant à la table que vous avez créée, puis choisissez **Sélectionner une métrique**.
1. Sous l'onglet **Spécifier les métriques et les conditions**, dans la section **Métriques** :
1. Pour **Statistics** (Statistique), choisissez **Sum** (Somme).
1. Pour **Période**, choisissez **1 minute**.
1. Sous la section **Conditions** :
1. Pour **Threshold type** (Type de seuil), choisissez **Static** (Statique).
1. Pour **Chaque fois que l'échec des règles de qualité des données est…**, sélectionnez **Supérieur ou égal**.
1. Pour **à…**, saisissez **1** comme valeur de seuil.
Ces options impliquent que si la métrique `glue.data.quality.rules.failed` émet une valeur supérieure ou égale à 1, nous déclencherons une alarme. Toutefois, s'il n'y a pas de données, nous les traiterons comme acceptables.
1. Choisissez **Suivant**.
1. Sous **Configurer les actions** :
1. Pour la section **Déclencheur d'état d'alarme**, choisissez **En alarme**.
1. Pour la section **Envoyer une notification à la rubrique SNS suivante**, choisissez **Créer une rubrique pour envoyer une notification via une nouvelle rubrique SNS**.
1. Pour **Points de terminaison de l'e-mail qui recevra la notification**, saisissez votre adresse e-mail. Cliquez ensuite sur **Créer une rubrique**.
1. Choisissez **Suivant**.
1. Pour **Nom de l'alarme**, saisissez `myFirstDQAlarm` et choisissez **Suivant**.
1. Une page récapitulative de toutes les sélections s'affiche. Choisissez **Créer une alarme** en bas de la page.
Vous pouvez désormais voir l'alarme en cours de création depuis le tableau de bord des CloudWatch alarmes Amazon.
## Interrogation des résultats de la qualité des données pour créer des tableaux de bord
Vous souhaiterez peut-être créer un tableau de bord pour afficher vos résultats de qualité de données. Il existe deux façons de procéder :
**Configurez Amazon EventBridge avec le code suivant pour écrire les données dans 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')
}
```
Après avoir écrit à Amazon S3, vous pouvez utiliser les robots d'exploration AWS Glue pour vous enregistrer auprès d'Athena et interroger les tables.
**Configurez un emplacement Amazon S3 lors d'une évaluation de la qualité des données :**
Lorsque vous exécutez des tâches de qualité des données dans le AWS Glue Data Catalog ou AWS Glue ETL, vous pouvez fournir un emplacement Amazon S3 pour écrire les résultats de qualité des données sur Amazon S3. Vous pouvez utiliser la syntaxe ci-dessous pour créer une table en référençant la cible afin de lire les résultats de qualité des données.
Notez que vous devez exécuter les requêtes `CREATE EXTERNAL TABLE` et `MSCK REPAIR TABLE` séparément.
```
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 ;
```
Une fois la table ci-dessus créée, vous pouvez exécuter des requêtes analytiques à l'aide d'Amazon Athena.
## Déploiement de règles de qualité des données en utilisant AWS CloudFormation
Vous pouvez l'utiliser AWS CloudFormation pour créer des règles de qualité des données. Pour plus d'informations, consultez [AWS CloudFormation AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/populate-with-cloudformation-templates.html).
## Planification de règles de qualité des données
Vous pouvez planifier des règles de qualité des données à l'aide des méthodes suivantes :
+ Planifiez les règles de qualité des données à partir du catalogue de données : aucun code Les utilisateurs ne peuvent utiliser cette option pour planifier facilement leurs analyses de qualité des données. AWS Glue Data Quality créera le calendrier sur Amazon EventBridge. Pour planifier des règles de qualité des données :
+ Accédez à l'ensemble de règles et cliquez sur **Exécuter**.
+ Dans la section **Fréquence d'exécution**, sélectionnez le calendrier souhaité et indiquez un **nom de tâche**. Ce nom de tâche est le nom de votre calendrier dans EventBridge.
+ Utilisez Amazon EventBridge et AWS Step Functions pour orchestrer les évaluations et les recommandations relatives aux règles de qualité des données.
# Le chiffrement des données est arrêté pour AWS Glue Data Quality
AWS Glue Data Qualityfournit un chiffrement par défaut pour protéger les données sensibles des clients au repos à l'aide de clés de chiffrement AWS détenues par nos soins.
## AWS clés possédées
AWS Glue Data Quality utilise ces clés pour chiffrer automatiquement les actifs de qualité des données des clients. Vous ne pouvez pas consulter, gérer ou utiliser les clés AWS détenues, ni auditer leur utilisation. Toutefois, vous n’avez pas besoin de prendre de mesure ou de modifier les programmes pour protéger les clés qui chiffrent vos données. Pour plus d'informations, consultez la section sur [les clés AWS détenues](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk) dans le Guide du AWS KMS développeur.
Le chiffrement des données au repos par défaut permet de réduire les frais opérationnels et la complexité liés à la protection des données sensibles. Dans le même temps, il vous permet de créer des applications sécurisées qui répondent aux exigences réglementaires et de conformité strictes en matière de chiffrement.
Bien que vous ne puissiez pas désactiver cette couche de chiffrement ou sélectionner un autre type de chiffrement, vous pouvez ajouter une deuxième couche de chiffrement aux clés de chiffrement AWS détenues existantes en choisissant une clé gérée par le client lorsque vous créez vos ressources de qualité des données.
## Clés gérées par le client
**Clés gérées par le client** : AWS Glue Data Quality prend en charge l'utilisation d'une clé symétrique gérée par le client que vous créez, détenez et gérez. Cela ajoute une deuxième couche de chiffrement par rapport au chiffrement AWS propre existant. Étant donné que vous avez le contrôle total de cette couche de chiffrement, vous pouvez effectuer les tâches suivantes :
+ Établissement et gestion des stratégies de clé
+ Établissement et gestion des politiques IAM
+ Activation et désactivation des stratégies de clé
+ Rotation des matériaux de chiffrement de clé
+ Ajout de balises
+ Création d’alias de clé
+ Planification des clés pour la suppression
Pour plus d'informations, consultez la section [Clés gérées par le client](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) dans le Guide du AWS KMS développeur.
Le tableau suivant résume la manière dont AWS Glue Data Quality chiffre les différents actifs de Data Quality.
| Type de données | AWS chiffrement par clé détenue | Chiffrement par clé gérée par le client |
| --- | --- | --- |
| **Ensemble de règles de qualité des données** Chaîne d’ensemble de règles DQDL référencée par l’ensemble de règles DQ persistant. Pour le moment, ces ensembles de règles persistants ne sont utilisés que dans l’expérience catalogue de données AWS Glue. | Activé | Activé |
| ** Rule/Analyzer Résultats relatifs à la qualité des données** Artefacts de résultat qui contiennent le pass/fail statut de chaque règle d'un ensemble de règles ainsi que les métriques collectées par les règles et les analyseurs. | Activé | Activé |
| **Observations** Des observations sont générées lorsqu’une anomalie est détectée dans les données. Elles contiennent des informations sur les limites supérieure et inférieure attendues et une règle suggérée basée sur ces limites. Si elles sont générées, elles sont affichées avec les résultats de qualité des données. | Activé | Activé |
| **Statistiques** Contient des informations sur les métriques collectées après avoir évalué les données selon un ensemble de règles, telles que la valeur de la métrique (par exemple RowCount, Exhaustivité), les noms des colonnes et d'autres métadonnées. | Activé | Activé |
| **Modèles statistiques de détection des anomalies** Les modèles statistiques contiennent les séries temporelles des limites supérieure et inférieure pour une métrique donnée, générées sur la base d’évaluations précédentes des données client. | Activé | Activé |
**Note**
AWS Data Quality active automatiquement le chiffrement au repos à l'aide de clés AWS détenues pour protéger gratuitement les données personnelles identifiables. Toutefois, AWS KMS des frais s'appliquent pour l'utilisation d'une clé gérée par le client. Pour plus d’informations sur la tarification, consultez [Tarification d’AWS KMS](https://aws.amazon.com/kms/pricing/).
Pour plus d'informations sur AWS KMS, voir [AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
## Création d’une clé gérée par le client
Vous pouvez créer une clé symétrique gérée par le client en utilisant le AWS Management Console, ou le AWS KMS APIs.
**Pour créer une clé symétrique gérée par le client :**
+ Suivez les étapes de [création de AWS KMS clés de chiffrement symétriques décrites](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) dans le manuel du AWS Key Management Service développeur.
### Stratégie de clé
Les stratégies de clé contrôlent l’accès à votre clé gérée par le client. Chaque clé gérée par le client doit avoir exactement une stratégie de clé, qui contient des instructions qui déterminent les personnes pouvant utiliser la clé et comment elles peuvent l’utiliser. Lorsque vous créez votre clé gérée par le client, vous pouvez spécifier une stratégie de clé. Pour plus d'informations, consultez la section [Politiques relatives aux AWS KMS clés](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) dans le Guide du AWS Key Management Service développeur.
Pour utiliser votre clé gérée par le client avec les ressources de qualité des données, les opérations d’API suivantes doivent être autorisées dans la stratégie de clé :
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)— Déchiffre le texte chiffré par une clé en utilisant AWS KMS `GenerateDataKeyWithoutPlaintext`
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html) : fournit les détails des clés gérées par le client pour permettre à Amazon Location de valider la clé.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html)— Renvoie une clé de données symétrique unique à utiliser en dehors de AWS KMS. Cette opération renvoie une clé de données chiffrée sous une clé KMS de chiffrement symétrique que vous spécifiez. Les octets de la clé sont aléatoires. Ils ne sont pas liés à l’appelant ni à la clé KMS. Sert à réduire le nombre d’appels KMS que le client doit passer.
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html) : déchiffre le texte chiffré, puis le rechiffre entièrement au sein d’ AWS KMS. Vous pouvez utiliser cette opération pour modifier la clé KMS sous laquelle les données sont chiffrées, par exemple lorsque vous [faites pivoter manuellement](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html#rotate-keys-manually) une clé KMS ou que vous modifiez la clé KMS qui protège un texte chiffré. Vous pouvez également l’utiliser pour rechiffrer du texte chiffré sous la même clé KMS, par exemple pour modifier le [contexte de chiffrement](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) d’un texte chiffré.
Voici des exemples de déclarations de stratégie que vous pouvez ajouter pour 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" : "*"
}
]
```
### Remarques concernant l'utilisation des clés KMS dans AWS Glue Data Quality
AWS Glue Data Quality ne prend pas en charge les transitions clés. Cela signifie que si vous chiffrez vos actifs de qualité des données avec la clé A et que vous décidez de passer à la clé B, nous ne chiffrerons pas à nouveau les données chiffrées avec la clé A pour utiliser la clé B. Vous pouvez toujours passer à la clé B, mais vous devrez conserver l’accès à la clé A pour accéder aux données précédemment chiffrées avec la clé A.
Pour plus d'informations sur la spécification des autorisations dans une politique, consultez la section [Autorisations pour les AWS services dans les politiques clés](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-services.html) du Guide du AWS Key Management Service développeur.
Pour plus d'informations sur la résolution des problèmes d'accès par clé, consultez la section [Résolution des problèmes d'accès par clé](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html) dans le Guide du AWS Key Management Service développeur.
## Création d'une configuration de sécurité
Dans AWS Glue, la [ressource Security Configurations](encryption-security-configuration.md) contient les propriétés nécessaires pour écrire des données chiffrées.
**Pour chiffrer les actifs liés à la qualité de vos données :**
1. Dans **Paramètres de chiffrement**, sous **Paramètres avancés**, choisissez **Activer le chiffrement de la qualité des données**.
1. Sélectionnez votre clé KMS ou choisissez **Créer une AWS KMS clé**
![\[La capture d'écran montre la page Ajouter une configuration de sécurité. L'option Activer DataQuality le chiffrement est sélectionnée.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/data-quality-add-security-configuration.png)
## AWS Contexte de chiffrement de Glue Data Quality
Un [contexte de chiffrement](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) est un ensemble facultatif de paires clé-valeur qui contient des informations contextuelles supplémentaires sur les données.
AWS KMS utilise le contexte de chiffrement comme [données authentifiées supplémentaires](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad) pour prendre en charge le chiffrement [authentifié.](https://docs.aws.amazon.com/crypto/latest/userguide/cryptography-concepts.html#term-aad) Lorsque vous incluez un contexte de chiffrement dans une demande de chiffrement de données, AWS KMS lie le contexte de chiffrement aux données chiffrées. Pour déchiffrer les données, vous devez inclure le même contexte de chiffrement dans la demande.
### AWS Exemple de contexte de chiffrement de Glue Data Quality
```
"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"
}
```
### Utilisation du contexte de chiffrement à des fins de surveillance
Lorsque vous utilisez une clé symétrique gérée par le client pour chiffrer les données de votre suivi ou de votre collection de périmètres virtuels, vous pouvez également utiliser le contexte de chiffrement dans les enregistrements et les journaux d’audit pour identifier la manière dont la clé gérée par le client est utilisée. Le contexte de chiffrement apparaît également dans les journaux générés par AWS CloudTrail ou Amazon CloudWatch Logs.
## Surveillance de vos clés de chiffrement pour AWS Glue Data Quality
Lorsque vous utilisez une clé gérée par le AWS KMS client avec vos ressources AWS Glue Data Quality, vous pouvez utiliser AWS CloudTrail ou Amazon CloudWatch Logs suivre les demandes auxquelles AWS Glue Data Quality envoie AWS KMS.
Les exemples suivants sont des AWS CloudTrail événements pour `GenerateDataKeyWithoutPlainText` et `Decrypt` pour surveiller les opérations KMS appelées par AWS Glue Data Quality afin d'accéder aux données chiffrées par votre clé gérée par le client.
**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"
}
```
## En savoir plus
Les ressources suivantes fournissent plus d'informations sur le chiffrement des données au repos.
+ Pour plus d'informations sur les [concepts AWS Key Management Service de base](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html), consultez le guide du AWS Key Management Service développeur.
+ Pour plus d'informations sur les [meilleures pratiques en matière de sécurité](https://docs.aws.amazon.com/kms/latest/developerguide/best-practices.html), AWS Key Management Service consultez le guide du AWS Key Management Service développeur.
# Résolution des erreurs liées à la qualité des données de AWS Glue
Si vous rencontrez des erreurs dans AWS Glue Data Quality, utilisez les solutions suivantes pour trouver la source des problèmes et les résoudre.
**Contents**
+ [Erreur : module AWS Glue Data Quality manquant](#data-quality-trouble-error-1)
+ [Erreur : autorisations insuffisantes pour AWS Lake Formation](#data-quality-trouble-error-2)
+ [Erreur : les ensembles de règles ne sont pas nommés de manière unique](#data-quality-trouble-error-3)
+ [Erreur : tables contenant des caractères spéciaux](#data-quality-trouble-error-4)
+ [Erreur : erreur de débordement avec un ensemble de règles volumineux](#data-quality-trouble-error-5)
+ [Erreur : échec du statut général de la règle](#data-quality-trouble-error-6)
+ [AnalysisException: Impossible de vérifier l'existence de la base de données par défaut](#data-quality-trouble-error-7)
+ [Message d'erreur : la clé de distribution fournie ne convient pas aux cadres de données fournies.](#data-quality-trouble-error-8)
+ [Exception dans la classe utilisateur : java.lang. RuntimeException : Impossible de récupérer les données. Vérifiez les connexions CloudWatch pour obtenir plus de détails](#data-quality-trouble-error-9)
+ [ERREUR DE LANCEMENT : erreur lors du téléchargement depuis S3 pour le compartiment](#data-quality-trouble-error-10)
+ [InvalidInputException (statut : 400) : DataQuality les règles ne peuvent pas être analysées](#data-quality-trouble-error-11)
+ [Erreur : Eventbridge ne déclenche pas les tâches Glue DQ selon le calendrier que j'ai configuré.](#data-quality-trouble-error-12)
+ [Erreurs CustomSQL](#data-quality-trouble-error-13)
+ [Règles dynamiques](#data-quality-trouble-error-14)
+ [Exception dans la classe utilisateur : org.apache.spark.sql. AnalysisException: org.apache.hadoop.hive.ql.metadata. HiveException](#data-quality-trouble-error-15)
+ [UNCLASSIFIED\$1ERROR ; IllegalArgumentException : Erreur d'analyse : aucune règle ni analyseur fournis., aucune alternative viable en entrée](#data-quality-trouble-error-16)
## Erreur : module AWS Glue Data Quality manquant
**Message d'erreur** : aucun module nommé « awsgluedq ».
**Résolution** : Cette erreur se produit lorsque vous exécutez AWS Glue Data Quality dans une version non prise en charge. AWS Glue Data Quality n'est prise en charge que dans les versions 3.0 et ultérieures de Glue.
## Erreur : autorisations insuffisantes pour AWS Lake Formation
**Message d'erreur** : exception dans la classe utilisateur `com.amazonaws.services.glue.model.AccessDeniedException` : autorisations de Lake Formation insuffisantes sur impact\$1sdg\$1involvement (Service : ; Code d'état : 400 ; Code d'erreur : AWS Glue ; ID de demande : AccessDeniedException 465ae693-b7ba-4df0-a4e4-6b17xxxxxxxx ; Proxy : nul).
**Résolution** : Vous devez fournir des autorisations suffisantes dans AWS Lake Formation.
## Erreur : les ensembles de règles ne sont pas nommés de manière unique
**Message d'erreur** : Exception dans la classe utilisateur :... services.glue.model. AlreadyExistsException: Un autre ensemble de règles portant le même nom existe déjà.
**Résolution** : les ensembles de règles sont globaux et doivent être uniques.
## Erreur : tables contenant des caractères spéciaux
**Message d'erreur** : Exception dans la classe utilisateur : org.apache.spark.sql. AnalysisException: impossible de résoudre les colonnes d'entrée « C » données : [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] ; ligne 1 pos 44 ;.
**Résolution** : Il existe actuellement une limite selon laquelle AWS Glue Data Quality ne peut pas être exécuté sur des tables contenant des caractères spéciaux tels que «. ».
## Erreur : erreur de débordement avec un ensemble de règles volumineux
**Message d'erreur** : Exception dans la classe utilisateur : java.lang. StackOverflowError.
**Résolution** : si vous disposez d'un ensemble de règles de plus de 2 000 règles, vous pouvez rencontrer ce problème. Divisez vos règles en plusieurs ensembles de règles.
## Erreur : échec du statut général de la règle
**Condition d'erreur** : mon ensemble de règles est réussi, mais le statut général de mes règles est un échec.
**Résolution** : Cette erreur s'est probablement produite parce que vous avez choisi l'option de publier les statistiques sur Amazon CloudWatch lors de la publication. Si votre ensemble de données se trouve dans un VPC, celui-ci n'autorise peut-être pas AWS Glue à publier des métriques sur Amazon. CloudWatch Dans ce cas, vous devez configurer un point de terminaison pour que votre VPC puisse accéder à Amazon. CloudWatch
## AnalysisException: Impossible de vérifier l'existence de la base de données par défaut
**Condition d'erreur** AnalysisException : Impossible de vérifier l'existence de la base de données par défaut : com.amazonaws.services.glue.model. AccessDeniedException: Autorisations de Lake Formation insuffisantes par défaut (Service : AWS Glue ; Code d'état : 400 ; Code d'erreur : ; ID de demande : AccessDeniedException XXXXXXXX-XXXX-XXXX-XXXX -XXXXXXXXXXXX ; Proxy : nul)
**Résolution** : dans l'intégration du catalogue de la tâcheAWS Glue, AWS Glue essaie toujours de vérifier si la base de données par défaut existe ou non en utilisant AWS Glue `GetDatabase API`. Lorsque l'autorisation `DESCRIBE` Lake Formation n'est pas accordée ou que l'autorisation `GetDatabase IAM` est accordée, la tâche échoue lors de la vérification de l'existence de la base de données par défaut.
Pour résoudre le problème :
1. Ajoutez l'autorisation `DESCRIBE` dans Lake Formation pour la base de données par défaut.
1. Configurez le rôle IAM associé à la tâche AWS Glue en tant que créateur de base de données dans Lake Formation. Cela crée automatiquement une base de données par défaut et accorde les autorisations Lake Formation requises pour le rôle.
1. Désactivez l'option `--enable-data-catalog`. (Elle est affichée en tant que **Utiliser Data Catalog en tant que métastore Hive dans AWS Glue Studio**).
Si vous n'avez pas besoin de l'intégration Data Catalog de Spark SQL dans la tâche, vous pouvez la désactiver.
## Message d'erreur : la clé de distribution fournie ne convient pas aux cadres de données fournies.
**Condition d'erreur** : la clé de distribution fournie ne convient pas aux cadres de données fournies.
**Résolution** : vous utilisez le **DataSetMatch**type de règle et les clés de jointure sont dupliquées. Vos clés de jointure doivent être uniques et ne doivent pas être nulles. Dans les cas où vous ne pouvez pas avoir de clés de jointure uniques, envisagez d'utiliser d'autres types de règles, par exemple **AggregateMatch**pour établir une correspondance sur des données récapitulatives.
## Exception dans la classe utilisateur : java.lang. RuntimeException : Impossible de récupérer les données. Vérifiez les connexions CloudWatch pour obtenir plus de détails
**Condition d'erreur** : exception dans la classe utilisateur : java.lang. RuntimeException : Impossible de récupérer les données. Vérifiez les connexions CloudWatch pour obtenir plus de détails.
**Résolution** : Cela se produit lorsque vous créez des règles DQ sur un tableau basé sur Amazon S3 qui est comparé à Amazon RDS ou. Amazon Redshift Dans ces cas, AWS Glue ne peut pas charger la connexion. Essayez plutôt de configurer une règle DQ sur le jeu de données Amazon Redshift ou Amazon RDS. Il s'agit d'un bogue connu.
## ERREUR DE LANCEMENT : erreur lors du téléchargement depuis S3 pour le compartiment
**Condition d'erreur** : ERREUR DE LANCEMENT : erreur lors du téléchargement depuis S3 pour le compartiment : `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) `.
**Résolution** : Les autorisations associées au rôle transmises à AWS Glue Data Quality doivent permettre la lecture depuis l'emplacement Amazon S3 précédent. Cette politique IAM doit être associée au rôle :
```
{
"Sid": "allowS3",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::aws-glue-ml-data-quality-assets-/*"
}
```
Reportez-vous à [Data Quality authorization](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html) pour obtenir la liste des autorisations détaillées. Ces bibliothèques sont nécessaires pour évaluer la qualité des données de vos jeux de données.
## InvalidInputException (statut : 400) : DataQuality les règles ne peuvent pas être analysées
**Condition d'erreur** : InvalidInputException (statut : 400) : DataQuality les règles ne peuvent pas être analysées.
**Résolution** : il existe de nombreuses possibilités pour cette erreur. Il est possible que vos règles comportent des guillemets simples. Assurez-vous qu’ils sont entre guillemets. Par exemple :
```
Rules = [
ColumnValues "tipo_vinculo" in ["CODO", "DOCO", "COCO", "DODO"] AND "categoria" = 'ES"
AND "cod_bandera" = 'CEP'
```
Remplacer par :
```
Rules = [
(ColumnValues "tipovinculo" in [ "CODO", "DOCO", "COCO", "DODO"]) AND (ColumnValues "categoria" = "ES")
AND (ColumnValues "codbandera" = "CEP")
]
```
## Erreur : Eventbridge ne déclenche pas les tâches Glue DQ selon le calendrier que j'ai configuré.
**Condition d'erreur** : erreur : Eventbridge ne déclenche pas les tâches AWS Glue Data Quality selon le calendrier que j'ai configuré.
**Résolution** : le rôle déclenchant la tâche ne dispose peut-être pas des autorisations appropriées. Assurez-vous que le rôle que vous utilisez pour lancer les tâches dispose des autorisations mentionnées dans la rubrique [Configuration IAM nécessaire à la planification des évaluations](https://docs.aws.amazon.com/glue/latest/dg/data-quality-authorization.html#data-quality-iam-setup-evaluation-runs).
## Erreurs CustomSQL
**Condition d'erreur** : ` 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`.
**Résolution** : la requête SQL est valide, mais assurez-vous que vous ne sélectionnez que les colonnes de la table principale. La sélection de fonctions d'agrégation telles que somme, nombre sur les colonnes à partir de la table principale peut entraîner cette erreur.
**Condition d'erreur** : ` There was a problem when executing your SQL statement: cannot resolve "Col"`.
**Résolution** : cette colonne n'est pas présente dans la table principale.
**Condition d'erreur** : ` 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"`.
**Résolution** : dans les requêtes SQL, lorsque vous attachez la table principale à d’autres tables de référence, assurez-vous que votre instruction SELECT ne contient que des noms de colonnes de votre table principale afin de générer des résultats au niveau de la ligne pour la table principale.
## Règles dynamiques
**Condition d’erreur**`: Dynamic rules require job context, and cannot be evaluated in interactive session or data preview.`.
**Cause :** ce message d’erreur peut apparaître dans les résultats de l’aperçu des données, ou dans d’autres sessions interactives, lorsque votre jeu de règles contient des règles DQ dynamiques. Les règles dynamiques font référence à des métriques historiques associées à un nom de tâche et à un contexte d’évaluation particuliers, de sorte qu’elles ne peuvent pas être évaluées lors de sessions interactives.
**Résolution** : l’exécution de votre tâche AWS Glue produira des métriques historiques, qui pourront être référencées lors d’exécutions ultérieures de la même tâche.
**Condition d’erreur** :
+ ` [RuleType] rule only supports simple atomic operands in thresholds.`.
+ `Function last not yet implemented for [RuleType] rule.`
**Résolution** : les règles dynamiques sont généralement prises en charge pour tous les types de règles DQDL dans les expressions numériques (voir [Référence DQDL](dqdl.md)). Cependant, certaines règles qui produisent plusieurs métriques ColumnValues et ColumnLength ne sont pas encore prises en charge.
**Condition d'erreur** : ` Binary expression operands must resolve to a single number.`.
**Cause** : les règles dynamiques prennent en charge les expressions binaires, telles que `RowCount > avg(last(5)) * 0.9`. Ici, l’expression binaire est `avg(last(5)) * 0.9`. Cette règle est valide parce que les opérandes `avg(last(5))` et `0.9` se résolvent en un seul nombre. Un exemple incorrect est `RowCount > last(5) * 0.9` parce que `last(5)` produira une liste qui ne pourra pas être comparée de manière significative au nombre actuel de lignes.
**Résolution** : utilisez des fonctions d’agrégation pour réduire un opérande à valeurs multiples en un seul nombre.
**Condition d’erreur** :
+ `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.`
**Cause** : les règles dynamiques peuvent être utilisées pour comparer certaines fonctionnalités de votre jeu de données avec ses valeurs historiques. La fonction « last » permet de récupérer plusieurs valeurs historiques, à condition de fournir un argument entier positif. Par exemple, `last(5)` récupérera les cinq dernières valeurs observées lors des exécutions de tâches pour votre règle.
**Résolution** : une fonction d’agrégation doit être utilisée pour réduire ces valeurs en un seul nombre afin de réaliser une comparaison significative avec la valeur observée dans l’exécution de tâche actuelle.
Exemples valides :
+ `RowCount >= avg(last(5))`
+ `RowCount > last(1)`
+ `RowCount < last()`
Exemple non valide : `RowCount > last(5)`.
**Condition d’erreur** :
+ `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.`
**Résolution** : lors de la création de règles dynamiques, vous pouvez utiliser la fonction d’agrégation `index` pour sélectionner une valeur historique à partir d’une liste. Par exemple, `RowCount > index(last(5)`, 1) vérifiera si le nombre de lignes observé dans l’exécution de tâche actuelle est strictement supérieur au nombre de lignes le plus récent, après le dernier, observé pour votre tâche. `index` est indexé à partir de zéro.
**Condition d'erreur** : ` IllegalArgumentException: Parsing Error: Rule Type: DetectAnomalies is not valid`.
**Résolution** : la détection d’anomalies est uniquement disponible dans AWS Glue 4.0.
**Condition d'erreur** : ` IllegalArgumentException: Parsing Error: Unexpected condition for rule of type ... no viable alternative at input ...`.
Remarque : `...` est dynamique. Exemple: `IllegalArgumentException: Parsing Error: Unexpected condition for rule of type RowCount with number return type, line 4:19 no viable alternative at input '>last'`.
**Résolution** : la détection d’anomalies est uniquement disponible dans AWS Glue 4.0.
## Exception dans la classe utilisateur : org.apache.spark.sql. AnalysisException: org.apache.hadoop.hive.ql.metadata. HiveException
**Condition d’erreur**`: 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)`
**Cause :** vous utilisez Apache Iceberg dans AWS Glue Data Catalog et l'attribut Input Format est vide dans AWS Glue Data Catalog.
**Résolution** : ce problème se produit lorsque vous utilisez le type de règle CustomSQL dans votre règle DQ. Une façon de résoudre ce problème consiste à utiliser « principal » ou à ajouter un nom de catalogue `glue_catalog.` à `. in Custom ruletype`.
## UNCLASSIFIED\$1ERROR ; IllegalArgumentException : Erreur d'analyse : aucune règle ni analyseur fournis., aucune alternative viable en entrée
**Condition d’erreur**`: UNCLASSIFIED_ERROR; IllegalArgumentException: Parsing Error: No rules or analyzers provided., no viable alternative at input`
**Résolution** : le DQDL n’est pas analysable. Cela peut se produire dans quelques instances. Si vous utilisez des règles composites, assurez-vous qu’elles comportent des parenthèses droites.
```
(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
```