AWS Glue Data Catalog-Unterstützung für Spark-SQL-Jobs

Der AWS Glue Data Catalog ist ein Apache Hive-Metastore-kompatibler Katalog. Sie können Ihre AWS Glue-Aufträge und -Entwicklungsendpunkte für die Nutzung des Data Catalogs als externen Apache-Hive-Metastore konfigurieren. Anschließend können Sie Apache Spark SQL-Abfragen direkt in den im Data Catalog gespeicherten Tabellen ausführen. Dynamische Frames von AWS Glue werden standardmäßig in den Data Catalog integriert. Mit diesem Feature können Spark-SQL-Aufträge unter Verwendung des Data Catalogs als externer Hive-Metastore gestartet werden.

Für dieses Feature ist ein Netzwerkzugriff auf den AWS Glue-API-Endpunkt erforderlich. Für AWS Glue-Aufträge mit Verbindungen in privaten Subnetzen müssen Sie entweder einen VPC-Endpunkt oder ein NAT-Gateway konfigurieren, um den Netzwerkzugriff bereitzustellen. Informationen zur Konfiguration von VPC-Endpunkten finden Sie in Netzwerkzugriff auf Datenspeicher einrichten. Informationen zum Erstellen eines NAT-Gateways finden Sie unter NAT-Gateways im Amazon-VPC-Benutzerhandbuch.

Sie können AWS Glue-Aufträge und -Entwicklungsendpunkte konfigurieren, indem Sie das Argument "--enable-glue-datacatalog": "" zu Auftragsargumenten bzw. Entwicklungsendpunktargumenten hinzufügen. Durch die Übergabe dieses Arguments werden bestimmte Konfigurationen in Spark festgelegt, die ihm Zugriff auf den Data Catalog als externer Hive-Metastore ermöglichen. Außerdem ermöglicht es Hive-Unterstützung in dem SparkSession-Objekt, das im AWS Glue-Auftrag oder -Entwicklungsendpunkt erstellt wird.

Um den Datenkatalogzugriff zu aktivieren, aktivieren Sie das Kontrollkästchen AWS Glue-Datenkatalog als Hive-Metastore verwenden in der Optionsgruppe Katalog auf der Seite Job hinzufügen oder Endpunkt hinzufügen in der Konsole. Beachten Sie, dass die für den Auftrag oder den Entwicklungsendpunkt verwendete IAM-Rolle über glue:CreateDatabase-Berechtigungen verfügen sollte. Sofern nicht bereits vorhanden, wird im Data Catalog eine Datenbank namens „default“ angelegt.

Schauen Sie sich ein Beispiel dazu an, wie Sie dieses Feature in Ihren Spark-SQL-Aufträgen nutzen können. Im folgenden Beispiel wird davon ausgegangen, dass Sie das US-Gesetzgeber-Dataset durchsucht haben, das unter s3://awsglue-datasets/examples/us-legislators verfügbar ist.

Für serialize/deserialize Daten aus den im AWS Glue-Datenkatalog definierten Tabellen benötigt Spark SQL die SerDeHive-Klasse für das Format, das im AWS Glue-Datenkatalog im Klassenpfad des Spark-Jobs definiert ist.

SerDes denn bestimmte gängige Formate werden von vertrieben. AWS Glue Im Folgenden finden Sie die Amazon-S3-Links dafür:

Fügen Sie das JSON SerDe als zusätzliches JAR zum Entwicklungsendpunkt hinzu. Bei Jobs können Sie das SerDe mithilfe des --extra-jars Arguments im Argumentfeld hinzufügen. Weitere Informationen finden Sie unter Verwenden von Auftragsparametern in AWS Glue-Jobs.

Im Folgenden finden Sie ein Beispiel für eine JSON-Eingabe zum Erstellen eines Entwicklungsendpunkts mit aktiviertem Data Catalog für Spark SQL.

{
    "EndpointName": "Name",
    "RoleArn": "role_ARN",
    "PublicKey": "public_key_contents",
    "NumberOfNodes": 2,
    "Arguments": {
      "--enable-glue-datacatalog": ""
    },
    "ExtraJarsS3Path": "s3://crawler-public/json/serde/json-serde.jar"
}

Führen Sie nun eine Abfrage der aus dem USA-Gesetzgeber-Dataset erstellten Tabellen mit Spark SQL durch.

>>> spark.sql("use legislators")
DataFrame[]
>>> spark.sql("show tables").show()
+-----------+------------------+-----------+
|   database|         tableName|isTemporary|
+-----------+------------------+-----------+
|legislators|        areas_json|      false|
|legislators|    countries_json|      false|
|legislators|       events_json|      false|
|legislators|  memberships_json|      false|
|legislators|organizations_json|      false|
|legislators|      persons_json|      false|
+-----------+------------------+-----------+
>>> spark.sql("describe memberships_json").show()
+--------------------+---------+-----------------+
|            col_name|data_type|          comment|
+--------------------+---------+-----------------+
|             area_id|   string|from deserializer|
|     on_behalf_of_id|   string|from deserializer|
|     organization_id|   string|from deserializer|
|                role|   string|from deserializer|
|           person_id|   string|from deserializer|
|legislative_perio...|   string|from deserializer|
|          start_date|   string|from deserializer|
|            end_date|   string|from deserializer|
+--------------------+---------+-----------------+

Wenn die SerDe Klasse für das Format im Klassenpfad des Jobs nicht verfügbar ist, wird eine Fehlermeldung ähnlich der folgenden angezeigt.

>>> spark.sql("describe memberships_json").show()

Caused by: MetaException(message:java.lang.ClassNotFoundException Class org.openx.data.jsonserde.JsonSerDe not found)
    at org.apache.hadoop.hive.metastore.MetaStoreUtils.getDeserializer(MetaStoreUtils.java:399)
    at org.apache.hadoop.hive.ql.metadata.Table.getDeserializerFromMetaStore(Table.java:276)
    ... 64 more

Um nur die eindeutigen organization_ids aus der memberships-Tabelle anzuzeigen, führen Sie die folgende SQL-Abfrage durch.

>>> spark.sql("select distinct organization_id from memberships_json").show()
+--------------------+
|     organization_id|
+--------------------+
|d56acebe-8fdc-47b...|
|8fa6c3d2-71dc-478...|
+--------------------+

Wenn Sie bei Dynamic Frames genauso verfahren müssen, führen Sie die folgenden Schritte aus.

>>> memberships = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="memberships_json")
>>> memberships.toDF().createOrReplaceTempView("memberships")
>>> spark.sql("select distinct organization_id from memberships").show()
+--------------------+
|     organization_id|
+--------------------+
|d56acebe-8fdc-47b...|
|8fa6c3d2-71dc-478...|
+--------------------+

Obwohl sie für ETL-Operationen optimiert DynamicFrames sind, bietet die Möglichkeit, Spark SQL direkt auf den Datenkatalog zuzugreifen, eine übersichtliche Möglichkeit, komplexe SQL-Anweisungen auszuführen oder bestehende Anwendungen zu portieren.