Executar um DAG de análise de dados no Google Cloud usando dados da AWS

Cloud Composer 1 | Cloud Composer 2 | Cloud Composer 3

Este tutorial é uma modificação de Executar um DAG de análise de dados no Google Cloud que mostra como conectar seu ambiente do Cloud Composer ao Amazon Web Services para utilizar os dados armazenados nele. Ele mostra como usar o Cloud Composer para criar um DAG do Apache Airflow. O O DAG mescla os dados de um conjunto de dados público do BigQuery e um arquivo CSV armazenado em uma Bucket S3 da Amazon Web Services (AWS) e executa um job em lote do Dataproc sem servidor para processar os dados dados.

O conjunto de dados público do BigQuery neste tutorial é ghcn_d, um banco de dados integrado de resumos climáticos em todo o mundo. O arquivo CSV contém informações sobre as datas e os nomes dos feriados dos EUA de 1997 a 2021.

A pergunta que queremos responder usando a DAG é: "Qual foi a temperatura em Chicago no Dia de Ação de Graças nos últimos 25 anos?"

Observação: este tutorial usa o Airflow 2.

Objetivos

• Criar um ambiente do Cloud Composer na configuração padrão
• Criar um bucket no AWS S3
• Criar um conjunto de dados vazio do BigQuery
• Crie um novo bucket do Cloud Storage
• Crie e execute um DAG que inclua as seguintes tarefas:
  • Carregar um conjunto de dados externo do S3 para o Cloud Storage
  • Carregue um conjunto de dados externo do Cloud Storage para BigQuery
  • Mesclar dois conjuntos de dados no BigQuery
  • Executar um job de análise de dados do PySpark

Antes de começar

Gerenciar permissões na AWS

1. Crie uma conta da AWS.

2. Siga a seção "Criar políticas com o editor visual" do tutorial da AWS sobre como criar políticas do IAM para criar uma política personalizada do IAM para o AWS S3 com a seguinte configuração:

   • Serviço: S3
   • ListAllMyBuckets (s3:ListAllMyBuckets), para acessar seu bucket do S3
   • CreateBucket (s3:CreateBucket), para criar um bucket
   • PutBucketOwnershipControls (s3:PutBucketOwnershipControls), para criar um bucket
   • ListBucket (s3:ListBucket), para conceder permissão para listar objetos em um bucket do S3
   • PutObject (s3:PutObject), para fazer upload de arquivos em um bucket
   • GetBucketVersioning (s3:GetBucketVersioning), para excluir um objeto em um bucket
   • DeleteObject (s3:DeleteObject) para excluir um objeto em um bucket
   • ListBucketVersions (s3:ListBucketVersions), para excluir um bucket
   • DeleteBucket (s3:DeleteBucket) para excluir um bucket
   • Recursos:escolha "Qualquer um". ao lado de "bucket" e "objeto" para conceder permissões a qualquer recurso desse tipo.
   • Tag: nenhuma
   • Nome: TutorialPolicy

   Consulte a lista de ações compatíveis com o Amazon S3 para mais informações sobre cada configuração acima.

3. Adicione a política de IAM TutorialPolicy à sua identidade

Cuidado: escolher "Any" para "bucket" e "object" concede permissão a qualquer recurso no S3. Para restringir o escopo dessa política, é possível limitar as permissões a um bucket e um objeto específicos depois de criá-los mais adiante no tutorial.

Ativar APIs

Ative as APIs a seguir:

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

Conceder permissões

Conceda os seguintes papéis e permissões à sua conta de usuário:

• Conceder papéis para gerenciar ambientes e buckets de ambiente do Cloud Composer.

• Conceda o papel Proprietário de dados do BigQuery (roles/bigquery.dataOwner) para criar um conjunto de dados do BigQuery.

• Conceda o papel Administrador do Storage (roles/storage.admin) para criar um bucket do Cloud Storage.

Criar e preparar seu ambiente do Cloud Composer

1. Crie um ambiente do Cloud Composer com parâmetros padrão:

   • Escolha uma região dos EUA.
   • Escolha a versão mais recente do Cloud Composer.
   Observação :a parte do BigQuery deste tutorial precisa ser executada no US multirregional. Recomendamos escolher uma região dos EUA para o ambiente do Cloud Composer e reduzir os custos e a latência, mas o tutorial ainda pode ser executado se o ambiente do Cloud Composer estiver em outra região.

2. Conceda os papéis a seguir à conta de serviço usada no ambiente do Cloud Composer para que os workers do Airflow executar corretamente as tarefas do DAG:

   • Usuário do BigQuery (roles/bigquery.user)
   • Proprietário de dados do BigQuery (roles/bigquery.dataOwner)
   • Usuário da conta de serviço (roles/iam.serviceAccountUser)
   • Editor do Dataproc (roles/dataproc.editor)
   • Worker do Dataproc (roles/dataproc.worker)

Criar e modificar recursos relacionados no Google Cloud

1. Instalar o apache-airflow-providers-amazon pacote PyPI no ambiente do Cloud Composer.

2. Crie um conjunto de dados vazio do BigQuery com os seguintes parâmetros:

   • Nome: holiday_weather
   • Região: US

3. Crie um bucket do Cloud Storage na multirregião US.

4. Execute o comando a seguir para ativar o Acesso particular do Google na sub-rede padrão na região em que você quer executar o Dataproc sem servidor para atender aos requisitos de rede. Recomendamos usar a mesma região do seu ambiente do Cloud Composer.

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

Atenção :o conjunto de dados vazio do BigQuery precisa estar na região dos EUA para atender a requisitos de colocation para transferir o conjunto de dados público ghcn_d do BigQuery.

Criar recursos relacionados na AWS

Crie um bucket do S3 com as configurações padrão da região de sua preferência.

Conectar-se à AWS pelo Cloud Composer

Observação: recomendamos armazenar todas as credenciais para conexões no Secret Manager. Se você planeja usar este tutorial para para fins de produção, configure o Secret Manager para em seu ambiente. Para mais informações, consulte Configurar o Secret Manager para seu ambiente.

1. Conferir o ID e a chave de acesso secreta da AWS

2. Adicione sua conexão do AWS S3 usando a interface do Airflow:

   1. Acesse Administrador > Conexões.

   2. Crie uma nova conexão com a seguinte configuração:

      • ID da conexão: aws_s3_connection
      • Tipo de conexão: Amazon S3
      • Extras: {"aws_access_key_id":"your_aws_access_key_id", "aws_secret_access_key": "your_aws_secret_access_key"}

Processamento de dados usando o Dataproc Serverless

Confira o exemplo de job do PySpark

O código mostrado abaixo é um exemplo de job do PySpark que converte a temperatura décimos de grau de Celsius para graus Celsius. Esta vaga converte de temperatura do conjunto de dados em um formato diferente.

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

Faça upload do arquivo PySpark para o Cloud Storage

Para fazer upload do arquivo PySpark no Cloud Storage:

1. Salve data_analytics_process.py na sua máquina local.

2. No console do Google Cloud, acesse a página Navegador do Cloud Storage:

   Ir para o navegador do Cloud Storage

3. Clique no nome do bucket que você criou anteriormente.

4. Na guia Objetos do bucket, clique no botão Fazer upload de arquivos. selecione data_analytics_process.py na caixa de diálogo exibida e clique em Abrir.

Fazer upload do arquivo CSV para o AWS S3

Para fazer upload do arquivo holidays.csv:

1. Salve holidays.csv na máquina local.
2. Siga o Guia da AWS para fazer upload do arquivo no bucket.

DAG de análise de dados

Confira o exemplo de DAG

O DAG usa vários operadores para transformar e unificar os dados:

• O S3ToGCSOperator transfere o arquivo holidays.csv do seu bucket da AWS S3 ao bucket do Cloud Storage.

