Cree una canalización de datos para incorporar, transformar y analizar los datos de Google Analytics con el kit de AWS DataOps desarrollo

Creada por Anton Kukushkin (AWS) y Rudy Puig () AWS

Resumen

Este patrón describe cómo crear una canalización de datos para ingerir, transformar y analizar los datos de Google Analytics mediante el kit de AWS DataOps desarrollo (DDK) y otros servicios. AWS AWSDDKSe trata de un marco de desarrollo de código abierto que te ayuda a crear flujos de trabajo de datos y una arquitectura de datos moderna. AWS Uno de sus principales objetivos AWS DDK es ahorrarle el tiempo y el esfuerzo que normalmente se dedican a tareas de canalización de datos que requieren mucha mano de obra, como organizar las canalizaciones, construir infraestructuras y crear las bases de esa infraestructura. DevOps Puedes prescindir de estas tareas que requieren mucha mano de obra para AWS DDK poder centrarte en escribir código y otras actividades de gran valor.

Requisitos previos y limitaciones

Requisitos previos 

Versiones de producto

Arquitectura

Pila de tecnología

Arquitectura de destino

El siguiente diagrama muestra el proceso basado en eventos que incorpora, transforma y analiza los datos de Google Analytics.

En el diagrama, se muestra el siguiente flujo de trabajo:

Herramientas

AWSherramientas

Código

El código de este patrón está disponible en los GitHub AWS DataOps repositorios Development Kit (DDK) y Analyzing Google Analytics data with Amazon AppFlow, Amazon Athena y AWS DataOps Development Kit.

Epics

git clone https://github.com/aws-samples/aws-ddk-examples.git

cd google-analytics-data-using-appflow/python && python3 -m venv .venv

source .venv/bin/activate && pip install -r requirements.txt

Resolución de problemas

Recursos relacionados

Información adicional

AWSDDKlas canalizaciones de datos se componen de una o varias etapas. Los siguientes ejemplos de código emplean AppFlowIngestionStage para incorporar datos de Google Analytics, SqsToLambdaStage para gestionar la transformación de datos y AthenaSQLStage para ejecutar la consulta de Athena.

En primer lugar, se crean las etapas de transformación e incorporación de datos, como se muestra en el siguiente ejemplo de código:

        appflow_stage = AppFlowIngestionStage(
            self,
            id="appflow-stage",
            flow_name=flow.flow_name,
        )
        sqs_lambda_stage = SqsToLambdaStage(
            self,
            id="lambda-stage",
            lambda_function_props={
                "code": Code.from_asset("./ddk_app/lambda_handlers"),
                "handler": "handler.lambda_handler",
                "layers": [
                    LayerVersion.from_layer_version_arn(
                        self,
                        id="layer",
                        layer_version_arn=f"arn:aws:lambda:{self.region}:336392948345:layer:AWSDataWrangler-Python39:1",
                    )
                ],
                "runtime": Runtime.PYTHON_3_9,
            },
        )
        # Grant lambda function S3 read & write permissions
        bucket.grant_read_write(sqs_lambda_stage.function)
        # Grant Glue database & table permissions
        sqs_lambda_stage.function.add_to_role_policy(
            self._get_glue_db_iam_policy(database_name=database.database_name)
        )
        athena_stage = AthenaSQLStage(
            self,
            id="athena-sql",
            query_string=[
                (
                    "SELECT year, month, day, device, count(user_count) as cnt "
                    f"FROM {database.database_name}.ga_sample "
                    "GROUP BY year, month, day, device "
                    "ORDER BY cnt DESC "
                    "LIMIT 10; "
                )
            ],
            output_location=Location(
                bucket_name=bucket.bucket_name, object_key="query-results/"
            ),
            additional_role_policy_statements=[
                self._get_glue_db_iam_policy(database_name=database.database_name)
            ],
        )

A continuación, la DataPipeline construcción se utiliza para «conectar» las etapas mediante EventBridge reglas, como se muestra en el siguiente ejemplo de código:

        (
            DataPipeline(self, id="ingestion-pipeline")
            .add_stage(
                stage=appflow_stage,
                override_rule=Rule(
                    self,
                    "schedule-rule",
                    schedule=Schedule.rate(Duration.hours(1)),
                    targets=appflow_stage.targets,
                ),
            )
            .add_stage(
                stage=sqs_lambda_stage,
                # By default, AppFlowIngestionStage stage emits an event after the flow run finishes successfully
                # Override rule below changes that behavior to call the the stage when data lands in the bucket instead
                override_rule=Rule(
                    self,
                    "s3-object-created-rule",
                    event_pattern=EventPattern(
                        source=["aws.s3"],
                        detail={
                            "bucket": {"name": [bucket.bucket_name]},
                            "object": {"key": [{"prefix": "ga-data"}]},
                        },
                        detail_type=["Object Created"],
                    ),
                    targets=sqs_lambda_stage.targets,
                ),
            )
            .add_stage(stage=athena_stage)
        )

Para ver más ejemplos de código, consulta el GitHub repositorio Análisis de datos de Google Analytics con Amazon AppFlow, Amazon Athena y AWS DataOps Development Kit.