Exécuter un DAG d'analyse de données dans Google Cloud

Cloud Composer 3 | Cloud Composer 2 | Cloud Composer 1

Ce tutoriel explique comment utiliser Cloud Composer pour créer un DAG Apache Airflow. Le DAG joint les données d'un ensemble de données public BigQuery et d'un fichier CSV stocké dans un bucket Cloud Storage, puis exécute un job par lot Dataproc sans serveur pour traiter les données jointes.

L'ensemble de données public BigQuery utilisé dans ce tutoriel est ghcn_d, une base de données intégrée de résumés climatiques à travers le monde. Le fichier CSV contient des informations sur les dates et les noms des jours fériés aux États-Unis de 1997 à 2021.

La question à laquelle nous voulons répondre à l'aide du DAG est la suivante : "Quelle a été la température à Chicago le jour de Thanksgiving au cours des 25 dernières années ?"

Objectifs

  • Créer un environnement Cloud Composer avec la configuration par défaut
  • Créer un ensemble de données BigQuery vide
  • Créer un bucket Cloud Storage
  • Créez et exécutez un DAG comprenant les tâches suivantes :
    • Charger un ensemble de données externe de Cloud Storage vers BigQuery
    • Joindre deux ensembles de données dans BigQuery
    • Exécuter un job PySpark d'analyse de données

Avant de commencer

Activer les API

Activez les API suivantes :

Console

Enable the Dataproc, Cloud Composer, BigQuery, Cloud Storage APIs.

Enable the APIs

gcloud

Enable the Dataproc, Cloud Composer, BigQuery, Cloud Storage APIs: 

gcloud services enable dataproc.googleapis.com  composer.googleapis.com  bigquery.googleapis.com  storage.googleapis.com

Octroyer des autorisations

Attribuez les rôles et autorisations suivants à votre compte utilisateur :

Créer et préparer votre environnement Cloud Composer

  1. Créez un environnement Cloud Composer avec les paramètres par défaut :

  2. Attribuez les rôles suivants au compte de service utilisé dans votre environnement Cloud Composer pour que les nœuds de calcul Airflow puissent exécuter correctement les tâches DAG :

    • Utilisateur BigQuery (roles/bigquery.user)
    • Propriétaire de données BigQuery (roles/bigquery.dataOwner)
    • Utilisateur du compte de service (roles/iam.serviceAccountUser)
    • Éditeur Dataproc (roles/dataproc.editor)
    • Nœud de calcul Dataproc (roles/dataproc.worker)

  1. Créez un ensemble de données BigQuery vide avec les paramètres suivants :

    • Nom : holiday_weather
    • Région : US

  2. Créez un bucket Cloud Storage dans la multirégion US.

  3. Exécutez la commande suivante pour activer l'accès privé à Google sur le sous-réseau par défaut de la région dans laquelle vous souhaitez exécuter Dataproc sans serveur afin de répondre aux exigences réseau. Nous vous recommandons d'utiliser la même région que votre environnement Cloud Composer.

    gcloud compute networks subnets update default \
    --region DATAPROC_SERVERLESS_REGION \
    --enable-private-ip-google-access

Traitement des données à l'aide de Dataproc sans serveur

Explorer l'exemple de job PySpark

Le code ci-dessous est un exemple de tâche PySpark qui convertit la température de dixièmes de degrés Celsius en degrés Celsius. Cette tâche convertit les données de température de l'ensemble de données dans un autre format.

import sys


from py4j.protocol import Py4JJavaError
from pyspark.sql import SparkSession
from pyspark.sql.functions import col


if __name__ == "__main__":
    BUCKET_NAME = sys.argv[1]
    READ_TABLE = sys.argv[2]
    WRITE_TABLE = sys.argv[3]

    # Create a SparkSession, viewable via the Spark UI
    spark = SparkSession.builder.appName("data_processing").getOrCreate()

    # Load data into dataframe if READ_TABLE exists
    try:
        df = spark.read.format("bigquery").load(READ_TABLE)
    except Py4JJavaError as e:
        raise Exception(f"Error reading {READ_TABLE}") from e

    # Convert temperature from tenths of a degree in celsius to degrees celsius
    df = df.withColumn("value", col("value") / 10)
    # Display sample of rows
    df.show(n=20)

    # Write results to GCS
    if "--dry-run" in sys.argv:
        print("Data will not be uploaded to BigQuery")
    else:
        # Set GCS temp location
        temp_path = BUCKET_NAME

        # Saving the data to BigQuery using the "indirect path" method and the spark-bigquery connector
        # Uses the "overwrite" SaveMode to ensure DAG doesn't fail when being re-run
        # See https://spark.apache.org/docs/latest/sql-data-sources-load-save-functions.html#save-modes
        # for other save mode options
        df.write.format("bigquery").option("temporaryGcsBucket", temp_path).mode(
            "overwrite"
        ).save(WRITE_TABLE)
        print("Data written to BigQuery")

Importer des fichiers associés dans Cloud Storage

Pour importer le fichier PySpark et l'ensemble de données stockés dans holidays.csv :

  1. Enregistrez data_analytics_process.py sur votre machine locale.

  2. Enregistrez holidays.csv sur votre ordinateur local.

  3. Dans la console Google Cloud , accédez à la page du navigateur Cloud Storage :

    Accéder au navigateur Cloud Storage

  4. Cliquez sur le nom du bucket que vous avez créé précédemment.

  5. Dans l'onglet Objets du bucket, cliquez sur le bouton Importer des fichiers, sélectionnez data_analytics_process.py et holidays.csv dans la boîte de dialogue qui s'affiche, puis cliquez sur Ouvrir.

DAG d'analyse de données

Explorer l'exemple de DAG

Le DAG utilise plusieurs opérateurs pour transformer et unifier les données :

  • La commande GCSToBigQueryOperator ingère le fichier holidays.csv depuis Cloud Storage dans une nouvelle table de l'ensemble de données BigQuery holidays_weather que vous avez créé précédemment.

  • DataprocCreateBatchOperator crée et exécute un job par lot PySpark à l'aide de Dataproc sans serveur.

  • BigQueryInsertJobOperator joint les données de holidays.csv sur la colonne "Date" avec les données météorologiques de l'ensemble de données public BigQuery ghcn_d. Les tâches BigQueryInsertJobOperator sont générées de manière dynamique à l'aide d'une boucle for. Elles se trouvent dans un TaskGroup pour une meilleure lisibilité dans la vue Graphique de l'interface utilisateur Airflow.

import datetime

from airflow import models
from airflow.providers.google.cloud.operators import dataproc
from airflow.providers.google.cloud.operators.bigquery import BigQueryInsertJobOperator
from airflow.providers.google.cloud.transfers.gcs_to_bigquery import (
    GCSToBigQueryOperator,
)
from airflow.utils.task_group import TaskGroup

PROJECT_NAME = "{{var.value.gcp_project}}"

# BigQuery configs
BQ_DESTINATION_DATASET_NAME = "holiday_weather"
BQ_DESTINATION_TABLE_NAME = "holidays_weather_joined"
BQ_NORMALIZED_TABLE_NAME = "holidays_weather_normalized"

# Dataproc configs
BUCKET_NAME = "{{var.value.gcs_bucket}}"
PROCESSING_PYTHON_FILE = f"gs://{BUCKET_NAME}/data_analytics_process.py"

BATCH_ID = "data-processing-{{ ts_nodash | lower}}"  # Dataproc serverless only allows lowercase characters
BATCH_CONFIG = {
    "runtime_config": {"version": "1.1"},
    "pyspark_batch": {
        "main_python_file_uri": PROCESSING_PYTHON_FILE,
        "args": [
            BUCKET_NAME,
            f"{BQ_DESTINATION_DATASET_NAME}.{BQ_DESTINATION_TABLE_NAME}",
            f"{BQ_DESTINATION_DATASET_NAME}.{BQ_NORMALIZED_TABLE_NAME}",
        ],
    },
    "environment_config": {
        "execution_config": {
            "service_account": "{{var.value.dataproc_service_account}}"
        }
    },
}

yesterday = datetime.datetime.combine(
    datetime.datetime.today() - datetime.timedelta(1), datetime.datetime.min.time()
)

default_dag_args = {
    # Setting start date as yesterday starts the DAG immediately when it is
    # detected in the Cloud Storage bucket.
    "start_date": yesterday,
    # To email on failure or retry set 'email' arg to your email and enable
    # emailing here.
    "email_on_failure": False,
    "email_on_retry": False,
}

with models.DAG(
    "data_analytics_dag",
    # Continue to run DAG once per day
    schedule_interval=datetime.timedelta(days=1),
    default_args=default_dag_args,
) as dag:
    create_batch = dataproc.DataprocCreateBatchOperator(
        task_id="create_batch",
        project_id=PROJECT_NAME,
        region="{{ var.value.gce_region }}",
        batch=BATCH_CONFIG,
        batch_id=BATCH_ID,
    )
    # This data is static and it is safe to use WRITE_TRUNCATE
    # to reduce chance of 409 duplicate errors
    load_external_dataset = GCSToBigQueryOperator(
        task_id="run_bq_external_ingestion",
        bucket=BUCKET_NAME,
        source_objects=["holidays.csv"],
        destination_project_dataset_table=f"{BQ_DESTINATION_DATASET_NAME}.holidays",
        source_format="CSV",
        schema_fields=[
            {"name": "Date", "type": "DATE"},
            {"name": "Holiday", "type": "STRING"},
        ],
        skip_leading_rows=1,
        write_disposition="WRITE_TRUNCATE",
    )

    with TaskGroup("join_bq_datasets") as bq_join_group:
        for year in range(1997, 2022):
            # BigQuery configs
            BQ_DATASET_NAME = f"bigquery-public-data.ghcn_d.ghcnd_{str(year)}"
            BQ_DESTINATION_TABLE_NAME = "holidays_weather_joined"
            # Specifically query a Chicago weather station
            WEATHER_HOLIDAYS_JOIN_QUERY = f"""
            SELECT Holidays.Date, Holiday, id, element, value
            FROM `{PROJECT_NAME}.holiday_weather.holidays` AS Holidays
            JOIN (SELECT id, date, element, value FROM {BQ_DATASET_NAME} AS Table WHERE Table.element="TMAX" AND Table.id="USW00094846") AS Weather
            ON Holidays.Date = Weather.Date;
            """

            # for demo purposes we are using WRITE_APPEND
            # but if you run the DAG repeatedly it will continue to append
            # Your use case may be different, see the Job docs
            # https://cloud.google.com/bigquery/docs/reference/rest/v2/Job
            # for alternative values for the writeDisposition
            # or consider using partitioned tables
            # https://cloud.google.com/bigquery/docs/partitioned-tables
            bq_join_holidays_weather_data = BigQueryInsertJobOperator(
                task_id=f"bq_join_holidays_weather_data_{str(year)}",
                configuration={
                    "query": {
                        "query": WEATHER_HOLIDAYS_JOIN_QUERY,
                        "useLegacySql": False,
                        "destinationTable": {
                            "projectId": PROJECT_NAME,
                            "datasetId": BQ_DESTINATION_DATASET_NAME,
                            "tableId": BQ_DESTINATION_TABLE_NAME,
                        },
                        "writeDisposition": "WRITE_APPEND",
                    }
                },
                location="US",
            )

        load_external_dataset >> bq_join_group >> create_batch

Utiliser l'interface utilisateur d'Airflow pour ajouter des variables

Dans Airflow, les variables constituent un moyen universel de stocker et de récupérer des paramètres ou des configurations arbitraires sous forme de simple magasin de paires clé/valeur. Ce DAG utilise des variables Airflow pour stocker des valeurs courantes. Pour les ajouter à votre environnement :

  1. Accédez à l'interface utilisateur d'Airflow depuis la console Cloud Composer.

  2. Accédez à Admin > Variables.

  3. Ajoutez les variables suivantes :

    • gcp_project : ID de votre projet.

    • gcs_bucket : nom du bucket que vous avez créé précédemment (sans le préfixe gs://).

    • gce_region : région dans laquelle vous souhaitez exécuter votre job Dataproc qui répond aux exigences réseau de Dataproc sans serveur. Il s'agit de la région dans laquelle vous avez activé l'accès privé à Google précédemment.

    • dataproc_service_account : compte de service de votre environnement Cloud Composer. Vous trouverez ce compte de service dans l'onglet de configuration de l'environnement Cloud Composer.

Importer le DAG dans le bucket de votre environnement

Cloud Composer programme les DAG qui se trouvent dans le dossier /dags du bucket de votre environnement. Pour importer le DAG à l'aide de la consoleGoogle Cloud  :

  1. Sur votre machine locale, enregistrez data_analytics_dag.py.

  2. Dans la console Google Cloud , accédez à la page Environnements.

    Accéder à la page Environnements

  3. Dans la liste des environnements, dans la colonne Dossier des DAG, cliquez sur le lien DAG. Le dossier des DAG de votre environnement s'ouvre.

  4. Cliquez sur Importer des fichiers.

  5. Sélectionnez data_analytics_dag.py sur votre machine locale, puis cliquez sur Ouvrir.

Déclencher le DAG

  1. Dans votre environnement Cloud Composer, cliquez sur l'onglet DAG.

  2. Cliquez sur l'ID de DAG data_analytics_dag.

  3. Cliquez sur Déclencher le DAG.

  4. Patientez cinq à dix minutes jusqu'à ce qu'une coche verte indique que les tâches ont été effectuées.

Valider la réussite du DAG

  1. Dans la console Google Cloud , accédez à la page BigQuery.

    Accéder à BigQuery

  2. Dans le panneau Explorateur, cliquez sur le nom de votre projet.

  3. Cliquez sur holidays_weather_joined.

  4. Cliquez sur "Aperçu" pour afficher le tableau obtenu. Notez que les nombres de la colonne "Valeur" sont exprimés en dixièmes de degrés Celsius.

  5. Cliquez sur holidays_weather_normalized.

  6. Cliquez sur "Aperçu" pour afficher le tableau obtenu. Notez que les nombres de la colonne "Valeur" sont exprimés en degrés Celsius.

Approfondir vos connaissances avec Dataproc sans serveur (facultatif)

Vous pouvez essayer une version avancée de ce DAG avec un flux de traitement de données PySpark plus complexe. Consultez l'extension Dataproc pour l'exemple d'analyse de données sur GitHub.

Nettoyage

Supprimez les ressources individuelles que vous avez créées pour ce tutoriel :

Étapes suivantes