• O GCSToBigQueryOperator ingere o arquivo holidays.csv do Cloud Storage para uma nova tabela no BigQuery conjunto de dados holidays_weather criado anteriormente.

• O DataprocCreateBatchOperator cria e executa um job em lote do PySpark usando o Dataproc sem servidor.

• O BigQueryInsertJobOperator une os dados de holidays.csv na coluna "Data" com os dados meteorológicos do conjunto de dados público do BigQuery ghcn_d. As tarefas BigQueryInsertJobOperator estão geradas dinamicamente usando uma repetição for, e essas tarefas estão em um TaskGroup para uma melhor legibilidade na visualização de gráfico da interface do Airflow.

Importante: o DataprocCreateBatchOperator está disponível nas versões 6.2.0 e mais recentes do pacote apache-airflow-providers-google. As versões necessárias desse pacote são pré-instaladas no seu ambiente a partir das versões 1.17.10 e 2.0.3 do Cloud Composer.

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

Usar a interface do Airflow para adicionar variáveis

No Airflow, variables são uma forma universal de armazenar e recuperar configurações arbitrárias ou personalizadas como um repositório simples de chave-valor. Esse DAG usa variáveis do Airflow para e armazenar valores comuns. Para adicionar ao seu ambiente:

1. Acesse a IU do Airflow pelo console do Cloud Composer.

2. Acesse Administrador > Variáveis.

3. Adicione as seguintes variáveis:

   • s3_bucket: o nome do bucket do S3 criado anteriormente.

   • gcp_project: o ID do projeto.

   • gcs_bucket: o nome do bucket criado anteriormente. (sem o prefixo gs://).

   • gce_region: a região em que você quer que as job do Dataproc que atenda Requisitos de rede sem servidor do Dataproc. Esta é a região em que você ativou o Acesso privado do Google anteriormente.

   • dataproc_service_account: a conta de serviço do seu ambiente do Cloud Composer. Essa conta de serviço pode ser encontrada na guia de configuração do ambiente do Cloud Composer.

Faça upload do DAG para o bucket do ambiente

O Cloud Composer programa DAGs que estão na pasta /dags no bucket do ambiente. Para fazer upload do DAG usando o console do Google Cloud:

1. Na sua máquina local, salve s3togcsoperator_tutorial.py

2. No console do Google Cloud, acesse a página Ambientes.

   Acessar "Ambientes"

3. Na lista de ambientes, na coluna Pasta de DAGs, clique no link DAGs. A pasta de DAGs do seu ambiente é aberta.

4. Clique em Fazer o upload dos arquivos.

5. Selecione s3togcsoperator_tutorial.py na sua máquina local e clique em Abrir.

Como acionar o DAG

1. No ambiente do Cloud Composer, clique na guia DAGs.

2. Clique no ID do DAG s3_to_gcs_dag.

3. Clique em Trigger DAG.

4. Aguarde de cinco a dez minutos até que uma marca de seleção verde apareça, indicando que as tarefas foram concluídas.

Valide o sucesso do DAG

1. No console do Google Cloud, acesse a página do BigQuery.

   Ir para o BigQuery

2. No painel Explorer, clique no nome do projeto.

3. Clique em holidays_weather_joined.

4. Clique em "Visualizar" para ver a tabela resultante. Os números na coluna "Valor" estão em décimos de um grau Celsius.

5. Clique em holidays_weather_normalized.

6. Clique em "Visualizar" para ver a tabela resultante. Os números na coluna de valores estão em graus Celsius.

Limpeza

Exclua os recursos individuais criados para este tutorial:

• Excluir o arquivo holidays.csv no bucket S3 da AWS.

• Exclua o bucket do AWS S3 que você criou.

• Exclua o bucket do Cloud Storage que você criou para este tutorial.

• Exclua o conjunto de dados do BigQuery.

• Exclua o ambiente do Cloud Composer, incluindo a exclusão manual do bucket do ambiente.

A seguir

• Execute um DAG de análise de dados no Google Cloud.
• Execute um DAG de análise de dados no Azure.