Uso de vistas materializadas con AWS Glue

La versión 5.1 y posteriores de AWS Glue admiten la creación y administración de vistas materializadas de Apache Iceberg en el catálogo de datos de AWS Glue. Una vista materializada es una tabla administrada que almacena el resultado precalculado de una consulta SQL en formato Apache Iceberg y se actualiza de forma incremental a medida que cambian las tablas de origen subyacentes. Puede utilizar las vistas materializadas para simplificar la canalización de transformación de datos y acelerar el rendimiento de las consultas para cargas de trabajo analíticas complejas.

Cuando crea una vista materializada mediante Spark en AWS Glue, la definición de la vista y sus metadatos se almacenan en el catálogo de datos de AWS Glue. Los resultados precalculados se almacenan como tablas de Apache Iceberg en buckets de tablas de Amazon S3 o en buckets de uso general de Amazon S3 dentro de su cuenta. El catálogo de datos de AWS Glue supervisa automáticamente las tablas de origen y actualiza las vistas materializadas mediante infraestructura de cómputo administrada.

Cómo funcionan las vistas materializadas con AWS Glue

Las vistas materializadas se integran con AWS Glue mediante la compatibilidad con Iceberg de Apache Spark en tareas de AWS Glue y cuadernos de AWS Glue Studio. Cuando configura su sesión de Spark para usar el catálogo de datos de AWS Glue, puede crear vistas materializadas mediante sintaxis SQL estándar. El optimizador de Spark puede reescribir automáticamente las consultas para utilizar vistas materializadas cuando ofrecen un mejor rendimiento, lo que elimina la necesidad de modificar manualmente el código de la aplicación.

El catálogo de datos de AWS Glue administra todos los aspectos operativos del mantenimiento de la vista materializada, incluidos:

Puede consultar vistas materializadas desde AWS Glue mediante las mismas interfaces de Spark SQL que utiliza para las tablas normales. También se puede acceder a los datos precalculados desde otros servicios, como Amazon Athena y Amazon Redshift.

Requisitos previos

Para utilizar vistas materializadas con AWS Glue, necesita:

Configuración de Spark para usar vistas materializadas

Para crear y administrar vistas materializadas en AWS Glue, configure su sesión de Spark con las extensiones de Iceberg y la configuración del catálogo requeridas. El método de configuración varía en función de si utiliza tareas de AWS Glue o cuadernos de AWS Glue Studio.

Configuración de tareas de AWS Glue

Al crear o actualizar un trabajo de AWS Glue, añada los siguientes parámetros de configuración como parámetros del trabajo:

Para buckets de tablas de S3

job = glue.create_job(
    Name='materialized-view-job',
    Role='arn:aws:iam::111122223333:role/GlueServiceRole',
    Command={
        'Name': 'glueetl',
        'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
        'PythonVersion': '3'
    },
    DefaultArguments={
        '--enable-glue-datacatalog': 'true',
        '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
        '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
                  '--conf spark.sql.catalog.glue_catalog.type=glue '
                  '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
                  '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
                  '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 '
                  '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
                  '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
                  '--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog '
                  '--conf spark.sql.catalog.s3t_catalog.type=glue '
                  '--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket ',
                  '--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 ',
                  '--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true ',
                  '--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse '
                  '--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 '
                  '--conf spark.sql.defaultCatalog=s3t_catalog '
                  '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
                  '--conf spark.sql.materializedViews.metadataCache.enabled=true'
    },
    GlueVersion='5.1'
)

Para buckets de uso general de S3

job = glue.create_job(
    Name='materialized-view-job',
    Role='arn:aws:iam::111122223333:role/GlueServiceRole',
    Command={
        'Name': 'glueetl',
        'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
        'PythonVersion': '3'
    },
    DefaultArguments={
        '--enable-glue-datacatalog': 'true',
        '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
                  '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
                  '--conf spark.sql.catalog.glue_catalog.type=glue '
                  '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
                  '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
                  '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ',
                  '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
                  '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
                  '--conf spark.sql.defaultCatalog=glue_catalog '
                  '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
                  '--conf spark.sql.materializedViews.metadataCache.enabled=true'
    },
    GlueVersion='5.1'
)

Configuración de cuadernos de AWS Glue Studio

En los cuadernos de AWS Glue Studio, configure su sesión de Spark mediante el comando mágico %%configure al inicio del cuaderno:

%%configure
{
    "conf": {
        "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
        "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
        "spark.sql.catalog.glue_catalog.type": "glue",
        "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
        "spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
        "spark.sql.catalog.glue_catalog.glue.id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
        "spark.sql.defaultCatalog": "glue_catalog",
        "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
        "spark.sql.materializedViews.metadataCache.enabled": "true"
    }
}

Habilitación de la actualización incremental

Para habilitar la optimización de la actualización incremental, añada las siguientes propiedades de configuración a los parámetros del trabajo o a la configuración del cuaderno:

--conf spark.sql.optimizer.incrementalMVRefresh.enabled=true
--conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false

Parámetros de configuración

Los siguientes parámetros de configuración controlan el comportamiento de la vista materializada:

Creación de vistas materializadas

Puede crear vistas materializadas mediante la instrucción SQL CREATE MATERIALIZED VIEW en tareas o en cuadernos de AWS Glue. La definición de vista especifica la lógica de transformación como una consulta SQL que hace referencia a una o más tablas de origen.

Creación de una vista materializada básica en las tareas de AWS Glue

En el siguiente ejemplo, se muestra cómo crear una vista materializada en un script de tarea de AWS Glue; utilice nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes en la definición de la vista:

from awsglue.context import GlueContext
from pyspark.context import SparkContext

sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session

# Create materialized view
spark.sql("""
    CREATE MATERIALIZED VIEW customer_orders
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

Creación de una vista materializada con actualización automática

Para configurar la actualización automática, especifique un calendario de actualización al crear la vista y utilice nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes en la definición de la vista:

spark.sql("""
    CREATE MATERIALIZED VIEW customer_orders
    SCHEDULE REFRESH EVERY 1 HOUR
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

Creación de una vista materializada con referencias entre catálogos

Cuando las tablas de origen se encuentran en un catálogo distinto del de la vista materializada, utilice nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes tanto en el nombre de la vista como en la definición de la vista:

spark.sql("""
    CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

Creación de vistas materializadas en cuadernos de AWS Glue Studio

En los cuadernos de AWS Glue Studio, puede usar el comando mágico %%sql para crear vistas materializadas y utilizar nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes en la definición de la vista:

%%sql
CREATE MATERIALIZED VIEW customer_orders
AS 
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM glue_catalog.sales.orders
GROUP BY customer_name

Consulta de vistas materializadas

Después de crear una vista materializada, puede consultarla como cualquier otra tabla mediante instrucciones SQL SELECT estándar en sus tareas o cuadernos de AWS Glue.

Consultas en tareas de AWS Glue

from awsglue.context import GlueContext
from pyspark.context import SparkContext

sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session

# Query materialized view
result = spark.sql("SELECT * FROM customer_orders")
result.show()

Consultas en los cuadernos de AWS Glue Studio

%%sql
SELECT * FROM customer_orders

Reescritura automática de consultas

Cuando la reescritura automática de consultas está habilitada, el optimizador de Spark analiza las consultas y utiliza automáticamente las vistas materializadas para mejorar el rendimiento. Por ejemplo, la siguiente consulta no se ejecuta:

result = spark.sql("""
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM orders
    GROUP BY customer_name
""")

El optimizador de Spark reescribe automáticamente esta consulta para utilizar la vista materializada «customer_orders» en lugar de procesar la tabla base de pedidos, siempre que la vista materializada esté actualizada.

Verificación de la reescritura automática de consultas

Para verificar si una consulta utiliza la reescritura automática de consultas, use el comando EXPLAIN EXTENDED:

spark.sql("""
    EXPLAIN EXTENDED
    SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount 
    FROM orders
    GROUP BY customer_name
""").show(truncate=False)

En el plan de ejecución, busque el nombre de la vista materializada en la operación BatchScan. Si el plan muestra BatchScan glue_catalog.analytics.customer_orders en lugar de BatchScan glue_catalog.sales.orders, la consulta se ha reescrito automáticamente para usar la vista materializada.

Tenga en cuenta que la reescritura automática de consultas requiere tiempo para que se complete la caché de metadatos de Spark después de crear una vista materializada. Este proceso suele completarse en un plazo de 30 segundos.

Actualización de vistas materializadas

Puede actualizar las vistas materializadas mediante dos métodos: actualización completa o actualización incremental. La actualización completa vuelve a calcular toda la vista materializada a partir de todos los datos de las tablas base, mientras que la actualización incremental procesa únicamente los datos que han cambiado desde la última actualización.

Actualización completa manual en tareas de AWS Glue

Para realizar una actualización completa de una vista materializada:

spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL")

# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()

Actualización incremental manual en tareas de AWS Glue

Para realizar una actualización incremental, asegúrese de que la actualización incremental esté habilitada en la configuración de su sesión de Spark y, a continuación, ejecute:

spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()

El catálogo de datos de AWS Glue determina automáticamente si la actualización incremental es aplicable en función de la definición de la vista y de la cantidad de datos modificados. Si la actualización incremental no es posible, la operación recurre a una actualización completa.

Actualización en los cuadernos de AWS Glue Studio

En los cuadernos, use el comando mágico %%sql:

%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL

Verificación de la ejecución de la actualización incremental

Para confirmar que la actualización incremental se ejecutó correctamente, habilite el registro de depuración en su tarea de AWS Glue:

from awsglue.context import GlueContext
from pyspark.context import SparkContext
import logging

sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session

# Enable debug logging
logger = logging.getLogger('org.apache.spark.sql')
logger.setLevel(logging.DEBUG)

# Execute refresh
spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

Busque el siguiente mensaje en los registros de la tarea de AWS Glue:

DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh

Administración de vistas materializadas

AWS Glue proporciona comandos SQL para administrar el ciclo de vida de las vistas materializadas en sus tareas y cuadernos.

Descripción de una vista materializada

Para ver los metadatos de una vista materializada, incluida su definición, el estado de actualización y la marca de tiempo de la última actualización:

spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False)

Modificación de una vista materializada

Para modificar el calendario de actualización de una vista materializada existente:

spark.sql("""
    ALTER MATERIALIZED VIEW customer_orders 
    ADD SCHEDULE REFRESH EVERY 2 HOURS
""")

Para eliminar la actualización automática:

spark.sql("""
    ALTER MATERIALIZED VIEW customer_orders 
    DROP SCHEDULE
""")

Eliminación de una vista materializada

Para eliminar una vista materializada:

spark.sql("DROP MATERIALIZED VIEW customer_orders")

Este comando elimina la definición de la vista materializada del catálogo de datos de AWS Glue y borra los datos de la tabla Iceberg subyacente de su bucket de Amazon S3.

Listado de vistas materializadas

Para enumerar todas las vistas materializadas de una base de datos:

spark.sql("SHOW VIEWS FROM analytics").show()

Permisos para vistas materializadas

Para crear y administrar vistas materializadas, debe configurar los permisos de AWS Lake Formation. El rol de IAM que crea la vista materializada (la función de definición) requiere permisos específicos en las tablas de origen y las bases de datos de destino.

Permisos requeridos para el rol definidor

El rol definidor debe contar con los siguientes permisos de Lake Formation:

Cuando crea una vista materializada, el ARN del rol definidor se almacena en la definición de la vista. El catálogo de datos de AWS Glue asume este rol al ejecutar operaciones de actualización automática. Si el rol definidor pierde el acceso a las tablas de origen, las operaciones de actualización fallarán hasta que se restablezcan los permisos.

Permisos de IAM para tareas de AWS Glue

El rol de IAM de su tarea de AWS Glue requiere los siguientes permisos:

{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "glue:GetCatalog",
                "glue:GetCatalogs",
                "glue:GetTable",
                "glue:GetTables",
                "glue:CreateTable",
                "glue:UpdateTable",
                "glue:DeleteTable",
                "glue:GetDatabase",
                "glue:GetDatabases",
                "cloudwatch:PutMetricData"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:*:*:*:/aws-glue/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "lakeformation:GetDataAccess"
            ],
            "Resource": "*"
        }
    ]
}

El rol que utilice para la actualización automática de vistas materializadas debe contar con el permiso iam:PassRole sobre dicho rol.

{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource": [
        "arn:aws:iam::111122223333:role/materialized-view-role-name"
      ]
    }
  ]
}
      

Para permitir que Glue actualice automáticamente la vista materializada, el rol también debe contar con la siguiente política de confianza, que habilita al servicio a asumir dicho rol.

{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource": [
        "arn:aws:iam::111122223333:role/materialized-view-role-name"
      ]
    }
  ]
}
      

Si la vista materializada se almacena en buckets de tablas de S3, también debe añadir el siguiente permiso al rol.

{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3tables:PutTableMaintenanceConfiguration"
      ],
      "Resource": "arn:aws:s3tables:*:123456789012:*"
    }
  ]
}
      

Concesión de acceso a vistas materializadas

Para conceder a otros usuarios acceso para consultar una vista materializada, utilice AWS Lake Formation para otorgar el permiso SELECT sobre la tabla de la vista materializada. Los usuarios pueden consultar la vista materializada sin necesidad de tener acceso directo a las tablas de origen subyacentes.

Para obtener información detallada sobre la configuración de los permisos de Lake Formation, consulte Concesión y revocación de permisos en recursos del catálogo de datos en la Guía para desarrolladores de AWS Lake Formation.

Supervisión de las operaciones de vistas materializadas

El catálogo de datos de AWS Glue publica métricas y registros para las operaciones de actualización de vistas materializadas en Amazon CloudWatch. Puede supervisar el estado de actualización, la duración y el volumen de datos procesados mediante métricas de CloudWatch.

Visualización de registros de la tarea

Para ver los registros de las tareas de AWS Glue que crean o actualizan vistas materializadas:

Configuración de alarmas

Para recibir notificaciones cuando las operaciones de actualización fallen o superen la duración prevista, cree alarmas de CloudWatch sobre las métricas de las vistas materializadas. También puede configurar reglas de Amazon EventBridge para activar respuestas automatizadas ante eventos de actualización.

Ejemplo: flujo de trabajo completo

En el siguiente ejemplo, se muestra un flujo de trabajo completo para crear y utilizar una vista materializada en AWS Glue.

Ejemplo de script de tarea de AWS Glue

import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job

args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)

# Create database and base table
spark.sql("CREATE DATABASE IF NOT EXISTS sales")
spark.sql("USE sales")

spark.sql("""
    CREATE TABLE IF NOT EXISTS orders (
        id INT,
        customer_name STRING,
        amount DECIMAL(10,2),
        order_date DATE
    )
""")

# Insert sample data
spark.sql("""
    INSERT INTO orders VALUES 
        (1, 'John Doe', 150.00, DATE('2024-01-15')),
        (2, 'Jane Smith', 200.50, DATE('2024-01-16')),
        (3, 'Bob Johnson', 75.25, DATE('2024-01-17'))
""")

# Create materialized view
spark.sql("""
    CREATE MATERIALIZED VIEW customer_summary
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

# Query the materialized view
print("Initial materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()

# Insert additional data
spark.sql("""
    INSERT INTO orders VALUES 
        (4, 'Jane Smith', 350.00, DATE('2024-01-18')),
        (5, 'Bob Johnson', 100.25, DATE('2024-01-19'))
""")

# Refresh the materialized view
spark.sql("REFRESH MATERIALIZED VIEW customer_summary FULL")

# Query updated results
print("Updated materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()

job.commit()

Ejemplo de cuaderno de AWS Glue Studio

%%configure
{
    "conf": {
        "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
        "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
        "spark.sql.catalog.glue_catalog.type": "glue",
        "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
        "spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
        "spark.sql.catalog.glue_catalog.glue.id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
        "spark.sql.defaultCatalog": "glue_catalog",
        "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
        "spark.sql.materializedViews.metadataCache.enabled": "true"
    }
}

%%sql
CREATE DATABASE IF NOT EXISTS sales

%%sql
USE sales

%%sql
CREATE TABLE IF NOT EXISTS orders (
    id INT,
    customer_name STRING,
    amount DECIMAL(10,2),
    order_date DATE
)

%%sql
INSERT INTO orders VALUES 
    (1, 'John Doe', 150.00, DATE('2024-01-15')),
    (2, 'Jane Smith', 200.50, DATE('2024-01-16')),
    (3, 'Bob Johnson', 75.25, DATE('2024-01-17'))

%%sql
CREATE MATERIALIZED VIEW customer_summary
AS 
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM glue_catalog.sales.orders
GROUP BY customer_name

%%sql
SELECT * FROM customer_summary

%%sql
INSERT INTO orders VALUES 
    (4, 'Jane Smith', 350.00, DATE('2024-01-18')),
    (5, 'Bob Johnson', 100.25, DATE('2024-01-19'))

%%sql
REFRESH MATERIALIZED VIEW customer_summary FULL

%%sql
SELECT * FROM customer_summary

Consideraciones y limitaciones

Tenga en cuenta lo siguiente al usar vistas materializadas con AWS Glue: