Vereinfachen und beschleunigen Sie Apache Spark-Anwendungen auf Amazon Redshift-Daten mit der Amazon Redshift-Integration für Apache Spark

Neuauflage von Plato

Verfolger: 0

Kunden verwenden Amazon RedShift um ihre geschäftskritischen Analysen auf Petabytes von strukturierten und halbstrukturierten Daten auszuführen. Apache Spark ist ein beliebtes Framework, mit dem Sie Anwendungen für Anwendungsfälle wie ETL (Extrahieren, Transformieren und Laden), interaktive Analysen und maschinelles Lernen (ML) erstellen können. Mit Apache Spark können Sie Anwendungen in einer Vielzahl von Sprachen wie Java, Scala und Python erstellen, indem Sie auf die Daten in Ihrem Amazon Redshift Data Warehouse zugreifen.

Die Amazon Redshift-Integration für Apache Spark unterstützt Entwickler beim nahtlosen Erstellen und Ausführen von Apache Spark-Anwendungen auf Amazon Redshift-Daten. Entwickler können AWS-Analyse- und ML-Dienste wie z Amazon EMR, AWS-Kleber und Amazon Sage Maker um mühelos Apache Spark-Anwendungen zu erstellen, die aus ihrem Amazon Redshift Data Warehouse lesen und schreiben. Sie können dies tun, ohne die Leistung Ihrer Anwendungen oder die Transaktionskonsistenz Ihrer Daten zu beeinträchtigen.

In diesem Beitrag erörtern wir, warum die Amazon Redshift-Integration für Apache Spark für Analysen und ML entscheidend und effizient ist. Darüber hinaus diskutieren wir Anwendungsfälle, die die Amazon Redshift-Integration mit Apache Spark nutzen, um die geschäftlichen Auswirkungen zu steigern. Abschließend führen wir Sie Schritt für Schritt durch Beispiele zur Verwendung dieses offiziellen AWS-Konnektors in einer Apache Spark-Anwendung.

Amazon Redshift-Integration für Apache Spark

Die Amazon Redshift-Integration für Apache Spark minimiert den umständlichen und oft manuellen Prozess der Einrichtung eines Spark-Redshift-Konnektors (Community-Version) und verkürzt die Vorbereitungszeit für Analyse- und ML-Aufgaben. Sie müssen nur die Verbindung zu Ihrem Data Warehouse angeben und können innerhalb weniger Minuten mit Amazon Redshift-Daten aus Ihren Apache Spark-basierten Anwendungen arbeiten.

Sie können mehrere Pushdown-Funktionen für Vorgänge wie Sortieren, Aggregieren, Begrenzen, Verbinden und Skalarfunktionen verwenden, sodass nur die relevanten Daten aus Ihrem Amazon Redshift-Data Warehouse in die verbrauchende Apache Spark-Anwendung verschoben werden. Dadurch können Sie die Leistung Ihrer Anwendungen verbessern. Amazon Redshift-Administratoren können das von Spark-basierten Anwendungen generierte SQL leicht identifizieren. In diesem Beitrag zeigen wir, wie Sie das vom Apache Spark-Job generierte SQL herausfinden können.

Darüber hinaus verwendet die Amazon Redshift-Integration für Apache Spark das Parquet-Dateiformat, wenn die Daten in einem temporären Verzeichnis bereitgestellt werden. Amazon Redshift verwendet die UNLOAD-SQL-Anweisung, um diese temporären Daten zu speichern Amazon Simple Storage-Service (Amazon S3). Die Apache Spark-Anwendung ruft die Ergebnisse aus dem temporären Verzeichnis ab (gespeichert im Parquet-Dateiformat), was die Leistung verbessert.

Sie können auch dazu beitragen, Ihre Anwendungen sicherer zu machen, indem Sie sie verwenden AWS Identity and Access Management and (IAM)-Anmeldeinformationen zum Herstellen einer Verbindung mit Amazon Redshift.

Die Amazon Redshift-Integration für Apache Spark basiert auf dem Spark-Redshift-Konnektor (Community-Version) und verbessert es für Leistung und Sicherheit, sodass Sie eine bis zu 10-mal schnellere Anwendungsleistung erzielen können.

Anwendungsfälle für die Amazon Redshift-Integration mit Apache Spark

Für unseren Anwendungsfall möchte die Führung des produktbasierten Unternehmens die Verkäufe für jedes Produkt auf mehreren Märkten kennen. Da die Verkäufe für das Unternehmen dynamisch schwanken, ist es für die Führung zu einer Herausforderung geworden, die Verkäufe über mehrere Märkte hinweg zu verfolgen. Die Gesamtumsätze gehen jedoch zurück, und die Unternehmensführung möchte herausfinden, welche Märkte nicht funktionieren, damit sie diese Märkte für Werbekampagnen ansprechen kann.

Für Verkäufe in mehreren Märkten sind die Produktverkaufsdaten wie Bestellungen, Transaktionen und Versanddaten auf Amazon S3 im Data Lake verfügbar. Das Data-Engineering-Team kann Apache Spark mit Amazon EMR oder AWS Glue verwenden, um diese Daten in Amazon S3 zu analysieren.

Die Bestandsdaten sind in Amazon Redshift verfügbar. Auf ähnliche Weise kann das Data-Engineering-Team diese Daten mit Apache Spark mithilfe von Amazon EMR oder einem AWS Glue-Job analysieren, indem es die Amazon Redshift-Integration für Apache Spark verwendet, um Aggregationen und Transformationen durchzuführen. Der aggregierte und transformierte Datensatz kann mithilfe der Amazon Redshift-Integration für Apache Spark wieder in Amazon Redshift gespeichert werden.

Die Verwendung eines verteilten Frameworks wie Apache Spark mit der Amazon Redshift-Integration für Apache Spark kann die Transparenz über den Data Lake und das Data Warehouse bereitstellen, um Verkaufserkenntnisse zu generieren. Diese Erkenntnisse können den geschäftlichen Interessenvertretern und Branchenbenutzern in Amazon Redshift zur Verfügung gestellt werden, um fundierte Entscheidungen zu treffen, um gezielte Werbeaktionen für die Marktsegmente mit niedrigem Umsatz durchzuführen.

Darüber hinaus können wir die Amazon Redshift-Integration mit Apache Spark in den folgenden Anwendungsfällen verwenden:

Ein Amazon EMR- oder AWS Glue-Kunde, der Apache Spark-Jobs ausführt, möchte Daten transformieren und diese als Teil seiner ETL-Pipeline in Amazon Redshift schreiben
Ein ML-Kunde verwendet Apache Spark mit SageMaker für das Feature-Engineering für den Zugriff auf und die Transformation von Daten in Amazon Redshift
Ein Amazon EMR-, AWS Glue- oder SageMaker-Kunde verwendet Apache Spark für die interaktive Datenanalyse mit Daten auf Amazon Redshift von Notebooks

Beispiele für die Amazon Redshift-Integration für Apache Spark in einer Apache Spark-Anwendung

In diesem Beitrag zeigen wir die Schritte zum Verbinden von Amazon Redshift von Amazon EMR an Amazon Elastic Compute-Cloud (Amazon EC2), Amazon EMR ohne Serverund AWS Glue mit einem gemeinsamen Skript. Im folgenden Beispielcode generieren wir einen Bericht, der die vierteljährlichen Verkäufe für das Jahr 2008 zeigt. Dazu verbinden wir zwei Amazon Redshift-Tabellen mit einem Apache Spark DataFrame, führen ein Prädikat-Pushdown aus, aggregieren und sortieren die Daten und schreiben die transformierten Daten zurück zu Amazon Redshift. Das Skript verwendet PySpark

Das Skript verwendet IAM-basierte Authentifizierung für Amazon Redshift. IAM-Rollen, die von Amazon EMR und AWS Glue verwendet werden, sollten über die entsprechenden Berechtigungen zur Authentifizierung von Amazon Redshift und Zugriff auf einen S3-Bucket für die temporäre Datenspeicherung verfügen.

Die folgende Beispielrichtlinie ermöglicht es der IAM-Rolle, die GetClusterCredentials Operationen:

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

Die folgende Beispielrichtlinie ermöglicht den Zugriff auf einen S3-Bucket zur temporären Datenspeicherung:

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

Das vollständige Skript lautet wie folgt:

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

Wenn Sie das obige Skript in Ihrer Umgebung verwenden möchten, stellen Sie sicher, dass Sie die Werte für die folgenden Variablen durch die entsprechenden Werte für Ihre Umgebung ersetzen: jdbc_iam_url, temp_dir und aws_role.

Im nächsten Abschnitt führen wir die Schritte zum Ausführen dieses Skripts durch, um einen Beispieldatensatz zu aggregieren, der in Amazon Redshift verfügbar gemacht wird.

Voraussetzungen:

Bevor wir beginnen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

Stellen Sie Ressourcen mit AWS CloudFormation bereit

Führen Sie die folgenden Schritte aus, um den CloudFormation-Stack bereitzustellen:

Melden Sie sich bei der an AWS-Managementkonsole, starten Sie dann den CloudFormation-Stack:

Sie können uns auch Laden Sie die CloudFormation-Vorlage herunter um die in diesem Beitrag erwähnten Ressourcen durch Infrastruktur als Code (IaC) zu erstellen. Verwenden Sie diese Vorlage, wenn Sie einen neuen CloudFormation-Stack starten.

Scrollen Sie zum Auswählen nach unten zum Ende der Seite Ich erkenne an, dass AWS CloudFormation möglicherweise IAM-Ressourcen erstellt für Leistungen, Dann wählen Stapel erstellen.

Der Stack-Erstellungsprozess dauert 15–20 Minuten. Die CloudFormation-Vorlage erstellt die folgenden Ressourcen:

- Eine Amazon VPC mit den erforderlichen Subnetzen, Routing-Tabellen und dem NAT-Gateway
- Ein S3-Bucket mit dem Namen redshift-spark-databucket-xxxxxxx (Beachten Sie, dass xxxxxxx eine zufällige Zeichenfolge ist, um den Bucket-Namen eindeutig zu machen.)
- Ein Amazon Redshift-Cluster mit in die Datenbank geladenen Beispieldaten dev und der primäre Benutzer redshiftmasteruser. Für den Zweck dieses Blogbeitrags redshiftmasteruser mit Administratorrechten verwendet wird. Es wird jedoch empfohlen, in der Produktionsumgebung einen Benutzer mit differenzierter Zugriffskontrolle zu verwenden.
- Eine für Amazon Redshift zu verwendende IAM-Rolle mit der Möglichkeit, temporäre Anmeldeinformationen aus der Entwicklungsdatenbank des Amazon Redshift-Clusters anzufordern
- Amazon EMR-Studio mit den erforderlichen IAM-Rollen
- Amazon EMR-Version 6.9.0 auf einem EC2-Cluster mit den erforderlichen IAM-Rollen
- Eine Amazon EMR Serverless-Anwendung, Release-Version 6.9.0
- Eine AWS Glue-Verbindung und AWS Glue-Auftragsversion 4.0
- A Jupyter Notizbuch zur Ausführung mit Amazon EMR Studio mit Amazon EMR auf einem EC2-Cluster
- Ein PySpark-Skript zum Ausführen mit Amazon EMR Studio und Amazon EMR Serverless

Nachdem die Stack-Erstellung abgeschlossen ist, wählen Sie den Stack-Namen aus redshift-spark und navigiere zu Ausgänge

Wir verwenden diese Ausgabewerte später in diesem Beitrag.

In den nächsten Abschnitten zeigen wir die Schritte für die Amazon Redshift-Integration für Apache Spark von Amazon EMR auf Amazon EC2, Amazon EMR Serverless und AWS Glue.

Verwenden Sie die Amazon Redshift-Integration mit Apache Spark auf Amazon EMR auf EC2

Ab der Amazon EMR-Version 6.9.0 und höher sind der Konnektor mit Amazon Redshift-Integration für Apache Spark und der Amazon Redshift-JDBC-Treiber lokal auf Amazon EMR verfügbar. Diese Dateien befinden sich unter der /usr/share/aws/redshift/ Verzeichnis. In früheren Versionen von Amazon EMR war die community Version des spark-redshift Stecker ist verfügbar.

Das folgende Beispiel zeigt, wie Sie Amazon Redshift mit einem PySpark-Kernel über eine verbinden Amazon EMR-Studio Notizbuch. Der CloudFormation-Stack erstellte Amazon EMR Studio, Amazon EMR auf einem EC2-Cluster und ein zur Ausführung verfügbares Jupyter-Notebook. Führen Sie die folgenden Schritte aus, um dieses Beispiel durchzugehen:

Laden Sie das im S3-Bucket für Sie bereitgestellte Jupyter-Notebook herunter:
- Suchen Sie in den CloudFormation-Stapelausgaben nach dem Wert für EMRStudioNotebook, was auf die zeigen sollte redshift-spark-emr.ipynb Notebook im S3-Bucket verfügbar.
- Wählen Sie den Link aus oder öffnen Sie den Link in einem neuen Tab, indem Sie die URL für das Notizbuch kopieren.
- Nachdem Sie den Link geöffnet haben, laden Sie das Notizbuch herunter, indem Sie auswählen Herunterladen, wodurch die Datei lokal auf Ihrem Computer gespeichert wird.

Greifen Sie auf Amazon EMR Studio zu, indem Sie den Link auswählen oder kopieren, der in den CloudFormation-Stack-Ausgaben für den Schlüssel bereitgestellt wird EMRStudioURL.
Wählen Sie im Navigationsbereich Workspaces.
Auswählen Erstellen Sie Arbeitsbereich.
Geben Sie beispielsweise einen Namen für den Arbeitsbereich an redshift-spark.
Erweitern Sie die Erweiterte Konfiguration Abschnitt und wählen Sie Verbinden Sie Workspace mit einem EMR-Cluster.
Der An einen EMR-Cluster anhängen, wählen Sie den EMR-Cluster mit dem Namen aus emrCluster-Redshift-Spark.
Auswählen Erstellen Sie Arbeitsbereich.
Nachdem der Amazon EMR Studio-Arbeitsbereich erstellt wurde und sich im Status „Angehängt“ befindet, können Sie auf den Arbeitsbereich zugreifen, indem Sie den Namen des Arbeitsbereichs auswählen.

Dies sollte den Arbeitsbereich in einem neuen Tab öffnen. Beachten Sie, dass Sie, wenn Sie einen Popup-Blocker haben, möglicherweise zulassen müssen, dass der Workspace den Popup-Blocker öffnet oder deaktiviert.

Im Amazon EMR Studio Workspace laden wir nun das zuvor heruntergeladene Jupyter-Notebook hoch.

Auswählen Hochladen um Ihr lokales Dateisystem zu durchsuchen und das Jupyter-Notebook hochzuladen (redshift-spark-emr.ipynb).
Wählen Sie (Doppelklick) die redshift-spark-emr.ipynb Notizbuch im Arbeitsbereich, um das Notizbuch zu öffnen.

Das Notizbuch enthält die Details der verschiedenen Aufgaben, die es ausführt. Beachten Sie das im Abschnitt Definieren Sie die Variablen zum Herstellen einer Verbindung mit dem Amazon Redshift-Cluster, müssen Sie die Werte für nicht aktualisieren jdbc_iam_url, temp_dir und aws_role da diese von AWS CloudFormation für Sie aktualisiert werden. AWS CloudFormation hat auch die in der genannten Schritte durchgeführt Voraussetzungen: Abschnitt des Notizbuchs.

Sie können jetzt mit dem Ausführen des Notebooks beginnen.

Führen Sie die einzelnen Zellen aus, indem Sie sie auswählen und dann auswählen Play.

Sie können auch die Tastenkombination von verwenden Shift + Enter or Umschalt+Return. Alternativ können Sie alle Zellen ausführen, indem Sie wählen Führen Sie alle Zellen aus auf die Führen Sie Menü.

Suchen Sie den Prädikat-Pushdown-Vorgang, der von der Amazon Redshift-Integration für Apache Spark auf dem Amazon Redshift-Cluster ausgeführt wird.

Wir können auch die auf Amazon S3 gespeicherten temporären Daten im optimierten Parquet-Format sehen. Die Ausgabe kann durch Ausführen der Zelle im Abschnitt gesehen werden Rufen Sie die letzte Abfrage ab, die auf Amazon Redshift ausgeführt wurde.

Um die durch den Auftrag erstellte Tabelle von Amazon EMR auf Amazon EC2 zu validieren, navigieren Sie zur Amazon Redshift-Konsole und wählen Sie den Cluster aus redshift-spark-redshift-cluster auf die Dashboard für bereitgestellte Cluster
In den Clusterdetails auf der Daten abfragen Menü, wählen Sie Abfrage im Abfrageeditor v2.
Wählen Sie den Cluster im Navigationsbereich aus und verbinden Sie sich mit dem Amazon Redshift-Cluster, wenn dieser eine Authentifizierung anfordert.
Auswählen Temporäre Anmeldeinformationen.
Aussichten für Datenbase, eingeben dev.
Aussichten für Benutzername, eingeben redshiftmasteruser.
Auswählen Speichern.
Erweitern Sie im Navigationsbereich den Cluster redshift-spark-redshift-cluster, erweitern Sie die Entwicklerdatenbank, erweitern Sie tickit, und erweitern Tische um alle Tabellen innerhalb des Schemas aufzulisten tickit.

Sie sollten den Tisch finden test_emr.

Wählen Sie die Tabelle aus (Rechtsklick). test_emr, Dann wählen Tisch auswählen um die Tabelle abzufragen.
Auswählen Führen Sie um die SQL-Anweisung auszuführen.

Verwenden Sie die Amazon Redshift-Integration mit Apache Spark auf Amazon EMR Serverless

