Usar visões materializadas com AWS o Glue

A versão 5.1 e posterior do AWS Glue oferece suporte à criação e ao gerenciamento de visões materializadas do Apache Iceberg no Catálogo de Dados do AWS Glue. Uma visão materializada é uma tabela gerenciada que armazena o resultado pré-computado de uma consulta SQL no formato Apache Iceberg e é atualizada incrementalmente à medida que as tabelas de origem subjacentes mudam. Você pode usar visões materializadas para simplificar os pipelines de transformação de dados e acelerar o desempenho das consultas para workloads de analytics complexas.

Quando você cria uma visão materializada usando o Spark no AWS Glue, a definição da visão e os metadados são armazenados no Catálogo de Dados do AWS Glue. Os resultados pré-computados são armazenados como tabelas do Apache Iceberg em buckets do Tabelas do Amazon S3 ou buckets de uso geral do Amazon S3 em sua conta. O Catálogo de Dados do AWS Glue monitora automaticamente as tabelas de origem e atualiza as visões materializadas usando a infraestrutura de computação gerenciada.

Como as visões materializadas funcionam com o AWS Glue

As visões materializadas se integram ao AWS Glue por meio do suporte ao Iceberg do Apache Spark nos trabalhos do AWS Glue e nos cadernos do AWS Glue Studio. Ao configurar sua sessão do Spark para usar o Catálogo de Dados do AWS Glue, você pode criar visões materializadas usando a sintaxe SQL padrão. O otimizador do Spark pode reescrever automaticamente as consultas para usar visões materializadas quando elas oferecem melhor desempenho, eliminando a necessidade de modificar manualmente o código da aplicação.

O Catálogo de Dados do AWS Glue trata de todos os aspectos operacionais da manutenção da visão materializada, incluindo:

Você pode consultar visões materializadas do AWS Glue usando as mesmas interfaces SQL do Spark que você usa para tabelas comuns. Os dados pré-computados também podem ser acessados de outros serviços, incluindo Amazon Athena e Amazon Redshift.

Pré-requisitos

Para usar visões materializadas com o AWS Glue, você precisa:

Configurar o Spark para usar visões materializadas

Para criar e gerenciar visões materializadas no AWS Glue, configure sua sessão do Spark com as extensões e configurações de catálogo necessárias do Iceberg. O método de configuração varia dependendo se você está usando trabalhos do AWS Glue ou cadernos do AWS Glue Studio.

Configurar trabalhos do AWS Glue

Ao criar ou atualizar um trabalho do AWS Glue, adicione os seguintes parâmetros de configuração como parâmetros do trabalho:

Para buckets do Tabelas do 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 geral do 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'
)

Configurar cadernos do AWS Glue Studio

Nos cadernos do AWS Glue Studio, configure sua sessão do Spark usando o comando mágico %%configure no início do seu caderno:

%%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"
    }
}

Habilitar a atualização incremental

Para habilitar a otimização da atualização incremental, adicione as seguintes propriedades de configuração aos parâmetros do seu trabalho ou à configuração do caderno:

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

Parâmetros de configuração

Os seguintes parâmetros de configuração controlam o comportamento da visão materializada:

Criar visualizações materializadas

Você cria visões materializadas usando a instrução SQL CREATE MATERIALIZED VIEW nos trabalhos ou cadernos do AWS Glue. A definição da visão especifica a lógica de transformação como uma consulta SQL que faz referência a uma ou mais tabelas de origem.

Criar uma visão materializada básica em trabalhos do AWS Glue

O exemplo a seguir demonstra como criar uma visão materializada em um script de trabalho do AWS Glue. Use nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão:

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

Criar uma visão materializada com atualização automática

Para configurar a atualização automática, especifique uma programação de atualização ao criar a visão, usando nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão:

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

Criar uma visão materializada com referências de catálogos cruzados

Quando suas tabelas de origem estiverem em um catálogo diferente da visão materializada, use nomes de tabela totalmente qualificados com convenção de nomenclatura em três partes, tanto no nome da visão quanto na definição da visão:

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

Criar visões materializadas em cadernos do AWS Glue Studio

Nos cadernos do AWS Glue Studio, você pode usar o comando mágico %%sql para criar visões materializadas, usando nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão:

%%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

Consultar visões materializadas

Depois de criar uma visão materializada, você pode consultá-la como qualquer outra tabela usando instruções SQL SELECT padrão em seus trabalhos ou cadernos do AWS Glue.

Consultas em trabalhos no 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 em cadernos AWS Glue Studio

%%sql
SELECT * FROM customer_orders

Reescrita automática de consultas

Quando a reescrita automática de consultas está habilitada, o otimizador do Spark analisa suas consultas e usa automaticamente visões materializadas quando elas podem melhorar o desempenho. Por exemplo, se você executar a seguinte consulta:

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

O otimizador do Spark reescreve automaticamente essa consulta para usar a visão materializada customer_orders em vez de processar a tabela de pedidos base, desde que a visão materializada seja atual.

Verificar a reescrita automática de consulta

Para verificar se uma consulta usa a reescrita automática de consultas, use o 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)

