Exécuter un DAG d'analyse de données dans Google Cloud à l'aide de données Azure

Managed Airflow (3e génération) | Managed Airflow (2e génération) | Managed Airflow (1re génération, version héritée)

Ce tutoriel est une modification de Exécuter un DAG d'analyse de données dans Google Cloud et explique comment connecter votre environnement Managed Airflow à Microsoft Azure pour utiliser les données qui y sont stockées. Il explique comment utiliser Managed Airflow 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 stockage Blob Azure puis exécute un job par lot Managed Service pour Apache Spark afin de traiter les données jointes.

L'ensemble de données public BigQuery de ce tutoriel est ghcn_d, une base de données intégrée de résumés climatiques dans le monde entier. 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 était la température à Chicago le jour de Thanksgiving au cours des 25 dernières années ?"

Remarque : Ce tutoriel utilise Airflow 2.

Objectifs

• Créer un environnement Managed Airflow dans la configuration par défaut
• Créer un blob dans Azure
• Créer un ensemble de données BigQuery vide
• Créer un bucket Cloud Storage
• Créer et exécuter un DAG qui inclut les tâches suivantes :
  • Charger un ensemble de données externe depuis Azure Blob Storage vers Cloud Storage
  • Charger un ensemble de données externe depuis 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

Activez les API Managed Service pour Apache Spark, Managed Airflow, BigQuery et Cloud Storage.

Rôles requis pour activer les API

Pour activer les API, vous avez besoin du rôle IAM Administrateur d'utilisation du service (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.

Activer les API

gcloud

Activez les API Managed Service pour Apache Spark, Managed Airflow, BigQuery et Cloud Storage :

Rôles requis pour activer les API

Pour activer les API, vous avez besoin du rôle IAM Administrateur de Service Usage (roles/serviceusage.serviceUsageAdmin), qui contient l' serviceusage.services.enable autorisation. Découvrez comment attribuer des rôles.

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

Accorder des autorisations

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

• Attribuez des rôles pour gérer les environnements Managed Airflow et les buckets d'environnement.

• Attribuez le rôle Propriétaire de données BigQuery (roles/bigquery.dataOwner) pour créer un ensemble de données BigQuery.

• Attribuez le rôle Administrateur de l'espace de stockage (roles/storage.admin) pour créer un bucket Cloud Storage.

Créer et préparer votre environnement Managed Airflow

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

   • Choisissez une région basée aux États-Unis.
   • Choisissez la dernière version de Managed Airflow.
   Remarque : La partie BigQuery de ce tutoriel doit s'exécuter dans la US multirégion. Nous vous recommandons de choisir une région des États-Unis pour votre environnement Managed Airflow afin de réduire les coûts et la latence, mais le tutoriel peut toujours s'exécuter si votre environnement Managed Airflow se trouve dans une autre région.

2. Attribuez les rôles suivants au compte de service utilisé dans votre environnement Managed Airflow afin 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)

Créer et modifier des ressources associées dans Google Cloud

1. Installez le apache-airflow-providers-microsoft-azure package PyPI dans votre environnement Managed Airflow.

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

   • Nom : holiday_weather
   • Région : US

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

4. Exécutez la commande suivante pour activer l'accès privé à Google sur le sous-réseau par défaut dans la région où vous souhaitez exécuter Managed Service pour Apache Spark afin de répondre aux exigences réseau. Nous vous recommandons d'utiliser la même région que votre environnement Managed Airflow.

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

Attention : L'ensemble de données BigQuery vide doit se trouver dans la région des États-Unis pour répondre aux exigences de colocation pour le transfert de l'ensemble de données public BigQuery ghcn_d.

Créer des ressources associées dans Azure

1. Créez un compte de stockage avec les paramètres par défaut.

2. Obtenez la clé d'accès et la chaîne de connexion de votre compte de stockage.

3. Créez un conteneur avec les options par défaut dans le compte de stockage que vous venez de créer.

4. Attribuez le rôle Délégateur de blob de stockage pour le conteneur créé à l'étape précédente.

5. Importez holidays.csv pour créer un blob de blocs avec les options par défaut dans le portail Azure.

6. Créez un jeton SAP pour le blob de blocs que vous avez créé à l'étape précédente dans le portail Azure.

   • Méthode de signature : clé de délégation utilisateur
   • Autorisations : lecture
   • Adresse IP autorisée : aucune
   • Protocoles autorisés : HTTPS uniquement

Remarque : Les jetons SAP sont un moyen sécurisé et documenté d’accéder à votre compte de stockage Azure. Toutefois, ils sont sensibles au temps et chacun a une date d'expiration. Veuillez choisir une date d'expiration en conséquence.

Se connecter à Azure depuis Managed Airflow

Remarque : Nous vous recommandons de stocker tous les identifiants des connexions dans Secret Manager. Si vous prévoyez d'utiliser ce tutoriel à des fins de production, envisagez de configurer Secret Manager pour votre environnement. Pour en savoir plus, consultez Configurer Secret Manager pour votre environnement.

Ajoutez votre connexion Microsoft Azure à l'aide de l'interface utilisateur Airflow :

1. Accédez à Admin > Connexions.

2. Créez une connexion avec la configuration suivante :

   • ID de connexion : azure_blob_connection
   • Type de connexion : Azure Blob Storage
   • Identifiant Blob Storage : nom de votre compte de stockage
   • Clé Blob Storage : clé d'accès de votre compte de stockage
   • Chaîne de connexion du compte Blob Storage : chaîne de connexion de votre compte de stockage
   • Jeton SAP : jeton SAP généré à partir de votre blob

Traitement des données à l'aide de Managed Service pour Apache Spark

Explorer l'exemple de job PySpark

Le code ci-dessous est un exemple de job PySpark qui convertit la température de dixièmes de degré Celsius en degrés Celsius. Ce job 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 le fichier PySpark dans Cloud Storage

Pour importer le fichier PySpark dans Cloud Storage :

1. Enregistrez data_analytics_process.py sur votre machine locale.

2. Dans la Google Cloud console, accédez à la page Navigateur Cloud Storage :

   Accéder au navigateur Cloud Storage

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

4. Dans l'onglet Objets du bucket, cliquez sur le bouton Importer des fichiers , sélectionnez data_analytics_process.py 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 :

• The AzureBlobStorageToGCSOperator transfère le fichier holidays.csv de votre blob de blocs Azure vers votre bucket Cloud Storage.

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

• The DataprocCreateBatchOperator crée et exécute un job par lot PySpark à l'aide de Managed Service pour Apache Spark.

• Le BigQueryInsertJobOperator joint les données de holidays.csv dans la colonne "Date" aux 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", et ces tâches se trouvent dans un TaskGroup pour une meilleure lisibilité dans la vue graphique de l'interface utilisateur Airflow.

Important : Le DataprocCreateBatchOperator est disponible dans les versions 6.2.0 et ultérieures du package apache-airflow-providers-google. Les versions requises de ce package sont préinstallées dans votre environnement à partir des versions 1.17.10 et 2.0.3 de Managed 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.providers.microsoft.azure.transfers.azure_blob_to_gcs import (
    AzureBlobStorageToGCSOperator,
)
from airflow.utils.task_group import TaskGroup

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

# 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}}"
PYSPARK_JAR = "gs://spark-lib/bigquery/spark-bigquery-latest_2.12.jar"
PROCESSING_PYTHON_FILE = f"gs://{BUCKET_NAME}/data_analytics_process.py"

# Azure configs
AZURE_BLOB_NAME = "{{var.value.azure_blob_name}}"
AZURE_CONTAINER_NAME = "{{var.value.azure_container_name}}"

BATCH_ID = "data-processing-{{ ts_nodash | lower}}"  # Dataproc serverless only allows lowercase characters
BATCH_CONFIG = {
    "pyspark_batch": {
        "jar_file_uris": [PYSPARK_JAR],
        "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(
    "azure_to_gcs_dag",
    # Continue to run DAG once per day
    schedule_interval=datetime.timedelta(days=1),
    default_args=default_dag_args,
) as dag:
    azure_blob_to_gcs = AzureBlobStorageToGCSOperator(
        task_id="azure_blob_to_gcs",
        # Azure args
        blob_name=AZURE_BLOB_NAME,
        container_name=AZURE_CONTAINER_NAME,
        wasb_conn_id="azure_blob_connection",
        filename=f"https://console.cloud.google.com/storage/browser/{BUCKET_NAME}/",
        # GCP args
        gcp_conn_id="google_cloud_default",
        object_name="holidays.csv",
        bucket_name=BUCKET_NAME,
        gzip=False,
        impersonation_chain=None,
    )

    create_batch = dataproc.DataprocCreateBatchOperator(
        task_id="create_batch",
        project_id=PROJECT_NAME,
        region=REGION,
        batch=BATCH_CONFIG,
        batch_id=BATCH_ID,
    )

    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):
            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",
            )

        azure_blob_to_gcs >> load_external_dataset >> bq_join_group >> create_batch

Utiliser l'interface utilisateur Airflow pour ajouter des variables

Dans Airflow, les variables sont un moyen universel de stocker et de récupérer des paramètres ou des configurations arbitraires sous la forme d'un simple magasin de valeurs clés. Ce DAG utilise des variables Airflow pour stocker des valeurs communes. Pour les ajouter à votre environnement :

1. Accédez à l'interface utilisateur Airflow depuis la console Managed Airflow.

2. Accédez à Admin > Variables.

3. Ajoutez les variables suivantes :

   • gcp_project : ID du 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 que votre job Managed Service pour Apache Spark réponde aux exigences réseau de Managed Service pour Apache Spark. 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 Managed Airflow. Vous trouverez ce compte de service dans l'onglet de configuration de l'environnement de votre environnement Managed Airflow.

   • azure_blob_name : nom du blob que vous avez créé précédemment.

   • azure_container_name : nom du conteneur que vous avez créé précédemment.

Importer le DAG dans le bucket de votre environnement

Managed Airflow planifie les DAG qui se trouvent dans le dossier /dags du bucket de votre environnement. Pour importer le DAG à l'aide de la Google Cloud console :

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

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

   Accéder à la page Environnements

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

4. Cliquez sur Importer des fichiers.

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

Déclencher le DAG

1. Dans votre environnement Managed Airflow, cliquez sur l'onglet DAG.

2. Cliquez sur l'ID de DAG azure_blob_to_gcs_dag.

3. Cliquez sur Déclencher le DAG.

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

Valider la réussite du DAG

1. Dans la Google Cloud console, 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 la table résultante. Notez que les nombres de la colonne de valeurs sont exprimés en dixièmes de degré Celsius.

5. Cliquez sur holidays_weather_normalized.

6. Cliquez sur "Aperçu" pour afficher la table résultante. Notez que les nombres de la colonne de valeurs sont exprimés en degrés Celsius.

Nettoyage

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

• Supprimez le conteneur que vous avez créé dans Azure.

• Supprimez le bucket Cloud Storage que vous avez créé pour ce tutoriel.

• Supprimez l'ensemble de données BigQuery.

• Supprimez l'environnement Managed Airflow, y compris le bucket de l'environnement que vous avez supprimé manuellement.

Étape suivante

• Exécutez un DAG d'analyse de données dans Google Cloud.
• Exécutez un DAG d'analyse de données dans AWS.