Die Amazon EMR-Version 6.9.0 und höher bietet die Amazon Redshift-Integration für Apache Spark-JARs (verwaltet von Amazon Redshift) und Amazon Redshift-JDBC-JARs auch lokal auf Amazon EMR Serverless. Diese Dateien befinden sich unter der /usr/share/aws/redshift/ Verzeichnis. Im folgenden Beispiel verwenden wir das Python-Skript, das im S3-Bucket durch den zuvor erstellten CloudFormation-Stack verfügbar gemacht wird.

Notieren Sie sich in den CloudFormation-Stapelausgaben den Wert für EMRServerlessExecutionScript, das ist der Speicherort des Python-Skripts im S3-Bucket.
Beachten Sie auch den Wert für EMRServerlessJobExecutionRole, bei der es sich um die IAM-Rolle handelt, die zum Ausführen des Amazon EMR Serverless-Auftrags verwendet werden soll.
Greifen Sie auf Amazon EMR Studio zu, indem Sie den Link auswählen oder kopieren, der in den CloudFormation-Stack-Ausgaben für den Schlüssel bereitgestellt wird EMRStudioURL.
Auswählen Anwendungen für Serverlos im Navigationsbereich.

Sie finden eine vom CloudFormation-Stack erstellte EMR-Anwendung mit dem Namen emr-spark-redshift.

Wählen Sie den Anwendungsnamen aus, um einen Job zu übermitteln.
Auswählen Job senden.
Der JobdetailsZ. Name und Vorname, geben Sie einen identifizierbaren Namen für den Job ein.
Aussichten für Laufzeitrolle, wählen Sie die IAM-Rolle aus, die Sie zuvor aus der Ausgabe des CloudFormation-Stacks notiert haben.
Aussichten für Speicherort des Skripts, geben Sie den Pfad zu dem Python-Skript an, das Sie zuvor aus der Ausgabe des CloudFormation-Stacks notiert haben.
Erweitern Sie den Abschnitt Spark-Eigenschaften und wähle das Im Text bearbeiten

Geben Sie den folgenden Wert in das Textfeld ein, das den Pfad zur redshift-connector, Amazon Redshift JDBC-Treiber, spark-avro JAR und minimal-json JAR-Dateien:

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

Auswählen Job senden.
Warten Sie, bis der Auftrag abgeschlossen ist und der Ausführungsstatus als angezeigt wird Erfolge.
Navigieren Sie zum Amazon Redshift-Abfrage-Editor, um anzuzeigen, ob die Tabelle erfolgreich erstellt wurde.
Überprüfen Sie die ausgeführten Pushdown-Abfragen für die Amazon Redshift-Abfragegruppe emr-serverless-redshift. Sie können die folgende SQL-Anweisung für die Datenbank ausführen dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'emr-serverless-redshift' ORDER BY start_time DESC LIMIT 1
```

Sie können sehen, dass die Pushdown-Abfrage und die Rückgabeergebnisse im Parquet-Dateiformat auf Amazon S3 gespeichert werden.

Verwenden Sie die Amazon Redshift-Integration mit Apache Spark auf AWS Glue

Ab AWS Glue-Version 4.0 und höher können die Apache Spark-Jobs, die eine Verbindung zu Amazon Redshift herstellen, die Amazon Redshift-Integration für Apache Spark und den Amazon Redshift-JDBC-Treiber verwenden. Vorhandene AWS Glue-Jobs, die bereits Amazon Redshift als Quelle oder Ziel verwenden, können auf AWS Glue 4.0 aktualisiert werden, um diesen neuen Konnektor zu nutzen. Die mit diesem Beitrag bereitgestellte CloudFormation-Vorlage erstellt die folgenden AWS Glue-Ressourcen:

AWS Glue-Verbindung für Amazon Redshift – Die Verbindung zum Herstellen einer Verbindung von AWS Glue zu Amazon Redshift mithilfe der Amazon Redshift-Integration für Apache Spark
Dem AWS Glue-Job zugeordnete IAM-Rolle – Die IAM-Rolle zum Verwalten von Berechtigungen zum Ausführen des AWS Glue-Auftrags
AWS Kleberjob – Das Skript für den AWS Glue-Auftrag, der Transformationen und Aggregationen mit der Amazon Redshift-Integration für Apache Spark durchführt

Das folgende Beispiel verwendet die AWS Glue-Verbindung, die mit PySpark an den AWS Glue-Auftrag angehängt ist, und umfasst die folgenden Schritte:

Wählen Sie in der AWS Glue-Konsole aus Verbindungen im Navigationsbereich.
Der Verbindungen, wählen Sie die AWS Glue-Verbindung für Amazon Redshift aus, die von der CloudFormation-Vorlage erstellt wurde.
Überprüfen Sie die Verbindungsdetails.

Sie können diese Verbindung jetzt innerhalb eines Jobs oder über mehrere Jobs hinweg wiederverwenden.

Auf dem Anschluss Seite, wählen Sie den vom CloudFormation-Stack erstellten AWS Glue-Job unter Ihre Arbeitsplätze, oder greifen Sie auf den AWS Glue-Job zu, indem Sie die für den Schlüssel bereitgestellte URL verwenden GlueJob in der Ausgabe des CloudFormation-Stacks.
Greifen Sie auf das Skript für den AWS Glue-Job zu und überprüfen Sie es.
Auf dem Jobdetails Registerkarte, stellen Sie sicher, dass Klebeversion eingestellt ist Kleber 4.0.

Dadurch wird sichergestellt, dass der Job die neueste Version verwendet redshift-spark Stecker.

Erweitern Sie die Funktionalität der Erweiterte Eigenschaften und in der Verbindungen Stellen Sie im Abschnitt sicher, dass die vom CloudFormation-Stack erstellte Verbindung angehängt ist.
Überprüfen Sie die für den AWS Glue-Auftrag hinzugefügten Auftragsparameter. Diese Werte sind auch in der Ausgabe für den CloudFormation-Stack verfügbar.
Auswählen Speichern und dann Führen Sie.

Sie können den Status für die Jobausführung auf anzeigen Führen Sie Tab.

Nachdem die Auftragsausführung erfolgreich abgeschlossen wurde, können Sie die Ausgabe der vom AWS Glue-Auftrag erstellten Tabelle test-glue überprüfen.
Wir überprüfen die Pushdown-Abfragen, die für die Amazon Redshift-Abfragegruppe ausgeführt werden glue-redshift. Sie können die folgende SQL-Anweisung für die Datenbank ausführen dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1
```

Best Practices

Beachten Sie die folgenden Best Practices:

Erwägen Sie die Verwendung der Amazon Redshift-Integration für Apache Spark von Amazon EMR, anstatt die zu verwenden redshift-spark Connector (Community-Version) für Ihre neuen Apache Spark-Jobs.
Wenn Sie über vorhandene Apache Spark-Jobs verfügen, die die redshift-spark Connector (Community-Version), erwägen Sie ein Upgrade, um die Amazon Redshift-Integration für Apache Spark zu verwenden
Die Amazon Redshift-Integration für Apache Spark wendet automatisch Prädikat- und Abfrage-Pushdown an, um die Leistung zu optimieren. Wir empfehlen die Verwendung unterstützter Funktionen (autopushdown) in Ihrer Anfrage. Die Amazon Redshift-Integration für Apache Spark wandelt die Funktion in eine SQL-Abfrage um und führt die Abfrage in Amazon Redshift aus. Diese Optimierung führt dazu, dass erforderliche Daten abgerufen werden, sodass Apache Spark weniger Daten verarbeiten und eine bessere Leistung erzielen kann.
- Erwägen Sie die Verwendung von aggregierten Pushdown-Funktionen wie avg, count, max, min und sum um gefilterte Daten zur Datenverarbeitung abzurufen.
- Erwägen Sie die Verwendung von booleschen Pushdown-Operatoren wie in, isnull, isnotnull, contains, endswith und startswith um gefilterte Daten zur Datenverarbeitung abzurufen.
- Erwägen Sie die Verwendung logischer Pushdown-Operatoren wie and, or und not (oder !), um gefilterte Daten für die Datenverarbeitung abzurufen.
Es wird empfohlen, eine IAM-Rolle mit dem Parameter zu übergeben aws_iam_role für die Amazon Redshift-Authentifizierung von Ihrer Apache Spark-Anwendung auf Amazon EMR oder AWS Glue. Die IAM-Rolle sollte über die erforderlichen Berechtigungen verfügen, um temporäre IAM-Anmeldeinformationen abzurufen, um sich bei Amazon Redshift zu authentifizieren, wie im Abschnitt „Beispiele für die Amazon Redshift-Integration für Apache Spark in eine Apache Spark-Anwendung“ dieses Blogs gezeigt.
Mit dieser Funktion müssen Sie Ihren Amazon Redshift-Benutzernamen und Ihr Kennwort nicht im Secrets Manager und in der Amazon Redshift-Datenbank pflegen.
Amazon Redshift verwendet die UNLOAD-SQL-Anweisung, um diese temporären Daten auf Amazon S3 zu speichern. Die Apache Spark-Anwendung ruft die Ergebnisse aus dem temporären Verzeichnis ab (gespeichert im Parquet-Dateiformat). Dieses temporäre Verzeichnis auf Amazon S3 wird nicht automatisch bereinigt und kann daher zusätzliche Kosten verursachen. Wir empfehlen die Verwendung Amazon S3-Lebenszyklusrichtlinien um die Aufbewahrungsregeln für den S3-Bucket zu definieren.
Es wird empfohlen, es einzuschalten Amazon Redshift-Audit-Protokollierung um die Informationen über Verbindungen und Benutzeraktivitäten in Ihrer Datenbank zu protokollieren.
Es wird empfohlen, es einzuschalten Amazon Redshift-Verschlüsselung im Ruhezustand um Ihre Daten zu verschlüsseln, während Amazon Redshift sie in seine Rechenzentren schreibt, und sie für Sie zu entschlüsseln, wenn Sie darauf zugreifen.
Es wird empfohlen, auf AWS Glue v4.0 und höher zu aktualisieren, um die Amazon Redshift-Integration für Apache Spark zu verwenden, die standardmäßig verfügbar ist. Beim Upgrade auf diese Version von AWS Glue wird diese Funktion automatisch genutzt.
Es wird empfohlen, auf Amazon EMR v6.9.0 und höher zu aktualisieren, um die Amazon Redshift-Integration für Apache Spark zu verwenden. Sie müssen keine Treiber oder JAR-Dateien explizit verwalten.
Erwägen Sie die Verwendung von Amazon EMR Studio-Notebooks, um mit Ihren Amazon Redshift-Daten in Ihrer Apache Spark-Anwendung zu interagieren.
Erwägen Sie die Verwendung von AWS Glue Studio zum Erstellen von Apache Spark-Jobs mit einer visuellen Oberfläche. Sie können auch zum Schreiben von Apache Spark-Code in Scala oder PySpark innerhalb von AWS Glue Studio wechseln.

Aufräumen

Führen Sie die folgenden Schritte aus, um die Ressourcen zu bereinigen, die als Teil der CloudFormation-Vorlage erstellt werden, um sicherzustellen, dass Ihnen die Ressourcen nicht in Rechnung gestellt werden, wenn Sie sie nicht mehr verwenden:

Stoppen Sie die Amazon EMR Serverless-Anwendung:
- Greifen Sie auf Amazon EMR Studio zu, indem Sie den Link auswählen oder kopieren, der in den CloudFormation-Stack-Ausgaben für den Schlüssel bereitgestellt wird EMRStudioURL.
- Auswählen Anwendungen für Serverlos im Navigationsbereich.

Sie finden eine vom CloudFormation-Stack erstellte EMR-Anwendung mit dem Namen emr-spark-redshift.

- Wenn der Anwendungsstatus als Angehalten angezeigt wird, können Sie mit den nächsten Schritten fortfahren. Wenn der Anwendungsstatus jedoch Gestartet lautet, wählen Sie den Anwendungsnamen aus und wählen Sie dann aus Beenden Sie die Anwendung und Beenden Sie die Anwendung nochmal zur Bestätigung.

Löschen Sie den Amazon EMR Studio-Arbeitsbereich:
- Greifen Sie auf Amazon EMR Studio zu, indem Sie den Link auswählen oder kopieren, der in den CloudFormation-Stack-Ausgaben für den Schlüssel bereitgestellt wird EMRStudioURL.
- Auswählen Workspaces im Navigationsbereich.
- Wählen Sie den Arbeitsbereich aus, den Sie erstellt haben, und wählen Sie aus Löschen, Dann wählen Löschen nochmal zur Bestätigung.
Löschen Sie den CloudFormation-Stack:

- Navigieren Sie in der AWS CloudFormation-Konsole zu dem Stack, den Sie zuvor erstellt haben.
- Wählen Sie den Stack-Namen und wählen Sie dann Löschen um den Stapel zu entfernen und die Ressourcen zu löschen, die als Teil dieses Beitrags erstellt wurden.
- Wählen Sie auf dem Bestätigungsbildschirm Stapel löschen.

Zusammenfassung

In diesem Beitrag haben wir erklärt, wie Sie die Amazon Redshift-Integration für Apache Spark verwenden können, um Anwendungen mit Amazon EMR auf Amazon EC2, Amazon EMR Serverless und AWS Glue zu erstellen und bereitzustellen, um Prädikat- und Abfrage-Pushdown automatisch anzuwenden, um die Abfrageleistung für Daten zu optimieren bei Amazon Redshift. Es wird dringend empfohlen, die Amazon Redshift-Integration für Apache Spark für eine nahtlose und sichere Verbindung zu Amazon Redshift von Ihrem Amazon EMR oder AWS Glue zu verwenden.

Hier ist, was einige unserer Kunden über die Amazon Redshift-Integration für Apache Spark zu sagen haben:

„Wir befähigen unsere Ingenieure, ihre Datenpipelines und Anwendungen mit Apache Spark unter Verwendung von Python und Scala zu erstellen. Wir wollten eine maßgeschneiderte Lösung, die den Betrieb vereinfacht und schneller und effizienter für unsere Kunden bereitgestellt wird, und genau das bekommen wir mit der neuen Amazon Redshift-Integration für Apache Spark.“

– Huron Consulting

„GE Aerospace nutzt AWS Analytics und Amazon Redshift, um wichtige Geschäftseinblicke zu ermöglichen, die wichtige Geschäftsentscheidungen vorantreiben. Mit der Unterstützung für das automatische Kopieren von Amazon S3 können wir einfachere Datenpipelines erstellen, um Daten von Amazon S3 zu Amazon Redshift zu verschieben. Dies beschleunigt die Fähigkeit unserer Datenproduktteams, auf Daten zuzugreifen und Endbenutzern Einblicke zu liefern. Wir verbringen mehr Zeit mit der Wertschöpfung durch Daten und weniger Zeit mit Integrationen.“

– GE Luft- und Raumfahrt

„Unser Fokus liegt darauf, allen unseren Nutzern bei Goldman Sachs einen Self-Service-Zugriff auf Daten zu bieten. Über Legend, unsere Open-Source-Datenmanagement- und Governance-Plattform, ermöglichen wir es Benutzern, datenzentrische Anwendungen zu entwickeln und datengesteuerte Erkenntnisse zu gewinnen, während wir in der gesamten Finanzdienstleistungsbranche zusammenarbeiten. Mit der Amazon Redshift-Integration für Apache Spark wird unser Datenplattformteam in der Lage sein, mit minimalen manuellen Schritten auf Amazon Redshift-Daten zuzugreifen, was eine Null-Code-ETL ermöglicht, die es unseren Ingenieuren erleichtert, sich auf die Perfektionierung ihres Arbeitsablaufs zu konzentrieren Sie sammeln vollständige und zeitnahe Informationen. Wir erwarten eine Leistungssteigerung der Anwendungen und eine verbesserte Sicherheit, da unsere Benutzer jetzt problemlos auf die neuesten Daten in Amazon Redshift zugreifen können.“

– Goldmann Sachs

Über die Autoren

Gagan Brahmi ist Senior Specialist Solutions Architect mit Fokus auf Big-Data-Analysen und KI/ML-Plattformen bei Amazon Web Services. Gagan verfügt über mehr als 18 Jahre Erfahrung in der Informationstechnologie. Er unterstützt Kunden beim Entwerfen und Erstellen hochskalierbarer, leistungsfähiger und sicherer Cloud-basierter Lösungen auf AWS. In seiner Freizeit verbringt er Zeit mit seiner Familie und erkundet neue Orte.

Vivek Gautam ist Datenarchitekt mit Spezialisierung auf Data Lakes bei AWS Professional Services. Er arbeitet mit Unternehmenskunden zusammen, die Datenprodukte, Analyseplattformen und Lösungen auf AWS entwickeln. Wenn er nicht gerade Datenseen baut und gestaltet, ist Vivek ein Food-Enthusiast, der auch gerne neue Reiseziele erkundet und Wanderungen unternimmt.

Naresh Gautam ist ein Data Analytics- und KI/ML-Leiter bei AWS mit 20 Jahren Erfahrung, der Kunden gerne dabei unterstützt, hochverfügbare, leistungsstarke und kostengünstige Datenanalyse- und KI/ML-Lösungen zu entwickeln, um Kunden eine datengesteuerte Entscheidungsfindung zu ermöglichen . In seiner Freizeit meditiert und kocht er gerne.

Beaux-Sharifi ist Software Development Engineer im Team der Amazon Redshift-Fahrer, wo er die Entwicklung der Amazon Redshift-Integration mit dem Apache Spark-Konnektor leitet. Er verfügt über mehr als 20 Jahre Erfahrung im Aufbau datengesteuerter Plattformen in verschiedenen Branchen. In seiner Freizeit verbringt er gerne Zeit mit seiner Familie und surft.