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

Cloud Composer 1 | Cloud Composer 2 | Cloud Composer 3

Ce tutoriel est une modification Exécuter un DAG d'analyse de données dans Google Cloud expliquant comment connecter votre environnement Cloud Composer à Amazon services Web pour utiliser les données qui y sont stockées. Il explique comment utiliser Cloud Composer pour créer un DAG Apache Airflow. La Le DAG associe les données d'un ensemble de données public BigQuery à un fichier CSV stocké dans un Bucket Amazon Web Services (AWS) S3 puis exécute un job par lot Dataproc sans serveur pour traiter les données.

L'ensemble de données public BigQuery de ce tutoriel 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 des États-Unis de 1997 à 2021.

La question à laquelle nous voulons répondre à l'aide du DAG est la suivante : "Était-il chaud à Chicago ? à Thanksgiving ces 25 dernières années ?"

Objectifs

• Créer un environnement Cloud Composer dans la configuration par défaut
• Créer un bucket dans AWS S3
• 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 S3 vers Cloud Storage
  • Charger un ensemble de données externe de Cloud Storage vers BigQuery
  • Joindre deux ensembles de données dans BigQuery
  • Exécuter une tâche PySpark d'analyse de données

Avant de commencer

Gérer les autorisations dans AWS

1. Créez un compte AWS.

2. Suivez les instructions de la section "Créer des règles avec l'éditeur visuel". des Créer des stratégies IAM AWS afin de créer une stratégie IAM personnalisée pour AWS S3 avec la configuration suivante:

   • Service : S3
   • ListAllMyBuckets (s3:ListAllMyBuckets), pour afficher votre bucket S3
   • CreateBucket (s3:CreateBucket), pour créer un bucket ;
   • PutBucketOwnershipControls (s3:PutBucketOwnershipControls), pour créer un bucket
   • ListBucket (s3:ListBucket), pour accorder l'autorisation de répertorier les objets d'un bucket S3
   • PutObject (s3:PutObject) pour importer des fichiers dans un bucket
   • GetBucketVersioning (s3:GetBucketVersioning), pour supprimer un objet dans un bucket
   • DeleteObject (s3:DeleteObject) pour supprimer un objet dans un bucket
   • ListBucketVersions (s3:ListBucketVersions), pour supprimer un bucket
   • DeleteBucket (s3:DeleteBucket), pour supprimer un bucket
   • Ressources:sélectionnez "Toutes". à côté de "bucket" et "objet" accorder sur toutes les ressources de ce type.
   • Tag:aucun
   • Nom:TutorialPolicy

   Consultez le liste des actions disponibles dans Amazon S3 pour en savoir plus sur chacune des configurations mentionnées ci-dessus.

3. Ajouter la stratégie IAM TutorialPolicy à votre identité

Attention :Si vous sélectionnez "Toutes", pour "bucket" et "objet" accordera l'autorisation ressources de S3. Pour restreindre le champ d'application de cette règle, vous pouvez limiter des autorisations pour un bucket et un objet spécifiques une fois que vous les aurez créés ultérieurement dans le tutoriel.

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

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

• Accordez des rôles pour gérer les environnements Cloud Composer et les buckets d'environnement.

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

• Accordez le rôle Administrateur Storage (roles/storage.admin) pour créer un bucket Cloud Storage.

Créer et préparer votre environnement Cloud Composer

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

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

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

   • 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. Installer apache-airflow-providers-amazon Package PyPI dans le fichier Cloud Composer.

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

   • Nom : holiday_weather
   • Région : US

3. Créer un bucket Cloud Storage dans l'emplacement multirégional US.

4. 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. Mer recommandez d'utiliser la même région que votre instance Cloud Composer environnement.

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

Attention :L'ensemble de données BigQuery vide doit être situé dans la région US pour satisfaire exigences concernant la colocation permettant de transférer l'ensemble de données public BigQuery ghcn_d.

Créer des ressources associées dans AWS

Créer un bucket S3 avec les paramètres par défaut dans votre région préférée.

Se connecter à AWS depuis Cloud Composer

Remarque :Nous vous recommandons de stocker tous les identifiants de connexion 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 Configurez Secret Manager pour votre environnement.

1. Obtenir votre ID de clé d'accès AWS et votre clé d'accès secrète

2. Ajouter votre AWS S3 connexion à l'aide de l'interface utilisateur d'Airflow:

   1. Accédez à Administration > Connexions.

   2. Créez une connexion en utilisant la configuration suivante:

      • ID de connexion:aws_s3_connection
      • Type de connexion:Amazon S3
      • Bonus: {"aws_access_key_id":"your_aws_access_key_id", "aws_secret_access_key": "your_aws_secret_access_key"}

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 dixièmes de degré en degrés Celsius en degrés Celsius. Cette tâche effectue une conversion les données de température de l'ensemble de données dans un format différent.

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. Enregistrer data_analytics_process.py sur votre ordinateur local.

2. Dans la console Google Cloud, accédez à la page du 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.

Importer le fichier CSV dans AWS S3

Pour importer le fichier holidays.csv:

1. Enregistrez holidays.csv sur votre ordinateur local.
2. Suivez le guide AWS pour importer le fichier dans votre bucket.

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 S3ToGCSOperator transfère le fichier holidays.csv de votre bucket AWS S3 vers votre bucket Cloud Storage.

• La GCSToBigQueryOperator ingère le fichier holidays.csv à partir de Cloud Storage vers une nouvelle table dans BigQuery Ensemble de données 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.

• La BigQueryInsertJobOperator associe les données du fichier holidays.csv "Date" contenant des données météorologiques issues de l'ensemble de données public BigQuery ghcn_d. Les tâches BigQueryInsertJobOperator sont générées dynamiquement à l'aide d'une boucle For, et ces tâches se trouvent dans une TaskGroup pour améliorer la lisibilité de la vue graphique de l'interface utilisateur d'Airflow.

Important :DataprocCreateBatchOperator est disponible dans le Versions du package apache-airflow-providers-google 6.2.0 et ultérieures. Les versions requises de ce package sont préinstallées dans votre environnement à partir des versions Cloud Composer 1.17.10 et 2.0.3.

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.google.cloud.transfers.s3_to_gcs import S3ToGCSOperator
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"

# S3 configs
S3_BUCKET_NAME = "{{var.value.s3_bucket}}"

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(
    "s3_to_gcs_dag",
    # Continue to run DAG once per day
    schedule_interval=datetime.timedelta(days=1),
    default_args=default_dag_args,
) as dag:
    s3_to_gcs_op = S3ToGCSOperator(
        task_id="s3_to_gcs",
        bucket=S3_BUCKET_NAME,
        gcp_conn_id="google_cloud_default",
        aws_conn_id="aws_s3_connection",
        dest_gcs=f"gs://{BUCKET_NAME}",
    )

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

        s3_to_gcs_op >> load_external_dataset >> bq_join_group >> create_batch

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

Dans Airflow, variables sont un moyen universel de stocker et de récupérer des paramètres ou des comme un simple magasin de paires clé-valeur. Ce DAG utilise des variables Airflow pour pour stocker des valeurs communes. Pour les ajouter à votre environnement:

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

2. Accédez à Administration > Variables.

3. Ajoutez les variables suivantes :

   • s3_bucket: nom du bucket S3 que vous avez créé précédemment.

   • 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 Dataproc qui répond aux exigences Configuration requise pour la mise en réseau sans serveur avec Dataproc Il s'agit de la région dans laquelle vous avez précédemment activé l'accès privé à Google.

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

Importer le DAG dans le bucket de votre environnement

Cloud Composer planifie les DAG situés dans le /dags dans le bucket de votre environnement. Pour importer le DAG à l'aide de la méthode Console Google Cloud:

1. Sur votre machine locale, enregistrez s3togcsoperator_tutorial.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 du DAG, cliquez sur le lien des DAG. Le dossier des DAG de votre environnement s'ouvre.

4. Cliquez sur Importer des fichiers.

5. Sélectionnez s3togcsoperator_tutorial.py sur votre ordinateur local, 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 s3_to_gcs_dag.

3. Cliquez sur Déclencher le DAG.

4. Attendez environ cinq à dix minutes jusqu'à ce qu'une coche verte s'affiche, indiquant que les tâches ont bien é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 inclus dans valeur sont exprimées en dixièmes de degré Celsius.

5. Cliquez sur holidays_weather_normalized.

6. Cliquez sur "Aperçu" pour afficher la table obtenue. Notez que les nombres inclus dans valeur sont exprimées en degrés Celsius.

Nettoyage

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

• Supprimer le fichier holidays.csv dans votre bucket AWS S3.

• Supprimez le bucket AWS S3 que vous avez créé.

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

• Supprimez l'ensemble de données BigQuery.

• Supprimez l'environnement Cloud Composer, y compris supprimer manuellement le bucket de l'environnement.

Étape suivante

• Exécuter un DAG Data Analytics dans Google Cloud
• Exécutez un DAG d'analyse de données dans Azure.