Configuration des alertes, des déploiements et de la planification - AWS Glue
Configuration des alertes et des notifications dans le cadre de EventBridge l'intégration AmazonConfigurer des alertes et des notifications lors de l' CloudWatch intégrationInterrogation des résultats de la qualité des donnéesDéploiement des règles de qualité des donnéesPlanification de règles de qualité des données

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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.

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

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.

  2. Choisissez Règles dans la section Bus de la barre de navigation.

  3. Choisissez Create Rule (Créer une règle).

  4. Sous Définir les détails de la règle :

    1. Pour le nom, saisissez myDQRule.

    2. Saisissez une description (facultatif).

    3. 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.

    4. Pour Type de règle, sélectionnez Règle avec un modèle d'événement, puis choisissez Suivant.

  5. 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.

    2. Ignorez la section de l'exemple d'événement.

    3. Pour la méthode de création, sélectionnez Utiliser le formulaire de modèle.

    4. Pour le modèle d'événement :

      1. Sélectionnez Services AWS pour Source de l'événement.

      2. Sélectionnez Glue Data Quality pour le AWS service.

      3. Sélectionnez Résultats de l'évaluation de la qualité des données disponibles pour Type d'événement.

      4. 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"]
  }
}

      5. Pour plus d'options de configuration, consultez Options de configuration supplémentaires pour le modèle d'événement.

  6. Sous Cibles sélectionnées :

    1. Pour Types de cibles, sélectionnez Service AWS .

    2. 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.

  7. Sous Configurer les balises, cliquez sur Ajouter de nouvelles balises pour ajouter des balises facultatives, puis choisissez Suivant.

  8. 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

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:<region-code>:<account-id>:<sns-topic-name>'



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.

  2. 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).

  3. Pour créer l'alarme, sélectionnez Toutes les alarmes sous Alarmes.

  4. Choisissez Create alarm (Créer une alerte).

  5. Choisissez Sélectionner une métrique.

  6. 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.

  7. Sous l'onglet Spécifier les métriques et les conditions, dans la section Métriques :

    1. Pour Statistics (Statistique), choisissez Sum (Somme).

    2. Pour Période, choisissez 1 minute.

  8. Sous la section Conditions :

    1. Pour Threshold type (Type de seuil), choisissez Static (Statique).

    2. Pour Chaque fois que l'échec des règles de qualité des données est…, sélectionnez Supérieur ou égal.

    3. 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.

  9. Choisissez Suivant.

  10. Sous Configurer les actions :

    1. Pour la section Déclencheur d'état d'alarme, choisissez En alarme.

    2. Pour la section Envoyer une notification à la rubrique SNS suivante, choisissez Créer une rubrique pour envoyer une notification via une nouvelle rubrique SNS.

    3. Pour Points de terminaison de l'e-mail qui recevra la notification, saisissez votre adresse e-mail. Cliquez ensuite sur Créer une rubrique.

    4. Choisissez Suivant.

  11. Pour Nom de l'alarme, saisissez myFirstDQAlarm et choisissez Suivant.

  12. 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 <my_table_name>(
    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 <my_table_name>;

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.

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.