Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Apache Spark in Amazon Athena verwenden
Amazon Athena vereinfacht die interaktive Ausführung von Datenanalysen und -erkundungen mithilfe von Apache Spark, ohne dass Sie Ressourcen planen, konfigurieren oder verwalten müssen. Das Ausführen von Apache-Spark-Anwendungen auf Athena bedeutet, dass Spark-Code zur Verarbeitung übermittelt und die Ergebnisse direkt empfangen werden, ohne dass eine zusätzliche Konfiguration erforderlich ist. Apache Spark auf Amazon Athena ist Serverless und bietet eine automatische, bedarfsgerechte Skalierung, die sofortige Rechenleistung für sich ändernde Daten-Volumes und Verarbeitungsanforderungen bereitstellt.
In der Release-Version [PySpark Engine-Version 3](notebooks-spark-release-versions.md#notebooks-spark-release-versions-pyspark-3) können Sie die vereinfachte Notebook-Oberfläche in der Amazon Athena Athena-Konsole verwenden, um Apache Spark-Anwendungen mit Python oder Athena Notebook zu entwickeln. APIs
In der Release-Version [Apache Spark Version 3.5](notebooks-spark-release-versions.md#notebooks-spark-release-versions-spark-35) können Sie Spark-Code von Amazon SageMaker Unified Studio-Notebooks oder Ihren bevorzugten Spark Connect-kompatiblen Clients ausführen.
Amazon Athena bietet die folgenden Features:
+ **Konsolennutzung** — Reichen Sie Ihre Spark-Anwendungen von der Amazon Athena Athena-Konsole aus ein (nur Pyspark Enginer Version 3).
+ **Scripting** – Erstellen und debuggen Sie schnell und interaktiv Apache-Spark-Anwendungen in Python.
+ **Dynamische Skalierung** – Amazon Athena bestimmt automatisch die Rechen- und Arbeitsspeicherressourcen, die zum Ausführen eines Auftrags erforderlich sind, und skaliert diese Ressourcen fortlaufend entsprechend bis zu den von Ihnen angegebenen Höchstwerten. Diese dynamische Skalierung reduziert die Kosten, ohne die Geschwindigkeit zu beeinträchtigen.
+ **Notebook-Erfahrung** — Verwenden Sie die Amazon SageMaker AI Unified Studio-Notebooks, um Berechnungen über eine vertraute Oberfläche zu erstellen, zu bearbeiten und auszuführen. In der Pyspark-Engine-Version 3 können Sie Athena-Notebooks in der Konsole verwenden, die mit Jupyter-Notebooks kompatibel sind und eine Liste von Zellen enthalten, die der Reihe nach als Berechnungen ausgeführt werden. Zelleninhalte können Code, Text, Markdown, Mathematik, Diagramme und Multimedia enthalten.
Weitere Informationen finden Sie unter [Run Spark SQL on Amazon Athena Spark](https://aws.amazon.com/blogs/big-data/run-spark-sql-on-amazon-athena-spark/) und [Spark SQL auf Amazon Athena Spark ausführen](https://aws.amazon.com/blogs/big-data/explore-your-data-lake-using-amazon-athena-for-apache-spark/) Erkunden Sie Ihren Data Lake mit Amazon Athena für Apache SparkRun Spark SQL on Amazon Athena Spark im *AWS -Big-Data-Blog*.
**Topics**
+ [Release-Versionen](notebooks-spark-release-versions.md)
+ [Überlegungen und Einschränkungen](notebooks-spark-considerations-and-limitations.md)
+ [Erste Schritte](notebooks-spark-getting-started.md)
+ [Notebook-Dateien verwalten](notebooks-spark-managing.md)
+ [Notebook-Editor](notebooks-spark-editor.md)
+ [Nicht-Hive-Tabellenformate verwenden](notebooks-spark-table-formats.md)
+ [Unterstützung für Python-Bibliotheken](notebooks-spark-python-library-support.md)
+ [Benutzerdefinierte Konfiguration angeben](notebooks-spark-custom-jar-cfg.md)
+ [Unterstützte Daten- und Speicherformate](notebooks-spark-data-and-storage-formats.md)
+ [Apache Spark überwachen](notebooks-spark-metrics.md)
+ [Zuordnung der Kosten](notebooks-spark-cost-attribution.md)
+ [Protokollierung und Überwachung](notebooks-spark-logging-monitoring.md)
+ [Zugriff auf die Spark-Benutzeroberfläche](notebooks-spark-ui-access.md)
+ [Spark Connect](notebooks-spark-connect.md)
+ [Aktivieren von Zahlung durch den Anforderer für Buckets](notebooks-spark-requester-pays.md)
+ [Integration von Lake Formation](notebooks-spark-lakeformation.md)
+ [Spark-Verschlüsselung aktivieren](notebooks-spark-encryption.md)
+ [Kontenübergreifender Katalogzugriff](spark-notebooks-cross-account-glue.md)
+ [Servicekontingente](notebooks-spark-quotas.md)
+ [Athena Spark APIs](notebooks-spark-api-list.md)
+ [Fehlerbehebung](notebooks-spark-troubleshooting.md)
# Release-Versionen
Amazon Athena für Apache Spark bietet die folgenden Release-Versionen:
## PySpark Engine-Version 3
PySpark Version 3 enthält Apache Spark Version 3.2.1. Mit dieser Version können Sie Spark-Code in Athena-Konsolen-Notebooks ausführen.
## Apache Spark Version 3.5
Apache Spark Version 3.5 basiert auf Amazon EMR 7.12 und paketiert Apache Spark Version 3.5.6. Mit dieser Version können Sie Spark-Code vom Amazon SageMaker AI Unified Studio-Notebook oder Ihren bevorzugten kompatiblen Spark-Clients aus ausführen. Diese Version fügt wichtige Funktionen hinzu, um ein verbessertes Erlebnis bei interaktiven Workloads zu bieten:
+ **Secure Spark Connect** — Fügt Spark Connect als authentifizierten und autorisierten AWS Endpunkt hinzu.
+ **Kostenzuweisung auf Sitzungsebene** — Benutzer können die Kosten pro interaktiver Sitzung im AWS Cost Explorer oder in Kosten- und Nutzungsberichten verfolgen. Weitere Informationen finden Sie unter [Kostenzuweisung auf Sitzungsebene](notebooks-spark-cost-attribution.md).
+ **Erweiterte Debugging-Funktionen** — Fügt Live-Spark-UI und Spark History Server-Unterstützung für das Debuggen von Workloads sowohl von Notebooks als auch von APIs Notebooks hinzu. Weitere Informationen finden Sie unter [Zugriff auf die Spark-Benutzeroberfläche](notebooks-spark-ui-access.md#notebooks-spark-ui-access-methods).
+ **Unterstützung für ungefilterten Zugriff** — Greifen Sie auf geschützte AWS Glue Datenkatalogtabellen zu, für die Sie über vollständige Tabellenberechtigungen verfügen. Weitere Informationen finden Sie unter [Verwenden von Lake Formation mit Athena Spark-Arbeitsgruppen](notebooks-spark-lakeformation.md).
### Spark-Standardeigenschaften
In der folgenden Tabelle sind Spark-Eigenschaften und ihre Standardwerte aufgeführt, die für SparkConnect Athena-Sitzungen angewendet werden.
| Key (Schlüssel) | Standardwert | Description |
| --- | --- | --- |
| `spark.app.id` | `` | Dies ist nicht änderbar. |
| `spark.app.name` | `default` | |
| `spark.driver.cores` | `4` | Die Anzahl der vom Treiber verwendeten Kerne. Dies kann beim ersten Start nicht geändert werden. |
| `spark.driver.memory` | `10g` | Menge an Speicher, die jeder Treiber verwendet. Dies kann beim ersten Start nicht geändert werden. |
| `spark.driver.memoryOverhead` | `6g` | Höhe des Speicheraufwands, der Python-Workloads und anderen Prozessen zugewiesen wurde, die auf dem Treiber ausgeführt werden. Dies kann beim ersten Start nicht geändert werden. |
| `spark.cortex.driver.disk` | `64g` | Die Spark-Treiberdiskette. Dies kann beim ersten Start nicht geändert werden. |
| `spark.executor.cores` | `4` | Die Anzahl der Kerne, die jeder Executor verwendet. Dies kann beim ersten Start nicht geändert werden. |
| `spark.executor.memory` | `10g` | Menge an Speicher, die jeder Treiber verwendet. |
| `spark.executor.memoryOverhead` | `6g` | Höhe des Speicher-Overheads, der Python-Workloads und anderen Prozessen zugewiesen wurde, die auf dem Executor ausgeführt werden. Dies kann beim ersten Start nicht geändert werden. |
| `spark.cortex.executor.disk` | `64g` | Die Spark-Executor-Diskette. Dies kann beim ersten Start nicht geändert werden. |
| `spark.cortex.executor.architecture` | `AARCH_64` | Architektur des Executors. |
| `spark.driver.extraJavaOptions` | `-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false` | Zusätzliche Java-Optionen für den Spark-Treiber. Dies kann beim ersten Start nicht geändert werden. |
| `spark.executor.extraJavaOptions` | `-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false` | Zusätzliche Java-Optionen für den Spark-Executor. Dies kann beim ersten Start nicht geändert werden. |
| `spark.executor.instances` | `1` | Die Anzahl der zuzuweisenden Spark-Executor-Container. |
| `spark.dynamicAllocation.enabled` | `TRUE` | Option, die die dynamische Ressourcenzuweisung aktiviert. Diese Option skaliert die Anzahl der bei der Anwendung registrierten Executoren je nach Arbeitslast nach oben oder unten. |
| `spark.dynamicAllocation.minExecutors` | `0` | Die Untergrenze für die Anzahl der Executoren, wenn Sie die dynamische Zuweisung aktivieren. |
| `spark.dynamicAllocation.maxExecutors` | `59` | Die Obergrenze für die Anzahl der Executoren, wenn Sie die dynamische Zuweisung aktivieren. |
| `spark.dynamicAllocation.initialExecutors` | `1` | Die anfängliche Anzahl von Executoren, die ausgeführt werden sollen, wenn Sie die dynamische Zuweisung aktivieren. |
| `spark.dynamicAllocation.executorIdleTimeout` | `60s` | Die Zeitspanne, für die ein Executor inaktiv bleiben kann, bevor Spark ihn entfernt. Dies gilt nur, wenn Sie die dynamische Zuweisung aktivieren. |
| `spark.dynamicAllocation.shuffleTracking.enabled` | `TRUE` | Wenn DRA aktiviert ist, muss das Shuffle-Tracking aktiviert sein. |
| `spark.dynamicAllocation.sustainedSchedulerBacklogTimeout` | `1s` | Timeout definiert, wie lange der Spark-Scheduler einen anhaltenden Rückstand an ausstehenden Aufgaben beobachten muss, bevor er eine Anfrage an den Clustermanager auslöst, neue Executors zu starten. |
| `spark.sql.catalogImplementation` | `hive` | |
| `spark.hadoop.hive.metastore.client.factory.class` | `com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory` | Die Metastore-Implementierungsklasse. AWS Glue |
| `spark.hadoop.hive.metastore.glue.catalogid` | `` | AWS Glue Katalog-Konto-ID. |
| `spark.sql.hive.metastore.sharedPrefixes` | `software.amazon.awssdk.services.dynamodb` | Die Eigenschaft gibt eine durch Kommas getrennte Liste von Paketpräfixen für Klassen an, die von der Anwendung geladen werden sollen und ClassLoader nicht von dem isolierten, für Hive Metastore ClassLoader Client-Code erstellten Code. |
| `spark.hadoop.fs.s3.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Definiert die Implementierung für den S3-Client zur Verwendung von S3A. |
| `spark.hadoop.fs.s3a.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Definiert die Implementierung für den S3A-Client (S3A). |
| `spark.hadoop.fs.s3n.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Definiert die Implementierung für den Native S3-Client (S3N) zur Verwendung von S3A. |
| `spark.hadoop.fs.AbstractFileSystem.s3.impl` | `org.apache.hadoop.fs.s3a.S3A` | |
| `spark.hadoop.fs.s3a.aws.credentials.provider` | `software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider` | |
| `spark.hadoop.fs.s3.customAWSCredentialsProvider` | `com.amazonaws.auth.DefaultAWSCredentialsProviderChain` | |
| `spark.hadoop.mapreduce.output.fs.optimized.committer.enabled` | `TRUE` | Diese Eigenschaft ermöglicht ein optimiertes Commit-Protokoll für Spark-Jobs beim Schreiben von Daten in Amazon S3. Wenn sie auf true gesetzt ist, hilft sie Spark dabei, kostspielige Operationen zum Umbenennen von Dateien zu vermeiden, was im Vergleich zum standardmäßigen Hadoop-Committer zu schnelleren und zuverlässigeren atomaren Schreibvorgängen führt. |
| `spark.hadoop.fs.s3a.endpoint.region` | `` | Diese Konfiguration legt explizit die AWS Region für den Amazon S3 S3-Bucket fest, auf den über den S3A-Client zugegriffen wird. |
| `spark.hadoop.fs.s3.getObject.initialSocketTimeoutMilliseconds` | `2000` | Dies gibt das Timeout für die Socket-Verbindung in Millisekunden an. |
| `spark.hadoop.fs.s3a.committer.magic.enabled` | `TRUE` | Dadurch wird der S3A „Magic“ Committer aktiviert, ein hochperformantes, aber spezifisches Commit-Protokoll, das auf der Unterstützung spezieller Pfade durch den zugrundeliegenden Clustermanager beruht. |
| `spark.hadoop.fs.s3a.committer.magic.track.commits.in.memory.enabled` | `TRUE` | Dies ist nur relevant, wenn der Magic Committer aktiviert ist. Es gibt an, ob die Liste der Dateien, die durch eine Aufgabe übergeben wurden, im Speicher nachverfolgt werden soll, anstatt in temporäre Festplattendateien geschrieben zu werden. |
| `spark.hadoop.fs.s3a.committer.name` | `magicv2` | Mit dieser Einstellung wird explizit der spezifische S3A Output Committer-Algorithmus ausgewählt, der verwendet werden soll (z. B. Verzeichnis, partitioniert oder Magic). Durch Angabe des Namens wählen Sie die Strategie aus, die temporäre Daten verwaltet, Aufgabenausfälle behandelt und den letzten atomaren Commit für den Amazon S3 S3-Zielpfad durchführt. |
| `spark.hadoop.fs.s3.s3AccessGrants.enabled` | `FALSE` | Property ermöglicht die Unterstützung von Amazon S3 Access Grants beim Zugriff auf Amazon S3 S3-Daten über den S3A/EMRFS-Dateisystemclient. |
| `spark.hadoop.fs.s3.s3AccessGrants.fallbackToIAM` | `FALSE` | Wenn Amazon S3 Access Grants aktiviert sind, steuert diese Eigenschaft, ob der Amazon S3 S3-Client auf herkömmliche IAM-Anmeldeinformationen zurückgreifen soll, wenn die Suche nach Access Grants fehlschlägt oder keine ausreichenden Berechtigungen bereitstellt. |
| `spark.pyspark.driver.python` | `/usr/bin/python3.11` | Python-Pfad für den Treiber. |
| `spark.pyspark.python` | `/usr/bin/python3.11` | Python-Pfad für den Executor. |
| `spark.python.use.daemon` | `TRUE` | Diese Konfiguration steuert, ob Spark auf jedem Executor einen Python-Worker-Daemon-Prozess verwendet. Wenn diese Option aktiviert ist (true, Standard), hält der Executor den Python-Worker zwischen den Aufgaben am Leben, um den Aufwand zu vermeiden, wiederholt einen neuen Python-Interpreter für jede Aufgabe zu starten und zu initialisieren, wodurch die Leistung von Anwendungen erheblich verbessert wird. PySpark |
| `spark.sql.execution.arrow.pyspark.enabled` | `TRUE` | Ermöglicht die Verwendung von Apache Arrow zur Optimierung der Datenübertragung zwischen den JVM- und Python-Prozessen in PySpark. |
| `spark.sql.execution.arrow.pyspark.fallback.enabled` | `TRUE` | Konfigurationseigenschaft, die das Verhalten von Spark steuert, wenn bei der Datenübertragung zwischen der JVM und Python mithilfe der Apache Arrow-Optimierung ein Fehler auftritt. |
| `spark.sql.parquet.fs.optimized.committer.optimization-enabled` | `TRUE` | Konfigurationseigenschaft, die steuert, ob Spark beim Schreiben von Parquet-Dateien in bestimmte Dateisysteme, insbesondere Cloud-Speichersysteme wie Amazon S3, einen optimierten Datei-Committer verwendet. |
| `spark.sql.parquet.output.committer.class` | `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter` | Spark-Konfigurationseigenschaft, die den vollqualifizierten Klassennamen des Hadoop OutputCommitter angibt, der beim Schreiben von Parquet-Dateien verwendet werden soll. |
| `spark.resourceManager.cleanupExpiredHost` | `TRUE` | Diese Eigenschaft steuert, ob der Treiber aktiv Spark-Anwendungsressourcen bereinigt, die mit Executoren verknüpft sind, die auf gelöschten oder abgelaufenen Knoten ausgeführt wurden. |
| `spark.blacklist.decommissioning.enabled` | `TRUE` | Diese Eigenschaft ermöglicht es der Logik von Spark, Executoren, die derzeit vom Clustermanager außer Betrieb genommen (Graceful Shutdown) werden, automatisch auf eine schwarze Liste zu setzen. Dadurch wird verhindert, dass der Scheduler neue Aufgaben an Executoren sendet, die im Begriff sind, das System zu beenden, wodurch die Stabilität des Jobs während der Ressourcenreduzierung verbessert wird. |
| `spark.blacklist.decommissioning.timeout` | `1h` | Maximale Zeit, während der Spark wartet, bis eine Aufgabe erfolgreich von einem außer Betrieb genommenen Executor migriert wurde, bevor der Host auf die schwarze Liste gesetzt wird. |
| `spark.stage.attempt.ignoreOnDecommissionFetchFailure` | `TRUE` | Weist Spark an, nachsichtig zu sein und nicht die gesamte Phase des Versuchs fehlzuschlagen, falls beim Lesen von Shuffle-Daten von einem Executor bei der Außerbetriebnahme ein Abruffehler auftritt. Der Fehlschlag beim Abrufen gilt als behebbar, und Spark ruft die Daten erneut von einem anderen Ort ab (was möglicherweise eine Neuberechnung erfordert). Dabei wird der Ausführung des Jobs Vorrang vor der strikten Fehlerbehandlung bei ordnungsgemäßem Herunterfahren eingeräumt. |
| `spark.decommissioning.timeout.threshold` | `20` | Diese Eigenschaft wird normalerweise intern oder in bestimmten Cluster-Manager-Setups verwendet, um die maximale Gesamtdauer zu definieren, die Spark für die Außerbetriebnahme eines Hosts erwartet. Wenn die tatsächliche Stilllegungszeit diesen Schwellenwert überschreitet, kann Spark aggressive Maßnahmen ergreifen, z. B. den Host auf eine schwarze Liste setzen oder eine erzwungene Kündigung beantragen, um die Ressource freizugeben. |
| `spark.files.fetchFailure.unRegisterOutputOnHost` | `TRUE` | Wenn eine Aufgabe keine Shuffle- oder RDD-Daten von einem bestimmten Host abrufen kann, weist die Einstellung auf true Spark an, die Registrierung aller mit der fehlgeschlagenen Anwendung verknüpften Ausgabeblöcke auf diesem Host aufzuheben. Dadurch wird verhindert, dass future Aufgaben versuchen, Daten vom unzuverlässigen Host abzurufen, wodurch Spark gezwungen ist, die erforderlichen Blöcke an anderer Stelle neu zu berechnen, was die Robustheit des Jobs gegenüber zeitweiligen Netzwerkproblemen erhöht. |
# Überlegungen und Einschränkungen
## Apache Spark Version 3.5
Im Folgenden sind die Überlegungen und Einschränkungen für die Release-Version Apache Spark Version 3.5 aufgeführt:
+ Diese Release-Version ist in den folgenden Versionen verfügbar AWS-Regionen:
+ Asien-Pazifik (Mumbai)
+ Asia Pacific (Seoul)
+ Asien-Pazifik (Singapur)
+ Asien-Pazifik (Sydney)
+ Asien-Pazifik (Tokio)
+ Canada (Central)
+ Europe (Frankfurt)
+ Europa (Irland)
+ Europa (London)
+ Europe (Paris)
+ Europa (Stockholm)
+ Südamerika (São Paulo)
+ USA Ost (Nord-Virginia)
+ USA Ost (Ohio)
+ USA West (Oregon)
+ Diese Engine-Version unterstützt keine Athena In-Console-Notebooks oder Notebooks. APIs Stattdessen ist diese Version in Amazon SageMaker AI Unified Studio-Notebooks integriert. Sie können auch kompatible Spark Connect-Clients verwenden.
+ Die Berechnung APIs -`StartCalculationExecution`, `ListCalculationExecutions` und`GetCalculationExecution`, werden in dieser Version nicht unterstützt.
+ Sie können eine Arbeitsgruppe nicht von PySpark Engine-Version 3 auf Apache Spark-Version 3.5 aktualisieren.
## Pyspark-Engine, Version 3
Im Folgenden sind die Überlegungen und Einschränkungen für die Release-Version Pyspark Engine Version 3 aufgeführt:
+ Diese Release-Version ist in den folgenden AWS-Regionen Versionen verfügbar:
+ Asien-Pazifik (Mumbai)
+ Asien-Pazifik (Singapur)
+ Asien-Pazifik (Sydney)
+ Asien-Pazifik (Tokio)
+ Europe (Frankfurt)
+ Europa (Irland)
+ USA Ost (Nord-Virginia)
+ USA Ost (Ohio)
+ USA West (Oregon)
+ AWS Lake Formation wird nicht unterstützt.
+ Tabellen, die Partitionsprojektion verwenden, werden nicht unterstützt.
+ Apache-Spark-fähige Arbeitsgruppen können den Athena-Notebook-Editor verwenden, aber nicht den Athena-Abfrage-Editor. Nur Athena-SQL-Arbeitsgruppen können den Athena-Abfrageeditor verwenden.
+ Engine-übergreifende Ansichten-Abfragen werden nicht unterstützt. Mit Athena SQL erstellte Ansichten können von Athena für Spark nicht abgefragt werden. Da die Ansichten für die beiden Engines unterschiedlich implementiert sind, sind sie nicht für die Engine-übergreifende Verwendung kompatibel.
+ MLlib (Apache Spark-Bibliothek für maschinelles Lernen) und das `pyspark.ml` Paket werden nicht unterstützt. Eine Liste der unterstützten Python-Bibliotheken finden Sie unter [Liste der vorinstallierten Python-Bibliotheken](notebooks-spark-preinstalled-python-libraries.md).
+ `pip install` wird derzeit in Athena für Spark-Sitzungen nicht unterstützt.
+ Pro Notebook ist nur eine aktive Sitzung zulässig.
+ Wenn mehrere Benutzer die Konsole zum Öffnen einer vorhandenen Sitzung in einer Arbeitsgruppe verwenden, greifen diese auf dasselbe Notebook zu. Um Verwirrung zu vermeiden, öffnen Sie nur Sitzungen, die Sie selbst erstellt haben.
+ Die Hosting-Domains für Apache Spark-Anwendungen, die Sie möglicherweise mit Amazon Athena verwenden (z. B. `analytics-gateway.us-east-1.amazonaws.com`), sind in der Internet [Public Suffix List (PSL](https://publicsuffix.org/list/public_suffix_list.dat)) registriert. Falls Sie jemals sensible Cookies in Ihren Domains einrichten müssen, empfehlen wir Ihnen, Cookies mit einem `__Host-`-Präfix zu verwenden, um Ihre Domain vor CSRF-Versuchen (Cross-Site Request Forgery) zu schützen. Weitere Informationen finden Sie auf der [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes)-Seite in der Entwicklerdokumentation von Mozilla.org.
+ Informationen zur Fehlerbehebung bei Spark-Notebooks, -Sitzungen und -Arbeitsgruppen in Athena finden Sie unter [Fehlerbehebung in Athena für Spark](notebooks-spark-troubleshooting.md).
# Erste Schritte mit Apache Spark auf Amazon Athena
**Anmerkung**
Folgen Sie für die Release-Version Apache Spark Version 3.5 der Anleitung Erste Schritte in [SageMaker Notebooks](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html). Verwenden Sie dieses Handbuch für die Release-Version Pyspark Engine Version 3.
Um mit Apache Spark auf Amazon Athena beginnen zu können, müssen Sie zunächst eine Spark-fähige Arbeitsgruppe erstellen. Nachdem Sie zur Arbeitsgruppe gewechselt sind, können Sie ein Notebook erstellen oder ein vorhandenes Notebook öffnen. Wenn Sie ein Notebook in Athena öffnen, wird automatisch eine neue Sitzung dafür gestartet und Sie können direkt im Athena-Notebook-Editor damit arbeiten.
**Anmerkung**
Stellen Sie sicher, dass Sie eine Spark-fähige Arbeitsgruppe erstellen, bevor Sie versuchen, ein Notebook zu erstellen.
## Schritt 1: Erstellen Sie eine Spark-fähige Arbeitsgruppe in Athena
Sie können [Arbeitsgruppen](workgroups-manage-queries-control-costs.md) in Athena verwenden, um Benutzer, Teams, Anwendungen oder Workloads zu gruppieren und Kosten zu verfolgen. Um Apache Spark in Amazon Athena zu verwenden, erstellen Sie eine Amazon-Athena-Arbeitsgruppe, die eine Spark-Engine verwendet.
**Anmerkung**
Apache-Spark-fähige Arbeitsgruppen können den Athena-Notebook-Editor verwenden, aber nicht den Athena-Abfrage-Editor. Nur Athena-SQL-Arbeitsgruppen können den Athena-Abfrageeditor verwenden.
**So erstellen Sie eine Spark-fähige Arbeitsgruppe in Athena**
1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home)
1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.
![\[Wählen Sie das Erweiterungsmenü aus.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/nav-pane-expansion.png)
1. Wählen Sie im Navigationsbereich die Option **Arbeitsgruppen** aus.
1. Wählen Sie auf der Seite **Workgroups** (Arbeitsgruppen) die Option **Create workgroup** (Arbeitsgruppe erstellen) aus.
1. Geben Sie als **Workgroup name** (Arbeitsgruppenname) einen Namen für Ihre Apache-Spark-Arbeitsgruppe ein.
1. (Optional) Geben Sie im Feld **Description** (Beschreibung) eine Beschreibung für Ihre Arbeitsgruppe ein.
1. Wählen Sie als **Analytics engine** (Analytik-Engine) die Option **Apache Spark** aus.
**Anmerkung**
Nachdem Sie eine Arbeitsgruppe erstellt haben, kann der Analytik-Engine-Typ der Arbeitsgruppe nicht mehr geändert werden. Beispielsweise kann eine Arbeitsgruppe der Athena Engine Version 3 nicht in eine Arbeitsgruppe der PySpark Engine Version 3 geändert werden.
1. Wählen Sie für die Zwecke dieses Tutorials **Turn on example notebook** (Beispiel-Notebook aktivieren) aus. Diese optionale Funktion fügt Ihrer Arbeitsgruppe ein Beispielnotizbuch mit dem Namen `example-notebook-random_string` hinzu und fügt AWS Glue zugehörige Berechtigungen hinzu, die das Notizbuch verwendet, um bestimmte Datenbanken und Tabellen in Ihrem Konto zu erstellen, anzuzeigen und zu löschen, sowie Leseberechtigungen in Amazon S3 für den Beispieldatensatz. Um die hinzugefügten Berechtigungen anzuzeigen, wählen Sie **View additional permissions details** (Details zu zusätzlichen Berechtigungen anzeigen) aus.
**Anmerkung**
Für den Betrieb des Beispiel-Notebooks können zusätzliche Kosten anfallen.
1. Wählen Sie für die **Einstellungen für Berechnungsergebnisse** aus den folgenden Optionen:
+ **Neuen S3-Bucket erstellen** – Mit dieser Option wird in Ihrem Konto ein Amazon-S3-Bucket für Ihre Berechnungsergebnisse erstellt. Der Bucket-Name hat das Format `account_id-region-athena-results-bucket-alphanumeric_id` und verwendet die Einstellungen „ ACLs Deaktiviert“, „Öffentlicher Zugriff gesperrt“, „Versionierung deaktiviert“ und „Bucket Owner erzwungen“.
+ **Einen vorhandenen S3-Speicherort auswählen** – Gehen Sie bei dieser Option wie folgt vor:
+ Geben Sie den S3-Pfad zu einem vorhandenen Speicherort in das Suchfeld ein oder wählen Sie **Browse S3** (S3 durchsuchen) aus, um einen Bucket aus einer Liste auszuwählen.
**Anmerkung**
Wenn Sie einen bereits vorhandenen Speicherort in Amazon S3 auswählen, fügen Sie dem Speicherort keinen nachgestellten Schrägstrich (`/`) hinzu. Dies führt dazu, dass der Link zum Speicherort der Berechnungsergebnisse auf der [Seite mit den Berechnungsdetails](#notebooks-spark-getting-started-viewing-session-and-calculation-details) auf das falsche Verzeichnis verweist. Bearbeiten Sie in diesem Fall den Speicherort der Ergebnisse der Arbeitsgruppe, um den nachgestellten Schrägstrich zu entfernen.
+ (Optional) Wählen Sie **View** (Anzeigen) aus, um die Seite **Buckets** der Amazon-S3-Konsole zu öffnen. Hier finden Sie weitere Informationen über den vorhandenen Bucket, den Sie ausgewählt haben.
+ (Optional) Geben Sie unter **Expected Bucket Owner** die AWS Konto-ID ein, von der Sie erwarten, dass sie der Besitzer Ihres Buckets für die Ausgabe des Abfrageergebnisses sein wird. Wir empfehlen Ihnen, diese Option nach Möglichkeit als zusätzliche Sicherheitsmaßnahme zu wählen. Wenn die Konto-ID des Bucket-Eigentümers nicht mit der von Ihnen angegebenen ID übereinstimmt, schlagen Versuche zur Ausgabe an den Bucket fehl. Ausführliche Informationen finden Sie unter [Überprüfen der Bucket-Eigentümerschaft mit Bucket-Eigentümer-Bedingung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html) im *Amazon-S3-Benutzerhandbuch*.
+ (Optional) Wählen Sie **Assign bucket owner full control over query results** (Bucket-Eigetümer die volle Kontrolle über Abfrageergebnisse zuweisen) aus, wenn der Speicherort Ihrer Berechnungsergebnisse einem anderen Konto gehört und Sie dem anderen Konto die volle Kontrolle über Ihre Abfrageergebnisse geben möchten.
1. (Optional) Wählen Sie **Abfrageergebnisse verschlüsseln** aus, wenn Sie die Abfrageergebnisse verschlüsseln möchten.
+ Wählen Sie für **Veschlüsselungstyp** eine der folgenden Optionen:
+ **SSE\$1S3** – Diese Option verwendet eine serverseitige Verschlüsselung (SSE) mit von Amazon S3 verwalteten Verschlüsselungsschlüsseln.
+ **SSE\$1KMS** — Diese Option verwendet serverseitige Verschlüsselung (SSE) mit AWS KMS verwalteten Schlüsseln.
**Wählen Sie für Wählen Sie einen AWS KMS Schlüssel eine** der folgenden Optionen aus.
+ ** AWS Eigenen Schlüssel verwenden** — Der AWS KMS Schlüssel gehört und wird von diesem verwaltet AWS. Für die Verwendung dieses Schlüssels wird Ihnen keine zusätzliche Gebühr berechnet.
+ **Wählen Sie einen anderen AWS KMS Schlüssel (erweitert)** — Führen Sie für diese Option einen der folgenden Schritte aus:
+ Um einen vorhandenen Schlüssel zu verwenden, verwenden Sie das Suchfeld, um einen Schlüssel-ARN auszuwählen AWS KMS oder einen einzugeben.
+ Um einen Schlüssel in der AWS KMS Konsole zu **erstellen, wählen Sie Create an AWS KMS Key**. Ihre Ausführungsrolle muss über die Berechtigung verfügen, den von Ihnen erstellten Schlüssel verwenden zu können. Wenn Sie mit der Erstellung des Schlüssels in der KMS-Konsole fertig sind, kehren Sie zur Seite **Arbeitsgruppe erstellen** in der Athena-Konsole zurück und **wählen Sie dann mit dem Suchfeld AWS KMS Schlüssel oder ARN eingeben** den Schlüssel aus, den Sie gerade erstellt haben.
**Wichtig**
Wenn Sie den [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) für eine Arbeitsgruppe ändern, verweisen Notebooks, die vor dem Update bearbeitet wurden, weiterhin auf den alten KMS-Schlüssel. Notebooks, die nach dem Update bearbeitet werden, verwenden den neuen KMS-Schlüssel. Um die alten Notebooks so zu aktualisieren, dass sie auf den neuen KMS-Schlüssel verweisen, exportieren und importieren Sie jedes der alten Notebooks. Wenn Sie den alten KMS-Schlüssel löschen, bevor Sie die alten Notebook-Referenzen auf den neuen KMS-Schlüssel aktualisieren, sind die alten Notebooks nicht mehr entschlüsselbar und können nicht wiederhergestellt werden.
Dieses Verhalten gilt auch für Aktualisierungen von [Aliassen](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), bei denen es sich um Anzeigenamen für KMS-Schlüssel handelt. Wenn Sie einen KMS-Schlüssel-Alias aktualisieren, um auf einen neuen KMS-Schlüssel zu verweisen, verweisen die vor der Alias-Aktualisierung verwalteten Notebooks weiterhin auf den alten KMS-Schlüssel und die nach der Alias-Aktualisierung verwalteten Notebooks verwenden den neuen KMS-Schlüssel. Berücksichtigen Sie diese Punkte, bevor Sie Ihre KMS-Schlüssel oder -Aliase aktualisieren.
1. Wählen Sie für **Zusätzliche Konfigurationen** die Option **Standardwerte verwenden**. Diese Option hilft Ihnen beim Einstieg in Ihre Spark-fähige Arbeitsgruppe. Wenn Sie Standardwerte verwenden, erstellt Athena für Sie eine IAM-Rolle und einen Speicherort für Berechnungsergebnisse in Amazon S3. Der Name der IAM-Rolle und der zu erstellende S3-Bucket-Speicherort werden in dem Feld unter der Überschrift **Additional configurations** (Zusätzliche Konfigurationen) angezeigt.
Fall Sie nicht Standardwerte verwenden möchten, fahren Sie mit den Schritten im [(Optional) Ihre eigenen Arbeitsgruppenkonfigurationen festlegen](#notebooks-spark-getting-started-workgroup-configuration)-Abschnitt fort, um Ihre Arbeitsgruppe manuell zu konfigurieren.
1. (Optional) **Tags** – Verwenden Sie diese Option, um Ihrer Arbeitsgruppe Tags hinzuzufügen. Weitere Informationen finden Sie unter [Athena-Ressourcen markieren](tags.md).
1. Wählen Sie **Create workgroup** (Arbeitsgruppe erstellen) aus. Eine Meldung informiert Sie darüber, dass die Arbeitsgruppe erfolgreich erstellt wurde, und die Arbeitsgruppe wird in der Liste der Arbeitsgruppen angezeigt.
### (Optional) Ihre eigenen Arbeitsgruppenkonfigurationen festlegen
Wenn Sie Ihre eigene IAM-Rolle und den Speicherort der Berechnungsergebnisse für Ihr Notebook festlegen möchten, folgen Sie den Schritten in diesem Abschnitt. Wenn Sie **Use defaults** (Standardwerte verwenden) für die Option **Additional configurations** (Zusätzliche Konfigurationen) ausgewählt haben, überspringen Sie diesen Abschnitt und gehen Sie direkt zu [Schritt 2: Öffnen Sie den Notebook-Explorer und wechseln die Arbeitsgruppen](#notebooks-spark-getting-started-switching-workgroups-and-opening-notebook-explorer).
Das folgende Verfahren setzt voraus, dass Sie die Schritte 1 bis 9 des Verfahrens **To create a Spark enabled workgroup in Athena** (So erstellen Sie eine Spark-fähige Arbeitsgruppe in Athena) im vorherigen Abschnitt abgeschlossen haben.
**So legen Sie Ihre eigenen Arbeitsgruppenkonfigurationen fest**
1. Wenn Sie Ihre eigene IAM-Rolle erstellen oder verwenden oder die Notebook-Verschlüsselung konfigurieren möchten, erweitern Sie die **IAM role configuration** (IAM-Rollenkonfiguration).
+ Wählen Sie für **Servicerolle zur Autorisierung von Athena** einen der folgenden Optionen:
+ **Eine neu Servicerolle erstellen un verweden** – Wählen Sie diese Option aus, damit Athena eine Servicerolle für Sie erstellt. Um die Berechtigungen anzuzeigen, die die Rolle gewährt, wählen Sie **View permission details** (Berechtigungsdetails anzeigen).
+ **Eine vorhandene Servicerolle verwenden** – Wählen Sie aus dem Dropdown-Menü eine vorhandene Rolle aus. Die von Ihnen gewählte Rolle muss die Berechtigungen aus der ersten Option enthalten. Weitere Informationen über Berechtigungen für Notebooks finden Sie unter [Fehlerbehebung bei Spark-fähigen Arbeitsgruppen](notebooks-spark-troubleshooting-workgroups.md).
+ Wählen Sie für die **Notebook and calculation code encryption key management** (Verwaltung von Notebook- und Berechnungscode-Verschlüsselungsschlüsseln) eine der folgenden Optionen aus:
+ **Mit AWS eigenem Schlüssel verschlüsseln (Standard)** — Der AWS KMS Schlüssel gehört und wird von diesem verwaltet. AWS Für die Verwendung dieses Schlüssels wird Ihnen keine zusätzliche Gebühr berechnet.
+ **Verschlüsseln mit Ihrem eigenen AWS KMS -Schlüssel** – Führen Sie für diese Option einen der folgenden Schritte aus:
+ Um einen vorhandenen Schlüssel zu verwenden, verwenden Sie das Suchfeld, um einen Schlüssel-ARN auszuwählen AWS KMS oder einen einzugeben.
+ Um einen Schlüssel in der AWS KMS Konsole zu **erstellen, wählen Sie Create an AWS KMS Key**. Ihre Ausführungsrolle muss über die Berechtigung verfügen, den von Ihnen erstellten Schlüssel verwenden zu können. Wenn Sie mit der Erstellung des Schlüssels in der KMS-Konsole fertig sind, kehren Sie zur Seite **Arbeitsgruppe erstellen** in der Athena-Konsole zurück und **wählen Sie dann mit dem Suchfeld AWS KMS Schlüssel oder ARN eingeben** den Schlüssel aus, den Sie gerade erstellt haben.
**Wichtig**
Wenn Sie den [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) für eine Arbeitsgruppe ändern, verweisen Notebooks, die vor dem Update bearbeitet wurden, weiterhin auf den alten KMS-Schlüssel. Notebooks, die nach dem Update bearbeitet werden, verwenden den neuen KMS-Schlüssel. Um die alten Notebooks so zu aktualisieren, dass sie auf den neuen KMS-Schlüssel verweisen, exportieren und importieren Sie jedes der alten Notebooks. Wenn Sie den alten KMS-Schlüssel löschen, bevor Sie die alten Notebook-Referenzen auf den neuen KMS-Schlüssel aktualisieren, sind die alten Notebooks nicht mehr entschlüsselbar und können nicht wiederhergestellt werden.
Dieses Verhalten gilt auch für Aktualisierungen von [Aliassen](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), bei denen es sich um Anzeigenamen für KMS-Schlüssel handelt. Wenn Sie einen KMS-Schlüssel-Alias aktualisieren, um auf einen neuen KMS-Schlüssel zu verweisen, verweisen die vor der Alias-Aktualisierung verwalteten Notebooks weiterhin auf den alten KMS-Schlüssel und die nach der Alias-Aktualisierung verwalteten Notebooks verwenden den neuen KMS-Schlüssel. Berücksichtigen Sie diese Punkte, bevor Sie Ihre KMS-Schlüssel oder -Aliase aktualisieren.
1. (Optional) **Weitere Einstellungen** — Erweitern Sie diese Option, um die Option ** CloudWatch Metriken veröffentlichen für die Arbeitsgruppe** zu aktivieren oder zu deaktivieren. Dieses Feld ist standardmäßig ausgewählt. Weitere Informationen finden Sie unter [Apache Spark mit CloudWatch Metriken überwachen](notebooks-spark-metrics.md).
1. (Optional) **Tags** – Verwenden Sie diese Option, um Ihrer Arbeitsgruppe Tags hinzuzufügen. Weitere Informationen finden Sie unter [Athena-Ressourcen markieren](tags.md).
1. Wählen Sie **Create workgroup** (Arbeitsgruppe erstellen) aus. Eine Meldung informiert Sie darüber, dass die Arbeitsgruppe erfolgreich erstellt wurde, und die Arbeitsgruppe wird in der Liste der Arbeitsgruppen angezeigt.
## Schritt 2: Öffnen Sie den Notebook-Explorer und wechseln die Arbeitsgruppen
Bevor Sie die soeben erstellte Spark-fähige Arbeitsgruppe verwenden können, müssen Sie zur Arbeitsgruppe wechseln. Um zwischen Spark-fähigen Arbeitsgruppen zu wechseln, können Sie die Option **Workgroup** (Arbeitsgruppe) im Notebook-Explorer oder Notebook-Editor verwenden.
**Anmerkung**
Vergewissern Sie sich bevor Sie anfangen, dass Ihr Browser Cookies von Drittanbietern nicht blockiert. Jeder Browser, der Cookies von Drittanbietern standardmäßig oder per Benutzereinstellung blockiert, verhindert das Starten von Notebooks. Weitere Informationen zum Verwalten von Cookies finden Sie unter:
[Chrome](https://support.alertlogic.com/hc/en-us/articles/360018127132-Turn-Off-Block-Third-Party-Cookies-in-Chrome-for-Windows)
[Firefox](https://support.mozilla.org/en-US/kb/third-party-cookies-firefox-tracking-protection)
[Safari](https://support.apple.com/guide/safari/manage-cookies-sfri11471/mac)
**So öffnen Sie den Notebook-Explorer und wechseln die Arbeitsgruppen**
1. Wählen Sie im Navigationsbereich **Notebook explorer** (Notebook-Explorer) aus.
1. Verwenden Sie die Option **Workgroup** (Arbeitsgruppe) oben rechts in der Konsole, um die Spark-fähige Arbeitsgruppe auszuwählen, die Sie erstellt haben. Das Beispiel-Notebook wird in der Liste der Notebooks angezeigt.
Sie können den Notebook-Explorer auf folgende Weise verwenden:
+ Wählen Sie den verknüpften Namen eines Notebooks, um das Notebook in einer neuen Sitzung zu öffnen.
+ Verwenden Sie das Menü **Actions** (Aktionen), um Ihr Notebook umzubenennen, zu löschen oder zu exportieren.
+ Um eine Notebook-Datei zu importieren, wählen Sie **Import file** (Datei importieren).
+ Um ein Notebook zu erstellen, wählen Sie **Create notebook** (Notebook erstellen) aus.
## Schritt 3: Führen Sie das Beispiel-Notebook aus
Das Beispiel-Notebook fragt Daten aus einem öffentlich zugänglichen Datensatz für Taxifahrten in New York City ab. Das Notizbuch enthält Beispiele, die zeigen, wie Sie mit Spark DataFrames, Spark SQL und dem AWS Glue Data Catalog arbeiten.
**So führen Sie das Beispiel-Notebook aus**
1. Wählen Sie im Notebook-Explorer den verknüpften Namen des Beispiel-Notebooks aus.
Dadurch wird eine Notebook-Sitzung mit Standardparametern gestartet und das Notebook im Notebook-Editor geöffnet. Eine Meldung informiert Sie darüber, dass eine neue Apache Spark-Sitzung mit den Standardparametern (maximal 20 DPUs) gestartet wurde.
1. Um die Zellen der Reihe nach auszuführen und die Ergebnisse zu überwachen, wählen Sie einmal für jede Zelle des Notebooks die Schaltfläche **Run** (Ausführen) aus.
+ Scrollen Sie nach unten, um die Ergebnisse anzuzeigen und neue Zellen einzublenden.
+ Für die Zellen, die eine Berechnung enthalten, zeigt ein Fortschrittsbalken den abgeschlossenen Prozentsatz, die verstrichene Zeit und die verbleibende Zeit an.
+ Das Beispiel-Notebook erstellt eine Beispieldatenbank und -tabelle in Ihrem Konto. Die letzte Zelle entfernt diese in einem Schritt der Datenbereinigung.
**Anmerkung**
Wenn Sie Ordner-, Tabellen- oder Datenbanknamen im Beispiel-Notebook ändern, stellen Sie sicher, dass diese Änderungen in den von Ihnen verwendeten IAM-Rollen widergespiegelt werden. Andernfalls kann das Notebook aufgrund unzureichender Berechtigungen nicht ausgeführt werden.
## Schritt 4: Bearbeiten Sie Sitzungsdetails
Nachdem Sie eine Notebook-Sitzung gestartet haben, können Sie Sitzungsdetails wie Tabellenformat, Verschlüsselung, Timeout bei Sitzungsinaktivität und die maximale Anzahl von Datenverarbeitungseinheiten (DPUs), die Sie gleichzeitig verwenden möchten, bearbeiten. Eine DPU ist ein relativer Maßstab für die Rechenleistung, der sich aus 4 V CPUs Rechenkapazität und 16 GB Arbeitsspeicher zusammensetzt.
**So bearbeiten Sie Sitzungsdetails**
1. Wählen Sie im Notebook-Editor aus dem Menü **Session** (Sitzung) oben rechts die Option **Edit session** (Sitzung bearbeiten) aus.
1. Wählen Sie im Dialogfeld **Sitzungsdetails bearbeiten** im Abschnitt **Spark-Parameter** Werte für die folgenden Optionen aus oder geben Sie sie ein:
+ **Zusätzliches Tabellenformat** – Wählen Sie **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg** oder **Benutzerdefiniert**.
+ Für die Tabellenoptionen **Delta**, **Hudi** oder **Iceberg** werden Ihnen die erforderlichen Tabelleneigenschaften für das entsprechende Tabellenformat automatisch in den Optionen **In Tabelle bearbeiten** und **In JSON bearbeiten** zur Verfügung gestellt. Weitere Informationen zum Verwenden dieser Tabellenformate finden Sie unter [Nicht-Hive-Tabellenformate in Athena für Spark verwenden](notebooks-spark-table-formats.md).
+ Um Tabelleneigenschaften für die **benutzerdefinierte** oder andere Tabellenarten hinzuzufügen oder zu entfernen, verwenden Sie die Optionen **In Tabelle bearbeiten** und **In JSON bearbeiten**.
+ Wählen Sie für die Option **In Tabelle bearbeiten** die Option **Eigenschaft hinzufügen** aus, um eine Eigenschaft hinzuzufügen, oder wählen Sie **Entfernen**, um eine Eigenschaft zu entfernen. Verwenden Sie die Felder **Schlüssel** und **Wert**, um Eigenschaftsnamen und ihre Werte einzugeben.
+ Verwenden Sie für die Option **In JSON bearbeiten** den JSON-Texteditor, um die Konfiguration direkt zu bearbeiten.
+ Wählen Sie zum Kopieren des JSON-Textes in die Zwischenablage **Kopieren** aus.
+ Wählen Sie **Löschen**, um den gesamten Text aus dem JSON-Editor zu entfernen.
+ Wählen Sie das Einstellungssymbol (Zahnrad), um den Zeilenumbruch zu konfigurieren, oder wählen Sie ein Farbdesign für den JSON-Editor.
+ **Spark-Verschlüsselung aktivieren** – Wählen Sie diese Option, um Daten zu verschlüsseln, die auf die Festplatte geschrieben und über Spark-Netzwerkknoten gesendet werden. Weitere Informationen finden Sie unter [Apache-Spark-Verschlüsselung aktivieren](notebooks-spark-encryption.md).
1. Wählen Sie im Abschnitt **Sitzungsparameter** die Werte für die folgenden Optionen aus oder geben Sie sie ein:
+ **Session idle timeout** (Zeitüberschreitung bei Sitzungsleerlauf) – Wählen Sie einen Wert zwischen 1 und 480 Minuten aus oder geben Sie ihn ein. Die Standardeinstellung ist 20.
+ **Coordinator size** (Größe des Koordinators) – Ein *Koordinator* ist ein spezieller Executor, der die Verarbeitungsarbeit orchestriert und andere Executors in einer Notebook-Sitzung verwaltet. Derzeit ist 1 DPU der Standardwert und der einzig mögliche Wert.
+ **Executor size** (Größe des Executors) – Ein *Executor* ist die kleinste Recheneinheit, die eine Notebook-Sitzung von Athena anfragen kann. Derzeit ist 1 DPU der Standardwert und der einzig mögliche Wert.
+ **Maximaler gleichzeitiger Wert** — Die maximale Anzahl gleichzeitig laufender DPUs Programme. Der Standardwert ist 20, der Mindestwert ist 3 und der Höchstwert ist 60. Wenn Sie diesen Wert erhöhen, werden zusätzliche Ressourcen nicht automatisch zugewiesen. Stattdessen wird Athena versuchen, die Ressourcen bis zum angegebenen Höchstwert zuzuweisen, sofern die Rechenlast dies erfordert und die Ressourcen verfügbar sind.
1. Wählen Sie **Speichern**.
1. Wählen Sie bei der Aufforderung zur **Confirm edit** (Änderung bestätigen) die Option **Confirm** (Bestätigen) aus.
Athena speichert Ihr Notebook und startet eine neue Sitzung mit den von Ihnen angegebenen Parametern. Ein Banner im Notebook-Editor informiert Sie darüber, dass eine neue Sitzung mit den geänderten Parametern gestartet wurde.
**Anmerkung**
Athena merkt sich Ihre Sitzungseinstellungen für dieses Notebook. Wenn Sie die Parameter einer Sitzung bearbeiten und dann die Sitzung beenden, verwendet Athena die Sitzungsparameter, die Sie beim nächsten Start einer Sitzung für das Notebook konfiguriert haben.
## Schritt 5: Zeigen Sie Sitzungs- und Berechnungsdetails an
Nachdem Sie das Notebook ausgeführt haben, können Sie Ihre Sitzungs- und Berechnungsdetails anzeigen.
**So zeigen Sie Sitzungs- und Berechnungsdetails an**
1. Wählen Sie im Menü **Session** (Sitzung) oben rechts die Option **View details** (Details anzeigen) aus.
+ Auf der Registerkarte **Current session** (Aktuelle Sitzung) werden Informationen zur aktuellen Sitzung angezeigt, einschließlich Sitzungs-ID, Erstellungszeit, Status und Arbeitsgruppe.
+ Auf der Registerkarte **Verlauf** werden die Sitzungen früherer Sitzungen IDs aufgeführt. Um die Details einer vorherigen Sitzung anzuzeigen, wählen Sie die Registerkarte **History** (Verlauf) und wählen Sie dann eine Sitzungs-ID aus der Liste aus.
+ Der Abschnitt **Calculations** (Berechnungen) zeigt eine Liste der Berechnungen, die in der Sitzung ausgeführt wurden.
1. Um die Details einer Berechnung anzuzeigen, wählen Sie die Berechnungs-ID aus.
1. Auf der Seite **Calculation details** (Berechnungsdetails) können Sie Folgendes tun:
+ Den Code für die Berechnung finden Sie im Abschnitt **Code**.
+ Um die Ergebnisse der Berechnung anzuzeigen, wählen Sie die Registerkarte **Results** (Ergebnisse).
+ Um die angezeigten Ergebnisse im Textformat herunterzuladen, wählen Sie **Download results** (Ergebnisse herunterladen) aus.
+ Um Informationen zu den Berechnungsergebnissen in Amazon S3 anzuzeigen, wählen Sie **View in S3** (In S3 anzeigen) aus.
## Schritt 6: Beenden der Sitzung
**So beenden Sie die Notebook-Sitzung**
1. Wählen Sie im Notebook-Editor im Menü **Session** (Sitzung) oben rechts die Option **Terminate** (Beenden) aus.
1. Wählen Sie bei der Aufforderung **Confirm session termination** (Beenden der Sitzung bestätigen) die Option **Confirm** (Bestätigen) aus. Ihr Notebook wird gespeichert und Sie kehren zum Notebook-Editor zurück.
**Anmerkung**
Mit dem Schließen der Notebook-Registerkarte im Notebook-Editor wird die Sitzung für ein aktives Notebook nicht automatisch beendet. Wenn Sie sicherstellen möchten, dass die Sitzung beendet wird, verwenden Sie die Optionen **Session** (Sitzung) und **Terminate** (Beenden).
## Schritt 7: Erstellen Sie ein eigenes Notebook
Nachdem Sie eine Spark-fähige Athena-Arbeitsgruppe erstellt haben, können Sie Ihr eigenes Notebook erstellen.
**So erstellen Sie ein Notebook**
1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.
1. Wählen Sie im Navigationsbereich der Athena-Konsole den **Notebook explorer** (Notebook-Explorer) oder den **Notebook editor** (Notebook-Editor) aus.
1. Führen Sie eine der folgenden Aktionen aus:
+ Wählen Sie im **Notebook explorer** (Notebook-Explorer) die Option **Create notebook** (Notebook erstellen) aus.
+ Wählen Sie im **Notebook explorer** (Notebook-Editor) die Option **Create notebook** (Notebook erstellen) oder klicken Sie auf das Plussymbol (**\$1**), um ein Notebook hinzuzufügen.
1. Geben Sie im Dialogfeld **Create notebook** (Notebook erstellen) unter **Notebook name** (Notebook-Name) einen Namen ein.
1. (Optional) Erweitern Sie die **Sitzungsparameter** und wählen Sie dann Werte für die folgenden Optionen aus, oder geben Sie diese ein:
+ **Zusätzliches Tabellenformat** – Wählen Sie **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg** oder **Benutzerdefiniert**.
+ Für die Tabellenoptionen **Delta**, **Hudi** oder **Iceberg** werden Ihnen die erforderlichen Tabelleneigenschaften für das entsprechende Tabellenformat automatisch in den Optionen **In Tabelle bearbeiten** und **In JSON bearbeiten** zur Verfügung gestellt. Weitere Informationen zum Verwenden dieser Tabellenformate finden Sie unter [Nicht-Hive-Tabellenformate in Athena für Spark verwenden](notebooks-spark-table-formats.md).
+ Um Tabelleneigenschaften für die **benutzerdefinierte** oder andere Tabellenarten hinzuzufügen oder zu entfernen, verwenden Sie die Optionen **In Tabelle bearbeiten** und **In JSON bearbeiten**.
+ Wählen Sie für die Option **In Tabelle bearbeiten** die Option **Eigenschaft hinzufügen** aus, um eine Eigenschaft hinzuzufügen, oder wählen Sie **Entfernen**, um eine Eigenschaft zu entfernen. Verwenden Sie die Felder **Schlüssel** und **Wert**, um Eigenschaftsnamen und ihre Werte einzugeben.
+ Verwenden Sie für die Option **In JSON bearbeiten** den JSON-Texteditor, um die Konfiguration direkt zu bearbeiten.
+ Wählen Sie zum Kopieren des JSON-Textes in die Zwischenablage **Kopieren** aus.
+ Wählen Sie **Löschen**, um den gesamten Text aus dem JSON-Editor zu entfernen.
+ Wählen Sie das Einstellungssymbol (Zahnrad), um den Zeilenumbruch zu konfigurieren, oder wählen Sie ein Farbdesign für den JSON-Editor.
+ **Spark-Verschlüsselung aktivieren** – Wählen Sie diese Option, um Daten zu verschlüsseln, die auf die Festplatte geschrieben und über Spark-Netzwerkknoten gesendet werden. Weitere Informationen finden Sie unter [Apache-Spark-Verschlüsselung aktivieren](notebooks-spark-encryption.md).
1. (Optional) Erweitern Sie die **Session parameters** (Sitzungsparameter) und wählen Sie dann Werte für die folgenden Optionen aus, oder geben Sie diese ein:
+ **Session idle timeout** (Zeitüberschreitung bei Sitzungsleerlauf) – wählen Sie einen Wert zwischen 1 und 480 Minuten aus oder geben Sie diesen ein. Die Standardeinstellung ist 20.
+ **Coordinator size** (Größe des Koordinators) – Ein *Koordinator* ist ein spezieller Executor, der die Verarbeitungsarbeit orchestriert und andere Executors in einer Notebook-Sitzung verwaltet. Derzeit ist 1 DPU der Standardwert und der einzig mögliche Wert. Eine DPU (Datenverarbeitungseinheit) ist ein relatives Maß für die Rechenleistung, das aus 4 V CPUs Rechenkapazität und 16 GB Arbeitsspeicher besteht.
+ **Executor size** (Größe des Executors) – Ein *Executor* ist die kleinste Recheneinheit, die eine Notebook-Sitzung von Athena anfragen kann. Derzeit ist 1 DPU der Standardwert und der einzig mögliche Wert.
+ **Maximaler gleichzeitiger Wert** — Die maximale Anzahl gleichzeitig DPUs laufender Geräte. Der Standardwert ist 20 und der Höchstwert ist 60. Wenn Sie diesen Wert erhöhen, werden zusätzliche Ressourcen nicht automatisch zugewiesen. Stattdessen wird Athena versuchen, die Ressourcen bis zum angegebenen Höchstwert zuzuweisen, sofern die Rechenlast dies erfordert und die Ressourcen verfügbar sind.
1. Wählen Sie **Erstellen** aus. Ihr Notebook wird in einer neuen Sitzung im Notebook-Editor geöffnet.
Informationen zur Verwaltung Ihrer Notebook-Dateien finden Sie unter [Notebook-Dateien verwalten](notebooks-spark-managing.md).
# Notebook-Dateien verwalten
**Anmerkung**
Der Athena-Notebook-Editor wird in der Pyspark-Engine-Version 3 unterstützt. [Informationen zur Verwendung von Notebooks mit Apache Spark Version 3.5 finden Sie unter SageMaker Notebooks.](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html)
Sie können den Notebook-Explorer nicht nur zum [Erstellen](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) von Notebooks verwenden, sondern auch zum Öffnen, Umbenennen, Löschen, Exportieren oder Importieren von Notebooks oder zum Anzeigen des Sitzungsverlaufs für ein bestimmtes Notebook.
**Um ein zuvor erstelltes Notizbuch zu öffnen**
1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.
1. Wählen Sie im Navigationsbereich der Athena-Konsole den **Notebook editor** (Notebook-Editor) oder den **Notebook explorer** (Notebook-Explorer) aus.
1. Führen Sie eine der folgenden Aktionen aus:
+ Wählen Sie im **Notebook editor** (Notebook-Editor) ein Notebook aus der Liste **Recent notebooks** (Zuletzt verwendete Notebooks) oder **Saved notebooks** (Gespeicherte Notebooks) aus. Das Notebook öffnet sich in einer neuen Sitzung.
+ Wählen Sie im **Notebook explorer** (Notebook-Explorer) den Namen eines Notebooks aus der Liste aus. Das Notebook öffnet sich in einer neuen Sitzung.
**So benennen Sie ein Notebook um**
1. [Beenden](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) Sie alle aktiven Sitzungen für das Notebook, das Sie umbenennen möchten. Die aktiven Sitzungen des Notebooks müssen beendet werden, bevor Sie das Notebook umbenennen können.
1. Öffnen Sie den **Notebook explorer** (Notebook-Explorer).
1. Wählen Sie in der Liste **Notebooks** das Optionsfeld für das Notebook, das Sie umbenennen möchten.
1. Wählen Sie im Menü **Actions** (Aktionen) die Option **Rename** (Umbenennen).
1. Geben Sie bei der Aufforderung **Rename notebook** (Notebook umbenennen) den neuen Namen ein, und wählen Sie anschließend **Save** (Speichern) aus. Der neue Notebook-Name wird in der Notebook-Liste angezeigt.
**So löschen Sie ein Notebook**
1. [Beenden](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) Sie alle aktiven Sitzungen für das Notebook, das Sie löschen möchten. Die aktiven Sitzungen des Notebooks müssen beendet werden, bevor Sie das Notebook löschen können.
1. Öffnen Sie den **Notebook explorer** (Notebook-Explorer).
1. Wählen Sie in der Liste **Notebooks** das Optionsfeld für das Notebook, das Sie löschen möchten.
1. Wählen Sie im Menü **Actions (Aktionen)** die Option **Delete (Löschen)** aus.
1. Geben Sie bei der Eingabeaufforderung **Delete notebook?** (Notebook löschen?) den Namen des Notebooks ein und wählen Sie dann **Delete** (Löschen), um den Löschvorgang zu bestätigen. Der Name des Notebooks wird aus der Notebook-Liste entfernt.
**So exportieren Sie ein Notebook**
1. Öffnen Sie den **Notebook explorer** (Notebook-Explorer).
1. Wählen Sie in der Liste **Notebooks** das Optionsfeld für das Notebook, das Sie exportieren möchten.
1. Wählen Sie im Menü **Actions** (Aktionen) die Option **Export file** (Datei exportieren).
**So importieren Sie ein Notebook**
1. Öffnen Sie den **Notebook explorer** (Notebook-Explorer).
1. Wählen Sie **Import file** (Datei importieren).
1. Navigieren Sie auf Ihrem lokalen Computer zum Speicherort der Datei, die Sie importieren möchten, und wählen Sie dann **Open** (Öffnen) aus. Das importierte Notebook wird in der Notebook-Liste angezeigt.
**So zeigen Sie den Sitzungsverlauf für ein Notebook an**
1. Öffnen Sie den **Notebook explorer** (Notebook-Explorer).
1. Wählen Sie in der Liste **Notebooks** das Optionsfeld für das Notebook, dessen Sitzungsverlauf Sie anzeigen möchten.
1. Wählen Sie im Menü **Actions** (Aktionen) die Option **Session history** (Sitzungsverlauf) aus.
1. Wählen Sie auf der Registerkarte **History** (Verlauf) eine **Session ID** (Sitzungs-ID) aus, um Informationen über die Sitzung und ihre Berechnungen anzuzeigen.
# Verwenden des Athena-Notebook-Editors
**Anmerkung**
Der Athena-Notebook-Editor wird in der Pyspark-Engine-Version 3 unterstützt. [Informationen zur Verwendung von Notebooks mit Apache Spark Version 3.5 finden Sie unter SageMaker Notebooks.](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html)
Sie verwalten Ihre Notebooks im Athena-Notebook-Explorer und bearbeiten und führen sie in Sitzungen mit dem Athena-Notebook-Editor aus. Sie können die DPU-Nutzung für Ihre Notebook-Sitzungen gemäß Ihren Anforderungen konfigurieren.
Wenn Sie ein Notebook anhalten, beenden Sie die zugehörige Sitzung. Alle Dateien werden gespeichert, aber laufende Änderungen an deklarierten Variablen, Funktionen und Klassen gehen verloren. Wenn Sie das Notebook neu starten, lädt Athena die Notebook-Datei neu und Sie können Ihren Code erneut ausführen.
Der Athena-Notebook-Editor ist eine interaktive Umgebung für das Schreiben und Ausführen von Code. Die folgenden Abschnitte beschreiben die Features der Umgebung.
## Grundlegendes über Notebook-Sitzungen und Berechnungen
Jedes Notebook ist einem einzelnen Python-Kernel zugeordnet und führt Python-Code aus. Ein Notebook kann eine oder mehrere Zellen beinhalten, die Befehle enthalten. Um die Zellen in einem Notebook auszuführen, erstellen Sie zunächst eine Sitzung für das Notebook. In Sitzungen werden die Variablen und der Status der Notebooks nachverfolgt.
Das Ausführen einer Zelle in einem Notebook bedeutet das Ausführen einer Berechnung in der aktuellen Sitzung. Berechnungen verbessern den Status des Notebooks und können Aufgaben wie das Lesen aus Amazon S3 oder das Schreiben in andere Datenspeicher ausführen. Solange eine Sitzung ausgeführt wird, verwenden und ändern Berechnungen den Status, der für das Notebook verwaltet wird.
Wenn Sie den Status nicht mehr benötigen, können Sie eine Sitzung beenden. Wenn Sie eine Sitzung beenden, bleibt das Notebook erhalten, aber die Variablen und andere Statusinformationen werden zerstört. Wenn Sie an mehreren Projekten gleichzeitig arbeiten müssen, können Sie für jedes Projekt eine Sitzung erstellen, und die Sitzungen sind voneinander unabhängig.
Sitzungen verfügen über eine dedizierte Rechenkapazität, gemessen in DPU. Wenn Sie eine Sitzung erstellen, können Sie der Sitzung eine Anzahl von zuweisen DPUs. Unterschiedliche Sitzungen können abhängig von den Anforderungen der Aufgabe unterschiedliche Kapazitäten haben.
## Zwischen Befehlsmodus und Bearbeitungsmodus wechseln
Der Notebook-Editor verfügt über eine modale Benutzeroberfläche: einen Bearbeitungsmodus für die Eingabe von Text in eine Zelle und einen Befehlsmodus für die Ausgabe von Befehlen an den Editor selbst wie Kopieren, Einfügen oder Ausführen.
Um den Bearbeitungsmodus und den Befehlsmodus zu verwenden, können Sie die folgenden Aufgaben ausführen:
+ Um in den Bearbeitungsmodus zu wechseln, drücken Sie **ENTER** oder wählen Sie eine Zelle aus. Wenn sich eine Zelle im Bearbeitungsmodus befindet, hat die Zelle einen grünen linken Rand.
+ Um in den Befehlsmodus zu wechseln, drücken Sie **ESC** oder klicken Sie außerhalb einer Zelle. Beachten Sie, dass Befehle normalerweise nur für die aktuell ausgewählte Zelle gelten, nicht für alle Zellen. Wenn sich der Editor im Befehlsmodus befindet, hat die Zelle einen blauen linken Rand.
+ Im Befehlsmodus können Sie Tastenkombinationen und das Menü über dem Editor verwenden, aber keinen Text in einzelne Zellen eingeben.
+ Um eine Zelle auszuwählen, klicken Sie auf die Zelle.
+ Um alle Zellen auszuwählen, drücken Sie **Ctrl\$1A** (Windows) oder **Cmd\$1A** (Mac).
## Aktionen im Notebook-Editor-Menü verwenden
Die Symbole im oberen Menü des Notebook-Editors bieten die folgenden Optionen:
+ **Speichern** – Speichert den aktuellen Status des Notebooks.
+ **Zelle unterhalb einfügen** – Fügt eine neue (leere) Zelle unterhalb der aktuell ausgewählten ein.
+ **Ausgewählte Zellen ausschneiden** – Entfernt die ausgewählte Zelle von ihrem aktuellen Standort und kopiert die Zelle in den Speicher.
+ **Ausgewählte Zellen kopieren** – Kopiert die ausgewählte Zelle in den Speicher.
+ **Zellen unterhalb einfügen** – Fügt die kopierte Zelle unterhalb der aktuellen Zelle ein.
+ **Ausgewählte Zellen nach oben verschieben** – Verschiebt die aktuelle Zelle über die darüber liegende Zelle.
+ **Ausgewählte Zellen nach unten verschieben** – Verschiebt die aktuelle Zelle unter die darunter liegende Zelle.
+ **Ausführen** – Führt die aktuelle (ausgewählte) Zelle aus. Die Ausgabe wird unmittelbar unter der aktuellen Zelle angezeigt.
+ **Alle ausführen** – Führt alle Zellen im Notebook aus. Die Ausgabe für jede Zelle wird unmittelbar unter der aktuellen Zelle angezeigt.
+ **Stoppen (Kernel unterbrechen)** – Stoppt das aktuelle Notebook durch Unterbrechen des Kernels.
+ **Formatierungsoption** – Wählt das Zellenformat aus, das eines der folgenden sein kann:
+ **Code** – Wird für Python-Code (die Voreinstellung) verwendet.
+ **Markdown — Wird** für die Eingabe von Text im [Markdown-Format im GitHub -Style](https://docs.github.com/en/get-started/writing-on-github) verwendet. Um den Markdown zu rendern, führen Sie die Zelle aus.
+ **Raw NBConvert** — Wird für die Eingabe von Text in unveränderter Form verwendet. Als **Raw** markierte Zellen NBConvert können mit dem Befehlszeilentool Jupyter [nbconvert](https://nbconvert.readthedocs.io/en/latest/usage.html) in ein anderes Format wie HTML konvertiert werden.
+ **Überschrift** – Dient zum Ändern der Überschriftenebene der Zelle.
+ **Befehlspalette** – Enthält Jupyter-Notebook-Befehle und ihre Tastenkombinationen. Weitere Informationen zu den Tastenkombinationen finden Sie in den Abschnitten weiter unten in diesem Dokument.
+ **Sitzung** – Verwenden Sie die Optionen in diesem Menü, um die Details einer Sitzung [anzuzeigen](notebooks-spark-getting-started.md#notebooks-spark-getting-started-viewing-session-and-calculation-details), [Sitzungsparameter zu bearbeiten](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) oder die Sitzung zu [beenden](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session).
## Verwenden Sie Tastenkombinationen im Befehlsmodus für mehr Produktivität
Im Folgenden finden Sie einige gängige Tastenkombinationen für den Befehlsmodus des Notebook-Editors. Diese Tastenkombinationen sind verfügbar, nachdem Sie **ESC** gedrückt haben, um in den Befehlsmodus zu wechseln. Um eine vollständige Liste der im Editor verfügbaren Befehle anzuzeigen, drücken Sie **ESC \$1 H**.
****
| Key (Schlüssel) | Action |
| --- | --- |
| 1 - 6 | Ändern Sie den Zellentyp in Markdown und stellen Sie die Überschriftsebene auf die eingegebene Zahl ein |
| a | Erstellt eine Zelle über der aktuellen Zelle |
| b | Erstellt eine Zelle unter der aktuellen Zelle |
| c | Kopiert die aktuelle Zelle in den Speicher |
| d d | Löscht die aktuelle Zelle |
| h | Zeigt den Hilfebildschirm für Tastaturkürzel an |
| j | Eine Zelle nach unten |
| k | Eine Zelle nach oben |
| m | Ändert das aktuelle Zellenformat zu Markdown |
| r | Ändert das aktuelle Zellenformat zu Raw |
| s | Speichert das Notebook |
| v | Fügt Speicherinhalte unter die aktuelle Zelle ein |
| x | Schneidet die ausgewählte(n) Zelle oder Zellen aus |
| y | Ändert das Zellenformat zu Code |
| z | Rückgängig |
| Ctrl\$1Enter | Führt die aktuelle Zelle aus und ruft den Befehlsmodus auf |
| Shift\$1Enter oder Alt\$1Enter | Führt die aktuelle Zelle aus, erstellt eine neue Zelle unterhalb der Ausgabe und ruft die neue Zelle im Bearbeitungsmodus auf |
| Space | Seite nach unten |
| Shift\$1Space | Seite nach oben |
| Shift \$1 L | Schaltet die Sichtbarkeit von Zeilennummern in Zellen ein oder aus |
## Tastenkürzeln im Befehlsmodus anpassen
Der Notebook-Editor verfügt über eine Option zum Anpassen der Tastenkombinationen für den Befehlsmodus.
**So bearbeiten Sie Tastenkombinationen im Befehlsmodus**
1. Wählen Sie im Menü des Notebook-Editors die **Command palette** (Befehlspalette) aus.
1. Wählen Sie in der Befehlspalette den Befehl **Edit command mode keyboard shortcuts** (Tastenkombinationen für den Befehlsmodus bearbeiten) aus.
1. Verwenden Sie die Schnittstelle **Edit command mode shortcuts** (Befehlsmodus-Kurzbefehle bearbeiten), um der Tastatur Befehle zuzuordnen oder neu zuzuordnen.
Um Anweisungen zum Bearbeiten von Tastenkombinationen für den Befehlsmodus anzuzeigen, scrollen Sie zum unteren Rand des Bildschirms **Edit command mode shortcuts** (Tastenkombinationen für den Befehlsmodus bearbeiten).
Hinweise zur Verwendung von Magic-Befehlen in Athena für Apache Spark finden Sie unter [Magics-Befehle verwenden](notebooks-spark-magics.md).
**Topics**
+ [Grundlegendes über Notebook-Sitzungen und Berechnungen](#notebooks-spark-sessions-and-calculations)
+ [Zwischen Befehlsmodus und Bearbeitungsmodus wechseln](#notebooks-spark-command-mode-vs-edit-mode)
+ [Aktionen im Notebook-Editor-Menü verwenden](#notebooks-spark-notebook-editor-menu)
+ [Verwenden Sie Tastenkombinationen im Befehlsmodus für mehr Produktivität](#notebooks-spark-command-mode-keyboard-shortcuts)
+ [Tastenkürzeln im Befehlsmodus anpassen](#notebooks-spark-editing-command-mode-shortcuts)
+ [Magics-Befehle verwenden](notebooks-spark-magics.md)
# Magics-Befehle verwenden
Magische Befehle oder Magics sind spezielle Befehle, die Sie in einer Notebook-Zelle ausführen können. Beispielsweise zeigt `%env` die Umgebungsvariablen in einer Notebook-Sitzung an. Athena unterstützt die magischen Funktionen in IPython 6.0.3.
Dieser Abschnitt zeigt einige wichtige Magics-Befehle in Athena für Apache Spark.
+ Um eine Liste von Magics-Befehlen in Athena anzuzeigen, führen Sie den Befehl **%lsmagic** in einer Notebook-Zelle aus.
+ Informationen zur Verwendung von Magics zur Erstellung von Diagrammen in Athena-Notebooks finden Sie unter [Verwenden Sie Magics, um Datendiagramme zu erstellen](notebooks-spark-magics-graphs.md).
+ Informationen zu zusätzlichen magischen Befehlen finden Sie in der [Dokumentation unter Integrierte magische Befehle](https://ipython.readthedocs.io/en/stable/interactive/magics.html). IPython
**Anmerkung**
Derzeit schlägt der `%pip`-Befehl bei der Ausführung fehl. Dies ist ein bekanntes Problem.
**Topics**
+ [Zellen-Magics](notebooks-spark-magics-cell-magics.md)
+ [Linien-Magics](notebooks-spark-magics-line-magics.md)
+ [Diagramm-Magics](notebooks-spark-magics-graphs.md)
# Zellen-Magics verwenden
Magics, die sich über mehrere Zeilen verteilen, wird ein doppeltes Prozentzeichen (`%%`) vorangestellt und sie werden als Zellen-Magic-Funktionen oder Zellen-Magics bezeichnet.
## %%sql
Diese Zellen-Magics ermöglicht es, SQL-Anweisungen direkt auszuführen, ohne sie mit einer Spark-SQL-Anweisung verzieren zu müssen. Der Befehl zeigt auch die Ausgabe an, indem er implizit den zurückgegebenen Datenrahmen `.show()` aufruft.
![\[Verwenden von %%sql\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-1.png)
Der `%%sql`-Befehl kürzt Spaltenausgaben automatisch auf eine Breite von 20 Zeichen. Diese Einstellung ist derzeit nicht konfigurierbar. Um diese Einschränkung zu umgehen, verwenden Sie die folgende vollständige Syntax und ändern Sie die Parameter der `show`-Methode entsprechend.
```
spark.sql("""YOUR_SQL""").show(n=number, truncate=number, vertical=bool)
```
+ **n** `int`, optional. Die Anzahl der anzuzeigenden Zeilen.
+ **kürzt** – `bool` oder `int`, optional – wenn `true`, kürzt Zeichenketten, die länger als 20 Zeichen sind. Wenn dieser Wert auf eine Zahl größer als 1 gesetzt ist, werden lange Zeichenketten auf die angegebene Länge gekürzt und die Zellen werden rechtsbündig ausgerichtet.
+ **vertikal** – `bool`, optional. Wenn `true`, werden die Ausgabezeilen vertikal ausgedruckt (eine Zeile pro Spaltenwert).
# Zeilen-Magics verwenden
Magics, die sich auf einer einzelnen Zeile befinden, wird ein Prozentzeichen (`%`) vorangestellt und sie werden als Zeilen-Magic-Funktionen oder Zeilen-Magics bezeichnet.
## %help
Zeigt Beschreibungen der verfügbaren Magic-Befehle an.
![\[Verwenden von %help\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-2.png)
## %list\$1sessions
Listet die mit dem Noebook verknüpften Sitzungen auf. Zu den Informationen für jede Sitzung gehören die Sitzungs-ID, der Sitzungsstatus sowie Datum und Uhrzeit des Beginns und Endes der Sitzung.
![\[Verwenden von %list_sessions\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-3.png)
## %session\$1id
Ruft die aktuelle Sitzungs-ID ab.
![\[Verwenden von session_id\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-4.png)
## %set\$1log\$1level
Setzt den Logger auf die angegebene Protokollstufe oder setzt ihn zurück. Die möglichen Werte sind `DEBUG`, `ERROR`, `FATAL`, `INFO` und `WARN` oder `WARNING`. Werte müssen in Großbuchstaben geschrieben sein und dürfen nicht in einfache oder doppelte Anführungszeichen eingeschlossen sein.
![\[Verwenden von %set_log_level\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-5.png)
## %status
Beschreibt die aktuelle Sitzung. Die Ausgabe umfasst die Sitzungs-ID, den Sitzungsstatus, den Arbeitsgruppennamen, die PySpark Engine-Version und die Startzeit der Sitzung. Dieser Magic-Befehl erfordert eine aktive Sitzung, um Sitzungsdetails abzurufen.
Folgende Werte sind für Status möglich:
**ERSTELLEN** – Die Sitzung wird gestartet, einschließlich des Erwerbs von Ressourcen.
**ERSTELLT** – Die Sitzung wurde gestartet.
**UNTÄTIG** – Die Sitzung kann eine Berechnung akzeptieren.
**BESCHÄFTIGT** – Die Sitzung verarbeitet gerade eine andere Aufgabe und kann keine Berechnung akzeptieren.
**BEENDE** – Der Service wird gerade heruntergefahren.
**BEENDET** – Die Sitzung und ihre Ressourcen werden nicht mehr ausgeführt.
**HERABGESTUFT** – Die Sitzung hat keine funktionierenden Koordinatoren.
**FEHLGESCHLAGEN** – Aufgrund eines Fehlers werden die Sitzung und ihre Ressourcen nicht mehr ausgeführt.
![\[Verwenden von %status\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-6.png)
# Verwenden Sie Magics, um Datendiagramme zu erstellen
Die Linien-Magics in diesem Abschnitt spezialisieren sich auf das Rendern von Daten für bestimmte Datentypen oder in Verbindung mit Grafikbibliotheken.
## %table
Sie können den `%table`-Magics-Befehl verwenden, um Dataframe-Daten im Tabellenformat anzuzeigen.
Im folgenden Beispiel wird ein Datenrahmen mit zwei Spalten und drei Datenzeilen erstellt und die Daten anschließend im Tabellenformat angezeigt.
![\[Mit dem Magics-Befehl %table.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-graphs-1.png)
## %matplot
[Matplotlib](https://matplotlib.org/) ist eine umfassende Bibliothek zur Erstellung statischer, animierter und interaktiver Visualisierungen in Python. Sie können den `%matplot`-Magics-Befehl verwenden, um ein Diagramm zu erstellen, nachdem Sie die Matplotlib-Bibliothek in eine Notebook-Zelle importiert haben.
Das folgende Beispiel importiert die Matplotlib-Bibliothek, erstellt einen Satz von X- und Y-Koordinaten und verwendet dann den Befehl use `%matplot` magic, um ein Diagramm der Punkte zu erstellen.
```
import matplotlib.pyplot as plt
x=[3,4,5,6,7,8,9,10,11,12]
y= [9,16,25,36,49,64,81,100,121,144]
plt.plot(x,y)
%matplot plt
```
![\[Den Befehl %matplot-Magics-Befehl verwenden.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-graphs-2.png)
### Die Bibliotheken matplotlib und seaborn zusammen verwenden
[Seaborn](https://seaborn.pydata.org/tutorial/introduction) ist eine Bibliothek zur Erstellung statistischer Grafiken in Python. Es baut auf Matplotlib auf und ist eng in die Datenstrukturen von [Pandas](https://pandas.pydata.org/) (Python-Datenanalyse) integriert. Sie können auch den `%matplot`-Magics-Befehl verwenden, um Seaborn-Daten zu rendern.
Das folgende Beispiel verwendet sowohl die Bibliotheken matplotlib als auch seaborn, um ein einfaches Balkendiagramm zu erstellen.
```
import matplotlib.pyplot as plt
import seaborn as sns
x = ['A', 'B', 'C']
y = [1, 5, 3]
sns.barplot(x, y)
%matplot plt
```
![\[Verwendung von %matplot zum Rendern von Seaborn-Daten.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-graphs-3.png)
## %plotly
[Plotly](https://plotly.com/python/) ist eine Open-Source-Grafikbibliothek für Python, mit der Sie interaktive Grafiken erstellen können. Sie können auch den `%ploty`-Magics-Befehl verwenden, um Plotly-Daten zu rendern.
Im folgenden Beispiel werden die Bibliotheken [StringIO](https://docs.python.org/3.13/library/io.html#io.StringIO), Plotly und Pandas für Aktienkursdaten verwendet, um ein Diagramm der Aktienaktivitäten im Februar und März 2015 zu erstellen.
```
from io import StringIO
csvString = """
Date,AAPL.Open,AAPL.High,AAPL.Low,AAPL.Close,AAPL.Volume,AAPL.Adjusted,dn,mavg,up,direction
2015-02-17,127.489998,128.880005,126.919998,127.830002,63152400,122.905254,106.7410523,117.9276669,129.1142814,Increasing
2015-02-18,127.629997,128.779999,127.449997,128.720001,44891700,123.760965,107.842423,118.9403335,130.0382439,Increasing
2015-02-19,128.479996,129.029999,128.330002,128.449997,37362400,123.501363,108.8942449,119.8891668,130.8840887,Decreasing
2015-02-20,128.619995,129.5,128.050003,129.5,48948400,124.510914,109.7854494,120.7635001,131.7415509,Increasing
2015-02-23,130.020004,133,129.660004,133,70974100,127.876074,110.3725162,121.7201668,133.0678174,Increasing
2015-02-24,132.940002,133.600006,131.169998,132.169998,69228100,127.078049,111.0948689,122.6648335,134.2347981,Decreasing
2015-02-25,131.559998,131.600006,128.149994,128.789993,74711700,123.828261,113.2119183,123.6296667,134.0474151,Decreasing
2015-02-26,128.789993,130.869995,126.610001,130.419998,91287500,125.395469,114.1652991,124.2823333,134.3993674,Increasing
2015-02-27,130,130.570007,128.240005,128.460007,62014800,123.510987,114.9668484,124.8426669,134.7184854,Decreasing
2015-03-02,129.25,130.279999,128.300003,129.089996,48096700,124.116706,115.8770904,125.4036668,134.9302432,Decreasing
2015-03-03,128.960007,129.520004,128.089996,129.360001,37816300,124.376308,116.9535132,125.9551669,134.9568205,Increasing
2015-03-04,129.100006,129.559998,128.320007,128.539993,31666300,123.587892,118.0874253,126.4730002,134.8585751,Decreasing
2015-03-05,128.580002,128.75,125.760002,126.410004,56517100,121.539962,119.1048311,126.848667,134.5925029,Decreasing
2015-03-06,128.399994,129.369995,126.260002,126.599998,72842100,121.722637,120.190797,127.2288335,134.26687,Decreasing
2015-03-09,127.959999,129.570007,125.059998,127.139999,88528500,122.241834,121.6289771,127.631167,133.6333568,Decreasing
2015-03-10,126.410004,127.220001,123.800003,124.510002,68856600,119.71316,123.1164763,127.9235004,132.7305246,Decreasing
"""
csvStringIO = StringIO(csvString)
from io import StringIO
import plotly.graph_objects as go
import pandas as pd
from datetime import datetime
df = pd.read_csv(csvStringIO)
fig = go.Figure(data=[go.Candlestick(x=df['Date'],
open=df['AAPL.Open'],
high=df['AAPL.High'],
low=df['AAPL.Low'],
close=df['AAPL.Close'])])
%plotly fig
```
![\[Den %ploty-Magics-Befehl verwenden.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-magics-graphs-4.png)
# Nicht-Hive-Tabellenformate in Athena für Spark verwenden
**Anmerkung**
Diese Seite bezieht sich auf die Verwendung von Python-Bibliotheken in der Release-Version Pyspark Engine Version 3. Informationen zu den unterstützten Versionen im Open-Table-Format finden Sie in [Amazon EMR 7.12](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html).
Wenn Sie in Athena für Spark mit Sessions und Notebooks arbeiten, können Sie neben Apache-Hive-Tabellen auch Linux-Foundation-Delta-Lake-, Apache-Hudi- und Apache-Iceberg-Tabellen verwenden.
## Überlegungen und Einschränkungen
Wenn Sie andere Tabellenformate als Apache Hive mit Athena für Spark verwenden, sollten Sie die folgenden Punkte berücksichtigen:
+ Zusätzlich zu Apache Hive wird nur ein Tabellenformat pro Notebook unterstützt. Um mehrere Tabellenformate in Athena für Spark zu verwenden, erstellen Sie für jedes Tabellenformat ein separates Notizbuch. Informationen zum Erstellen von Notebooks in Athena für Spark finden Sie unter [Schritt 7: Erstellen Sie ein eigenes Notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
+ Die Tabellenformate Delta Lake, Hudi und Iceberg wurden auf Athena for Spark getestet, indem sie AWS Glue als Metastore verwendet wurden. Möglicherweise können Sie andere Metastores verwenden, aber eine solche Verwendung wird derzeit nicht unterstützt.
+ Um die zusätzlichen Tabellenformate zu verwenden, überschreiben Sie die `spark_catalog`-Standardeigenschaft, wie in der Athena-Konsole und in dieser Dokumentation angegeben. Diese Nicht-Hive-Kataloge können zusätzlich zu ihren eigenen Tabellenformaten Hive-Tabellen lesen.
## Tabellenversionen
Die folgende Tabelle zeigt die unterstützten Nicht-Hive-Tabellenversionen in Amazon Athena für Apache Spark.
****
| Tabellenformat | Unterstützte Version |
| --- | --- |
| Apache Iceberg | 1.2.1 |
| Apache Hudi | 0.13 |
| Linux Foundation Delta Lake | 2.0.2 |
In Athena für Spark werden diese `.jar`-Dateien im Tabellenformat und ihre Abhängigkeiten in den Klassenpfad für Spark-Treiber und -Ausführern geladen.
Einen *AWS -Big-Data-Blog*-Beitrag, der zeigt, wie Sie mit den Tabellenformaten Iceberg, Hudi und Delta Lake mithilfe von Spark SQL in Amazon Athena-Notebooks arbeiten, finden Sie unter [Verwenden von Amazon Athena mit Spark SQL für Ihre Open-Source-Transaktionstabellenformate](https://aws.amazon.com/blogs/big-data/use-amazon-athena-with-spark-sql-for-your-open-source-transactional-table-formats/).
**Topics**
+ [Überlegungen und Einschränkungen](#notebooks-spark-table-formats-considerations-and-limitations)
+ [Tabellenversionen](#notebooks-spark-table-formats-versions)
+ [Iceberg](notebooks-spark-table-formats-apache-iceberg.md)
+ [Hudi](notebooks-spark-table-formats-apache-hudi.md)
+ [Delta Lake](notebooks-spark-table-formats-linux-foundation-delta-lake.md)
# Apache-Iceberg-Tabellen in Athena für Spark verwenden
[Apache Iceberg](https://iceberg.apache.org/) ist ein offenes Tabellenformat für große Datensätze in Amazon Simple Storage Service (Amazon S3). Es bietet Ihnen schnelle Abfrageleistung bei großen Tabellen, atomare Commits, gleichzeitige Schreibvorgänge und eine SQL-kompatible Tabellenentwicklung.
Um Apache-Iceberg-Tabellen in Athena für Spark zu verwenden, konfigurieren Sie die folgenden Spark-Eigenschaften. Diese Eigenschaften werden standardmäßig in der Athena für Spark-Konsole für Sie konfiguriert, wenn Sie Apache-Iceberg als Tabellenformat wählen. Die Schritte finden Sie in [Schritt 4: Bearbeiten Sie Sitzungsdetails](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) oder [Schritt 7: Erstellen Sie ein eigenes Notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
```
"spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog",
"spark.sql.catalog.spark_catalog.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.sql.catalog.spark_catalog.io-impl": "org.apache.iceberg.aws.s3.S3FileIO",
"spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
```
Das folgende Verfahren zeigt Ihnen, wie Sie eine Apache-Iceberg-Tabelle in einem Notebook von Athena für Spark verwenden. Führen Sie jeden Schritt in einer neuen Zelle im Notebook aus.
**Wie Sie Apache-Iceberg-Tabellen in Amazon Athena für Apache Spark verwenden**
1. Definieren Sie die Konstanten, die im Notebook verwendet werden sollen.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Erstellen Sie einen Apache Spark [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html).
```
columns = ["language","users_count"]
data = [("Golang", 3000)]
df = spark.createDataFrame(data, columns)
```
1. Erstellen Sie eine Datenbank.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Erstellen Sie eine leere Apache-Iceberg-Tabelle.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING ICEBERG
""".format(DB_NAME, TABLE_NAME))
```
1. Fügt eine Datenzeile in die Tabelle ein.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME))
```
1. Vergewissern Sie sich, dass Sie die neue Tabelle abfragen können.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
Weitere Informationen und Beispiele zur Arbeit mit Spark- DataFrames und Iceberg-Tabellen finden Sie unter [Spark-Abfragen](https://iceberg.apache.org/docs/latest/spark-queries/) in der Apache Iceberg-Dokumentation.
# Apache-Hudi-Tabellen in Athena für Spark verwenden
[https://hudi.apache.org/](https://hudi.apache.org/) ist ein Open-Source-Datenmanagement-Framework, das die inkrementelle Datenverarbeitung vereinfacht. Aktionen zum Einfügen, Aktualisieren, Upsert und Löschen auf Datensatzebene werden mit höherer Präzision verarbeitet, wodurch der Overhead reduziert wird.
Um Apache-Hudi-Tabellen in Athena für Spark zu verwenden, konfigurieren Sie die folgenden Spark-Eigenschaften. Diese Eigenschaften werden standardmäßig in der Athena für Spark-Konsole für Sie konfiguriert, wenn Sie Apache-Hudi als Tabellenformat wählen. Die Schritte finden Sie in [Schritt 4: Bearbeiten Sie Sitzungsdetails](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) oder [Schritt 7: Erstellen Sie ein eigenes Notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
```
"spark.sql.catalog.spark_catalog": "org.apache.spark.sql.hudi.catalog.HoodieCatalog",
"spark.serializer": "org.apache.spark.serializer.KryoSerializer",
"spark.sql.extensions": "org.apache.spark.sql.hudi.HoodieSparkSessionExtension"
```
Das folgende Verfahren zeigt Ihnen, wie Sie eine Apache-Hudi-Tabelle in einem Athena für Spark-Notebook verwenden. Führen Sie jeden Schritt in einer neuen Zelle im Notebook aus.
**Wie Sie Apache-Hudi-Tabellen in Amazon Athena für Apache Spark verwenden**
1. Definieren Sie die Konstanten, die im Notebook verwendet werden sollen.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Erstellen Sie einen Apache Spark. [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html)
```
columns = ["language","users_count"]
data = [("Golang", 3000)]
df = spark.createDataFrame(data, columns)
```
1. Erstellen Sie eine Datenbank.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Erstellen Sie eine leere Apache-Hudi-Tabelle.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING HUDI
TBLPROPERTIES (
primaryKey = 'language',
type = 'mor'
);
""".format(DB_NAME, TABLE_NAME))
```
1. Fügt eine Datenzeile in die Tabelle ein.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME,TABLE_NAME))
```
1. Vergewissern Sie sich, dass Sie die neue Tabelle abfragen können.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
# Delta Lake-Tabellen von Linux Foundation in Athena für Spark verwenden
[Linux Foundation Delta Lake](https://delta.io/) ist ein Tabellenformat für Big-Data-Analytik. Sie können Athena für Spark verwenden, um in Amazon S3 gespeicherte Delta-Lake-Tabellen direkt zu lesen.
Um Apache-Delta-Lake-Tabellen in Athena für Spark zu verwenden, konfigurieren Sie die folgenden Spark-Eigenschaften. Diese Eigenschaften werden standardmäßig in der Athena für Spark-Konsole für Sie konfiguriert, wenn Sie Delta Lake als Tabellenformat wählen. Die Schritte finden Sie in [Schritt 4: Bearbeiten Sie Sitzungsdetails](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) oder [Schritt 7: Erstellen Sie ein eigenes Notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
```
"spark.sql.catalog.spark_catalog" : "org.apache.spark.sql.delta.catalog.DeltaCatalog",
"spark.sql.extensions" : "io.delta.sql.DeltaSparkSessionExtension"
```
Das folgende Verfahren zeigt Ihnen, wie Sie eine Delta-Lake-Tabelle in einem Athena für Spark-Notebook verwenden. Führen Sie jeden Schritt in einer neuen Zelle im Notebook aus.
**Wie Sie eine Delta-Lake-Tabelle in Athena für Spark verwenden**
1. Definieren Sie die Konstanten, die im Notebook verwendet werden sollen.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Erstellen Sie einen Apache Spark [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html).
```
columns = ["language","users_count"]
data = [("Golang", 3000)]
df = spark.createDataFrame(data, columns)
```
1. Erstellen Sie eine Datenbank.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Erstellen Sie eine leere Delta-Lake-Tabelle.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING DELTA
""".format(DB_NAME, TABLE_NAME))
```
1. Fügt eine Datenzeile in die Tabelle ein.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME))
```
1. Vergewissern Sie sich, dass Sie die neue Tabelle abfragen können.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
# Python-Bibliotheken in Athena für Spark verwenden
**Anmerkung**
Diese Seite bezieht sich auf die Verwendung von Python-Bibliotheken in der Release-Version Pyspark Engine Version 3. Die Release-Version Apache Spark Version 3.5 basiert auf [Amazon EMR 7.12](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html). Informationen zu den in dieser Version enthaltenen Bibliotheken finden Sie in EMR 7.12.
Auf dieser Seite werden die verwendete Terminologie und das befolgte Lebenszyklusmanagement für die Laufzeiten, Bibliotheken und Pakete beschrieben, die in Amazon Athena für Apache Spark verwendet werden.
## Definitionen
+ **Amazon Athena for Apache Spark** (Amazon Athena für Apache Spark) ist eine benutzerdefinierte Version von Open Source Apache Spark. Um die aktuelle Version zu sehen, führen Sie den Befehl `print(f'{spark.version}')` in einer Notebookzelle aus.
+ Die **Athena runtime** (Athena-Laufzeit) ist die Umgebung, in der Ihr Code ausgeführt wird. Die Umgebung umfasst einen Python-Interpreter und PySpark Bibliotheken.
+ Eine **external library or package** (externe Bibliothek oder ein Paket) ist eine Java- oder Scala-JAR- oder Python-Bibliothek, die nicht Teil der Athena-Laufzeit ist, aber in Athena-für-Spark-Aufträge enthalten sein kann. Externe Pakete können von Amazon oder von Ihnen erstellt werden.
+ Ein **convenience package** (Convenience-Paket) ist eine Sammlung externer Pakete, die von Athena ausgewählt wurden und die Sie in Ihre Spark-Anwendungen aufnehmen können.
+ Ein **bundle** (Bundle) kombiniert die Athena-Laufzeit und ein Convenience-Paket.
+ Eine **user library** (Benutzerbibliothek) ist eine externe Bibliothek oder ein externes Paket, das Sie Ihrem Athena-für-Spark-Auftrag explizit hinzufügen.
+ Eine Benutzerbibliothek ist ein externes Paket, das nicht Teil eines Convenience-Pakets ist. Eine Benutzerbibliothek muss geladen und installiert werden. Wenn Sie beispielsweise einige `.py`-Dateien schreiben, komprimieren Sie sie und fügen Sie die `.zip`-Datei dann zu Ihrer Anwendung hinzu.
+ Eine **Athena for Spark application** (Athena-für-Spark-Anwendung) ist ein Auftrag oder eine Abfrage, die Sie an Athena für Spark senden.
## Lebenszyklusmanagement
In den folgenden Abschnitten werden die Richtlinien bezüglich Versionsverwaltung und Verfall für die Laufzeit- und Convenience-Pakete beschrieben, die in Athena für Spark verwendet werden.
### Versionsverwaltung und Veraltung zur Laufzeit
Die Hauptkomponente in der Athena-Laufzeit ist der Python-Interpreter. Da Python eine sich entwickelnde Sprache ist, werden regelmäßig neue Versionen veröffentlicht und die Unterstützung für ältere Versionen entfernt. Athena rät davon ab, Programme mit veralteten Versionen des Python-Interpreters auszuführen, und empfiehlt dringend, nach Möglichkeit die neueste Athena-Laufzeitumgebung zu verwenden.
Der Zeitplan für die Veraltung der Athena-Laufzeit sieht wie folgt aus:
1. Nachdem Athena eine neue Laufzeit bereitgestellt hat, unterstützt Athena die vorherige Laufzeit weiterhin für 6 Monate. Während dieser Zeit wendet Athena Sicherheitspatches und Updates auf die vorherige Laufzeit an.
1. Nach 6 Monaten beendet Athena die Unterstützung für die vorherige Laufzeit. Athena wendet keine Sicherheitspatches und andere Updates mehr auf die vorherige Laufzeit an. Spark-Anwendungen, die die vorherige Laufzeit verwenden, haben keinen Anspruch mehr auf technischen Support.
1. Nach 12 Monaten können Sie Spark-Anwendungen in einer Arbeitsgruppe, die die vorherige Laufzeit verwendet, nicht mehr aktualisieren oder bearbeiten. Wir empfehlen Ihnen, Ihre Spark-Anwendungen vor Ablauf dieses Zeitraums zu aktualisieren. Nach Ablauf des Zeitraums können Sie vorhandene Notebooks weiterhin ausführen, aber alle Notebooks, die noch die vorherige Laufzeit verwenden, protokollieren eine entsprechende Warnung.
1. Nach 18 Monaten können Sie in der Arbeitsgruppe keine Aufträge mehr mit der vorherigen Laufzeit ausführen.
### Versionsverwaltung und Veraltung von Convenience-Paketen
Der Inhalt von Convenience-Paketen ändert sich im Laufe der Zeit. Athena fügt diese Convenience-Pakete gelegentlich hinzu, entfernt oder aktualisiert sie.
Athena verwendet die folgenden Richtlinien für Convenience-Pakete:
+ Convenience-Pakete verfügen über ein einfaches Versionsverwaltungsschema wie 1, 2, 3.
+ Jede Version des Convenience-Pakets enthält spezifische Versionen externer Pakete. Nachdem Athena ein Convenience-Paket erstellt hat, ändern sich die externen Pakete des Convenience-Pakets und ihre entsprechenden Versionen nicht.
+ Athena erstellt eine neue Convenience-Paketversion, wenn es ein neues externes Paket enthält, ein externes Paket entfernt oder die Version eines oder mehrerer externer Pakete aktualisiert.
Athena markiert ein Convenience-Paket als veraltet, wenn es die vom Paket verwendete Athena-Laufzeit als veraltet markiert. Athena kann Pakete früher als veraltet markieren, um die Anzahl der unterstützten Bundles zu begrenzen.
Der Zeitplan für die Verwerfung von Convenience-Paketen folgt dem Zeitplan für die Verwerfung der Athena-Laufzeit.
# Liste der vorinstallierten Python-Bibliotheken
Zu den vorinstallierten Python-Bibliotheken gehören die folgenden.
```
boto3==1.24.31
botocore==1.27.31
certifi==2022.6.15
charset-normalizer==2.1.0
cycler==0.11.0
cython==0.29.30
docutils==0.19
fonttools==4.34.4
idna==3.3
jmespath==1.0.1
joblib==1.1.0
kiwisolver==1.4.4
matplotlib==3.5.2
mpmath==1.2.1
numpy==1.23.1
packaging==21.3
pandas==1.4.3
patsy==0.5.2
pillow==9.2.0
plotly==5.9.0
pmdarima==1.8.5
pyathena==2.9.6
pyparsing==3.0.9
python-dateutil==2.8.2
pytz==2022.1
requests==2.28.1
s3transfer==0.6.0
scikit-learn==1.1.1
scipy==1.8.1
seaborn==0.11.2
six==1.16.0
statsmodels==0.13.2
sympy==1.10.1
tenacity==8.0.1
threadpoolctl==3.1.0
urllib3==1.26.10
pyarrow==9.0.0
```
## Hinweise
+ MLlib (Apache Spark-Bibliothek für maschinelles Lernen) und das `pyspark.ml` Paket werden nicht unterstützt.
+ `pip install` wird derzeit in Athena für Spark-Sitzungen nicht unterstützt.
Weitere Informationen zum Importieren von Python-Bibliotheken in Amazon Athena für Apache Spark finden Sie unter [Dateien und Python-Bibliotheken in Amazon Athena für Spark importieren](notebooks-import-files-libraries.md).
# Dateien und Python-Bibliotheken in Amazon Athena für Spark importieren
Dieses Dokument enthält Beispiele für den Import von Dateien und Python-Bibliotheken in Amazon Athena für Apache Spark.
## Überlegungen und Einschränkungen
+ **Python-Version** – Derzeit verwendet Athena für Spark die Python-Version 3.9.16. Beachten Sie, dass Python-Pakete empfindlich auf Python-Nebenversionen reagieren.
+ **Athena for Spark-Architektur** — Athena for Spark verwendet Amazon Linux 2 für die Architektur. ARM64 Beachten Sie, dass einige Python-Bibliotheken keine Binärdateien für diese Architektur verteilen.
+ **Binäre gemeinsame Objekte (SOs)** — Da die SparkContext [addPyFile](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.addPyFile.html)Methode keine binären gemeinsamen Objekte erkennt, kann sie in Athena for Spark nicht verwendet werden, um Python-Pakete hinzuzufügen, die von gemeinsamen Objekten abhängen.
+ **Resilient Distributed Datasets (RDDs)** — [RDDs](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.RDD.html)werden nicht unterstützt.
+ **DataFrame.forEach — Die PySpark DataFrame .foreach-Methode** [wird nicht unterstützt.](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.foreach.html)
## Beispiele
In den Beispielen werden die folgenden Konventionen verwendet.
+ Der Platzhalter Amazon-S3-Speicherort `s3://amzn-s3-demo-bucket`. Ersetzen Sie dies durch Ihren eigenen S3-Bucket-Speicherort.
+ Alle Codeblöcke, die von einer Unix-Shell aus ausgeführt werden, werden als angezeigt. *directory\$1name* `$` Beispielsweise werden der Befehl `ls` im Verzeichnis `/tmp` und seine Ausgabe wie folgt angezeigt:
```
/tmp $ ls
```
**Ausgabe**
```
file1 file2
```
## Importieren von Textdateien zur Verwendung in Berechnungen
Die Beispiele in diesem Abschnitt veranschaulichen, wie Sie Textarchive für Berechnungen in Ihren Notebooks in Athena für Spark importieren.
### Hinzufügen einer Datei zu einem Notebook nachdem Sie sie in das lokale temporäre Verzeichnis schreiben
Das folgende Beispiel zeigt, wie eine Datei in ein lokales temporäres Verzeichnis geschrieben, einem Notebook hinzugefügt und getestet wird.
```
import os
from pyspark import SparkFiles
tempdir = '/tmp/'
path = os.path.join(tempdir, "test.txt")
with open(path, "w") as testFile:
_ = testFile.write("5")
sc.addFile(path)
def func(iterator):
with open(SparkFiles.get("test.txt")) as testFile:
fileVal = int(testFile.readline())
return [x * fileVal for x in iterator]
#Test the file
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show()
```
**Ausgabe**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
### Importieren einer Datei aus Amazon S3
Das folgende Beispiel zeigt, wie Sie eine Datei aus Amazon S3 in ein Notebook importieren und testen.
**Importieren einer Datei aus Amazon S3 in ein Notebook**
1. Erstellen Sie eine Datei mit dem Namen `test.txt`, die eine einzelne Zeile mit dem Wert `5` enthält.
1. Fügen Sie die Datei einem Bucket in Amazon S3 hinzu. In diesem Beispiel wird der Speicherort `s3://amzn-s3-demo-bucket` verwendet.
1. Verwenden Sie den folgenden Code, um die Datei in Ihr Notebook zu importieren und die Datei zu testen.
```
from pyspark import SparkFiles
sc.addFile('s3://amzn-s3-demo-bucket/test.txt')
def func(iterator):
with open(SparkFiles.get("test.txt")) as testFile:
fileVal = int(testFile.readline())
return [x * fileVal for x in iterator]
#Test the file
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show()
```
**Ausgabe**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
## Python-Dateien hinzufügen
Die Beispiele in diesem Abschnitt zeigen, wie Sie Ihren Spark-Notebooks in Athena-Python-Dateien und -Bibliotheken hinzufügen.
### Hinzufügen von Python-Dateien und Registrieren einer UDF
Das folgende Beispiel zeigt, wie Sie Python-Dateien aus Amazon S3 zu Ihrem Notebook hinzufügen und eine UDF registrieren.
**So fügen Sie Ihrem Notebook Python-Dateien hinzu und registrieren eine UDF**
1. Verwenden Sie Ihren eigenen Amazon-S3-Speicherort und erstellen Sie die Datei `s3://amzn-s3-demo-bucket/file1.py` mit dem folgenden Inhalt:
```
def xyz(input):
return 'xyz - udf ' + str(input);
```
1. Erstellen Sie am selben S3-Speicherort die Datei `s3://amzn-s3-demo-bucket/file2.py` mit dem folgenden Inhalt:
```
from file1 import xyz
def uvw(input):
return 'uvw -> ' + xyz(input);
```
1. Führen Sie in Ihrem Athena-for-Spark-Notebook die folgenden Befehle aus.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/file1.py')
sc.addPyFile('s3://amzn-s3-demo-bucket/file2.py')
def func(iterator):
from file2 import uvw
return [uvw(x) for x in iterator]
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show(10)
```
**Ausgabe**
```
Calculation started (calculation_id=1ec09e01-3dec-a096-00ea-57289cdb8ce7) in (session=c8c09e00-6f20-41e5-98bd-4024913d6cee). Checking calculation status...
Calculation completed.
+---+---+--------------------+
| _1| _2| col|
+---+---+--------------------+
| 1 | a|[uvw -> xyz - ud... |
| 2 | b|[uvw -> xyz - ud... |
+---+---+--------------------+
```
### Importieren einer Python-ZIP-Datei
Sie können die Python-Methoden `addPyFile` und `import` verwenden, um eine Python-ZIP-Datei in Ihr Notebook zu importieren.
**Anmerkung**
Die `.zip`-Dateien, die Sie in Athena Spark importieren, enthalten möglicherweise nur Python-Pakete. Beispielsweise wird das Einbeziehen von Paketen mit C-basierten Dateien nicht unterstützt.
**So importieren Sie eine `.zip`-Python-Datei in Ihr Notebook**
1. Erstellen Sie auf Ihrem lokalen Computer in einem Desktop-Verzeichnis wie z. B. `\tmp` ein Verzeichnis mit dem Namen `moduletest`.
1. Erstellen Sie im Verzeichnis `moduletest` eine Datei namens `hello.py` mit folgendem Inhalt:
```
def hi(input):
return 'hi ' + str(input);
```
1. Fügen Sie im selben Verzeichnis eine leere Datei mit dem Namen `__init__.py` hinzu.
Wenn Sie die Verzeichnisinhalte auflisten, sollten diese jetzt wie folgt aussehen.
```
/tmp $ ls moduletest
__init__.py hello.py
```
1. Verwenden Sie den `zip`-Befehl, um die beiden Moduldateien in einer Datei mit dem Namen `moduletest.zip` zu platzieren.
```
moduletest $ zip -r9 ../moduletest.zip *
```
1. Laden Sie die `.zip`-Datei in Ihren Bucket in Amazon S3 hoch.
1. Verwenden Sie den folgenden Code, um die `.zip`-Python-Datei in Ihr Notebook zu importieren.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/moduletest.zip')
from moduletest.hello import hi
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
hi_udf = udf(hi)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Ausgabe**
```
Calculation started (calculation_id=6ec09e8c-6fe0-4547-5f1b-6b01adb2242c) in (session=dcc09e8c-3f80-9cdc-bfc5-7effa1686b76). Checking calculation status...
Calculation completed.
+---+---+----+
| _1| _2| col|
+---+---+----+
| 1| a|hi a|
| 2| b|hi b|
+---+---+----+
```
### Importieren von zwei Versionen einer Python-Bibliothek als separate Module
Die folgenden Codebeispiele zeigen, wie Sie zwei verschiedene Versionen einer Python-Bibliothek von einem Speicherort in Amazon S3 als zwei separate Module hinzufügen und importieren. Der Code fügt jeweils die Bibliotheksdatei aus S3 hinzu, importiert sie und gibt dann die Bibliotheksversion aus, um den Import zu überprüfen.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_15.zip')
sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_17_6.zip')
import simplejson_v3_15
print(simplejson_v3_15.__version__)
```
**Ausgabe**
```
3.15.0
```
```
import simplejson_v3_17_6
print(simplejson_v3_17_6.__version__)
```
**Ausgabe**
```
3.17.6
```
### Importieren einer Python-ZIP-Datei aus PyPI
In diesem Beispiel wird der `pip`-Befehl verwendet, um eine Python-ZIP-Datei des Projekts [bpabel/piglatin](https://github.com/bpabel/piglatin) aus dem [Python Package Index (PyPI)](https://pypi.org/) herunterzuladen.
**So importieren Sie eine Python-ZIP-Datei aus PyPI**
1. Verwenden Sie auf Ihrem lokalen Desktop die folgenden Befehle, um ein Verzeichnis mit dem Namen `testpiglatin` zu erstellen und eine virtuelle Umgebung zu erstellen.
```
/tmp $ mkdir testpiglatin
/tmp $ cd testpiglatin
testpiglatin $ virtualenv .
```
**Ausgabe**
```
created virtual environment CPython3.9.6.final.0-64 in 410ms
creator CPython3Posix(dest=/private/tmp/testpiglatin, clear=False, no_vcs_ignore=False, global=False)
seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/Users/user1/Library/Application Support/virtualenv)
added seed packages: pip==22.0.4, setuptools==62.1.0, wheel==0.37.1
activators BashActivator,CShellActivator,FishActivator,NushellActivator,PowerShellActivator,PythonActivator
```
1. Erstellen Sie ein Unterverzeichnis mit dem Namen `unpacked`, um das Projekt zu speichern.
```
testpiglatin $ mkdir unpacked
```
1. Verwenden Sie den `pip`-Befehl, um das Projekt in das `unpacked`-Verzeichnis zu installieren.
```
testpiglatin $ bin/pip install -t $PWD/unpacked piglatin
```
**Ausgabe**
```
Collecting piglatin
Using cached piglatin-1.0.6-py2.py3-none-any.whl (3.1 kB)
Installing collected packages: piglatin
Successfully installed piglatin-1.0.6
```
1. Überprüfen Sie den Inhalt des Verzeichnisses.
```
testpiglatin $ ls
```
**Ausgabe**
```
bin lib pyvenv.cfg unpacked
```
1. Wechseln Sie in das `unpacked`-Verzeichnis und zeigen Sie den Inhalt an.
```
testpiglatin $ cd unpacked
unpacked $ ls
```
**Ausgabe**
```
piglatin piglatin-1.0.6.dist-info
```
1. Verwenden Sie den `zip`-Befehl, um den Inhalt des Piglatin-Projekts in einer Datei mit dem Namen `library.zip` zu platzieren.
```
unpacked $ zip -r9 ../library.zip *
```
**Ausgabe**
```
adding: piglatin/ (stored 0%)
adding: piglatin/__init__.py (deflated 56%)
adding: piglatin/__pycache__/ (stored 0%)
adding: piglatin/__pycache__/__init__.cpython-39.pyc (deflated 31%)
adding: piglatin-1.0.6.dist-info/ (stored 0%)
adding: piglatin-1.0.6.dist-info/RECORD (deflated 39%)
adding: piglatin-1.0.6.dist-info/LICENSE (deflated 41%)
adding: piglatin-1.0.6.dist-info/WHEEL (deflated 15%)
adding: piglatin-1.0.6.dist-info/REQUESTED (stored 0%)
adding: piglatin-1.0.6.dist-info/INSTALLER (stored 0%)
adding: piglatin-1.0.6.dist-info/METADATA (deflated 48%)
```
1. (Optional) Verwenden Sie die folgenden Befehle, um den Import lokal zu testen.
1. Legen Sie den Python-Pfad auf den Speicherort der `library.zip`-Datei fest und starten Sie Python.
```
/home $ PYTHONPATH=/tmp/testpiglatin/library.zip
/home $ python3
```
**Ausgabe**
```
Python 3.9.6 (default, Jun 29 2021, 06:20:32)
[Clang 12.0.0 (clang-1200.0.32.29)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
```
1. Importieren Sie die Bibliothek und führen Sie einen Testbefehl aus.
```
>>> import piglatin
>>> piglatin.translate('hello')
```
**Ausgabe**
```
'ello-hay'
```
1. Verwenden Sie Befehle wie die folgenden, um die `.zip`-Datei aus Amazon S3 hinzuzufügen, sie in Ihr Notebook in Athena zu importieren und zu testen.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/library.zip')
import piglatin
piglatin.translate('hello')
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
hi_udf = udf(piglatin.translate)
df = spark.createDataFrame([(1, "hello"), (2, "world")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Ausgabe**
```
Calculation started (calculation_id=e2c0a06e-f45d-d96d-9b8c-ff6a58b2a525) in (session=82c0a06d-d60e-8c66-5d12-23bcd55a6457). Checking calculation status...
Calculation completed.
+---+-----+--------+
| _1| _2| col|
+---+-----+--------+
| 1|hello|ello-hay|
| 2|world|orld-way|
+---+-----+--------+
```
### Importieren einer Python-ZIP-Datei aus PyPI mit Abhängigkeiten
In diesem Beispiel wird das [md2gemini](https://github.com/makeworld-the-better-one/md2gemini)-Paket, das Text im Markdown in das [Gemini](https://gemini.circumlunar.space/)-Textformat konvertiert, aus PyPI importiert. Das Paket weist folgende [Abhängigkeiten](https://libraries.io/pypi/md2gemini) auf:
```
cjkwrap
mistune
wcwidth
```
**So importieren Sie eine Python-ZIP-Datei mit Abhängigkeiten**
1. Verwenden Sie auf Ihrem lokalen Computer die folgenden Befehle, um ein Verzeichnis mit dem Namen `testmd2gemini` zu erstellen und eine virtuelle Umgebung zu erstellen.
```
/tmp $ mkdir testmd2gemini
/tmp $ cd testmd2gemini
testmd2gemini$ virtualenv .
```
1. Erstellen Sie ein Unterverzeichnis mit dem Namen `unpacked`, um das Projekt zu speichern.
```
testmd2gemini $ mkdir unpacked
```
1. Verwenden Sie den `pip`-Befehl, um das Projekt in das `unpacked`-Verzeichnis zu installieren.
```
/testmd2gemini $ bin/pip install -t $PWD/unpacked md2gemini
```
**Ausgabe**
```
Collecting md2gemini
Downloading md2gemini-1.9.0-py3-none-any.whl (31 kB)
Collecting wcwidth
Downloading wcwidth-0.2.5-py2.py3-none-any.whl (30 kB)
Collecting mistune<3,>=2.0.0
Downloading mistune-2.0.2-py2.py3-none-any.whl (24 kB)
Collecting cjkwrap
Downloading CJKwrap-2.2-py2.py3-none-any.whl (4.3 kB)
Installing collected packages: wcwidth, mistune, cjkwrap, md2gemini
Successfully installed cjkwrap-2.2 md2gemini-1.9.0 mistune-2.0.2 wcwidth-0.2.5
...
```
1. Wechseln Sie in das `unpacked`-Verzeichnis und überprüfen Sie den Inhalt.
```
testmd2gemini $ cd unpacked
unpacked $ ls -lah
```
**Ausgabe**
```
total 16
drwxr-xr-x 13 user1 wheel 416B Jun 7 18:43 .
drwxr-xr-x 8 user1 wheel 256B Jun 7 18:44 ..
drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 CJKwrap-2.2.dist-info
drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 __pycache__
drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 bin
-rw-r--r-- 1 user1 staff 5.0K Jun 7 18:43 cjkwrap.py
drwxr-xr-x 7 user1 staff 224B Jun 7 18:43 md2gemini
drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 md2gemini-1.9.0.dist-info
drwxr-xr-x 12 user1 staff 384B Jun 7 18:43 mistune
drwxr-xr-x 8 user1 staff 256B Jun 7 18:43 mistune-2.0.2.dist-info
drwxr-xr-x 16 user1 staff 512B Jun 7 18:43 tests
drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 wcwidth
drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 wcwidth-0.2.5.dist-info
```
1. Verwenden Sie den `zip`-Befehl, um den Inhalt des md2gemini-Projekts in einer Datei mit dem Namen `md2gemini.zip` zu platzieren.
```
unpacked $ zip -r9 ../md2gemini *
```
**Ausgabe**
```
adding: CJKwrap-2.2.dist-info/ (stored 0%)
adding: CJKwrap-2.2.dist-info/RECORD (deflated 37%)
....
adding: wcwidth-0.2.5.dist-info/INSTALLER (stored 0%)
adding: wcwidth-0.2.5.dist-info/METADATA (deflated 62%)
```
1. (Optional) Verwenden Sie die folgenden Befehle, um zu testen, ob die Bibliothek auf Ihrem lokalen Computer funktioniert.
1. Legen Sie den Python-Pfad auf den Speicherort der `md2gemini.zip`-Datei fest und starten Sie Python.
```
/home $ PYTHONPATH=/tmp/testmd2gemini/md2gemini.zip
/home python3
```
1. Importieren Sie die Bibliothek und führen Sie einen Test durch.
```
>>> from md2gemini import md2gemini
>>> print(md2gemini('[abc](https://abc.def)'))
```
**Ausgabe**
```
https://abc.def abc
```
1. Verwenden Sie die folgenden Befehle, um die `.zip`-Datei aus Amazon S3 hinzuzufügen, diese in Ihr Notebook in Athena zu importieren und einen Nicht-UDF-Test durchzuführen.
```
# (non udf test)
sc.addPyFile('s3://amzn-s3-demo-bucket/md2gemini.zip')
from md2gemini import md2gemini
print(md2gemini('[abc](https://abc.def)'))
```
**Ausgabe**
```
Calculation started (calculation_id=0ac0a082-6c3f-5a8f-eb6e-f8e9a5f9bc44) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status...
Calculation completed.
=> https://abc.def (https://abc.def/) abc
```
1. Verwenden Sie die folgenden Befehle, um einen UDF-Test durchzuführen.
```
# (udf test)
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
from md2gemini import md2gemini
hi_udf = udf(md2gemini)
df = spark.createDataFrame([(1, "[first website](https://abc.def)"), (2, "[second website](https://aws.com)")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Ausgabe**
```
Calculation started (calculation_id=60c0a082-f04d-41c1-a10d-d5d365ef5157) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status...
Calculation completed.
+---+--------------------+--------------------+
| _1| _2| col|
+---+--------------------+--------------------+
| 1|[first website](h...|=> https://abc.de...|
| 2|[second website](...|=> https://aws.co...|
+---+--------------------+--------------------+
```
# Spark-Eigenschaften verwenden um eine benutzerdefinierte Konfiguration anzugeben
Wenn Sie eine Sitzung in Amazon Athena für Apache Spark erstellen oder bearbeiten, können Sie [Spark-Eigenschaften](https://spark.apache.org/docs/latest/configuration.html#spark-properties) verwenden, um `.jar`-Dateien, Pakete oder eine andere benutzerdefinierte Konfiguration für die Sitzung anzugeben. Um Ihre Spark-Eigenschaften anzugeben, können Sie die Athena-Konsole AWS CLI, die oder die Athena-API verwenden.
## Verwenden der Athena-Konsole zur Angabe von Spark-Eigenschaften
In der Athena-Konsole können Sie Ihre Spark-Eigenschaften angeben, wenn Sie [ein Notebook erstellen](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) oder [eine aktuelle Sitzung bearbeiten](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details).
**Um Eigenschaften im Dialogfeld **Notebook erstellen** oder **Sitzungsdetails bearbeiten** hinzuzufügen**
1. Erweitern Sie **Spark-Eigenschaften**.
1. Um Ihre Eigenschaften hinzuzufügen, verwenden Sie die Option **In Tabelle bearbeiten** oder **In JSON bearbeiten**.
+ Wählen Sie für die Option **In Tabelle bearbeiten** die Option **Eigenschaft hinzufügen** aus, um eine Eigenschaft hinzuzufügen, oder wählen Sie **Entfernen**, um eine Eigenschaft zu entfernen. Verwenden Sie die Felder **Schlüssel** und **Wert**, um Eigenschaftsnamen und ihre Werte einzugeben.
+ Verwenden Sie die `spark.jars`-Eigenschaft, um eine benutzerdefinierte `.jar`-Datei hinzuzufügen.
+ Um eine Paketdatei anzugeben, verwenden Sie die `spark.jars.packages`-Eigenschaft.
+ Um Ihre Konfiguration direkt einzugeben und zu bearbeiten, wählen Sie die Option **In JSON bearbeiten**. Im JSON-Texteditor können Sie die folgenden Aufgaben durchführen:
+ Wählen Sie zum Kopieren der URL in die Zwischenablage **Kopieren** aus.
+ Wählen Sie **Löschen**, um den gesamten Text aus dem JSON-Editor zu entfernen.
+ Wählen Sie das Einstellungssymbol (Zahnrad), um den Zeilenumbruch zu konfigurieren, oder wählen Sie ein Farbdesign für den JSON-Editor.
### Hinweise
+ Sie können in Athena für Spark Eigenschaften festlegen, was dem direkten Einstellen von [Spark-Eigenschaften](https://spark.apache.org/docs/latest/configuration.html#spark-properties) für ein [SparkConf](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkConf.html)Objekt entspricht.
+ Starten Sie alle Spark-Eigenschaften mit dem `spark.`-Präfix. Eigenschaften mit anderen Präfixen werden ignoriert.
+ Nicht alle Spark-Eigenschaften sind für die benutzerdefinierte Konfiguration auf Athena verfügbar. Wenn Sie eine `StartSession`-Anfrage mit einer eingeschränkten Konfiguration einreichen, kann die Sitzung nicht gestartet werden.
+ Sie können das `spark.athena.`-Präfix nicht verwenden, da es reserviert ist.
## Verwenden Sie die AWS CLI oder Athena-API, um eine benutzerdefinierte Konfiguration bereitzustellen
Verwenden Sie die API-Aktion AWS CLI oder den CLI-Befehl [start-session](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/start-session.html), um Ihre Sitzungskonfiguration mithilfe der [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)API oder der Athena-API bereitzustellen. Verwenden Sie in Ihrer `StartSession` Anfrage das `SparkProperties` [EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html)Objektfeld, um Ihre Konfigurationsinformationen im JSON-Format zu übergeben. Dadurch wird eine Sitzung mit der von Ihnen angegebenen Konfiguration gestartet.
Um benutzerdefinierte Spark-Eigenschaften aus dem anzugeben AWS CLI, verwenden Sie die `engine-configuration` Konfiguration, wenn Sie eine interaktive Sitzung starten.
```
aws athena start-session \
--region "REGION"
--work-group "WORKGROUP" \
--engine-configuration '{
"Classifications": [{
"Name": "spark-defaults",
"Properties": {
"spark.dynamicAllocation.minExecutors": "1",
"spark.dynamicAllocation.initialExecutors": "2",
"spark.dynamicAllocation.maxExecutors": "10",
"spark.dynamicAllocation.executorIdleTimeout": "300"
}
}]
}'
```
Sie können mithilfe der `CreateWorkgroup` API-Aktion oder der API-Aktion auch Konfigurationsstandardwerte auf Arbeitsgruppenebene angeben. `UpdateWorkgroup` Die in der Arbeitsgruppe definierten Konfigurationsstandardwerte gelten für alle Sitzungen, die für diese Arbeitsgruppe gestartet wurden.
Um die Standard-Spark-Eigenschaften AWS CLI für eine Arbeitsgruppe anzugeben, verwenden Sie die `engine-configuration` Konfiguration, wenn Sie eine neue Arbeitsgruppe erstellen:
```
aws athena create-work-group \
--region "REGION" \
--name "WORKGROUP_NAME" \
--configuration '{
"EngineVersion": {
"SelectedEngineVersion": "Apache Spark version 3.5"
},
"ExecutionRole": "EXECUTION_ROLE",
"EngineConfiguration": {
"Classifications": [
{
"Name": "spark-defaults",
"Properties": {
"spark.dynamicAllocation.minExecutors": "1",
"spark.dynamicAllocation.initialExecutors": "2",
"spark.dynamicAllocation.maxExecutors": "10",
"spark.dynamicAllocation.executorIdleTimeout": "300"
}
}
]
}
}'
```
Um die Spark-Standardeigenschaften AWS CLI für eine Arbeitsgruppe zu ändern, verwenden Sie die `engine-configuration` Konfiguration, wenn Sie eine Arbeitsgruppe aktualisieren. Die Änderungen gelten ab sofort für neue interaktive Sitzungen.
```
aws athena update-work-group \
--region "REGION" \
--work-group "WORKGROUP_NAME" \
--configuration-updates '{
"EngineVersion": {
"SelectedEngineVersion": "Apache Spark version 3.5"
},
"ExecutionRole": "EXECUTION_ROLE",
"EngineConfiguration": {
"Classifications": [
{
"Name": "spark-defaults",
"Properties": {
"spark.dynamicAllocation.minExecutors": "1",
"spark.dynamicAllocation.initialExecutors": "2",
"spark.dynamicAllocation.maxExecutors": "12",
"spark.dynamicAllocation.executorIdleTimeout": "300"
}
}
]
}
}'
```
# Unterstützte Daten- und Speicherformate
Die folgende Tabelle zeigt Formate, die nativ in Athena für Apache Spark unterstützt werden.
****
| **Data format** (Datenformat) | **Read** (Lesen) | **Write** (Schreiben) | **Write compression** (Schreibkomprimierung) |
| --- | --- | --- | --- |
| parquet | Ja | Ja | none, uncompressed, snappy, gzip |
| orc | Ja | Ja | none, snappy, zlib, lzo |
| json | Ja | Ja | bzip2, gzip, deflate |
| csv | Ja | Ja | bzip2, gzip, deflate |
| text | Ja | Ja | none, bzip2, gzip, deflate |
| Binärdatei | Ja | – | – |
# Apache Spark mit CloudWatch Metriken überwachen
Athena veröffentlicht berechnungsbezogene Metriken auf Amazon, CloudWatch wenn die **[Publish CloudWatch metrics](notebooks-spark-getting-started.md#notebook-gs-metrics)**Option für Ihre Spark-fähige Arbeitsgruppe ausgewählt ist. In der Konsole können Sie benutzerdefinierte Dashboards erstellen und Alarme und Auslöser für Metriken einrichten. CloudWatch
Athena veröffentlicht die folgende Metrik auf der CloudWatch Konsole unter dem `AmazonAthenaForApacheSpark` Namespace:
+ `DPUCount`— Anzahl der während der Sitzung zur Ausführung der Berechnungen DPUs verbrauchten Daten.
Diese Metrik besitzt die folgenden Dimensionen:
+ `SessionId` – Die ID der Sitzung, in der die Berechnungen übermittelt werden.
+ `WorkGroup` – Name der Arbeitsgruppe.
**Um Metriken für Spark-fähige Arbeitsgruppen in der Amazon-Konsole anzuzeigen CloudWatch**
1. Öffnen Sie die Konsole unter CloudWatch . [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie im Navigationsbereich **Metrics** (Metriken) **All metrics** (Alle Metriken) aus.
1. Wählen Sie den **AmazonAthenaForApacheSpark**-Namespace.
**So zeigen Sie Metriken im CLI-Dashboard an**
+ Führen Sie eine der folgenden Aktionen aus:
+ Um die Metriken für Athena-Spark-fähige Arbeitsgruppen aufzulisten, öffnen Sie eine Eingabeaufforderung und verwenden Sie den folgenden Befehl:
```
aws cloudwatch list-metrics --namespace "AmazonAthenaForApacheSpark"
```
+ Verwenden Sie den folgenden Befehl, um alle verfügbaren Metriken aufzulisten:
```
aws cloudwatch list-metrics
```
## Liste der CloudWatch Metriken und Dimensionen für Apache Spark-Berechnungen in Athena
Wenn Sie CloudWatch Metriken in Ihrer Spark-fähigen Athena-Arbeitsgruppe aktiviert haben, sendet Athena die folgende Metrik an jede Arbeitsgruppe. CloudWatch Die Metrik verwendet den `AmazonAthenaForApacheSpark`-Namespace.
****
| Metrikname | Description |
| --- | --- |
| DPUCount | Anzahl der DPUs (Datenverarbeitungseinheiten), die während der Sitzung zur Ausführung der Berechnungen verbraucht wurden. Eine DPU ist ein relatives Maß für die Rechenleistung, die sich aus 4 V CPUs Rechenkapazität und 16 GB Arbeitsspeicher zusammensetzt. |
Diese Metrik besitzt die folgenden Dimensionen.
| Dimension | Description |
| --- | --- |
| SessionId | Die ID der Sitzung, in der die Berechnungen übermittelt werden. |
| WorkGroup | Der Name der Arbeitsgruppe. |
## Liste der CloudWatch Metriken und Dimensionen für interaktive Athena Spark-Sitzungen
Wenn Sie in der Release-Version Apache Spark Version 3.5 CloudWatch Metriken in Ihrer Athena Spark-Arbeitsgruppe aktiviert haben, sendet Athena die folgende Metrik an. CloudWatch Die Metrik verwendet den `AmazonAthenaForApacheSpark`-Namespace.
****
| Name | Description |
| --- | --- |
| DPUConsumed | Die Anzahl der DPUs aktiven Abfragen in einem RUNNING-Status zu einem bestimmten Zeitpunkt in der Arbeitsgruppe. |
Diese Metrik besitzt die folgenden Dimensionen.
| Dimension | Description |
| --- | --- |
| Account | Die AWS Konto-ID. |
| WorkGroup | Der Name der Arbeitsgruppe. |
# Kostenzuweisung auf Sitzungsebene
Ab der Release-Version 3.5 von Apache Spark ermöglicht Athena die Nachverfolgung der Kosten für jede Sitzung. Sie können beim Starten einer Sitzung Tags für die Kostenzuweisung definieren. Die gemeldeten Kosten für eine Sitzung werden dann im Cost Explorer oder in Berichten zur AWS Fakturierungskostenzuweisung angezeigt. Sie können Tags für die Kostenzuweisung auch auf Arbeitsgruppenebene anwenden. Diese werden dann in alle Sitzungen kopiert, die in dieser Arbeitsgruppe gestartet wurden.
## Verwenden Sie die Kostenzuweisung auf Sitzungsebene
Standardmäßig werden alle auf Arbeitsgruppenebene angegebenen Tags für die Kostenzuweisung in interaktive Sitzungen kopiert, die in dieser Arbeitsgruppe gestartet wurden.
So deaktivieren Sie das Kopieren von Tags aus der Arbeitsgruppe, wenn Sie eine interaktive Sitzung von der folgenden Seite aus starten: AWS CLI
```
aws athena start-session \
--region "REGION" \
--work-group "WORKGROUP" \
--tags '[
{
"Key": "tag_key",
"Value": "tag_value"
}
]' \
--no-copy-work-group-tags
```
So aktivieren Sie das Kopieren von Tags aus der Arbeitsgruppe, wenn Sie eine interaktive Sitzung von der aus starten: AWS CLI
```
aws athena start-session \
--region "REGION" \
--work-group "WORKGROUP" \
--copy-work-group-tags
```
## Überlegungen und Einschränkungen
+ Sitzungs-Tags haben Vorrang vor Arbeitsgruppen-Tags mit denselben Schlüsseln.
# Protokollierung und Überwachung von Apache Spark-Sitzungen
Ab der Version Apache Spark Version 3.5 können Sie Managed, Amazon S3 oder CloudWatch Logging als Logging-Optionen angeben.
Bei verwalteter Protokollierung und S3-Protokollierung sind in der folgenden Tabelle die Protokollspeicherorte und die Verfügbarkeit der Benutzeroberfläche aufgeführt, die Sie erwarten können, wenn Sie diese Optionen wählen.
****
| Option | Ereignisprotokolle | Containerprotokolle | Benutzeroberfläche der Anwendung |
| --- | --- | --- | --- |
| Verwaltete Protokollierung (Standard) | Im verwalteten S3-Bucket gespeichert | Im verwalteten S3-Bucket gespeichert | Unterstützt |
| Sowohl verwaltete Protokollierung als auch S3-Bucket | An beiden Orten gespeichert | Im S3-Bucket gespeichert | Unterstützt |
| Amazon-S3-Bucket | Im S3-Bucket gespeichert | Im S3-Bucket gespeichert | Nicht unterstützt 1 |
1 Wir empfehlen, dass Sie die Option Verwaltete Protokollierung aktiviert lassen. Andernfalls können Sie die integrierte Anwendung nicht verwenden UIs.
## Verwaltete Protokollierung
Standardmäßig speichert Athena Spark Workgroups Anwendungsprotokolle sicher für maximal 30 Tage in serviceverwalteten S3-Buckets.
Sie können optional einen KMS-Schlüssel (Schlüssel-ID, ARN, Alias oder Alias-ARN) angeben, den der Dienst zur Verschlüsselung der verwalteten Protokolle verwendet.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"ManagedLoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
},
}'
--engine-configuration ''
```
**Anmerkung**
Wenn Sie die verwaltete Protokollierung deaktivieren, kann Athena in Ihrem Namen keine Fehler in Ihren Sitzungen beheben. Beispiel: Sie werden nicht über Amazon SageMaker AI Studio Notebooks oder über die API auf die `GetResourceDashboard` Spark-UI zugreifen.
Um diese Option von aus zu deaktivieren AWS CLI, verwenden Sie die `ManagedLoggingConfiguration` Konfiguration, wenn Sie eine interaktive Sitzung starten.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"ManagedLoggingConfiguration": {
"Enabled": false
},
}'
--engine-configuration ''
```
### Erforderliche Berechtigungen für die verwaltete Protokollierung
Wenn Sie einen KMS-Schlüssel angegeben haben, benötigen Sie die folgenden Berechtigungen in der Berechtigungsrichtlinie für die Ausführungsrolle.
```
{
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*",
"Effect": "Allow"
}
```
## Amazon S3 S3-Protokollierung
Sie können die Protokollzustellung an Amazon S3 S3-Buckets konfigurieren.
Um die S3-Protokollzustellung von zu aktivieren AWS CLI, verwenden Sie die `S3LoggingConfiguration` Konfiguration, wenn Sie eine interaktive Sitzung starten.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"S3LoggingConfiguration": {
"Enabled":true,
"LogLocation": "s3://bucket/",
},
}'
--engine-configuration ''
```
Sie können optional einen KMS-Schlüssel (Schlüssel-ID, ARN, Alias oder Alias-ARN) angeben, den der Dienst zum Verschlüsseln der S3-Protokolle verwendet.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"S3LoggingConfiguration": {
"Enabled":true,
"LogLocation": "s3://bucket/",
"KmsKey": "KMS_KEY"
},
}'
--engine-configuration ''
```
### Erforderliche Berechtigungen für die Protokollzustellung an Amazon S3
Bevor Ihre Sitzungen Protokolle an Amazon S3 S3-Buckets liefern können, müssen Sie die folgenden Berechtigungen in die Berechtigungsrichtlinie für die Ausführungsrolle aufnehmen.
```
{
"Action": "s3:*",
"Resource": "*",
"Effect": "Allow"
}
```
Wenn Sie einen KMS-Schlüssel angegeben haben, benötigen Sie außerdem die folgenden Berechtigungen in der Berechtigungsrichtlinie für die Ausführungsrolle.
```
{
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*",
"Effect": "Allow"
}
```
Wenn der KMS-Schlüssel und der Bucket nicht aus demselben Konto stammen, muss KMS den S3-Dienstprinzipal zulassen.
```
{
"Effect": "Allow",
"Principal": { "Service": "s3.amazonaws.com" },
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "ACCOUNT_HAVING_KMS_KEY"
}
}
}
```
## CloudWatch Protokollierung
Sie können die Protokollzustellung für CloudWatch Protokollgruppen konfigurieren.
Verwenden Sie die `CloudWatchLoggingConfiguration` Konfiguration, wenn Sie eine interaktive Sitzung starten AWS CLI, um die S3-Protokollzustellung von zu aktivieren.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-"
}
}'
--engine-configuration ''
```
Alle Protokolle werden standardmäßig übermittelt, Sie können jedoch optional angeben, welche Protokolltypen eingeschlossen werden sollen.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
}
}'
--engine-configuration ''
```
### Erforderliche Berechtigungen für die Protokollzustellung an CloudWatch
Bevor Ihre Sitzungen Protokolle an CloudWatch Protokollgruppen übermitteln können, müssen Sie die folgenden Berechtigungen in die Berechtigungsrichtlinie für die Ausführungsrolle aufnehmen.
```
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": "*",
"Effect": "Allow"
}
```
Und dann die Genehmigung für die KMS-Schlüsselressourcenrichtlinie.
```
{
"Effect": "Allow",
"Principal": {
"Service": "logs..amazonaws.com"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
}
```
## Konfiguration der Standardeinstellungen für die Protokollierung in der Arbeitsgruppe
Sie können auch Standardprotokollierungsoptionen auf Arbeitsgruppenebene angeben.
Um die Standardprotokollierungsoptionen AWS CLI für eine Arbeitsgruppe anzugeben, verwenden Sie beim Erstellen einer neuen Arbeitsgruppe die folgende `monitoring-configuration` Konfiguration:
```
aws athena create-work-group \
--region "REGION" \
--name "WORKGROUP_NAME" \
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
},
"ManagedLoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
},
"S3LoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
"LogLocation": "s3://bucket/",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
}
}'
```
Um die standardmäßigen Protokollierungsoptionen AWS CLI für eine Arbeitsgruppe zu ändern, verwenden Sie die `monitoring-configuration` Konfiguration beim Aktualisieren einer Arbeitsgruppe. Die Änderungen gelten ab sofort für neue interaktive Sitzungen.
```
aws athena update-work-group \
--region "REGION" \
--work-group "WORKGROUP_NAME"
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
},
"ManagedLoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
},
"S3LoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
"LogLocation": "s3://bucket/",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
}
}'
```
# Zugreifen auf die Spark-Benutzeroberfläche
Apache UIs Spark bietet visuelle Benutzeroberflächen mit detaillierten Informationen über Ihre laufenden und abgeschlossenen Spark-Jobs. Sie können interaktive Sitzungen in Athena Spark mit dem nativen Apache Spark überwachen und debuggen. Dort können Sie sich mit auftragsspezifischen Metriken und Informationen über Zeitpläne, Phasen, Aufgaben und Ausführende für jeden UIs Spark-Job befassen.
## Zugriff auf die Spark-Benutzeroberfläche
Nachdem Sie eine interaktive Athena Spark-Sitzung gestartet haben, können Sie die Spark-Benutzeroberfläche in Echtzeit für die Ausführung von Sitzungen in den Amazon SageMaker AI Unified Studio-Notebooks anzeigen oder über die `GetResourceDashboard` API eine sichere URL anfordern. Für abgeschlossene Sitzungen können Sie den Spark History Server über die Amazon SageMaker AI Unified Studio-Notebooks, die Amazon Athena Athena-Konsole oder über dieselbe API aufrufen.
```
aws athena get-resource-dashboard \
--region "REGION" \
--session-id "SESSION_ID"
```
## Erforderliche Berechtigungen für den Zugriff auf die Spark-Benutzeroberfläche
Bevor Sie auf die Spark-Benutzeroberfläche zugreifen können, müssen Sie die folgenden Berechtigungen in die Berechtigungsrichtlinie für den Benutzer oder die Rolle aufnehmen.
```
{
"Action": "athena:GetResourceDashboard",
"Resource": "WORKGROUP",
"Effect": "Allow"
}
```
# Spark Connect-Unterstützung
Spark Connect ist eine Client-Server-Architektur für Apache Spark, die den Anwendungsclient vom Treiberprozess des Spark-Clusters entkoppelt und so eine Fernverbindung zu Spark von unterstützten Clients aus ermöglicht. Spark Connect ermöglicht auch interaktives Debuggen während der Entwicklung direkt von Ihren bevorzugten IDEs /clients aus.
Ab der Apache Spark-Release-Version 3.5 unterstützt Athena Spark Connect als AWS Endpunkt, auf den über die `GetSessionEndpoint` API zugegriffen werden kann.
## API/CLI-Beispiele () GetSessionEndpoint
Sie können die `GetSessionEndpoint` API verwenden, um den Spark Connect-Endpunkt für eine interaktive Sitzung abzurufen.
```
aws athena get-session-endpoint \
--region "REGION" \
--session-id "SESSION_ID"
```
Diese API gibt die Spark Connect-Endpunkt-URL für diese Sitzung zurück.
```
{
"EndpointUrl": "ENDPOINT_URL",
"AuthToken": "AUTH_TOKEN",
"AuthTokenExpirationTime": "AUTH_TOKEN_EXPIRY_TIME"
}
```
## Verbindung von selbstverwalteten Clients aus herstellen
Sie können von selbstverwalteten Clients aus eine Verbindung zu einer interaktiven Athena Spark-Sitzung herstellen.
### Voraussetzungen
Installieren Sie den pyspark-connect-Client für Spark 3.5.6 und das AWS SDK für Python.
```
pip install --user pyspark[connect]==3.5.6
pip install --user boto3
```
Im Folgenden finden Sie ein Python-Skript zum direkten Senden von Anfragen an den Sitzungsendpunkt:
```
import boto3
import time
from pyspark.sql import SparkSession
client = boto3.client('athena', region_name='')
# start the session
response = client.start_session(
WorkGroup='',
EngineConfiguration={}
)
# wait for the session endpoint to be ready
time.sleep(5)
response = client.get_session_endpoint(SessionId=session_id)
# construct the authenticated remote url
authtoken=response['AuthToken']
endpoint_url=response['EndpointUrl']
endpoint_url=endpoint_url.replace("https", "sc")+":443/;use_ssl=true;"
url_with_headers = (
f"{endpoint_url}"
f"x-aws-proxy-auth={authtoken}"
)
# start the Spark session
start_time = time.time()
spark = SparkSession.builder\
.remote(url_with_headers)\
.getOrCreate()
spark.version
#
# Enter your spark code here
#
# stop the Spark session
spark.stop()
```
Im Folgenden finden Sie ein Python-Skript für den Zugriff auf die Live-Benutzeroberfläche von Spark oder den Spark History Server für eine Sitzung:
```
Region=''
WorkGroupName=''
SessionId=''
Partition='aws'
Account=''
SessionARN=f"arn:{Partition}:athena:{Region}:{Account}:workgroup/{WorkGroupName}/session/{SessionId}"
# invoke the API to get the live UI/persistence UI for a session
response = client.get_resource_dashboard(
ResourceARN=SessionARN
)
response['Url']
```
# Aktivieren von Zahlung durch den Anforderer für Amazon-S3-Buckets in Athena für Spark
Wenn ein Amazon-S3-Bucket mit Zahlung durch den Anforderer konfiguriert ist, werden die mit der Abfrage verbundenen Datenzugriffs- und Datenübertragungsgebühren dem Konto des Benutzers, der die Abfrage ausführt, belastet. Weitere Informationen finden Sie unter [Verwendung von Anforderer zahlt Buckets für Speicherübertragungen und -nutzung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html) im *Amazon-S3-Benutzerhandbuch*.
In Athena für Spark sind kostenpflichtige Buckets pro Sitzung aktiviert, nicht pro Arbeitsgruppe. Auf einer höheren Ebene umfasst die Aktivierung von Anforderer zahlt Buckets die folgenden Schritte:
1. Aktivieren Sie in der Amazon-S3-Konsole, dass der Antragsteller für die Eigenschaften des Buckets bezahlt, und fügen Sie eine Bucket-Richtlinie hinzu, um den Zugriff festzulegen.
1. Erstellen Sie in der IAM-Konsole eine IAM-Richtlinie, die den Zugriff auf den Bucket ermöglicht, und fügen Sie die Richtlinie dann der IAM-Rolle hinzu, die für den Zugriff auf den Bucket mit Zahlung durch den Anforderer verwendet wird.
1. Fügen Sie in Athena für Spark eine Sitzungseigenschaft hinzu, um das Feature Anforderer zahlt Buckets zu aktivieren.
## Schritt 1: Aktivieren Sie Zahlungen durch den Anforderer für einen Amazon-S3-Bucket und fügen Sie eine Bucket-Richtlinie hinzu
**So aktivieren Sie die Zahlung durch den Anforderer für einen Amazon-S3-Bucket**
1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Wählen Sie in der Liste Buckets den Link des Buckets aus, für den Sie die Zahlung durch den Anforderer aktivieren möchten.
1. Wählen Sie auf der Seite für Ihren Bucket die Registerkarte **Eigenschaften** aus.
1. Scrollen Sie nach unten zum Abschnitt **Anforderer zahlt** und wählen Sie anschließend **Bearbeiten** aus.
1. Wählen Sie auf der Seite **Anforderer zahlt** die Option **Aktivieren** und anschließend **Änderungen speichern** aus.
1. Wählen Sie die Registerkarte **Berechtigungen**.
1. Wählen Sie im Abschnitt **Bucket-Richtlinie** die Option **Bearbeiten** aus.
1. Wenden Sie auf der Seite **Bucket-Richtlinie bearbeiten** die gewünschte Bucket-Richtlinie auf den Quell-Bucket an. Die folgende Beispielrichtlinie gewährt Zugriff auf alle AWS Prinzipale (`"AWS": "*"`), Ihr Zugriff kann jedoch detaillierter sein. Beispielsweise möchten Sie möglicherweise nur eine bestimmte IAM-Rolle in einem anderen Konto angeben.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Sid": "Statement1", "Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::111122223333:root" },
"Action": "s3:*", "Resource": [
"arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket",
"arn:aws:s3:::555555555555-us-east-1-amzn-s3-demo-bucket/*"
] } ] }
```
------
## Schritt 2: Erstellen Sie eine IAM-Richtlinie und fügen Sie ihr die IAM-Rolle an
Als nächstes erstellen Sie eine IAM-Richtlinie, die Zugriff auf den Bucket gewährt. Dann fügen Sie die Richtlinie der Rolle zu, die für den Zugriff auf den Anforderer-zahlt-Bucket verwendet werden soll.
**Wie Sie eine IAM-Richtlinie für den Anforderer-zahlt-Bucket erstellen und die Richtlinie einer Rolle hinzufügen**
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Wählen Sie im Navigationsbereich der IAM-Konsole die Option **Richtlinien**.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Wählen Sie **JSON**.
1. Fügen Sie im **Bucket-Richtlinieneditor** eine Richtlinie, wie die folgende hinzu:
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Action": [ "s3:*" ], "Effect": "Allow",
"Resource": [
"arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket",
"arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket/*"
] } ] }
```
------
1. Wählen Sie **Weiter** aus.
1. Geben Sie auf der Seite **Überprüfen und erstellen** einen Namen und eine optionale Beschreibung für die Richtlinie ein und wählen Sie anschließend **Richtlinie erstellen** aus.
1. Wählen Sie im Navigationsbereich **Rollen**.
1. Suchen Sie auf der Seite **Rollen** die Rolle, die Sie verwenden möchten, und wählen Sie dann den Link mit dem Rollennamen.
1. Unter **Berechtigungsrichtlinien** im Abschnitt **Berechtigungen hinzufügen** wählen Sie **Richtlinien anfügen** aus.
1. Aktivieren Sie im Abschnitt **Andere Berechtigungsrichtlinien** das Kontrollkästchen für die Richtlinie, die Sie erstellt haben, und wählen Sie dann **Berechtigungen hinzufügen** aus.
## Schritt 3: Fügen Sie eine Sitzungseigenschaft von Athena für Spark hinzu
Nachdem Sie den Amazon-S3-Bucket und die zugehörigen Berechtigungen für Zahlungen durch den Antragsteller konfiguriert haben, können Sie das Feature in einer Athena-für-Spark-Sitzung aktivieren.
**So aktivieren Sie Anforderer-zahlt-Buckets in einer Athena-für-Spark-Sitzung**
1. Wählen Sie im Notebook-Editor aus dem Menü **Session** (Sitzung) oben rechts die Option **Edit session** (Sitzung bearbeiten) aus.
1. Erweitern Sie **Spark-Eigenschaften**.
1. Wählen Sie **In JSON bearbeiten** aus.
1. Geben Sie im JSON-Texteditor Folgendes ein:
```
{
"spark.hadoop.fs.s3.useRequesterPaysHeader":"true"
}
```
1. Wählen Sie **Speichern**.
# Verwenden von Lake Formation mit Athena Spark-Arbeitsgruppen
Mit der Release-Version Apache Spark Version 3.5 können Sie AWS Glue Data Catalog nutzen, AWS Lake Formation bei dem die Rolle zur Sitzungsausführung über vollständige Tabellenberechtigungen verfügt. Mit dieser Funktion können Sie in Ihren interaktiven Athena Spark-Sitzungen Tabellen lesen und in Tabellen schreiben, die durch Lake Formation geschützt sind. In den folgenden Abschnitten erfahren Sie mehr über Lake Formation und wie Sie es mit Athena Spark verwenden können.
## Schritt 1: Aktivieren Sie den vollständigen Tabellenzugriff in Lake Formation
Um den Modus Full Table Access (FTA) zu verwenden, müssen Sie Athena Spark erlauben, auf Daten zuzugreifen, ohne dass die IAM-Sitzungs-Tag-Validierung aktiviert ist. AWS Lake Formation Folgen Sie zur Aktivierung den Schritten unter [Application integration for full table access](https://docs.aws.amazon.com//lake-formation/latest/dg/fta-app-integration.html).
### Schritt 1.1: Registrieren Sie Datenstandorte in Lake Formation mithilfe einer benutzerdefinierten Rolle
Sie müssen eine benutzerdefinierte Rolle verwenden, um Datenspeicherorte in AWS Lake Formation zu registrieren. Einzelheiten finden Sie unter [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](https://docs.aws.amazon.com//lake-formation/latest/dg/registration-role.html).
## Schritt 2: Richten Sie die IAM-Berechtigungen für die Ausführungsrolle für die Sitzung ein
Für den Lese- oder Schreibzugriff auf zugrunde liegende Daten benötigt die Ausführungsrolle zusätzlich zu den Lake Formation Formation-Berechtigungen die `lakeformation:GetDataAccess` IAM-Berechtigung. Mit dieser Berechtigung gewährt Lake Formation die Anforderung von temporären Anmeldeinformationen für den Zugriff auf die Daten.
Im Folgenden finden Sie eine Beispielrichtlinie für die Bereitstellung von IAM-Berechtigungen für den Zugriff auf ein Skript in Amazon S3, für das Hochladen von Protokollen auf S3, AWS Glue API-Berechtigungen und für den Zugriff auf Lake Formation.
### Schritt 2.1: Lake Formation Formation-Berechtigungen konfigurieren
+ Spark-Jobs, die Daten aus S3 lesen, benötigen die Lake Formation `SELECT` Formation-Genehmigung.
+ Spark-Jobs, für die write/delete Daten in S3 ist die `ALL (SUPER)` Genehmigung von Lake Formation erforderlich.
+ Spark-Jobs, die mit dem AWS Glue Datenkatalog interagieren `DESCRIBE``ALTER`, erfordern eine entsprechende `DROP` Genehmigung.
## Schritt 3: Initialisieren Sie eine Spark-Sitzung für den vollständigen Tabellenzugriff mit Lake Formation
### Voraussetzungen
AWS Glue Der Datenkatalog muss als Metastore konfiguriert werden, um auf Lake Formation-Tabellen zugreifen zu können.
Legen Sie die folgenden Einstellungen fest, um den AWS Glue Katalog als Metastore zu konfigurieren:
```
{
"spark.hadoop.glue.catalogid": "ACCOUNT_ID",
"spark.hadoop.hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory",
"spark.hadoop.hive.metastore.glue.catalogid": "ACCOUNT_ID",
"spark.sql.catalogImplementation": "hive"
}
```
Um auf Tabellen zuzugreifen AWS Lake Formation, bei denen registriert ist, müssen bei der Spark-Initialisierung die folgenden Konfigurationen festgelegt werden, damit Spark für die Verwendung AWS Lake Formation von Anmeldeinformationen konfiguriert wird.
### Hive
```
{
"spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver",
"spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": "true",
"spark.hadoop.fs.s3.folderObject.autoAction.disabled": "true",
"spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": "true",
"spark.sql.catalog.createDirectoryAfterTable.enabled": "true",
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": "true"
}
```
### Apache Iceberg
```
{
"spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension",
"spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog",
"spark.sql.catalog.spark_catalog.warehouse": "s3://your-bucket/warehouse/",
"spark.sql.catalog.spark_catalog.client.region": "REGION",
"spark.sql.catalog.spark_catalog.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.sql.catalog.spark_catalog.glue.account-id": "ACCOUNT_ID",
"spark.sql.catalog.spark_catalog.glue.lakeformation-enabled": "true"
}
```
### Amazon S3 Tables
```
{
"spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension",
"spark.sql.catalog.{catalogName}": "org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.{catalogName}.warehouse": "arn:aws:s3tables:{region}:{accountId}:bucket/{bucketName}",
"spark.sql.catalog.{catalogName}.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.sql.catalog.{catalogName}.glue.id": "{accountId}:s3tablescatalog/{bucketName}",
"spark.sql.catalog.{catalogName}.glue.lakeformation-enabled": "true",
"spark.sql.catalog.{catalogName}.client.region": "REGION",
"spark.sql.catalog.{catalogName}.glue.account-id": "ACCOUNT_ID"
}
```
### Delta Lake
```
{
"spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension",
"spark.sql.catalog.spark_catalog": "org.apache.spark.sql.delta.catalog.DeltaCatalog",
"spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver",
"spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": "true",
"spark.hadoop.fs.s3.folderObject.autoAction.disabled": "true",
"spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": "true",
"spark.sql.catalog.createDirectoryAfterTable.enabled": "true",
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": "true"
}
```
## Überlegungen und Einschränkungen
+ Full Table Access wird für Hive-, Iceberg-, Amazon S3 S3-Tabellen und Delta-Tabellen unterstützt. Hudi-Tabellen unterstützen keinen vollständigen Tabellenzugriff.
+ Um einer aktiven Sitzung neue Kataloge hinzuzufügen, verwenden Sie die Option `spark.conf.set` mit neuen Katalogkonfigurationen.
+ Katalogkonfigurationen sind unveränderlich. Wenn Sie eine Katalogkonfiguration aktualisieren möchten, erstellen Sie einen neuen Katalog mit. `spark.conf.set`
+ Fügen Sie der Spark-Sitzung nur Kataloge hinzu, die Sie benötigen.
+ Um den Standardkatalog zu ändern: `spark.catalog.setCurrentCatalog("s3tablesbucket")`
+ Wenn Ihr Katalogname Sonderzeichen enthält, `-` maskieren Sie sie in Ihrer Abfrage wie:
```
SELECT sales_amount as nums FROM `my-s3-tables-bucket`.`s3namespace`.`daily_sales` LIMIT 100
```
# Apache-Spark-Verschlüsselung aktivieren
Sie können die Apache-Spark-Verschlüsselung in Athena aktivieren. Dadurch werden Daten während der Übertragung zwischen Spark-Knoten, sowie Daten im Ruhezustand, die lokal von Spark gespeichert werden, verschlüsselt. Um die Sicherheit dieser Daten zu erhöhen, verwendet Athena die folgende Verschlüsselungskonfiguration:
```
spark.io.encryption.keySizeBits="256"
spark.io.encryption.keygen.algorithm="HmacSHA384"
```
Um die Spark-Verschlüsselung zu aktivieren, können Sie die Athena-Konsole AWS CLI, die oder die Athena-API verwenden.
## Verwenden Sie die Athena-Konsole, um die Spark-Verschlüsselung in einem neuen Notebook zu aktivieren
**Um ein neues Notebook zu erstellen, für das die Spark-Verschlüsselung aktiviert ist**
1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.
1. Führen Sie eine der folgenden Aktionen aus:
+ Wählen Sie im **Notebook explorer** (Notebook-Explorer) die Option **Create notebook** (Notebook erstellen) aus.
+ Wählen Sie im **Notebook explorer** (Notebook-Editor) die Option **Create notebook** (Notebook erstellen) oder klicken Sie auf das Plussymbol (**\$1**), um ein Notebook hinzuzufügen.
1. Geben Sie unter **Notebookname** einen Namen für das Notebook ein.
1. Erweitern Sie die Option **Spark-Eigenschaften**.
1. Wählen Sie **Spark-Verschlüsselung aktivieren** aus.
1. Wählen Sie **Erstellen** aus.
Die von Ihnen erstellte Notebook-Sitzung ist verschlüsselt. Verwenden Sie das neue Notebook wie gewohnt. Wenn Sie später neue Sitzungen starten, die das Notebook verwenden, werden die neuen Sitzungen ebenfalls verschlüsselt.
## Verwenden Sie die Athena-Konsole, um die Spark-Verschlüsselung für ein vorhandenes Notebook zu aktivieren
Sie können auch die Athena-Konsole verwenden, um die Spark-Verschlüsselung für ein vorhandenes Notebook zu aktivieren.
**Um die Verschlüsselung für ein vorhandenes Notebook zu aktivieren**
1. [Öffnen Sie eine neue Sitzung](notebooks-spark-managing.md#opening-a-previously-created-notebook) für ein zuvor erstelltes Notebook.
1. Wählen Sie im Notebook-Editor aus dem Menü **Session** (Sitzung) oben rechts die Option **Edit session** (Sitzung bearbeiten) aus.
1. Erweitern Sie im Dialogfeld **Sitzungsdetails bearbeiten** die **Spark-Eigenschaften**.
1. Wählen Sie **Spark-Verschlüsselung aktivieren** aus.
1. Wählen Sie **Speichern**.
Die Konsole startet eine neue Sitzung, für die Verschlüsselung aktiviert ist. In späteren Sitzungen, die Sie für dieses Notebook erstellen, ist auch die Verschlüsselung aktiviert.
## Verwenden Sie die, AWS CLI um die Spark-Verschlüsselung zu aktivieren
Sie können die verwenden AWS CLI , um die Verschlüsselung zu aktivieren, wenn Sie eine Sitzung starten, indem Sie die entsprechenden Spark-Eigenschaften angeben.
**Um die Spark-Verschlüsselung AWS CLI zu aktivieren**
1. Verwenden Sie einen Befehl wie den folgenden, um ein JSON-Objekt für die Engine-Konfiguration zu erstellen, das die Spark-Verschlüsselungseigenschaften spezifiziert.
```
ENGINE_CONFIGURATION_JSON=$(
cat <
Um die Spark-Verschlüsselung mit der Athena-API zu aktivieren, verwenden Sie die [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)Aktion und ihren [EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html)`SparkProperties`Parameter, um die Verschlüsselungskonfiguration in Ihrer `StartSession` Anfrage anzugeben.
# Kontenübergreifenden AWS Glue Zugriff in Athena for Spark konfigurieren
In diesem Thema wird gezeigt, wie Verbraucherkonto *666666666666* und Besitzerkonto für den kontoübergreifenden AWS Glue Zugriff konfiguriert werden *999999999999* können. Wenn die Konten konfiguriert sind, kann das Verbraucherkonto Abfragen von Athena for Spark in den AWS Glue Datenbanken und Tabellen des Besitzers ausführen.
## Schritt 1: Geben AWS Glue Sie Zugriff auf Verbraucherrollen ein
In AWS Glue erstellt der Eigentümer eine Richtlinie, die den Rollen des Verbrauchers Zugriff auf den AWS Glue Datenkatalog des Besitzers gewährt.
**Um eine AWS Glue Richtlinie hinzuzufügen, die einer Verbraucherrolle Zugriff auf den Datenkatalog des Besitzers gewährt**
1. Melden Sie sich mit dem Konto des Katalogbesitzers bei der AWS-Managementkonsole an.
1. Öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Erweitern Sie im Navigationsbereich den Eintrag **Data Catalog** und wählen Sie dann **Katalogeinstellungen** aus.
1. Fügen Sie auf der Seite mit den **Datenkatalogeinstellungen** im Abschnitt **Berechtigungen** eine Richtlinie wie die folgende hinzu. Diese Richtlinie bietet Rollen für den *666666666666* Zugriff des Verbraucherkontos auf den Datenkatalog im Besitzerkonto*999999999999*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Cataloguers",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::666666666666:role/Admin",
"arn:aws:iam::666666666666:role/AWSAthenaSparkExecutionRole"
]
},
"Action": "glue:*",
"Resource": [
"arn:aws:glue:us-west-2:999999999999:catalog",
"arn:aws:glue:us-west-2:999999999999:database/*",
"arn:aws:glue:us-west-2:999999999999:table/*"
]
}
]
}
```
------
## Schritt 2: Konfigurieren Sie das Verbraucherkonto für den Zugriff
Erstellen Sie im Verbraucherkonto eine Richtlinie, die den Zugriff auf die Datenbanken und Tabellen des AWS Glue Data Catalog Besitzers ermöglicht, und ordnen Sie die Richtlinie einer Rolle zu. Im folgenden Beispiel wird ein Verbraucherkonto verwendet*666666666666*.
**Um eine AWS Glue Richtlinie für den Zugriff auf das Konto des Besitzers zu erstellen AWS Glue Data Catalog**
1. Melden Sie sich mit dem Verbraucherkonto bei der AWS-Managementkonsole an.
1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.
1. Erweitern Sie im Navigationsbereich die Option **Zugriffsverwaltung**, und wählen Sie dann **Richtlinien** aus.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Wählen Sie auf der Seite **Berechtigungen angeben** die Option **JSON** aus.
1. Geben Sie im **Richtlinieneditor** eine JSON-Anweisung wie die folgende ein, die AWS Glue Aktionen im Datenkatalog des Eigentümerkontos ermöglicht.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "glue:*",
"Resource": [
"arn:aws:glue:us-east-1:999999999999:catalog",
"arn:aws:glue:us-east-1:999999999999:database/*",
"arn:aws:glue:us-east-1:999999999999:table/*"
]
}
]
}
```
------
1. Wählen Sie **Weiter** aus.
1. Geben Sie auf der Seite **Richtlinie prüfen** im Feld **Name** einen Namen für die Richtlinie ein.
1. Wählen Sie **Richtlinie erstellen** aus.
Als Nächstes verwenden Sie die IAM-Konsole im Verbraucherkonto, um die Richtlinie, die Sie gerade erstellt haben, der IAM-Rolle oder den Rollen zuzuordnen, die das Verbraucherkonto für den Zugriff auf den Datenkatalog des Besitzers verwendet.
**Um die AWS Glue Richtlinie an die Rollen im Kundenkonto anzuhängen**
1. Wählen Sie im Navigationsbereich der IAM-Konsole **Rollen** aus.
1. Suchen Sie auf der Seite **Rollen** nach der Rolle, der Sie die Richtlinie zuordnen möchten.
1. Wählen Sie **Berechtigungen hinzufügen** aus und wählen Sie dann **Richtlinien direkt anhängen** aus.
1. Suchen Sie die Richtlinie, die Sie gerade erstellt haben.
1. Aktivieren Sie das Kontrollkästchen für die Richtlinie und wählen Sie dann **Berechtigungen hinzufügen** aus.
1. Wiederholen Sie die Schritte, um die Richtlinie zu anderen Rollen hinzuzufügen, die Sie verwenden möchten.
## Schritt 3: Konfigurieren Sie eine Sitzung und erstellen Sie eine Abfrage
Erstellen Sie in Athena Spark im Anfordererkonto mit der angegebenen Rolle eine Sitzung, um den Zugriff zu testen, indem Sie [ein Notebook erstellen](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) oder eine [aktuelle Sitzung bearbeiten](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details). Wenn Sie die [Sitzungseigenschaften konfigurieren](notebooks-spark-custom-jar-cfg.md#notebooks-spark-custom-jar-cfg-console), geben Sie eine der folgenden an:
+ **Das AWS Glue Katalogtrennzeichen** — Bei diesem Ansatz schließen Sie die Konto-ID des Besitzers in Ihre Abfragen ein. Verwenden Sie diese Methode, wenn Sie die Sitzung verwenden möchten, um Datenkataloge von verschiedenen Besitzern abzufragen.
+ **Die AWS Glue Katalog-ID** — Bei diesem Ansatz fragen Sie die Datenbank direkt ab. Diese Methode ist praktischer, wenn Sie die Sitzung verwenden möchten, um nur den Datenkatalog eines einzelnen Besitzers abzufragen.
### Verwenden Sie das AWS Glue Katalogtrennzeichen
Wenn Sie die Sitzungseigenschaften bearbeiten, fügen Sie Folgendes hinzu:
```
{
"spark.hadoop.aws.glue.catalog.separator": "/"
}
```
Wenn Sie eine Abfrage in einer Zelle ausführen, verwenden Sie eine Syntax wie im folgenden Beispiel. Beachten Sie, dass in der `FROM`-Klausel die Katalog-ID und das Trennzeichen vor dem Datenbanknamen angegeben werden müssen.
```
df = spark.sql('SELECT requestip, uri, method, status FROM `999999999999/mydatabase`.cloudfront_logs LIMIT 5')
df.show()
```
### Verwenden Sie die AWS Glue Katalog-ID
Wenn Sie die Sitzungseigenschaften bearbeiten, fügen Sie folgende Eigenschaft hinzu. Ersetzen Sie sie *999999999999* durch die Konto-ID des Besitzers.
```
{
"spark.hadoop.hive.metastore.glue.catalogid": "999999999999"
}
```
Wenn Sie eine Abfrage in einer Zelle ausführen, verwenden Sie eine Syntax wie die folgende. Beachten Sie, dass in der `FROM`-Klausel die Katalog-ID und das Trennzeichen vor dem Datenbanknamen nicht angegeben werden müssen.
```
df = spark.sql('SELECT * FROM mydatabase.cloudfront_logs LIMIT 10')
df.show()
```
## Weitere Ressourcen
[Kontenübergreifenden Zugriff auf AWS Glue Datenkataloge konfigurieren](security-iam-cross-account-glue-catalog-access.md)
[Verwaltung kontenübergreifender Berechtigungen AWS Glue sowohl mit Lake Formation als auch mit Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/hybrid-cross-account.html) im *AWS Lake Formation Developer Guide*.
[Konfigurieren Sie in *AWS Prescriptive* Guidance Patterns den kontoübergreifenden Zugriff auf ein geteiltes Objekt AWS Glue Data Catalog mithilfe von Amazon Athena](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-a-shared-aws-glue-data-catalog-using-amazon-athena.html).
# Grundlegendes über Service Quotas für Athena für Spark
*Dienstkontingente*, auch *Limits* genannt, sind die maximale Anzahl von Dienstressourcen oder Vorgängen, die Sie verwenden AWS-Konto können. Weitere Informationen zu den Servicekontingenten für andere AWS Dienste, die Sie mit Amazon Athena for Spark verwenden können, finden Sie unter [AWS Servicekontingenten](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) in der *Allgemeine Amazon Web Services-Referenz*.
**Anmerkung**
Bei den Standardwerten handelt es sich um die anfänglichen Kontingente AWS, die vom tatsächlich angewendeten Kontingent und dem maximal möglichen Servicekontingent getrennt sind. Neue Kontingente haben AWS-Konten möglicherweise anfänglich niedrigere Kontingente, die sich im Laufe der Zeit erhöhen können. Amazon Athena for Apache Spark überwacht die Kontonutzung innerhalb der einzelnen AWS-Region Konten und erhöht dann automatisch die Kontingente entsprechend Ihrer Nutzung. Wenn Ihre Anforderungen die angegebenen Grenzwerte überschreiten, wenden Sie sich an den Kundensupport.
In der folgenden Tabelle sind die Servicekontingente für Amazon Athena für Apache-Spark aufgeführt.
****
| Name | Standard | Anpassbar | Version | Description |
| --- | --- | --- | --- | --- |
| Parallelität von Apache Spark DPU | 160 | Nein | PySpark Version 3 | Die maximale Anzahl von Datenverarbeitungseinheiten (DPUs), die Sie derzeit gleichzeitig für Apache Spark-Berechnungen für ein einzelnes Konto verwenden können. AWS-Region Eine DPU ist ein relatives Maß für die Rechenleistung, das sich aus 4 V CPUs Rechenkapazität und 16 GB Arbeitsspeicher zusammensetzt. |
| Sitzungs-Parallelität von Apache Spark DPU | 60 | Nein | PySpark Version 3 | Die maximale Anzahl von, die DPUs Sie gleichzeitig für eine Apache Spark-Berechnung innerhalb einer Sitzung verwenden können. |
| Auf Abruf DPUs | 4 | Nein | Apache Spark Version 3.5 | Die maximale Anzahl von Datenverarbeitungseinheiten (DPUs), die Sie derzeit gleichzeitig für interaktive Apache Spark-Sitzungen verwenden können. AWS-Region |
# Benutze Athena Spark APIs
**Anmerkung**
Athena-Notebooks und Berechnungen APIs sind in der Release-Version Pyspark Engine Version 3 verfügbar. Notizbücher und Berechnungen APIs werden in der Release-Version Apache Spark Version 3.5 nicht unterstützt.
Die folgende Liste enthält Referenzlinks zu den Athena-Notebook-API-Aktionen. Datenstrukturen und andere Athena-API-Aktionen finden Sie in der [https://docs.aws.amazon.com/athena/latest/APIReference/](https://docs.aws.amazon.com/athena/latest/APIReference/).
+ [CreateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateNotebook.html)
+ [CreatePresignedNotebookUrl](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreatePresignedNotebookUrl.html)
+ [DeleteNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_DeleteNotebook.html)
+ [ExportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ExportNotebook.html)
+ [GetCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecution.html)
+ [GetCalculationExecutionCode](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecutionCode.html)
+ [GetCalculationExecutionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecutionStatus.html)
+ [GetNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetNotebookMetadata.html)
+ [GetSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetSession.html)
+ [GetSessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetSessionStatus.html)
+ [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html)
+ [ListApplicationDPUSizes](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListApplicationDPUSizes.html)
+ [ListCalculationExecutions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListCalculationExecutions.html)
+ [ListExecutors](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListExecutors.html)
+ [ListNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListNotebookMetadata.html)
+ [ListNotebookSessions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListNotebookSessions.html)
+ [ListSessions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListSessions.html)
+ [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html)
+ [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)
+ [StopCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StopCalculationExecution.html)
+ [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html)
+ [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html)
+ [UpdateNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebookMetadata.html)
# Fehlerbehebung in Athena für Spark
Verwenden Sie die folgenden Informationen, um Probleme zu beheben, die bei der Verwendung von Notebooks und Sitzungen auf Athena auftreten können.
**Topics**
+ [Erfahren Sie mehr über bekannte Probleme in Athena für Spark](notebooks-spark-known-issues.md)
+ [Fehlerbehebung bei Spark-fähigen Arbeitsgruppen](notebooks-spark-troubleshooting-workgroups.md)
+ [Verwenden der Spark-EXPLAIN-Anweisung zur Fehlerbehebung in Spark SQL](notebooks-spark-troubleshooting-explain.md)
+ [Spark-Anwendungsereignisse in Athena protokollieren](notebooks-spark-logging.md)
+ [Wird CloudTrail zur Fehlerbehebung bei Athena-Notebook-API-Aufrufen verwendet](notebooks-spark-troubleshooting-cloudtrail.md)
+ [Die Beschränkung der Codeblockgröße auf 68k überwinden](notebooks-spark-troubleshooting-code-block-size-limit.md)
+ [Sitzungsfehler beheben](notebooks-spark-troubleshooting-sessions.md)
+ [Beheben von Tabellen-Fehlern](notebooks-spark-troubleshooting-tables.md)
+ [Anfordern von Unterstützung](notebooks-spark-troubleshooting-support.md)
# Erfahren Sie mehr über bekannte Probleme in Athena für Spark
Diese Seite dokumentiert einige der bekannten Probleme in Athena für Apache Spark.
## Unzulässige Argumentausnahme beim Erstellen einer Tabelle
Spark erlaubt zwar nicht, Datenbanken mit einer leeren Standorteigenschaft zu erstellen, aber Datenbanken in AWS Glue können eine leere `LOCATION` Eigenschaft haben, wenn sie außerhalb von Spark erstellt wurden.
Wenn Sie eine Tabelle erstellen und eine AWS Glue Datenbank mit einem leeren `LOCATION` Feld angeben, kann eine Ausnahme wie die folgende auftreten IllegalArgumentException: Aus einer leeren Zeichenfolge kann kein Pfad erstellt werden.
Der folgende Befehl löst beispielsweise eine Ausnahme aus, wenn die Standarddatenbank in AWS Glue ein leeres `LOCATION`-Feld enthält:
```
spark.sql("create table testTable (firstName STRING)")
```
**Lösungsvorschlag A** — Verwenden Sie diese AWS Glue Option, um der Datenbank, die Sie verwenden, einen Speicherort hinzuzufügen.
**Um einer AWS Glue Datenbank einen Standort hinzuzufügen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Wählen Sie im Navigationsbereich **Datenbanken** aus.
1. Wählen Sie in der Liste der Datenbanken die Datenbank aus, die Sie bearbeiten möchten.
1. Wählen Sie auf der Detailseite für die Datenbank **Edit** (Bearbeiten) aus.
1. Geben Sie auf der Seite **Update a database** (Datenbank aktualisieren) für **Location** (Speicherort) einen Amazon-S3-Speicherort ein.
1. Wählen Sie **Update Database** (Datenbank aktualisieren) aus.
**Lösungsvorschlag B** – Verwenden Sie eine andere AWS Glue -Datenbank, die über einen vorhandenen, gültigen Speicherort in Amazon S3 verfügt. Wenn Sie beispielsweise eine Datenbank mit dem Namen `dbWithLocation` haben, verwenden Sie den Befehl `spark.sql("use dbWithLocation")`, um zu dieser Datenbank zu wechseln.
**Lösungsvorschlag C** – Wenn Sie Spark SQL zum Erstellen der Tabelle verwenden, geben Sie einen Wert für `location` an, wie im folgenden Beispiel.
```
spark.sql("create table testTable (firstName STRING)
location 's3://amzn-s3-demo-bucket/'").
```
**Lösungsvorschlag D** – Wenn Sie bei der Erstellung der Tabelle einen Speicherort angegeben haben, das Problem jedoch weiterhin auftritt, stellen Sie sicher, dass der von Ihnen angegebene Amazon-S3-Pfad einen abschließenden Schrägstrich enthält. Der folgende Befehl löst beispielsweise eine Ausnahme für ein unzulässiges Argument aus:
```
spark.sql("create table testTable (firstName STRING)
location 's3://amzn-s3-demo-bucket'")
```
Um dies zu korrigieren, fügen Sie dem Speicherort einen abschließenden Schrägstrich hinzu (z. B. `'s3://amzn-s3-demo-bucket/'`).
## An einem Arbeitsgruppenspeicherort erstellte Datenbank
Wenn Sie einen Befehl wie `spark.sql('create database db')` zum Erstellen einer Datenbank verwenden und keinen Speicherort für die Datenbank angeben, erstellt Athena ein Unterverzeichnis in Ihrem Arbeitsgruppenverzeichnis und verwendet diesen Speicherort für die neu erstellte Datenbank.
## Probleme mit von Hive verwalteten Tabellen in der AWS Glue Standarddatenbank
Wenn die `Location` Eigenschaft Ihrer Standarddatenbank in nicht leer AWS Glue ist und einen gültigen Speicherort in Amazon S3 angibt und Sie Athena for Spark verwenden, um eine von Hive verwaltete Tabelle in Ihrer AWS Glue Standarddatenbank zu erstellen, werden Daten in den Amazon S3 S3-Standort geschrieben, der in Ihrer Athena Spark-Arbeitsgruppe angegeben ist, anstatt in den von der Datenbank angegebenen Speicherort. AWS Glue
Dieses Problem tritt aufgrund der Art und Weise auf, wie Apache Hive seine Standarddatenbank behandelt. Apache Hive erstellt Tabellendaten im Stammverzeichnis des Hive-Warehouses, das sich vom tatsächlichen Standardspeicherort der Datenbank unterscheiden kann.
Wenn Sie Athena for Spark verwenden, um eine von Hive verwaltete Tabelle unter der Standarddatenbank in zu erstellen AWS Glue, können die AWS Glue Tabellenmetadaten auf zwei verschiedene Speicherorte verweisen. Dies kann zu unerwartetem Verhalten führen, wenn Sie versuchen, einen `INSERT`- oder `DROP TABLE`-Vorgang durchzuführen.
Gehen Sie wie folgt vor, um das Problem zu reproduzieren:
1. In Athena für Spark verwenden Sie eine der folgenden Methoden zum Erstellen oder Speichern einer verwalteten Hive-Tabelle:
+ Eine SQL-Anweisung wie `CREATE TABLE $tableName`
+ Ein PySpark solcher Befehl spezifiziert `df.write.mode("overwrite").saveAsTable($tableName)` die `path` Option in der DataFrame-API nicht.
Zu diesem Zeitpunkt zeigt die AWS Glue Konsole möglicherweise einen falschen Speicherort für die Tabelle in Amazon S3 an.
1. In Athena für Spark verwenden Sie die `DROP TABLE $table_name`-Anweisung, um die von Ihnen erstellte Tabelle zu entfernen.
1. Nachdem Sie die `DROP TABLE`-Anweisung ausgeführt haben, stellen Sie fest, dass die zugrunde liegenden Dateien in Amazon S3 immer noch vorhanden sind.
Sie lösen dieses Problem, indem Sie einen der folgenden Schritte ausführen:
**Lösung A** — Verwenden Sie eine andere AWS Glue Datenbank, wenn Sie von Hive verwaltete Tabellen erstellen.
**Lösung B** – Geben Sie einen leeren Speicherort für die Standarddatenbank in AWS Glue an. Erstellen Sie dann Ihre verwalteten Tabellen in der Standarddatenbank.
## Inkompatibilität der CSV- und JSON-Dateiformate zwischen Athena für Spark und Athena SQL
Aufgrund eines bekannten Problems mit Open-Source-Spark ist die Tabelle, wenn Sie in Athena für Spark mit CSV- oder JSON-Daten erstellen, möglicherweise nicht von Athena SQL aus lesbar und umgekehrt.
Für das Erstellen einer Tabelle in Athena für Spark steht Ihnen beispielsweise eine der folgenden Methoden zur Verfügung:
+ Mit der folgenden `USING csv`-Syntax:
```
spark.sql('''CREATE EXTERNAL TABLE $tableName (
$colName1 $colType1,
$colName2 $colType2,
$colName3 $colType3)
USING csv
PARTITIONED BY ($colName1)
LOCATION $s3_location''')
```
+ Mit der folgenden [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html)API-Syntax:
```
df.write.format('csv').saveAsTable($table_name)
```
Aufgrund des bekannten Problems mit Open Source Spark sind Abfragen von Athena SQL für die resultierenden Tabellen möglicherweise nicht erfolgreich.
**Lösungsvorschlag** – Versuchen Sie, die Tabelle in Athena für Spark mit der Apache-Hive-Syntax zu erstellen. Weitere Informationen finden Sie unter [HIVEFORMAT-TABELLE ERSTELLEN](https://spark.apache.org/docs/latest/sql-ref-syntax-ddl-create-table-hiveformat.html) in der Apache-Spark-Dokumentation.
# Fehlerbehebung bei Spark-fähigen Arbeitsgruppen
Verwenden Sie die folgenden Informationen für die Fehlerbehebung in Spark-fähigen Arbeitsgruppen in Athena.
## Die Sitzung reagiert nicht mehr, wenn eine vorhandene IAM-Rolle verwendet wird
Wenn Sie kein neues `AWSAthenaSparkExecutionRole` für Ihre Spark-fähige Arbeitsgruppe erstellt und stattdessen eine vorhandene IAM-Rolle aktualisiert oder ausgewählt haben, reagiert Ihre Sitzung möglicherweise nicht mehr. In diesem Fall müssen Sie möglicherweise die folgenden Vertrauens- und Berechtigungsrichtlinien zu Ihrer Spark-fähigen Arbeitsgruppen-Ausführungsrolle hinzufügen.
Fügen Sie die folgende Beispiel-Vertrauensrichtlinie hinzu. Die Richtlinie enthält eine verwechselte Stellvertreterprüfung für die Ausführungsrolle. Ersetzen Sie die Werte für `111122223333``aws-region`, und `workgroup-name` durch die AWS-Konto ID AWS-Region, und Arbeitsgruppe, die Sie verwenden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "athena.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:athena:us-east-1:111122223333:workgroup/workgroup-name"
}
}
}
]
}
```
------
Fügen Sie eine Berechtigungsrichtlinie wie die folgende Standardrichtlinie für Notebook-fähige Arbeitsgruppen hinzu. Ändern Sie den Platzhalter Amazon S3 S3-Speicherorte so AWS-Konto IDs , dass er den Speicherorten entspricht, die Sie verwenden. Ersetzen Sie die Werte für `amzn-s3-demo-bucket`, `aws-region`, `111122223333` und `workgroup-name` durch den Amazon-S3-Bucket, AWS-Region, AWS-Konto -ID und die Arbeitsgruppe, die Sie verwenden.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [
"s3:PutObject", "s3:ListBucket", "s3:DeleteObject", "s3:GetObject" ], "Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Effect": "Allow",
"Action": [ "athena:GetWorkGroup", "athena:CreatePresignedNotebookUrl",
"athena:TerminateSession", "athena:GetSession", "athena:GetSessionStatus",
"athena:ListSessions", "athena:StartCalculationExecution", "athena:GetCalculationExecutionCode",
"athena:StopCalculationExecution", "athena:ListCalculationExecutions",
"athena:GetCalculationExecution", "athena:GetCalculationExecutionStatus",
"athena:ListExecutors", "athena:ExportNotebook", "athena:UpdateNotebook" ], "Resource":
"arn:aws:athena:us-east-1:111122223333:workgroup/workgroup-name"
}, { "Effect": "Allow", "Action": [ "logs:CreateLogStream", "logs:DescribeLogStreams",
"logs:CreateLogGroup", "logs:PutLogEvents" ], "Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-athena:*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-athena*:log-stream:*"
] }, { "Effect": "Allow", "Action": "logs:DescribeLogGroups", "Resource":
"arn:aws:logs:us-east-1:111122223333:log-group:*"
}, { "Effect": "Allow", "Action": [ "cloudwatch:PutMetricData" ], "Resource": "*", "Condition":
{ "StringEquals": { "cloudwatch:namespace": "AmazonAthenaForApacheSpark" } } } ] }
```
------
# Verwenden der Spark-EXPLAIN-Anweisung zur Fehlerbehebung in Spark SQL
Sie können die `EXPLAIN`-Anweisung von Spark mit Spark SQL verwenden, um Fehler in Ihrem Spark-Code zu beheben. Die folgenden Code- und Ausgabebeispiele veranschaulichen diese Verwendung.
**Example – Spark-SELECT-Anweisung**
```
spark.sql("select * from select_taxi_table").explain(True)
```
**Ausgabe**
```
Calculation started (calculation_id=20c1ebd0-1ccf-ef14-db35-7c1844876a7e) in
(session=24c1ebcb-57a8-861e-1023-736f5ae55386).
Checking calculation status...
Calculation completed.
== Parsed Logical Plan ==
'Project [*]
+- 'UnresolvedRelation [select_taxi_table], [], false
== Analyzed Logical Plan ==
VendorID: bigint, passenger_count: bigint, count: bigint
Project [VendorID#202L, passenger_count#203L, count#204L]
+- SubqueryAlias spark_catalog.spark_demo_database.select_taxi_table
+- Relation spark_demo_database.select_taxi_table[VendorID#202L,
passenger_count#203L,count#204L] csv
== Optimized Logical Plan ==
Relation spark_demo_database.select_taxi_table[VendorID#202L,
passenger_count#203L,count#204L] csv
== Physical Plan ==
FileScan csv spark_demo_database.select_taxi_table[VendorID#202L,
passenger_count#203L,count#204L]
Batched: false, DataFilters: [], Format: CSV,
Location: InMemoryFileIndex(1 paths)
[s3://amzn-s3-demo-bucket/select_taxi],
PartitionFilters: [], PushedFilters: [],
ReadSchema: struct
```
**Example – Spark-Datenrahmen**
Das folgende Beispiel zeigt die Verwendung von `EXPLAIN` mit einem Spark-Datenrahmen.
```
taxi1_df=taxi_df.groupBy("VendorID", "passenger_count").count()
taxi1_df.explain("extended")
```
**Ausgabe**
```
Calculation started (calculation_id=d2c1ebd1-f9f0-db25-8477-3effc001b309) in
(session=24c1ebcb-57a8-861e-1023-736f5ae55386).
Checking calculation status...
Calculation completed.
== Parsed Logical Plan ==
'Aggregate ['VendorID, 'passenger_count],
['VendorID, 'passenger_count, count(1) AS count#321L]
+- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51,
passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55,
PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,
extra#60,mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64,
total_amount#65,congestion_surcharge#66,airport_fee#67] parquet
== Analyzed Logical Plan ==
VendorID: bigint, passenger_count: bigint, count: bigint
Aggregate [VendorID#49L, passenger_count#52L],
[VendorID#49L, passenger_count#52L, count(1) AS count#321L]
+- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51,
passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55,
PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,extra#60,
mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64,
total_amount#65,congestion_surcharge#66,airport_fee#67] parquet
== Optimized Logical Plan ==
Aggregate [VendorID#49L, passenger_count#52L],
[VendorID#49L, passenger_count#52L, count(1) AS count#321L]
+- Project [VendorID#49L, passenger_count#52L]
+- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51,
passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55,
PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,extra#60,
mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64,
total_amount#65,congestion_surcharge#66,airport_fee#67] parquet
== Physical Plan ==
AdaptiveSparkPlan isFinalPlan=false
+- HashAggregate(keys=[VendorID#49L, passenger_count#52L], functions=[count(1)],
output=[VendorID#49L, passenger_count#52L, count#321L])
+- Exchange hashpartitioning(VendorID#49L, passenger_count#52L, 1000),
ENSURE_REQUIREMENTS, [id=#531]
+- HashAggregate(keys=[VendorID#49L, passenger_count#52L],
functions=[partial_count(1)], output=[VendorID#49L,
passenger_count#52L, count#326L])
+- FileScan parquet [VendorID#49L,passenger_count#52L] Batched: true,
DataFilters: [], Format: Parquet,
Location: InMemoryFileIndex(1 paths)[s3://amzn-s3-demo-bucket/
notebooks/yellow_tripdata_2016-01.parquet], PartitionFilters: [],
PushedFilters: [],
ReadSchema: struct
```
# Spark-Anwendungsereignisse in Athena protokollieren
Der Athena-Notebook-Editor ermöglicht die Standardprotokollierung von Jupyter, Spark und Python. Sie können `df.show()` sie zur Anzeige von PySpark DataFrame Inhalten oder `print("Output")` zur Anzeige von Werten in der Zellenausgabe verwenden. Die `stdout`-, `stderr`-, und `results`-Ausgaben für Ihre Berechnungen werden in den Bucket-Speicherort Ihrer Abfrageergebnisse in Amazon S3 geschrieben.
## Spark-Anwendungsereignisse bei Amazon protokollieren CloudWatch
Ihre Athena-Sitzungen können auch Protokolle für das Konto, das Sie verwenden, an [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) schreiben.
### Grundlegendes zu Protokollstreams und Protokollgruppen
CloudWatch organisiert die Protokollaktivitäten in Protokollstreams und Protokollgruppen.
**Protokollstreams** — Ein CloudWatch Protokollstream ist eine Folge von Protokollereignissen, die dieselbe Quelle haben. Jede einzelne Protokollquelle in CloudWatch Logs bildet einen separaten Protokollstream.
**Protokollgruppen** — In CloudWatch Logs ist eine Protokollgruppe eine Gruppe von Protokollstreams, die dieselben Einstellungen für Aufbewahrung, Überwachung und Zugriffskontrolle verwenden.
Es gibt keine Begrenzung dazu, wie viele Protokollstreams zu einer Protokollgruppe gehören können.
Wenn Sie in Athena zum ersten Mal eine Notebook-Sitzung starten, erstellt Athena eine Protokollgruppe, die den Namen Ihrer Spark-fähigen Arbeitsgruppe verwendet, wie im CloudWatch folgenden Beispiel.
```
/aws-athena/workgroup-name
```
Diese Protokollgruppe erhält einen Protokollstream für jeden Executor in Ihrer Sitzung, der mindestens ein Protokollereignis erzeugt. Ein Executor ist die kleinste Recheneinheit, die eine Notebook-Sitzung von Athena anfragen kann. In CloudWatch beginnt der Name des Protokollstreams mit der Sitzungs-ID und der Executor-ID.
Weitere Informationen zu CloudWatch Protokollgruppen und Log-Streams finden Sie unter [Working with log groups and log streams](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) im Amazon CloudWatch Logs-Benutzerhandbuch.
### Verwenden von Standard-Protokollierungsobjekten in Athena für Spark
In einer Athena for Spark-Sitzung können Sie die folgenden zwei globalen Standard-Logger-Objekte verwenden, um Logs in Amazon CloudWatch zu schreiben:
+ **athena\$1user\$1logger** — Sendet Protokolle nur an. CloudWatch Verwenden Sie dieses Objekt, wenn Sie Informationen direkt in Ihre Spark-Anwendungen protokollieren möchten CloudWatch, wie im folgenden Beispiel.
```
athena_user_logger.info("CloudWatch log line.")
```
Im Beispiel wird ein Protokollereignis CloudWatch wie folgt geschrieben:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: CloudWatch log line.
```
+ **athena\$1shared\$1logger** — Sendet dasselbe Protokoll sowohl an als auch zu CloudWatch Supportzwecken. AWS Sie können dieses Objekt verwenden, um Protokolle zur Fehlerbehebung an AWS Serviceteams weiterzugeben, wie im folgenden Beispiel gezeigt.
```
athena_shared_logger.info("Customer debug line.")
var = [...some variable holding customer data...]
athena_shared_logger.info(var)
```
Das Beispiel protokolliert die `debug` Zeile und den Wert der `var` Variablen in CloudWatch Logs und sendet eine Kopie jeder Zeile an Support.
**Anmerkung**
Aus Datenschutzgründen werden Ihr Berechnungscode und Ihre Ergebnisse nicht an Dritte weitergegeben AWS. Stellen Sie sicher, dass Ihre Aufrufe an `athena_shared_logger` nur die Informationen schreiben, die Sie für Support sichtbar machen möchten.
Die bereitgestellten Protokollierer schreiben Ereignisse über [Apache Log4j](https://logging.apache.org/log4j/) und erben die Protokollierungsebenen dieser Schnittstelle. Mögliche Werte für die Protokollebene sind `DEBUG`, `ERROR`, `FATAL`, `INFO` und `WARN` oder `WARNING`. Sie können die entsprechend benannte Funktion auf dem Protokollierer verwenden, um diese Werte zu erzeugen.
**Anmerkung**
Verknüpfen Sie die Namen `athena_user_logger` oder `athena_shared_logger` nicht neu. Dadurch können die Protokollierungsobjekte CloudWatch für den Rest der Sitzung nicht mehr aufgerufen werden.
### Beispiel: Notizbuchereignisse protokollieren in CloudWatch
Das folgende Verfahren zeigt, wie Athena-Notebook-Ereignisse in Amazon CloudWatch Logs protokolliert werden.
**Um Athena-Notebook-Ereignisse in Amazon CloudWatch Logs zu protokollieren**
1. Befolgen Sie [Erste Schritte mit Apache Spark auf Amazon Athena](notebooks-spark-getting-started.md), um eine Spark-fähige Arbeitsgruppe in Athena mit einem eindeutigen Namen zu erstellen. In diesem Tutorial wird der Arbeitsgruppenname `athena-spark-example` verwendet.
1. Folgen Sie den Schritten unter [Schritt 7: Erstellen Sie ein eigenes Notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook), um ein Notebook zu erstellen und eine neue Sitzung zu starten.
1. Geben Sie im Athena-Notebook-Editor in einer neuen Notebook-Zelle den folgenden Befehl ein:
```
athena_user_logger.info("Hello world.")
```
1. Führen Sie die Zelle aus.
1. Rufen Sie die aktuelle Sitzungs-ID ab, indem Sie eine der folgenden Aktionen ausführen:
+ Zeigen Sie die Zellenausgabe an (z. B .`... session=72c24e73-2c24-8b22-14bd-443bdcd72de4`).
+ Führen Sie in einer neuen Zelle den [Magic](notebooks-spark-magics.md)-Befehl `%session_id` aus.
1. Speichern Sie die Sitzungs-ID.
1. Öffnen Sie mit derselben Konsole AWS-Konto , die Sie für die Ausführung der Notebook-Sitzung verwenden, die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Wählen Sie im Navigationsbereich der CloudWatch Konsole die Option **Protokollgruppen** aus.
1. Wählen Sie in der Liste von Protokollgruppen die Protokollgruppe aus, die den Namen Ihrer Spark-fähigen Athena-Arbeitsgruppe trägt, wie im folgenden Beispiel gezeigt.
```
/aws-athena/athena-spark-example
```
Der Abschnitt **Protokollstreams** enthält eine Liste mit einem oder mehreren Protokollstream-Links für die Arbeitsgruppe. Jeder Protokollstream-Name enthält die Sitzungs-ID, die Executor-ID und die eindeutige UUID, getrennt durch Schrägstriche.
Wenn die Sitzungs-ID beispielsweise `5ac22d11-9fd8-ded7-6542-0412133d3177` und die Executor-ID `f8c22d11-9fd8-ab13-8aba-c4100bfba7e2` lautet, ähnelt der Name des Protokollstreams dem folgenden Beispiel.
```
5ac22d11-9fd8-ded7-6542-0412133d3177/f8c22d11-9fd8-ab13-8aba-c4100bfba7e2/f012d7cb-cefd-40b1-90b9-67358f003d0b
```
1. Wählen Sie den Protokollstream-Link für Ihre Sitzung aus.
1. Rufen Sie auf der Seite **Log events** (Protokollereignisse) die Spalte **Message** (Nachricht) auf.
Das Protokollereignis für die Zelle, die Sie ausgeführt haben, sieht folgendermaßen aus:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: Hello world.
```
1. Kehren Sie zum Athena-Notebook-Editor zurück.
1. Geben Sie in einer neuen Zelle den folgenden Code ein. Der Code protokolliert eine Variable in CloudWatch:
```
x = 6
athena_user_logger.warn(x)
```
1. Führen Sie die Zelle aus.
1. Kehren Sie zur CloudWatch Konsolenseite „**Ereignisse protokollieren**“ für denselben Protokollstream zurück.
1. Der Protokollstream enthält nun einen Eintrag für ein Protokollereignis mit einer Meldung wie der folgenden:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 WARN builtins: 6
```
# Wird CloudTrail zur Fehlerbehebung bei Athena-Notebook-API-Aufrufen verwendet
Zur Fehlerbehebung bei API-Aufrufen von Notebooks können Sie die CloudTrail Athena-Protokolle untersuchen, um Anomalien zu untersuchen oder von Benutzern initiierte Aktionen zu entdecken. Ausführliche Informationen zur Verwendung CloudTrail mit Athena finden Sie unter[Amazon Athena Athena-API-Aufrufe protokollieren mit AWS CloudTrail](monitor-with-cloudtrail.md).
Die folgenden Beispiele zeigen CloudTrail Protokolleinträge für das Athena-Notizbuch APIs.
## StartSession
Das folgende Beispiel zeigt das CloudTrail Protokoll für ein [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)Notebook-Ereignis.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:alias",
"arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/Admin",
"accountId": "123456789012",
"userName": "Admin"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:41:51Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T17:05:36Z",
"eventSource": "athena.amazonaws.com",
"eventName": "StartSession",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.10",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
"requestParameters": {
"workGroup": "notebook-workgroup",
"engineConfiguration": {
"coordinatorDpuSize": 1,
"maxConcurrentDpus": 20,
"defaultExecutorDpuSize": 1,
"additionalConfigs": {
"NotebookId": "b8f5854b-1042-4b90-9d82-51d3c2fd5c04",
"NotebookIframeParentUrl": "https://us-east-1.console.aws.amazon.com"
}
},
"notebookVersion": "KeplerJupyter-1.x",
"sessionIdleTimeoutInMinutes": 20,
"clientRequestToken": "d646ff46-32d2-42f0-94d1-d060ec3e5d78"
},
"responseElements": {
"sessionId": "a2c1ebba-ad01-865f-ed2d-a142b7451f7e",
"state": "CREATED"
},
"requestID": "d646ff46-32d2-42f0-94d1-d060ec3e5d78",
"eventID": "b58ce998-eb89-43e9-8d67-d3d8e30561c9",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
},
"sessionCredentialFromConsole": "true"
}
```
## TerminateSession
Das folgende Beispiel zeigt das CloudTrail Protokoll für ein [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html)Notebook-Ereignis.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:alias",
"arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/Admin",
"accountId": "123456789012",
"userName": "Admin"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:41:51Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T17:21:03Z",
"eventSource": "athena.amazonaws.com",
"eventName": "TerminateSession",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.11",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
"requestParameters": {
"sessionId": "a2c1ebba-ad01-865f-ed2d-a142b7451f7e"
},
"responseElements": {
"state": "TERMINATING"
},
"requestID": "438ea37e-b704-4cb3-9a76-391997cf42ee",
"eventID": "49026c5a-bf58-4cdb-86ca-978e711ad238",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
},
"sessionCredentialFromConsole": "true"
}
```
## ImportNotebook
Das folgende Beispiel zeigt das CloudTrail Protokoll für ein [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html)Notebook-Ereignis. Aus Sicherheitsgründen werden einige Inhalte ausgeblendet.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:alias",
"arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/Admin",
"accountId": "123456789012",
"userName": "Admin"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:41:51Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T17:08:54Z",
"eventSource": "athena.amazonaws.com",
"eventName": "ImportNotebook",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.12",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
"requestParameters": {
"workGroup": "notebook-workgroup",
"name": "example-notebook-name",
"payload": "HIDDEN_FOR_SECURITY_REASONS",
"type": "IPYNB",
"contentMD5": "HIDDEN_FOR_SECURITY_REASONS"
},
"responseElements": {
"notebookId": "05f6225d-bdcc-4935-bc25-a8e19434652d"
},
"requestID": "813e777f-6dac-41f4-82a7-e99b7b33f319",
"eventID": "4abec837-143b-4458-9c1f-fa9fb88ab69b",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
},
"sessionCredentialFromConsole": "true"
}
```
## UpdateNotebook
Das folgende Beispiel zeigt das CloudTrail Protokoll für ein [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html)Notebook-Ereignis. Aus Sicherheitsgründen werden einige Inhalte ausgeblendet.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"arn": "arn:aws:sts::123456789012:assumed-role/AWSAthenaSparkExecutionRole-om0yj71w5l/AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/service-role/AWSAthenaSparkExecutionRole-om0yj71w5l",
"accountId": "123456789012",
"userName": "AWSAthenaSparkExecutionRole-om0yj71w5l"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:48:06Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T16:52:22Z",
"eventSource": "athena.amazonaws.com",
"eventName": "UpdateNotebook",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.13",
"userAgent": "Boto3/1.24.84 Python/3.8.14 Linux/4.14.225-175.364.amzn2.aarch64 Botocore/1.27.84",
"requestParameters": {
"notebookId": "c87553ff-e740-44b5-884f-a70e575e08b9",
"payload": "HIDDEN_FOR_SECURITY_REASONS",
"type": "IPYNB",
"contentMD5": "HIDDEN_FOR_SECURITY_REASONS",
"sessionId": "9cc1ebb2-aac5-b1ca-8247-5d827bd8232f"
},
"responseElements": null,
"requestID": "baaba1d2-f73d-4df1-a82b-71501e7374f1",
"eventID": "745cdd6f-645d-4250-8831-d0ffd2fe3847",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
}
}
```
## StartCalculationExecution
Das folgende Beispiel zeigt das CloudTrail Protokoll für ein [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html)Notebook-Ereignis. Aus Sicherheitsgründen werden einige Inhalte ausgeblendet.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"arn": "arn:aws:sts::123456789012:assumed-role/AWSAthenaSparkExecutionRole-om0yj71w5l/AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/service-role/AWSAthenaSparkExecutionRole-om0yj71w5l",
"accountId": "123456789012",
"userName": "AWSAthenaSparkExecutionRole-om0yj71w5l"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:48:06Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T16:52:37Z",
"eventSource": "athena.amazonaws.com",
"eventName": "StartCalculationExecution",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.14",
"userAgent": "Boto3/1.24.84 Python/3.8.14 Linux/4.14.225-175.364.amzn2.aarch64 Botocore/1.27.84",
"requestParameters": {
"sessionId": "9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"description": "Calculation started via Jupyter notebook",
"codeBlock": "HIDDEN_FOR_SECURITY_REASONS",
"clientRequestToken": "0111cd63-4fd0-4ad8-a738-fd350115fc21"
},
"responseElements": {
"calculationExecutionId": "82c1ebb4-bd08-e4c3-5631-a662fb2ff2c5",
"state": "CREATING"
},
"requestID": "1a107461-3f1b-481e-b8a2-7fbd524e2373",
"eventID": "b74dbd00-e839-4bd1-a1da-b75fbc70ab9a",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
}
}
```
# Die Beschränkung der Codeblockgröße auf 68k überwinden
Athena für Spark hat eine bekannte Blockgrößenbeschränkung für Berechnungscodes von 68 000 Zeichen. Wenn Sie eine Berechnung mit einem Codeblock ausführen, der diesen Grenzwert überschreitet, kann die folgende Fehlermeldung angezeigt werden:
'...' bei 'codeBlock' konnte Einschränkung nicht erfüllen: Mitglied muss eine Länge von höchstens 68 000 haben
Die folgende Abbildung zeigt diesen Fehler im Notebook-Editor der Athena-Konsole.
![\[Fehlermeldung zur Codeblockgröße im Athena-Notebook-Editor\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-troubleshooting-code-block-size-limit-1.png)
Derselbe Fehler kann auftreten, wenn Sie die verwenden AWS CLI , um eine Berechnung auszuführen, die einen großen Codeblock enthält, wie im folgenden Beispiel.
```
aws athena start-calculation-execution \
--session-id "{SESSION_ID}" \
--description "{SESSION_DESCRIPTION}" \
--code-block "{LARGE_CODE_BLOCK}"
```
Der Befehl gibt die folgende Fehlermeldung aus:
*\$1LARGE\$1CODE\$1BLOCK\$1*at 'CodeBlock' konnte die Einschränkung nicht erfüllen: Das Element muss eine Länge von weniger als oder gleich 68000 haben
## Workaround
Um dieses Problem zu umgehen, laden Sie die Datei mit Ihrem Anfrage- oder Berechnungscode auf Amazon S3 hoch. Verwenden Sie dann boto3, um die Datei zu lesen und Ihr SQL oder Ihren Code auszuführen.
In den folgenden Beispielen wird davon ausgegangen, dass Sie die Datei mit Ihrer SQL-Abfrage oder Ihrem Python-Code bereits auf Amazon S3 hochgeladen haben.
### SQL-Beispiel
Der folgende Beispielcode liest die `large_sql_query.sql` Datei aus einem Amazon-S3-Bucket und führt dann die umfangreiche Abfrage aus, die die Datei enthält.
```
s3 = boto3.resource('s3')
def read_s3_content(bucket_name, key):
response = s3.Object(bucket_name, key).get()
return response['Body'].read()
# SQL
sql = read_s3_content('bucket_name', 'large_sql_query.sql')
df = spark.sql(sql)
```
### PySpark Beispiel
Der folgende Beispielcode liest die `large_py_spark.py`-Datei aus einem Amazon-S3-Bucket und führt dann die umfangreiche Abfrage aus, die die Datei enthält.
```
s3 = boto3.resource('s3')
def read_s3_content(bucket_name, key):
response = s3.Object(bucket_name, key).get()
return response['Body'].read()
# PySpark
py_spark_code = read_s3_content('bucket_name', 'large_py_spark.py')
exec(py_spark_code)
```
# Sitzungsfehler beheben
Verwenden Sie die Informationen in diesem Abschnitt, um Sitzungsprobleme zu beheben.
Wenn während eines Sitzungsstarts ein benutzerdefinierter Konfigurationsfehler auftritt, zeigt die Konsole von Athena für Spark ein Fehlermeldungsbanner an. Um Fehler beim Sitzungsstart zu beheben, können Sie die Änderung des Sitzungsstatus oder die Protokollierungsinformationen überprüfen.
## Informationen zur Änderung des Sitzungsstatus anzeigen
Einzelheiten zu einer Änderung des Sitzungsstatus erhalten Sie im Athena-Notebook-Editor oder in der Athena-API.
**So zeigen Sie Informationen zum Sitzungsstatus in der Athena-Konsole an**
1. Wählen Sie im Notebook-Editor im Menü **Sitzung** oben rechts die Option **Details anzeigen** aus.
1. Sehen Sie sich die Registerkarte **Aktuelle Sitzung** an. Im Abschnitt **Sitzungsinformationen** werden Informationen wie Sitzungs-ID, Arbeitsgruppe, Status und Grund für die Statusänderung angezeigt.
Das folgende Beispiel für eine Bildschirmaufnahme zeigt Informationen im Abschnitt **Grund der Statusänderung** des Dialogfelds **Sitzungsinformationen** für einen Spark-Sitzungsfehler in Athena.
![\[Anzeigen von Informationen zu Sitzungsstatusänderungen in der Konsole von Athena für Spark.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/notebooks-spark-custom-jar-cfg-1.jpeg)
**So zeigen Sie Sitzungsstatusinformationen mithilfe der Athena-API an**
+ In der Athena-API finden Sie Informationen zur Änderung des Sitzungsstatus im `StateChangeReason` [SessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_SessionStatus.html)Objektfeld.
**Anmerkung**
Nachdem Sie eine Sitzung manuell beendet haben oder wenn die Sitzung nach einem Leerlauf-Timeout beendet wird (die Standardeinstellung ist 20 Minuten), wurde der Wert der **StateChangeReason**Änderungen an Session pro Anfrage beendet.
## Protokollierung zur Behebung von Sitzungsstartfehlern verwenden
Benutzerdefinierte Konfigurationsfehler, die während eines Sitzungsstarts auftreten, werden von [Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) protokolliert CloudWatch. Suchen Sie in Ihren CloudWatch Protokollen nach Fehlermeldungen von, `AthenaSparkSessionErrorLogger` um einen fehlgeschlagenen Sitzungsstart zu beheben.
Weitere Informationen zur Spark-Protokollierung finden Sie unter [Spark-Anwendungsereignisse in Athena protokollieren](notebooks-spark-logging.md).
Weitere Informationen zu Problembehandlungssitzungen in Athena für Spark finden Sie unter [Sitzungsfehler beheben](#notebooks-spark-troubleshooting-sessions).
## Spezifische Sitzungsprobleme
Verwenden Sie die Informationen in diesem Abschnitt, um bestimmte Sitzungsprobleme zu beheben.
### Sitzung in fehlerhaftem Zustand
Wenn Sie die Fehlermeldung Sitzung im fehlerhaftem Zustand erhalten. Erstellen Sie eine neue Sitzung, beenden Sie Ihre bestehende Sitzung und erstellen Sie eine neue.
### Es konnte keine Verbindung zum Notebook-Server hergestellt werden
Wenn Sie ein Notebook öffnen, finden Sie möglicherweise die folgende Fehlermeldung:
```
A connection to the notebook server could not be established.
The notebook will continue trying to reconnect.
Check your network connection or notebook server configuration.
```
#### Ursache
Wenn Athena ein Notebook öffnet, erstellt Athena eine Sitzung und stellt mithilfe einer vorsignierten Notebook-URL eine Verbindung zum Notebook her. Die Verbindung zum Notebook verwendet das WSS-Protokoll ([WebSocketSecure](https://en.wikipedia.org/wiki/WebSocket)).
Der Fehler kann aus folgenden Gründen auftreten:
+ Eine lokale Firewall (z. B. eine unternehmensweite Firewall) blockiert den WSS-Datenverkehr.
+ Proxy- oder Antivirensoftware auf Ihrem lokalen Computer blockiert die WSS-Verbindung.
#### Lösung
Angenommen, Sie haben eine WSS-Verbindung in der `us-east-1`-Region wie die Folgende:
```
wss://94c2bcdf-66f9-4d17-9da6-7e7338060183.analytics-gateway.us-east-1.amazonaws.com/
api/kernels/33c78c82-b8d2-4631-bd22-1565dc6ec152/channels?session_id=
7f96a3a048ab4917b6376895ea8d7535
```
Wenden Sie eine der folgenden Strategien an, um den Fehler zu beheben.
+ Verwenden Sie die Syntax mit Platzhaltermustern, um WSS-Datenverkehr auf dem Port `443` über AWS-Regionen und aufzulisten AWS-Konten.
```
wss://*amazonaws.com
```
+ Verwenden Sie die Syntax mit Platzhaltermustern, um WSS-Verkehr auf Port `443` in 1 AWS-Region und quer AWS-Konten in dem AWS-Region von Ihnen angegebenen Port aufzulisten. Im folgenden Beispiel wird `us-east-1` verwendet.
```
wss://*analytics-gateway.us-east-1.amazonaws.com
```
# Beheben von Tabellen-Fehlern
Verwenden Sie die Informationen in diesem Abschnitt, um Fehler in der Athena für Spark-Tabelle zu beheben.
## Beim Erstellen einer Tabelle kann kein Pfadfehler erstellt werden
**Fehlermeldung IllegalArgumentException**: Aus einer leeren Zeichenfolge kann kein Pfad erstellt werden.
**Ursache**: Dieser Fehler kann auftreten, wenn Sie Apache Spark in Athena verwenden, um eine Tabelle in einer AWS Glue Datenbank zu erstellen und die Datenbank eine leere `LOCATION` Eigenschaft hat.
**Lösungsvorschlag**: Weitere Informationen und Lösungen finden Sie unter [Unzulässige Argumentausnahme beim Erstellen einer Tabelle](notebooks-spark-known-issues.md#notebooks-spark-known-issues-illegal-argument-exception).
## AccessDeniedException beim Abfragen AWS Glue von Tabellen
**Fehlermeldung**: pyspark.sql.utils. AnalysisException: Das Vorhandensein der Standarddatenbank konnte nicht überprüft werden: com.amazonaws.services.glue.model. AccessDeniedException: Der Benutzer: arn:aws:sts: :assumed-role/ *aws-account-id* - AWSAthenaSparkExecutionRole/*unique-identifier*- AthenaExecutor ist *unique-identifier* nicht berechtigt,: glue: on GetDatabase resource: arn:aws:glue: :catalog auszuführen, *aws-region* weil *aws-account-id* keine identitätsbasierte Richtlinie die Aktion glue: zulässt (Service:; Statuscode: 400; Fehlercode:; Fehlercode:; Anforderungs-ID:; Proxy: null) GetDatabase AWSGlue AccessDeniedException *request-id*
Ursache**:** Der Ausführungsrolle für Ihre AWS Glue Spark-fähige Arbeitsgruppe fehlen Berechtigungen für den Zugriff auf Ressourcen.
**Vorgeschlagene Lösung**: Um dieses Problem zu lösen, gewähren Sie Ihrer Ausführungsrolle Zugriff auf AWS Glue Ressourcen und bearbeiten Sie dann Ihre Amazon S3 S3-Bucket-Richtlinie, um Zugriff auf Ihre Ausführungsrolle zu gewähren.
Das folgende Verfahren beschreibt diese Schritte im Detail.
**Um Ihrer Ausführungsrolle Zugriff auf AWS Glue Ressourcen zu gewähren**
1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.
![\[Wählen Sie das Erweiterungsmenü aus.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/nav-pane-expansion.png)
1. Wählen Sie im Navigationsbereich der Athena-Konsole **Workgroups** (Arbeitsgruppen) aus.
1. Wählen Sie auf der Seite der **Workgroups** (Arbeitsgruppen) den Link der Arbeitsgruppe aus, die Sie anzeigen möchten.
1. Wählen Sie auf der Seite **Overview Details** (Übersichtsdetails) für die Arbeitsgruppe den Link **Role ARN** (Rollen-ARN) aus. Über den Link wird die Spark-Ausführungsrolle in der IAM-Konsole geöffnet.
1. Wählen Sie im Abschnitt **Permissions policies** (Berechtigungsrichtlinien) den Namen der verknüpften Rollenrichtlinie.
1. Wählen Sie **Edit policy** (Richtlinie bearbeiten) und anschließend **JSON**.
1. Fügen Sie AWS Glue Zugriff auf die Rolle hinzu. In der Regel fügen Sie Berechtigungen für die Aktionen `glue:GetDatabase` und `glue:GetTable` hinzu. Weitere Informationen zum Konfigurieren von IAM-Rollen finden Sie unter [Hinzufügen und Entfernen von IAM-Identitätsberechtigungen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) im IAM-Benutzerhandbuch.
1. Wählen Sie **Review policy (Richtlinie überprüfen)** aus und klicken Sie anschließend auf **Save changes (Änderungen speichern)**.
1. Bearbeiten Sie Ihre Amazon-S3-Bucket-Richtlinie, um Zugriff auf die Ausführungsrolle zu gewähren. Beachten Sie, dass Sie der Rolle sowohl Zugriff auf den Bucket als auch auf die Objekte im Bucket gewähren müssen. Weitere Schritte finden Sie unter [Hinzufügen einer Bucket-Richtlinie mit der Amazon-S3-Konsole](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-bucket-policy.html) im Benutzerhandbuch zu Amazon Simple Storage Service.
# Anfordern von Unterstützung
Wenn Sie Unterstützung von benötigen AWS, wählen Sie **Support****, Support Center** aus der AWS-Managementkonsole. Um Ihre Erfahrung zu erleichtern, halten Sie bitte die folgenden Informationen bereit:
+ Athena-Abfragen-ID
+ Sitzungs-ID
+ Berechnungs-ID