Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation de vues matérialisées avec AWS Glue

AWS Les versions 5.1 et ultérieures de Glue prennent en charge la création et la gestion de vues matérialisées d'Apache Iceberg dans le AWS Catalogue de données Glue. Une vue matérialisée est une table gérée qui stocke le résultat précalculé d'une requête SQL au format Apache Iceberg et qui se met à jour de manière incrémentielle à mesure que les tables sources sous-jacentes changent. Vous pouvez utiliser des vues matérialisées pour simplifier les pipelines de transformation des données et accélérer les performances des requêtes pour les charges de travail analytiques complexes.

Lorsque vous créez une vue matérialisée à l'aide de Spark dans AWS Glue, la définition de la vue et les métadonnées sont stockées dans AWS Catalogue de données Glue. Les résultats précalculés sont stockés sous forme de tables Apache Iceberg dans des compartiments Amazon S3 Tables ou des compartiments Amazon S3 à usage général au sein de votre compte. Le AWS Glue Data Catalog surveille automatiquement les tables sources et actualise les vues matérialisées à l'aide d'une infrastructure informatique gérée.

Comment fonctionnent les vues matérialisées avec AWS Glue

Les vues matérialisées s'intègrent à AWS Découvrez le support Iceberg d'Apache Spark dans AWS Des travaux de colle et AWS Carnets Glue Studio. Lorsque vous configurez votre session Spark pour utiliser AWS Glue Data Catalog, vous pouvez créer des vues matérialisées à l'aide de la syntaxe SQL standard. L'optimiseur Spark peut réécrire automatiquement les requêtes pour utiliser des vues matérialisées lorsqu'elles offrent de meilleures performances, éliminant ainsi le besoin de modifier manuellement le code de l'application.

Le AWS Glue Data Catalog gère tous les aspects opérationnels de la maintenance des vues matérialisées, notamment :

Vous pouvez interroger des vues matérialisées à partir de AWS Glue utilise les mêmes interfaces Spark SQL que celles que vous utilisez pour les tables classiques. Les données précalculées sont également accessibles depuis d'autres services, notamment Amazon Athena et Amazon Redshift.

Conditions préalables

Pour utiliser des vues matérialisées avec AWS De la colle, il vous faut :

Configuration de Spark pour utiliser des vues matérialisées

Pour créer et gérer des vues matérialisées dans AWS Glue, configurez votre session Spark avec les extensions Iceberg et les paramètres de catalogue requis. La méthode de configuration varie selon que vous utilisez AWS Des travaux de colle ou AWS Carnets Glue Studio.

Configuration AWS Travaux de colle

Lorsque vous créez ou mettez à jour un AWS Glue job, ajoutez les paramètres de configuration suivants en tant que paramètres de job :

Pour les seaux S3 Tables

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.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.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'
)

Si vous utilisez AWS Lake Formation pour gérer l'accès à votre lac de données, ajoutez le paramètre suivant à chaque configuration de catalogue :

--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true

Pour les godets à usage général 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.defaultCatalog=glue_catalog '
                  '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
                  '--conf spark.sql.materializedViews.metadataCache.enabled=true'
    },
    GlueVersion='5.1'
)

Si vous utilisez AWS Lake Formation pour gérer l'accès à votre lac de données, ajoutez le paramètre suivant à chaque configuration de catalogue :

--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true

Configuration AWS Carnets Glue Studio

Dans AWS Pour les ordinateurs portables Glue Studio, configurez votre session Spark à l'aide de la commande magique %%configure au début de votre bloc-notes :

%%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.defaultCatalog": "glue_catalog",
        "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
        "spark.sql.materializedViews.metadataCache.enabled": "true"
    }
}

Si vous utilisez AWS Lake Formation, ajoutez la ligne suivante au conf bloc :

"spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true"

Activation de l'actualisation incrémentielle

Pour activer l'optimisation de l'actualisation incrémentielle, ajoutez les propriétés de configuration suivantes à vos paramètres de tâche ou à la configuration de votre bloc-notes :

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

Paramètres de configuration

Les paramètres de configuration suivants contrôlent le comportement des vues matérialisées :

Création de vues matérialisées

Vous créez des vues matérialisées à l'aide de l'instruction SQL CREATE MATERIALIZED VIEW dans AWS Des travaux de colle ou des cahiers. La définition de la vue spécifie la logique de transformation sous la forme d'une requête SQL qui fait référence à une ou plusieurs tables sources.

Création d'une vue matérialisée de base dans AWS Travaux de colle

L'exemple suivant montre la création d'une vue matérialisée dans un AWS Collez le script de travail, utilisez des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue :

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

Création d'une vue matérialisée avec actualisation automatique

Pour configurer l'actualisation automatique, spécifiez un calendrier d'actualisation lors de la création de la vue, en utilisant des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue :

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

Création d'une vue matérialisée avec des références inter-catalogues

Lorsque vos tables sources se trouvent dans un catalogue différent de celui de votre vue matérialisée, utilisez des noms de tables complets avec une convention de dénomination en trois parties à la fois pour le nom de la vue et pour la définition de la vue :

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

Création de vues matérialisées dans AWS Carnets Glue Studio

Dans AWS Pour les blocs-notes Glue Studio, vous pouvez utiliser la commande magique %%sql pour créer des vues matérialisées, en utilisant des noms de tables complets avec une convention de dénomination en trois parties dans la définition des vues :

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

Interrogation de vues matérialisées

Après avoir créé une vue matérialisée, vous pouvez l'interroger comme n'importe quelle autre table à l'aide des instructions SQL SELECT standard dans votre AWS Des travaux de colle ou des cahiers.

Interrogation dans AWS Travaux de colle

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

Interrogation dans AWS Carnets Glue Studio

%%sql
SELECT * FROM customer_orders

Réécriture automatique des requêtes

Lorsque la réécriture automatique des requêtes est activée, l'optimiseur Spark analyse vos requêtes et utilise automatiquement des vues matérialisées lorsqu'elles peuvent améliorer les performances. Par exemple, si vous exécutez la requête suivante :

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

L'optimiseur Spark réécrit automatiquement cette requête pour utiliser la vue matérialisée customer_orders au lieu de traiter la table des commandes de base, à condition que la vue matérialisée soit actuelle.

Vérification de la réécriture automatique des requêtes

Pour vérifier si une requête utilise une réécriture automatique, utilisez la commande 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)

Dans le plan d'exécution, recherchez le nom de la vue matérialisée dans le BatchScan opération. Si le plan le montre BatchScan glue_catalog.analytics.customer_orders au lieu de BatchScan glue_catalog.sales.orders, la requête a été automatiquement réécrite pour utiliser la vue matérialisée.

Notez que la réécriture automatique des requêtes nécessite un certain temps pour que le cache de métadonnées Spark soit rempli après la création d'une vue matérialisée. Ce processus se termine généralement en 30 secondes.

Actualisation de vues matérialisées

Vous pouvez actualiser les vues matérialisées à l'aide de deux méthodes : actualisation complète ou actualisation incrémentielle. L'actualisation complète recalcule l'intégralité de la vue matérialisée à partir de toutes les données de la table de base, tandis que l'actualisation incrémentielle traite uniquement les données qui ont changé depuis la dernière actualisation.

Actualisation complète manuelle AWS Travaux de colle

Pour actualiser complètement une vue matérialisée, procédez comme suit :

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

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

Actualisation incrémentielle manuelle dans AWS Travaux de colle

Pour effectuer une actualisation incrémentielle, assurez-vous que l'actualisation incrémentielle est activée dans la configuration de votre session Spark, puis exécutez :

spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

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

Le AWS Glue Data Catalog détermine automatiquement si l'actualisation incrémentielle est applicable en fonction de la définition de la vue et de la quantité de données modifiées. Si l'actualisation incrémentielle n'est pas possible, l'opération revient à l'actualisation complète.

Rafraîchissant AWS Carnets Glue Studio

Dans les blocs-notes, utilisez la commande magique %%sql :

%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL

Vérification de l'exécution de l'actualisation incrémentielle

Pour confirmer que l'actualisation incrémentielle s'est correctement exécutée, activez la journalisation du débogage dans votre AWS Travail de colle :

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

Recherchez le message suivant dans le AWS Journaux de travail Glue :

DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh

Gestion des vues matérialisées

AWS Glue fournit des commandes SQL pour gérer le cycle de vie des vues matérialisées dans vos jobs et blocs-notes.

Décrire une vue matérialisée

Pour afficher les métadonnées relatives à une vue matérialisée, notamment sa définition, son état d'actualisation et l'horodatage de la dernière actualisation :

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

Modification d'une vue matérialisée

Pour modifier le calendrier d'actualisation d'une vue matérialisée existante, procédez comme suit :

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

Pour supprimer l'actualisation automatique :

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

Supprimer une vue matérialisée

Pour supprimer une vue matérialisée :

spark.sql("DROP MATERIALIZED VIEW customer_orders")

Cette commande supprime la définition de la vue matérialisée du AWS Collez le catalogue de données et supprimez les données de la table Iceberg sous-jacentes de votre compartiment S3.

Répertorier les vues matérialisées

Pour répertorier toutes les vues matérialisées d'une base de données :

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

Autorisations pour les vues matérialisées

Pour créer et gérer des vues matérialisées, vous devez configurer les autorisations pour le rôle IAM qui crée la vue (le rôle de définition). AWS Glue prend en charge deux modèles d'autorisation :

Autorisations requises pour le rôle de définition

Si vous utilisez uniquement des politiques IAM :

Le rôle de définition doit disposer des autorisations IAM suivantes :

Lorsque vous créez une vue matérialisée, l'ARN du rôle de définition est stocké dans la définition de la vue. Le AWS Glue Data Catalog assume ce rôle lors de l'exécution d'opérations d'actualisation automatique. Si le rôle de définition perd l'accès aux tables sources, les opérations d'actualisation échoueront tant que les autorisations ne seront pas restaurées.

Si vous utilisez AWS Lake Formation:

Le rôle de définition doit être le suivant : AWS Lake Formation autorisations :

Lorsque vous créez une vue matérialisée, l'ARN du rôle de définition est stocké dans la définition de la vue. Le AWS Glue Data Catalog assume ce rôle lors de l'exécution d'opérations d'actualisation automatique. Si le rôle de définition perd l'accès aux tables sources, les opérations d'actualisation échoueront tant que les autorisations ne seront pas restaurées.

Autorisations IAM pour AWS Travaux de colle

Votre AWS Le rôle IAM de Glue Job nécessite les autorisations suivantes :

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

Si vous utilisez AWS Lake Formation, ajoutez également l'autorisation suivante :

{
    "Effect": "Allow",
    "Action": [
        "lakeformation:GetDataAccess"
    ],
    "Resource": "*"
}

Le rôle que vous utilisez pour l'actualisation automatique de la vue matérialisée doit avoir pour objectif :PassRole autorisation sur le rôle.

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

À louer AWS Glue actualise automatiquement la vue matérialisée pour vous. Le rôle doit également respecter la politique de confiance suivante qui permet au service d'assumer le rôle.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "glue.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
      

Si la vue matérialisée est stockée dans des compartiments S3 Tables, vous devez également ajouter l'autorisation suivante au rôle.

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

Autoriser l'accès aux vues matérialisées

Si vous utilisez uniquement des politiques IAM :

Toute identité IAM avec GetTable l'autorisation sur la vue matérialisée peut l'interroger. Les utilisateurs peuvent interroger la vue matérialisée sans avoir besoin d'accéder directement aux tables sources sous-jacentes.

Si vous utilisez AWS Lake Formation:

Pour autoriser d'autres utilisateurs à interroger une vue matérialisée, utilisez AWS Lake Formation pour accorder l'autorisation SELECT sur la table de vues matérialisée. Les utilisateurs peuvent interroger la vue matérialisée sans avoir besoin d'accéder directement aux tables sources sous-jacentes.

Pour des informations détaillées sur la configuration AWS Lake Formation autorisations, voir Octroi et révocation d'autorisations sur les ressources du catalogue de données dans le AWS Lake Formation Guide du développeur.

Surveillance des opérations de vues matérialisées

Le AWS Glue Data Catalog publie des mesures et des journaux pour les opérations d'actualisation des vues matérialisées sur Amazon CloudWatch. Vous pouvez surveiller l'état d'actualisation, la durée et le volume de données traitées via CloudWatch métriques.

Affichage des journaux des tâches

Pour consulter les journaux de AWS Jobs de collage qui créent ou actualisent des vues matérialisées :

Configuration des alarmes

Pour recevoir des notifications lorsque les opérations d'actualisation échouent ou dépassent la durée prévue, créez CloudWatch alarmes sur les métriques de vue matérialisées. Vous pouvez également configurer Amazon EventBridge règles pour déclencher des réponses automatisées aux événements d'actualisation.

Exemple : flux de travail complet

L'exemple suivant illustre un flux de travail complet pour créer et utiliser une vue matérialisée dans AWS Colle.

Exemple AWS Script de travail 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()

Exemple AWS Carnet 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.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

System-managed vues matérialisées

Une vue matérialisée gérée par le système est une vue matérialisée qui uniquement AWS La colle peut écrire. AWS Glue écrit à la fois ses données et sa définition, et aucun autre moteur ou utilisateur ne peut les modifier. Cela protège la vue matérialisée contre les modifications involontaires, afin que vous puissiez la partager sous la forme d'un ensemble de données fiable et cohérent. AWS Glue stocke la vue matérialisée sous la forme d'une table Apache Iceberg standard dans un compartiment Amazon S3 Tables de votre compte.

System-managed les vues matérialisées nécessitent AWS Glue 6.0 ou version ultérieure. Pour en créer une, définissez la configuration de la session Spark spark.sql.mv.managed.enabled pour true. System-managed les vues matérialisées sont stockées uniquement dans les tables Amazon S3 ; les compartiments à usage général Amazon S3 ne sont pas pris en charge.

Création d'une vue matérialisée gérée par le système

Créez la vue matérialisée depuis Spark à l'aide du mot clé MANAGED, dans une session qui a spark.sql.mv.managed.enabled=true:

spark.sql("""
    CREATE MANAGED 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
""")

AWS Glue calcule et écrit la vue matérialisée pour vous ; votre session Spark ne l'écrit pas directement. L'instruction CREATE MANAGED MATERIALIZED VIEW attend AWS Glue termine la création de la vue matérialisée avant qu'elle ne revienne. Cela peut donc prendre plus de temps que la création d'une vue matérialisée normale.

Comment fonctionnent les vues matérialisées gérées par le système

Lorsque vous créez une vue matérialisée gérée par le système, AWS Glue crée une table vide dans Amazon S3 Tables pour la vue matérialisée, puis exécute la requête de définition pour la renseigner. Pour suivre la progression de la création, appelez le GetTable API avec IncludeStatusDetails=true pour voir l'état de la création d'une tâche. Si la création échoue, la raison de l'échec est incluse dans le message d'erreur d'état de la table. Les actualisations sont suivies de la même manière que pour les autres vues matérialisées.

Protection contre l'écriture

Uniquement AWS Glue écrit les données de la vue matérialisée et ses métadonnées, telles que son schéma et son emplacement de stockage. Toute tentative de modification de celles-ci est rejetée, qu'elle provienne d'un autre moteur de requête, d'un AWS colle UpdateTable appel, ou écriture directe dans la table Apache Iceberg sous-jacente.

Vous pouvez toujours effectuer les opérations suivantes sur une vue matérialisée gérée par le système :

L'évolution du schéma n'est pas prise en charge pour une vue matérialisée gérée par le système. Pour modifier la définition SQL de la vue matérialisée, supprimez la vue matérialisée et créez-la à nouveau.

Considérations et restrictions

Tenez compte des points suivants lorsque vous utilisez des vues matérialisées avec AWS Colle :