Ottimizzazione delle letture con pushdown in AWS Glue ETL - AWS Glue
Il predicato pushdown sui file archiviati su Amazon S3Esecuzione del pushdown quando si utilizzano origini JDBC Note e limitazioni sul pushdown in AWS Glue

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Ottimizzazione delle letture con pushdown in AWS Glue ETL

Il pushdown è una tecnica di ottimizzazione che avvicina la logica di recupero dei dati all'origine dati. L'origine potrebbe essere un database o un file system come Amazon S3. Quando si eseguono determinate operazioni direttamente sull'origine, è possibile risparmiare tempo e potenza di elaborazione evitando di trasferire tutti i dati della rete al motore Spark gestito da AWS Glue.

Un altro modo per dire ciò è che il pushdown riduce la scansione dei dati. Per ulteriori informazioni sul processo di identificazione del momento in cui questa tecnica è appropriata, consulta Ridurre la quantità di scansione dei dati nella guida Best practice per l'ottimizzazione delle prestazioni dei processi AWS per Apache Spark nel Prontuario AWS.

Il predicato pushdown sui file archiviati su Amazon S3

Quando lavori su Amazon S3 con file organizzati per prefisso, puoi filtrare i percorsi Amazon S3 di destinazione definendo un predicato pushdown. Invece di leggere il set di dati completo e applicare filtri all'interno di un DynamicFrame, è possibile applicare il filtro direttamente ai metadati della partizione archiviati in Catalogo dati AWS Glue. Questo approccio consente di elencare e leggere in modo selettivo solo i dati necessari. Per ulteriori informazioni su questo processo, inclusa la scrittura per partizioni in un bucket, consulta la pagina Gestione delle partizioni per l'output ETL in AWS Glue.

È possibile ottenere il pushdown dei predicati in Amazon S3 utilizzando il parametro push_down_predicate. Prendi in considerazione un bucket in Amazon S3 partizionato per anno, mese e giorno. Se desideri recuperare i dati dei clienti relativi al mese di giugno 2022, puoi indicare ad AWS Glue di leggere solo i percorsi Amazon S3 pertinenti. Il push_down_predicate in questo caso è year='2022' and month='06'. Mettendo tutto insieme, l'operazione di lettura può essere eseguita come segue:

Python
customer_records = glueContext.create_dynamic_frame.from_catalog( 
    database = "customer_db", 
    table_name = "customer_tbl",
    push_down_predicate = "year='2022' and month='06'"
)
Scala
val customer_records = glueContext.getCatalogSource(
database="customer_db", 
tableName="customer_tbl", 
pushDownPredicate="year='2022' and month='06'"
).getDynamicFrame()

Nello scenario precedente, push_down_predicate recupera un elenco di tutte le partizioni da Catalogo dati AWS Glue e le filtra prima di leggere i file Amazon S3 sottostanti. Mentre elencare le partizioni è utile nella maggior parte dei casi, questo processo può richiedere molto tempo quando si lavora con set di dati che contengono milioni di partizioni. Per risolvere questo problema e migliorare le prestazioni è possibile utilizzare l'eliminazione delle partizioni lato server. Questo viene fatto creando un indice di partizione per i dati in Catalogo dati AWS Glue. Per ulteriori informazioni sugli indici di partizione, consulta la pagina Creazione di indici di partizione . È quindi possibile utilizzare l'opzione catalogPartitionPredicate per fare riferimento all'indice. Per un esempio di recupero di partizioni con catalogPartitionPredicate, consulta la pagina Filtraggio lato server utilizzando predicati delle partizioni di catalogo.

Esecuzione del pushdown quando si utilizzano origini JDBC

Il lettore JDBC di AWS Glue utilizzato nel GlueContext supporta il pushdown sui database supportati fornendo query SQL personalizzate che possono essere eseguite direttamente sull'origine. Ciò può essere ottenuto impostando il parametro sampleQuery. La tua query di esempio può specificare quali colonne selezionare e fornire un predicato di pushdown per limitare i dati trasferiti al motore Spark.

Per impostazione predefinita, le query di esempio funzionano su un singolo nodo, il che può causare errori di processo quando si gestiscono grandi volumi di dati. Per utilizzare questa funzionalità per eseguire query sui dati su larga scala, è necessario configurare il partizionamento delle query impostando enablePartitioningForSampleQuery su true, che distribuirà la query su più nodi attraverso una chiave a scelta. Il partizionamento delle query richiede anche alcuni altri parametri di configurazione necessari. Per ulteriori informazioni sul partizionamento delle query, consulta la pagina Lettura in parallelo dalle tabelle JDBC.

Durante l'impostazione di enablePartitioningForSampleQuery, AWS Glue combina il predicato di pushdown con un predicato di partizionamento durante l'esecuzione della query sul database. La sampleQuery deve terminare con un AND affinché AWS Glue aggiunga le condizioni di partizionamento. (Se non fornisci un predicato pushdown, sampleQuery deve terminare con un WHERE). Di seguito puoi trovare un esempio in cui effettuiamo il pushdown di un predicato per recuperare solo le righe il cui id è maggiore di 1.000. Questa sampleQuery restituirà solo le colonne del nome e della posizione per le righe il cui id è maggiore del valore specificato:

Python
sample_query = "select name, location from customer_tbl WHERE id>=1000 AND"
customer_records = glueContext.create_dynamic_frame.from_catalog(
    database="customer_db",
    table_name="customer_tbl",
    sample_query = "select name, location from customer_tbl WHERE id>=1000 AND",

    additional_options = { 
                           "hashpartitions": 36 , 
                           "hashfield":"id",
                           "enablePartitioningForSampleQuery":True, 
                           "sampleQuery":sample_query
                          }
)
Scala
val additionalOptions = Map( 
        "hashpartitions" -> "36", 
        "hashfield" -> "id", 
        "enablePartitioningForSampleQuery" -> "true", 
        "sampleQuery" -> "select name, location from customer_tbl WHERE id >= 1000 AND"
        )
 
    val customer_records = glueContext.getCatalogSource(
        database="customer_db", 
        tableName="customer_tbl").getDynamicFrame()
Nota

Se customer_tbl ha un nome diverso nel tuo Data Catalog e nel datastore sottostante, devi fornire il nome della tabella sottostante in sample_query, poiché la query viene passata al datastore sottostante.

È possibile eseguire query sulle tabelle JDBC anche senza l'integrazione con Catalogo dati AWS Glue. Invece di fornire nome utente e password come parametri del metodo, è possibile riutilizzare le credenziali di una connessione preesistente fornendo useConnectionProperties e connectionName. In questo esempio, recuperiamo le credenziali da una connessione chiamata my_postgre_connection.

Python
connection_options_dict = {
    "useConnectionProperties": True,
    "connectionName": "my_postgre_connection",
    "dbtable":"customer_tbl",
    "sampleQuery":"select name, location from customer_tbl WHERE id>=1000 AND",
    "enablePartitioningForSampleQuery":True,
    "hashfield":"id",
    "hashpartitions":36
    }

customer_records = glueContext.create_dynamic_frame.from_options(
    connection_type="postgresql",
    connection_options=connection_options_dict
    )
Scala
val connectionOptionsJson = """
      {
        "useConnectionProperties": true,
        "connectionName": "my_postgre_connection",
        "dbtable": "customer_tbl",
        "sampleQuery": "select name, location from customer_tbl WHERE id>=1000 AND",
        "enablePartitioningForSampleQuery" : true,
        "hashfield" : "id",
        "hashpartitions" : 36
      }
    """
    
    val connectionOptions = new JsonOptions(connectionOptionsJson)
    
    val dyf = glueContext.getSource("postgresql", connectionOptions).getDynamicFrame()

Note e limitazioni sul pushdown in AWS Glue

Il pushdown, come concetto, è applicabile alla lettura da origini non in streaming. AWS Glue supporta una varietà di origini: la capacità di eseguire il pushdown dipende dall'origine e dal connettore.

  • Quando ti connetti a Snowflake, puoi utilizzare l'opzione query. Funzionalità simili esistono nel connettore Redshift in AWS Glue 4.0 e versioni successive. Per ulteriori informazioni sulla lettura da Snowflake con query, consulta la pagina Lettura dalle tabelle Snowflake.

  • Il lettore DynamoDB ETL non supporta filtri o predicati pushdown. Inoltre, MongoDB e DocumentDB non supportano questo tipo di funzionalità.

  • Quando si leggono dati in formati di tabelle aperte archiviati in Amazon S3, il metodo di partizionamento dei file in Amazon S3 da solo non è più sufficiente. Per leggere e scrivere da partizioni utilizzando formati di tabelle aperte, consulta la documentazione relativa al formato.

  • DynamicFrame i metodi non eseguono il pushdown di proiezione di Amazon S3. Tutte le colonne verranno lette dai file che soddisfanno il filtro dei predicati.

  • Quando si utilizzano i connettori custom.jdbc in AWS Glue, la capacità di eseguire il pushdown dipende dall'origine e dal connettore. Consulta la documentazione del connettore appropriata per verificare se e come supporta il pushdown in AWS Glue.