No plano de execução, procure o nome da visão materializada na operação BatchScan. Se o plano mostrar BatchScan glue_catalog.analytics.customer_orders em vez de BatchScan glue_catalog.sales.orders, a consulta foi automaticamente reescrita para usar a visão materializada.

Observe que a reescrita automática da consulta requer tempo para que o cache de metadados do Spark seja preenchido após a criação de uma visão materializada. Normalmente, esse processo é concluído em 30 segundos.

Atualizar visões materializadas

Você pode atualizar as visões materializadas usando dois métodos: atualização completa ou atualização incremental. A atualização completa recalcula toda a visão materializada de todos os dados da tabela base, enquanto a atualização incremental processa somente os dados que foram alterados desde a última atualização.

Atualização manual completa nos trabalhos do AWS Glue

Para realizar uma atualização completa de uma visão materializada:

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

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

Atualização incremental manual em trabalhos do AWS Glue

Para realizar uma atualização incremental, certifique-se de que a atualização incremental esteja ativada na configuração da sua sessão do Spark e, em seguida, execute:

spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

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

O Catálogo de Dados do AWS Glue determina automaticamente se a atualização incremental é aplicável com base na definição da visão e na quantidade de dados alterados. Se a atualização incremental não for possível, a operação retornará à atualização completa.

Atualização nos cadernos do AWS Glue Studio

Em cadernos, use o comando mágico %%sql:

%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL

Verificar execução da atualização incremental

Para confirmar que a atualização incremental foi executada com sucesso, habilite o registro em log de depuração em seu trabalho do 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")

Pesquise a seguinte mensagem nos logs dos trabalhos do AWS Glue:

DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh

Gerenciar visões materializadas

O AWS Glue fornece comandos SQL para gerenciar o ciclo de vida das visões materializadas em seus trabalhos e cadernos.

Descrever uma visão materializada

Para visualizar metadados sobre uma visão materializada, incluindo sua definição, status de atualização e data e hora da última atualização:

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

Alterar uma visão materializada

Para modificar o cronograma de atualização de uma visão materializada existente:

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

Para remover a atualização automática:

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

Eliminar uma visão materializada

Para excluir uma visão materializada:

spark.sql("DROP MATERIALIZED VIEW customer_orders")

Esse comando remove a definição de visão materializada do Catálogo de Dados do AWS Glue e exclui os dados subjacentes da tabela do Iceberg do seu bucket do S3.

Listar visões materializadas

Para listar todas as visões materializadas em um banco de dados:

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

Permissões para visões materializadas

Para criar e gerenciar visões materializadas, você deve configurar as permissões do AWS Lake Formation. O perfil do IAM que cria a visão materializada (o perfil definidor) requer permissões específicas nas tabelas de origem e nos bancos de dados de destino.

Permissões necessárias para o perfil de definidor

O perfil deve ter as seguintes permissões:

Quando você cria uma visão materializada, o ARN do perfil definidor é armazenado na definição da visão. O Catálogo de Dados do AWS Glue assume esse perfil ao executar operações de atualização automática. Se o perfil do definidor perder o acesso às tabelas de origem, as operações de atualização falharão até que as permissões sejam restauradas.

Permissões do IAM para trabalhos do AWS Glue

O perfil do IAM do trabalho do AWS Glue requer as seguintes permissões:

{
    "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": "*"
        }
    ]
}

O perfil que você usa para atualizar automaticamente a visão materializada deve ter a permissão iam:PassRole no perfil.

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

Para que o Glue atualize automaticamente a visão materializada para você, o perfil também deve ter a política de confiança a seguir que permite que o serviço assuma o perfil.

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

Se a visão materializada estiver armazenada em buckets do Tabelas do S3, também precisará adicionar a seguinte permissão ao perfil.

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

Conceder acesso às visões materializadas

Para conceder acesso a outros usuários para consultar uma visão materializada, use AWS Lake Formation para conceder a permissão SELECT na tabela de visão materializada. Os usuários podem consultar a visão materializada sem precisar de acesso direto às tabelas de origem subjacentes.

Para obter informações detalhadas sobre como configurar as permissões do Lake Formation, consulte Conceder e revogar permissões nos recursos do Catálogo de Dados no Guia do Desenvolvedor do AWS Lake Formation.

Monitorar operações de visão materializada

O Catálogo de Dados do AWS Glue publica métricas e logs para operações de atualização de visões materializadas no Amazon CloudWatch. Você pode monitorar o status da atualização, a duração e o volume de dados processados por meio das métricas do CloudWatch.

Visualizar logs de trabalho

Para visualizar logs de trabalhos do AWS Glue que criam ou atualizam visões materializadas:

Definir alarmes

Para receber notificações quando as operações de atualização falharem ou excederem a duração esperada, crie alarmes do CloudWatch nas métricas de visão materializada. Você também pode configurar as regras do Amazon EventBridge para acionar respostas automatizadas para atualizar eventos.

Exemplo: concluir fluxo de trabalho

O exemplo a seguir demonstra um fluxo de trabalho completo para criar e usar uma visão materializada no AWS Glue.

Exemplo de script de trabalho do 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()

Exemplo de caderno do 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

Considerações e limitações

Pense no seguinte ao usar visões materializadas com o AWS Glue: