Simplify And Speed Up Apache Spark Applications On Amazon Redshift Data With Amazon Redshift Integration For Apache Spark

Ripubblicato da Platone

Seguaci: 0

I clienti usano Amazon RedShift per eseguire le loro analisi business-critical su petabyte di dati strutturati e semi-strutturati. Apache Spark è un framework popolare che puoi utilizzare per creare applicazioni per casi d'uso come ETL (estrazione, trasformazione e caricamento), analisi interattiva e machine learning (ML). Apache Spark ti consente di creare applicazioni in una varietà di linguaggi, come Java, Scala e Python, accedendo ai dati nel tuo data warehouse di Amazon Redshift.

L'integrazione di Amazon Redshift per Apache Spark aiuta gli sviluppatori a creare ed eseguire senza problemi applicazioni Apache Spark sui dati di Amazon Redshift. Gli sviluppatori possono utilizzare l'analisi AWS e i servizi ML come Amazon EMR, Colla AWSe Amazon Sage Maker per creare facilmente applicazioni Apache Spark che leggono e scrivono nel loro data warehouse Amazon Redshift. Puoi farlo senza compromettere le prestazioni delle tue applicazioni o la coerenza transazionale dei tuoi dati.

In questo post, spieghiamo perché l'integrazione di Amazon Redshift per Apache Spark è fondamentale ed efficiente per l'analisi e il machine learning. Inoltre, discutiamo di casi d'uso che utilizzano l'integrazione di Amazon Redshift con Apache Spark per promuovere l'impatto aziendale. Infine, ti guidiamo attraverso esempi passo passo su come utilizzare questo connettore AWS ufficiale in un'applicazione Apache Spark.

Integrazione di Amazon Redshift per Apache Spark

L'integrazione di Amazon Redshift per Apache Spark riduce al minimo il processo ingombrante e spesso manuale di configurazione di un connettore spark-redshift (versione community) e riduce il tempo necessario per prepararsi alle attività di analisi e ML. Devi solo specificare la connessione al tuo data warehouse e puoi iniziare a lavorare con i dati di Amazon Redshift dalle tue applicazioni basate su Apache Spark in pochi minuti.

Puoi utilizzare diverse funzionalità pushdown per operazioni come funzioni di ordinamento, aggregazione, limitazione, join e scalari in modo che solo i dati rilevanti vengano spostati dal tuo data warehouse di Amazon Redshift all'applicazione Apache Spark di consumo. Ciò consente di migliorare le prestazioni delle applicazioni. Gli amministratori di Amazon Redshift possono facilmente identificare l'SQL generato dalle applicazioni basate su Spark. In questo post, mostriamo come scoprire l'SQL generato dal job Apache Spark.

Inoltre, l'integrazione di Amazon Redshift per Apache Spark utilizza il formato di file Parquet durante lo staging dei dati in una directory temporanea. Amazon Redshift utilizza l'istruzione UNLOAD SQL per archiviare questi dati temporanei Servizio di archiviazione semplice Amazon (Amazon S3). L'applicazione Apache Spark recupera i risultati dalla directory temporanea (archiviata nel formato di file Parquet), che migliora le prestazioni.

Puoi anche contribuire a rendere le tue applicazioni più sicure utilizzando Gestione dell'identità e dell'accesso di AWS (IAM) per connettersi ad Amazon Redshift.

L'integrazione di Amazon Redshift per Apache Spark si basa sul connettore spark-redshift (versione community) e lo migliora in termini di prestazioni e sicurezza, aiutandoti a ottenere prestazioni delle applicazioni fino a 10 volte più veloci.

Casi d'uso per l'integrazione di Amazon Redshift con Apache Spark

Per il nostro caso d'uso, la leadership dell'azienda basata sul prodotto desidera conoscere le vendite di ciascun prodotto su più mercati. Poiché le vendite dell'azienda fluttuano in modo dinamico, è diventata una sfida per la leadership tenere traccia delle vendite su più mercati. Tuttavia, le vendite complessive stanno diminuendo e la dirigenza dell'azienda vuole scoprire quali mercati non stanno funzionando in modo da poterli scegliere come target per le campagne promozionali.

Per le vendite su più mercati, i dati di vendita dei prodotti come ordini, transazioni e dati di spedizione sono disponibili su Amazon S3 nel data lake. Il team di data engineering può utilizzare Apache Spark con Amazon EMR o AWS Glue per analizzare questi dati in Amazon S3.

I dati di inventario sono disponibili in Amazon Redshift. Allo stesso modo, il team di data engineering può analizzare questi dati con Apache Spark utilizzando Amazon EMR o un processo AWS Glue utilizzando l'integrazione di Amazon Redshift per Apache Spark per eseguire aggregazioni e trasformazioni. Il set di dati aggregato e trasformato può essere archiviato nuovamente in Amazon Redshift utilizzando l'integrazione di Amazon Redshift per Apache Spark.

L'utilizzo di un framework distribuito come Apache Spark con l'integrazione di Amazon Redshift per Apache Spark può fornire la visibilità attraverso il data lake e il data warehouse per generare approfondimenti sulle vendite. Queste informazioni possono essere messe a disposizione delle parti interessate aziendali e degli utenti della linea di business in Amazon Redshift per prendere decisioni informate per eseguire promozioni mirate per i segmenti di mercato a basso reddito.

Inoltre, possiamo utilizzare l'integrazione di Amazon Redshift con Apache Spark nei seguenti casi d'uso:

Un cliente Amazon EMR o AWS Glue che esegue processi Apache Spark vuole trasformare i dati e scriverli in Amazon Redshift come parte della propria pipeline ETL
Un cliente ML utilizza Apache Spark con SageMaker per la progettazione delle funzionalità per l'accesso e la trasformazione dei dati in Amazon Redshift
Un cliente Amazon EMR, AWS Glue o SageMaker utilizza Apache Spark per l'analisi interattiva dei dati con i dati su Amazon Redshift dai notebook

Esempi di integrazione di Amazon Redshift per Apache Spark in un'applicazione Apache Spark

In questo post, mostriamo i passaggi per connettere Amazon Redshift da Amazon EMR Cloud di calcolo elastico di Amazon (Amazon EC2), Amazon EMR senza servere AWS Glue utilizzando uno script comune. Nel seguente codice di esempio, generiamo un report che mostra le vendite trimestrali per l'anno 2008. A tale scopo, uniamo due tabelle Amazon Redshift utilizzando Apache Spark DataFrame, eseguiamo un pushdown del predicato, aggreghiamo e ordiniamo i dati e scriviamo il trasformato dati ad Amazon Redshift. Lo script utilizza PySpark

Lo script utilizza Autenticazione basata su IAM per Amazon Redshift. I ruoli IAM utilizzati da Amazon EMR e AWS Glue devono disporre delle autorizzazioni appropriate per autenticare Amazon Redshift e accedere a un bucket S3 per l'archiviazione temporanea dei dati.

La policy di esempio seguente consente al ruolo IAM di chiamare il GetClusterCredentials operazioni:

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": "redshift:GetClusterCredentials", "Resource": "arn:aws:redshift:<aws_region_name>:xxxxxxxxxxxx:dbuser:*/temp_*" }
}

La seguente policy di esempio consente l'accesso a un bucket S3 per l'archiviazione temporanea dei dati:

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "s3:PutObject", "s3:GetObject", "s3:ListBucket" ], "Resource": "arn:aws:s3:::<s3_bucket_name>" } ]
}

Lo script completo è il seguente:

from pyspark.sql import SparkSession
from pyspark.sql.functions import col # Initiate Apache Spark session
spark = SparkSession .builder .appName("SparkRedshiftConnector") .enableHiveSupport() .getOrCreate() # Set connection options for Amazon Redshift
jdbc_iam_url = "jdbc:redshift:iam://redshift-spark-connector-1.xxxxxxxxxxx.<aws_region_name>.redshift.amazonaws.com:5439/sample_data_dev"
temp_dir = 's3://<s3_bucket_name>/redshift-temp-dir/'
aws_role = 'arn:aws:iam::xxxxxxxxxxxx:role/redshift-s3' # Set query group for the query. More details on Amazon Redshift WLM https://docs.aws.amazon.com/redshift/latest/dg/cm-c-executing-queries.html
queryGroup = "emr-redshift"
jdbc_iam_url_withQueryGroup = jdbc_iam_url+'?queryGroup='+queryGroup # Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url_withQueryGroup+';user='+userName # Define the Amazon Redshift context
redshiftOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Create the sales DataFrame from Amazon Redshift table using io.github.spark_redshift_community.spark.redshift class
sales_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.sales") .load()
) # Create the date Data Frame from Amazon Redshift table
date_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.date") .load()
) # Assign a Data Frame to the above output which will be written back to Amazon Redshift
output_df= sales_df.join(date_df, sales_df.dateid == date_df.dateid, 'inner').where( col("year") == 2008).groupBy("qtr").sum("qtysold").select( col("qtr"), col("sum(qtysold)")).sort(["qtr"], ascending=[1]).withColumnRenamed("sum(qtysold)","total_quantity_sold") # Display the output
output_df.show() ## Lets drop the queryGroup for easy validation of push down queries
# Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url+'?user='+userName # Define the Amazon Redshift context
redshiftWriteOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Write the Data Frame back to Amazon Redshift
output_df.write .format("io.github.spark_redshift_community.spark.redshift") .mode("overwrite") .options(**redshiftWriteOptions) .option("dbtable", "tickit.test") .save()

Se prevedi di utilizzare lo script precedente nel tuo ambiente, assicurati di sostituire i valori per le seguenti variabili con i valori appropriati per il tuo ambiente: jdbc_iam_url, temp_dire aws_role.

Nella sezione successiva, esaminiamo i passaggi per eseguire questo script per aggregare un set di dati di esempio reso disponibile in Amazon Redshift.

Prerequisiti

Prima di iniziare, assicurati che siano soddisfatti i seguenti prerequisiti:

Distribuisci risorse utilizzando AWS CloudFormation

Completa i seguenti passaggi per distribuire lo stack CloudFormation:

Accedi al Console di gestione AWS, quindi avvia lo stack CloudFormation:

Puoi anche scarica il modello CloudFormation per creare le risorse menzionate in questo post attraverso l'infrastruttura come codice (IaC). Utilizza questo modello quando avvii un nuovo stack CloudFormation.

Scorri verso il basso fino alla fine della pagina per selezionare Riconosco che AWS CloudFormation potrebbe creare risorse IAM per Capabilities, Quindi scegliere Crea stack.

Il completamento del processo di creazione dello stack richiede 15-20 minuti. Il modello CloudFormation crea le seguenti risorse:

- Un Amazon VPC con le sottoreti, le tabelle di instradamento e il gateway NAT necessari
- Un bucket S3 con il nome redshift-spark-databucket-xxxxxxx (nota che xxxxxxx è una stringa casuale per rendere univoco il nome del bucket)
- Un cluster Amazon Redshift con dati di esempio caricati all'interno del database dev e l'utente principale redshiftmasteruser. Ai fini di questo post sul blog, redshiftmasteruser con autorizzazioni amministrative. Tuttavia, si consiglia di utilizzare un utente con controllo degli accessi granulare nell'ambiente di produzione.
- Un ruolo IAM da utilizzare per Amazon Redshift con la possibilità di richiedere credenziali temporanee dal database di sviluppo del cluster Amazon Redshift
- Amazon EMR Studio con i ruoli IAM necessari
- Amazon EMR versione 6.9.0 su un cluster EC2 con i ruoli IAM necessari
- Una release dell'applicazione Amazon EMR Serverless versione 6.9.0
- Una connessione AWS Glue e un lavoro AWS Glue versione 4.0
- A Notebook Jupyter da eseguire utilizzando Amazon EMR Studio utilizzando Amazon EMR su un cluster EC2
- Uno script PySpark da eseguire utilizzando Amazon EMR Studio e Amazon EMR Serverless

Al termine della creazione dello stack, scegli il nome dello stack redshift-spark e vai al Uscite

Utilizziamo questi valori di output più avanti in questo post.

Nelle sezioni successive, mostriamo i passaggi per l'integrazione di Amazon Redshift per Apache Spark da Amazon EMR su Amazon EC2, Amazon EMR Serverless e AWS Glue.

Utilizza l'integrazione di Amazon Redshift con Apache Spark su Amazon EMR su EC2

A partire dalla versione 6.9.0 e successive di Amazon EMR, il connettore che utilizza l'integrazione di Amazon Redshift per Apache Spark e il driver JDBC di Amazon Redshift sono disponibili localmente su Amazon EMR. Questi file si trovano sotto il file /usr/share/aws/redshift/ directory. Tuttavia, nelle versioni precedenti di Amazon EMR, il file comunità versione del spark-redshift connettore è disponibile.

L'esempio seguente mostra come connettere Amazon Redshift utilizzando un kernel PySpark tramite un Amazon EMR Studio taccuino. Lo stack CloudFormation ha creato Amazon EMR Studio, Amazon EMR su un cluster EC2 e un notebook Jupyter disponibile per l'esecuzione. Per esaminare questo esempio, completare i seguenti passaggi:

Scarica il notebook Jupyter reso disponibile nel bucket S3 per te:
- Negli output dello stack di CloudFormation, cerca il valore per EMRStudioNotebook, che dovrebbe puntare al redshift-spark-emr.ipynb notebook disponibile nel bucket S3.
- Scegli il collegamento o apri il collegamento in una nuova scheda copiando l'URL del taccuino.
- Dopo aver aperto il collegamento, scarica il taccuino scegliendo Scaricare, che salverà il file localmente sul tuo computer.

Accedi ad Amazon EMR Studio scegliendo o copiando il collegamento fornito negli output dello stack CloudFormation per la chiave EMRStudioURL.
Nel pannello di navigazione, scegli Aree di lavoro.
Scegli Crea spazio di lavoro.
Fornire un nome per l'area di lavoro, ad esempio redshift-spark.
espandere la Configurazione avanzata sezione e selezionare Collega Workspace a un cluster EMR.
Sotto Collegati a un cluster EMR, scegli il cluster EMR con il nome emrCluster-Redshift-Spark.
Scegli Crea spazio di lavoro.
Dopo che l'Amazon EMR Studio Workspace è stato creato e nello stato Collegato, puoi accedere all'area di lavoro scegliendo il nome dell'area di lavoro.

Questo dovrebbe aprire l'area di lavoro in una nuova scheda. Si noti che se si dispone di un blocco popup, potrebbe essere necessario consentire all'area di lavoro di aprirsi o disabilitare il blocco popup.

In Amazon EMR Studio Workspace, ora carichiamo il notebook Jupyter che abbiamo scaricato in precedenza.

Scegli Caricare per sfogliare il file system locale e caricare il notebook Jupyter (redshift-spark-emr.ipynb).
Scegli (doppio clic) sul file redshift-spark-emr.ipynb taccuino all'interno dell'area di lavoro per aprire il taccuino.

Il notebook fornisce i dettagli delle diverse attività che esegue. Si noti che nella sezione Definisci le variabili per la connessione al cluster Amazon Redshift, non è necessario aggiornare i valori per jdbc_iam_url, temp_dire aws_role perché questi vengono aggiornati per te da AWS CloudFormation. AWS CloudFormation ha anche eseguito le fasi menzionate nel Prerequisiti sezione del taccuino.

Ora puoi iniziare a eseguire il notebook.

Esegui le singole celle selezionandole e quindi scegliendo Giocare.

Puoi anche usare la combinazione di tasti di Maiusc + Invio or Maiusc+Invio. In alternativa, puoi eseguire tutte le celle scegliendo Esegui tutte le celle sul Correre menu.

Trova l'operazione pushdown del predicato eseguita sul cluster Amazon Redshift dall'integrazione Amazon Redshift per Apache Spark.

Possiamo anche vedere i dati temporanei archiviati su Amazon S3 nel formato Parquet ottimizzato. L'output può essere visto dall'esecuzione della cella nella sezione Ottieni l'ultima query eseguita su Amazon Redshift.

Per convalidare la tabella creata dal lavoro da Amazon EMR su Amazon EC2, accedi alla console Amazon Redshift e scegli il cluster redshift-spark-redshift-cluster sul Dashboard dei cluster con provisioning .
Nei dettagli del cluster, sul Interroga i dati menù, scegliere Query nell'editor di query v2.
Scegli il cluster nel riquadro di navigazione e connettiti al cluster Amazon Redshift quando richiede l'autenticazione.
Seleziona Credenziali temporanee.
Nel Banca Dati, accedere dev.
Nel nome utente, accedere redshiftmasteruser.
Scegli Risparmi.
Nel riquadro di navigazione espandere il cluster redshift-spark-redshift-cluster, espandi il database dev, espandi tickit, ed espandere tavoli per elencare tutte le tabelle all'interno dello schema tickit.

Dovresti trovare il tavolo test_emr.

Scegli (tasto destro) la tabella test_emr, Quindi scegliere Seleziona tabella per interrogare la tabella.
Scegli Correre per eseguire l'istruzione SQL.

Usa l'integrazione di Amazon Redshift con Apache Spark su Amazon EMR Serverless

La versione 6.9.0 e successive di Amazon EMR fornisce l'integrazione di Amazon Redshift per Apache Spark JAR (gestiti da Amazon Redshift) e Amazon Redshift JDBC JAR anche in locale su Amazon EMR Serverless. Questi file si trovano sotto il file /usr/share/aws/redshift/ directory. Nell'esempio seguente, utilizziamo lo script Python reso disponibile nel bucket S3 dallo stack CloudFormation che abbiamo creato in precedenza.

Negli output dello stack CloudFormation, prendi nota del valore for EMRServerlessExecutionScript, che è la posizione dello script Python nel bucket S3.
Si noti anche il valore per EMRServerlessJobExecutionRole, che è il ruolo IAM da utilizzare con l'esecuzione del processo Amazon EMR Serverless.
Accedi ad Amazon EMR Studio scegliendo o copiando il collegamento fornito negli output dello stack CloudFormation per la chiave EMRStudioURL.
Scegli Applicazioni per serverless nel pannello di navigazione.

Troverai un'applicazione EMR creata dallo stack CloudFormation con il nome emr-spark-redshift.

Scegli il nome dell'applicazione per inviare un lavoro.
Scegli Invia lavoro.
Sotto Dettagli di lavoro, Per Nome, immettere un nome identificabile per il lavoro.
Nel Ruolo di runtime, scegli il ruolo IAM che hai annotato dall'output dello stack CloudFormation in precedenza.
Nel Posizione dello script, fornisci il percorso dello script Python annotato in precedenza dall'output dello stack di CloudFormation.
Espandi la sezione Proprietà scintilla e scegliere il Modifica nel testo

Immettere il seguente valore nella casella di testo, che fornisce il percorso del file redshift-connector, driver JDBC Amazon Redshift, spark-avro VASO, e minimal-json File JAR:

--jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar

Scegli Invia lavoro.
Attendere il completamento del processo e lo stato di esecuzione visualizzato come Storie Di.
Passa all'editor di query di Amazon Redshift per vedere se la tabella è stata creata correttamente.
Controlla le query pushdown eseguite per il gruppo di query Amazon Redshift emr-serverless-redshift. È possibile eseguire la seguente istruzione SQL sul database dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'emr-serverless-redshift' ORDER BY start_time DESC LIMIT 1
```

Puoi vedere che la query pushdown e i risultati restituiti sono archiviati nel formato di file Parquet su Amazon S3.

Utilizza l'integrazione di Amazon Redshift con Apache Spark su AWS Glue

A partire da AWS Glue versione 4.0 e successive, i lavori Apache Spark che si connettono ad Amazon Redshift possono utilizzare l'integrazione di Amazon Redshift per Apache Spark e il driver JDBC di Amazon Redshift. I processi AWS Glue esistenti che utilizzano già Amazon Redshift come origine o destinazione possono essere aggiornati a AWS Glue 4.0 per sfruttare questo nuovo connettore. Il modello CloudFormation fornito con questo post crea le seguenti risorse AWS Glue:

Connessione AWS Glue per Amazon Redshift – La connessione per stabilire la connessione da AWS Glue ad Amazon Redshift utilizzando l'integrazione di Amazon Redshift per Apache Spark
Ruolo IAM collegato al processo AWS Glue – Il ruolo IAM per gestire le autorizzazioni per eseguire il processo AWS Glue
Lavoro AWS Glue – Lo script per il lavoro AWS Glue che esegue trasformazioni e aggregazioni utilizzando l'integrazione di Amazon Redshift per Apache Spark

L'esempio seguente utilizza la connessione AWS Glue collegata al processo AWS Glue con PySpark e include i passaggi seguenti:

Nella console AWS Glue, scegli Connessioni nel pannello di navigazione.
Sotto Connessioni, scegli la connessione AWS Glue per Amazon Redshift creata dal modello CloudFormation.
Verificare i dettagli della connessione.

Ora puoi riutilizzare questa connessione all'interno di un lavoro o tra più lavori.

Sulla Connettori RF pagina, scegli il lavoro AWS Glue creato dallo stack CloudFormation sotto I tuoi lavorioppure accedi al processo AWS Glue utilizzando l'URL fornito per la chiave GlueJob nell'output dello stack di CloudFormation.
Accedi e verifica lo script per il processo AWS Glue.
Sulla Dettagli di lavoro scheda, assicurati che Versione a colla è impostato su Colla 4.0.

In questo modo si garantisce che il processo utilizzi l'ultima versione redshift-spark connettore.

Espandere Proprietà avanzate e nella Connessioni sezione, verificare che la connessione creata dallo stack CloudFormation sia collegata.
Verifica i parametri del processo aggiunti per il processo AWS Glue. Questi valori sono disponibili anche nell'output per lo stack CloudFormation.
Scegli Risparmi e poi Correre.

È possibile visualizzare lo stato del lavoro eseguito su Correre scheda.

Dopo che l'esecuzione del processo è stata completata correttamente, puoi verificare l'output della colla di prova della tabella creata dal processo AWS Glue.
Controlliamo le query pushdown eseguite per il gruppo di query Amazon Redshift glue-redshift. È possibile eseguire la seguente istruzione SQL sul database dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1
```

Buone pratiche

Tieni presente le seguenti best practice:

Prendi in considerazione l'utilizzo dell'integrazione di Amazon Redshift per Apache Spark da Amazon EMR invece di utilizzare il redshift-spark connettore (versione community) per i nuovi processi Apache Spark.
Se disponi di processi Apache Spark esistenti che utilizzano il redshift-spark connettore (versione community), valuta la possibilità di aggiornarli per utilizzare l'integrazione Amazon Redshift per Apache Spark
L'integrazione di Amazon Redshift per Apache Spark applica automaticamente predicato e query pushdown per ottimizzare le prestazioni. Si consiglia di utilizzare le funzioni supportate (autopushdown) nella tua query. L'integrazione di Amazon Redshift per Apache Spark trasformerà la funzione in una query SQL ed eseguirà la query in Amazon Redshift. Questa ottimizzazione comporta il recupero dei dati richiesti, quindi Apache Spark può elaborare meno dati e avere prestazioni migliori.
- Prendi in considerazione l'utilizzo di funzioni pushdown aggregate come avg, count, max, mine sum per recuperare i dati filtrati per l'elaborazione dei dati.
- Prendi in considerazione l'utilizzo di operatori pushdown booleani come in, isnull, isnotnull, contains, endswithe startswith per recuperare i dati filtrati per l'elaborazione dei dati.
- Prendi in considerazione l'utilizzo di operatori pushdown logici come and, ore not (o !) per recuperare i dati filtrati per l'elaborazione dei dati.
Si consiglia di passare un ruolo IAM utilizzando il parametro aws_iam_role per l'autenticazione Amazon Redshift dalla tua applicazione Apache Spark su Amazon EMR o AWS Glue. Il ruolo IAM deve disporre delle autorizzazioni necessarie per recuperare le credenziali IAM temporanee per l'autenticazione in Amazon Redshift, come illustrato nella sezione "Esempi per l'integrazione di Amazon Redshift per Apache Spark in un'applicazione Apache Spark" di questo blog.
Con questa funzione, non è necessario conservare il nome utente e la password di Amazon Redshift nel gestore dei segreti e nel database di Amazon Redshift.
Amazon Redshift utilizza l'istruzione UNLOAD SQL per archiviare questi dati temporanei su Amazon S3. L'applicazione Apache Spark recupera i risultati dalla directory temporanea (archiviata nel formato di file Parquet). Questa directory temporanea su Amazon S3 non viene ripulita automaticamente e pertanto potrebbe aggiungere costi aggiuntivi. Si consiglia di utilizzare Politiche del ciclo di vita di Amazon S3 per definire le regole di conservazione per il bucket S3.
Si consiglia di accendere Registrazione di audit di Amazon Redshift per registrare le informazioni sulle connessioni e le attività degli utenti nel database.
Si consiglia di accendere Crittografia dei dati inattivi di Amazon Redshift per crittografare i tuoi dati mentre Amazon Redshift li scrive nei suoi data center e decrittografarli per te quando vi accedi.
Si consiglia di eseguire l'aggiornamento ad AWS Glue v4.0 e versioni successive per utilizzare l'integrazione di Amazon Redshift per Apache Spark, che è disponibile immediatamente. L'aggiornamento a questa versione di AWS Glue utilizzerà automaticamente questa funzionalità.
Si consiglia di eseguire l'aggiornamento ad Amazon EMR v6.9.0 e versioni successive per utilizzare l'integrazione di Amazon Redshift per Apache Spark. Non è necessario gestire in modo esplicito alcun driver o file JAR.
Prendi in considerazione l'utilizzo dei notebook Amazon EMR Studio per interagire con i tuoi dati Amazon Redshift nella tua applicazione Apache Spark.
Prendi in considerazione l'utilizzo di AWS Glue Studio per creare processi Apache Spark utilizzando un'interfaccia visiva. Puoi anche passare alla scrittura del codice Apache Spark in Scala o PySpark all'interno di AWS Glue Studio.

ripulire

Completa i seguenti passaggi per ripulire le risorse create come parte del modello CloudFormation per assicurarti che non ti vengano addebitate le risorse se non le utilizzerai più:

Arrestare l'applicazione Amazon EMR Serverless:
- Accedi ad Amazon EMR Studio scegliendo o copiando il collegamento fornito negli output dello stack CloudFormation per la chiave EMRStudioURL.
- Scegli Applicazioni per serverless nel pannello di navigazione.

Troverai un'applicazione EMR creata dallo stack CloudFormation con il nome emr-spark-redshift.

- Se lo stato dell'applicazione è Arrestato, puoi passare ai passaggi successivi. Tuttavia, se lo stato dell'applicazione è Avviato, scegliere il nome dell'applicazione, quindi scegliere Ferma l'applicazione ed Ferma l'applicazione di nuovo per confermare.

Elimina l'area di lavoro di Amazon EMR Studio:
- Accedi ad Amazon EMR Studio scegliendo o copiando il collegamento fornito negli output dello stack CloudFormation per la chiave EMRStudioURL.
- Scegli Aree di lavoro nel pannello di navigazione.
- Seleziona l'area di lavoro che hai creato e scegli Elimina, Quindi scegliere Elimina di nuovo per confermare.
Elimina lo stack di CloudFormation:

- Nella console AWS CloudFormation, vai allo stack che hai creato in precedenza.
- Scegli il nome dello stack e poi scegli Elimina per rimuovere lo stack ed eliminare le risorse create come parte di questo post.
- Nella schermata di conferma, scegli Elimina stack.

Conclusione

In questo post, abbiamo spiegato come utilizzare l'integrazione di Amazon Redshift per Apache Spark per creare e distribuire applicazioni con Amazon EMR su Amazon EC2, Amazon EMR Serverless e AWS Glue per applicare automaticamente predicati e query pushdown per ottimizzare le prestazioni delle query per i dati nell'Amazon Redshift. Si consiglia vivamente di utilizzare l'integrazione di Amazon Redshift per Apache Spark per una connessione continua e sicura ad Amazon Redshift da Amazon EMR o AWS Glue.

Ecco cosa hanno da dire alcuni dei nostri clienti sull'integrazione di Amazon Redshift per Apache Spark:

“Diamo ai nostri ingegneri la possibilità di costruire le loro pipeline di dati e applicazioni con Apache Spark utilizzando Python e Scala. Volevamo una soluzione su misura che semplificasse le operazioni e fornisse in modo più rapido ed efficiente per i nostri clienti, ed è quello che otteniamo con la nuova integrazione di Amazon Redshift per Apache Spark."

—Consulenza Huron

“GE Aerospace utilizza l'analisi di AWS e Amazon Redshift per consentire approfondimenti aziendali critici che guidano importanti decisioni aziendali. Con il supporto per la copia automatica da Amazon S3, possiamo creare pipeline di dati più semplici per spostare i dati da Amazon S3 ad Amazon Redshift. Ciò accelera la capacità dei nostri team di prodotto dati di accedere ai dati e fornire approfondimenti agli utenti finali. Dedichiamo più tempo ad aggiungere valore attraverso i dati e meno tempo alle integrazioni".

—GE aerospaziale

“Il nostro obiettivo è fornire un accesso self-service ai dati per tutti i nostri utenti di Goldman Sachs. Attraverso Legend, la nostra piattaforma open source per la gestione e la governance dei dati, consentiamo agli utenti di sviluppare applicazioni incentrate sui dati e ricavare informazioni basate sui dati mentre collaboriamo nel settore dei servizi finanziari. Con l'integrazione di Amazon Redshift per Apache Spark, il nostro team della piattaforma dati sarà in grado di accedere ai dati di Amazon Redshift con passaggi manuali minimi, consentendo un ETL a codice zero che aumenterà la nostra capacità di rendere più facile per gli ingegneri concentrarsi sul perfezionamento del loro flusso di lavoro come raccolgono informazioni complete e tempestive. Ci aspettiamo di vedere un miglioramento delle prestazioni delle applicazioni e una maggiore sicurezza poiché i nostri utenti possono ora accedere facilmente ai dati più recenti in Amazon Redshift".

—Goldman Sachs

Informazioni sugli autori

Gagan Brahmi è un Senior Specialist Solutions Architect focalizzato sull'analisi dei big data e sulla piattaforma AI/ML presso Amazon Web Services. Gagan ha oltre 18 anni di esperienza nella tecnologia dell'informazione. Aiuta i clienti a progettare e creare soluzioni basate su cloud altamente scalabili, performanti e sicure su AWS. Nel tempo libero trascorre del tempo con la sua famiglia ed esplora nuovi posti.

Vivek Gautam è un Data Architect con specializzazione in data lake presso AWS Professional Services. Lavora con clienti aziendali creando prodotti dati, piattaforme di analisi e soluzioni su AWS. Quando non costruisce e progetta data lake, Vivek è un appassionato di cibo a cui piace anche esplorare nuove destinazioni di viaggio e fare escursioni.

Naresh Gautam è un leader di analisi dei dati e AI/ML presso AWS con 20 anni di esperienza, a cui piace aiutare i clienti a progettare soluzioni di analisi dei dati e AI/ML altamente disponibili, ad alte prestazioni e convenienti per consentire ai clienti un processo decisionale basato sui dati . Nel tempo libero ama meditare e cucinare.

Beaux Sharifi è un Software Development Engineer all'interno del team di driver di Amazon Redshift, dove guida lo sviluppo dell'integrazione di Amazon Redshift con il connettore Apache Spark. Ha oltre 20 anni di esperienza nella creazione di piattaforme basate sui dati in diversi settori. Nel tempo libero ama passare il tempo con la sua famiglia e fare surf.