amazon athena - benutzerhandbuch · amazon athena benutzerhandbuch amazon's trademarks and...

Amazon AthenaBenutzerhandbuch

Amazon Athena: BenutzerhandbuchCopyright © 2019 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon Athena Benutzerhandbuch

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.


Table of ContentsWas ist Amazon Athena? .................................................................................................................... 1

Wann sollte ich Athena verwenden? .............................................................................................. 1Zugriff auf Athena ....................................................................................................................... 1Grundlegendes zu Tabellen, Datenbanken und zum Datenkatalog ...................................................... 2AWS-Service-Integrationen mit Athena ........................................................................................... 3

Versionshinweise ................................................................................................................................ 626. Juni 2019 ............................................................................................................................. 724. Mai 2019 .............................................................................................................................. 75. März 2019 ............................................................................................................................. 722. Februar 2019 ........................................................................................................................ 818. Februar 2019 ........................................................................................................................ 820. November 2018 .................................................................................................................. 1015. Oktober 2018 ...................................................................................................................... 1010. Oktober 2018 ...................................................................................................................... 116. September 2018 ................................................................................................................... 1123. August 2018 ....................................................................................................................... 1216. August 2018 ....................................................................................................................... 127. August 2018 ......................................................................................................................... 135. Juni 2018 ............................................................................................................................. 13

Unterstützung für Ansichten ................................................................................................ 13Verbesserungen und Aktualisierungen bei Fehlermeldungen .................................................... 13Fehlerbehebungen ............................................................................................................ 14

17. Mai 2018 ............................................................................................................................ 1419. April 2018 .......................................................................................................................... 146. April 2018 ............................................................................................................................ 1515. März 2018 .......................................................................................................................... 152. Februar 2018 ........................................................................................................................ 1519. Januar 2018 ........................................................................................................................ 1513. November 2017 .................................................................................................................. 161. November 2017 .................................................................................................................... 1619. Oktober 2017 ...................................................................................................................... 163. Oktober 2017 ........................................................................................................................ 1625. September 2017 .................................................................................................................. 1714. August 2017 ....................................................................................................................... 174. August 2017 ......................................................................................................................... 1722. Juni 2017 ........................................................................................................................... 178. Juni 2017 ............................................................................................................................. 1719. Mai 2017 ............................................................................................................................ 17

Verbesserungen ................................................................................................................ 18Fehlerbehebungen ............................................................................................................ 18

4. April 2017 ............................................................................................................................ 19Funktionen ....................................................................................................................... 19Verbesserungen ................................................................................................................ 19Fehlerbehebungen ............................................................................................................ 19

24. März 2017 .......................................................................................................................... 20Funktionen ....................................................................................................................... 20Verbesserungen ................................................................................................................ 20Fehlerbehebungen ............................................................................................................ 20

20. Februar 2017 ...................................................................................................................... 20Funktionen ....................................................................................................................... 20Verbesserungen ................................................................................................................ 22

Einrichten ........................................................................................................................................ 23Anmelden bei AWS ................................................................................................................... 23

So erstellen Sie ein Amazon-Konto ..................................................................................... 23

iii


Erstellen eines IAM-Benutzers .................................................................................................... 23So erstellen Sie eine Gruppe für Administratoren: .................................................................. 23So erstellen Sie einen IAM-Benutzer für sich, fügen ihn der Administratorengruppe hinzu understellen ein Passwort für den Benutzer ............................................................................... 24

Anfügen von verwalteten Richtlinien für die Nutzung von Athena ...................................................... 24Erste Schritte ................................................................................................................................... 25

Voraussetzungen ...................................................................................................................... 25Schritt 1: Erstellen einer Datenbank ............................................................................................. 25Schritt 2: Erstellen einer Tabelle .................................................................................................. 26Schritt 3: Abfragen von Daten ..................................................................................................... 27

Zugriff auf Amazon Athena ................................................................................................................. 29Über die Konsole ...................................................................................................................... 29Verwenden der API ................................................................................................................... 29Verwenden der CLI ................................................................................................................... 30

Erstellen von Tabellen und Datenbanken .............................................................................................. 31Tabellen- und Datenbankerstellung in Athena ................................................................................ 31

Voraussetzungen für Tabellen in Athena und Daten in Amazon S3 ........................................... 32Unterstützte Funktionen ..................................................................................................... 32Umwandlungen von Transaktionsdaten werden nicht unterstützt ............................................... 33Operationen, die Tabellenstatus ändern, sind ACID ................................................................ 33Alle Tabellen sind EXTERNAL ............................................................................................ 33So erstellen Sie eine Tabelle mit dem AWS Glue-Datenkatalog: ............................................... 33So erstellen Sie eine Tabelle mit dem Assistenten: ................................................................ 33So erstellen Sie eine Datenbank mit Hive DDL ...................................................................... 34So erstellen Sie eine Tabelle mit Hive DDL .......................................................................... 35

Namen für Tabellen, Datenbanken und Spalten ............................................................................. 35Tabellen- und Tabellenspaltennamen in Athena dürfen nur Kleinbuchstaben enthalten. ................. 35Für Tabellen-, Ansichts-, Datenbank- und Spaltennamen in Athena sind als Sonderzeichen nurder Unterstrich zulässig ..................................................................................................... 35Namen, die mit einem Unterstrich beginnen .......................................................................... 36Tabellen- oder Ansichtsnamen mit Zahlen ............................................................................ 36

Reservierte Schlüsselwörter ........................................................................................................ 36Liste reservierter Schlüsselwörter in DDL-Anweisungen .......................................................... 36Liste reservierter Schlüsselwörter in SQL-SELECT-Anweisungen .............................................. 37Beispiele für Abfragen mit reservierten Wörtern ..................................................................... 37

Tabellenspeicherort in Amazon S3 .............................................................................................. 38Tabellenspeicherort und Partitionen ..................................................................................... 39

Partitionieren von Daten ............................................................................................................. 39Szenario 1: Daten sind bereits partitioniert und im Hive-Format in S3 gespeichert. ....................... 40Szenario 2: Daten sind nicht partitioniert. .............................................................................. 41

Spaltenbasierte Speicherformate ................................................................................................. 43Konvertieren in spaltenbasierte Formate ....................................................................................... 44

Übersicht ......................................................................................................................... 44Bevor Sie beginnen ........................................................................................................... 25Beispiel: Konvertieren von Daten in Parquet mit einem EMR-Cluster ......................................... 46

Herstellen von Verbindungen mit Datenquellen ...................................................................................... 48Integration mit AWS Glue ........................................................................................................... 48

Verwenden von AWS Glue zum Herstellen einer Verbindung mit Datenquellen in Amazon S3 ........ 49Bewährte Methoden beim Verwenden von Athena mit AWS Glue ............................................. 51Schrittweises Upgrade auf den AWS Glue-Datenkatalog ......................................................... 60Häufig gestellte Fragen: Upgrade auf den AWS Glue-Datenkatalog ........................................... 62

Verwenden eines Hive-Metastores ............................................................................................... 65Überlegungen und Einschränkungen .................................................................................... 65Verbinden von Athena mit einem Apache Hive Metastore ........................................................ 65

Die Verwendung von ................................................................................................................. 66Überlegungen und Einschränkungen .................................................................................... 67Bereitstellen von Konnektoren und Herstellen von Verbindungen mit Datenquellen ...................... 67

iv


Verwendung des AWS Serverless Application Repository ........................................................ 69Athena-Datenquellenkonnektoren ........................................................................................ 69Schreiben von Verbundabfragen ......................................................................................... 71Schreiben eines Datenquellenkonnektors .............................................................................. 75Verwalten von Datenquellen ............................................................................................... 75

Herstellen einer Verbindung zu Amazon Athena mit ODBC- und JDBC-Treibern .................................. 76Verwenden von Athena mit dem JDBC-Treiber ...................................................................... 76Verbindung zu Amazon Athena mit ODBC ............................................................................ 78

Ausführen von Abfragen .................................................................................................................... 81Abfrageergebnisse und Abfrageverlauf ....................................................................................... 115

Abrufen einer Abfrage-ID .................................................................................................. 115Identifizieren von Abfrageausgabedateien ........................................................................... 116Herunterladen von Abfrageergebnisdateien mithilfe der Athena-Konsole ................................... 118Angeben eines Speicherorts des Abfrageergebnisses ........................................................... 118Anzeigen des Abfrageverlaufs ........................................................................................... 120

Arbeiten mit Ansichten ............................................................................................................. 121Einsetzen von Ansichten – wann sinnvoll? .......................................................................... 121Unterstützte Aktionen für Ansichten in Athena ..................................................................... 122Überlegungen für Ansichten .............................................................................................. 122Einschränkungen für Ansichten ......................................................................................... 123Arbeiten mit Ansichten in der Konsole ................................................................................ 123Erstellen von Ansichten .................................................................................................... 124Beispiele für Ansichten ..................................................................................................... 125Aktualisieren von Ansichten .............................................................................................. 126Löschen von Ansichten .................................................................................................... 126

Erstellen einer Tabelle aus Abfrageergebnissen (CTAS) ................................................................ 126Überlegungen und Einschränkungen für CTAS-Abfragen ....................................................... 127Ausführen von CTAS-Abfragen in der Konsole ..................................................................... 128Bucketing im Vergleich zur Partitionierung ........................................................................... 131Beispiele für CTAS-Abfragen ............................................................................................ 132

Verarbeiten von Schema-Updates .............................................................................................. 136Zusammenfassung: Updates und Datenformate in Athena ..................................................... 136Index-Zugriff in ORC und Parquet ...................................................................................... 138Arten von Updates .......................................................................................................... 139Updates in Tabellen mit Partitionen .................................................................................... 144

Abfragen von Arrays ................................................................................................................ 145Erstellen von Arrays ........................................................................................................ 146Verketten von Arrays ....................................................................................................... 147Konvertieren von Array-Datentypen .................................................................................... 148Suchen nach Längen ....................................................................................................... 149Zugreifen auf Array-Elemente ............................................................................................ 149Reduzieren von verschachtelten Arrays .............................................................................. 150Erstellen von Arrays aus Unterabfragen .............................................................................. 152Filtern von Arrays ............................................................................................................ 153Sortieren von Arrays ........................................................................................................ 154Verwenden von Aggregationsfunktionen mit Arrays ............................................................... 154Konvertieren von Arrays in Zeichenfolgen ........................................................................... 155Verwenden von Arrays zum Erstellen von Karten ................................................................. 155Abfragen von Arrays mit komplexen Typen und verschachtelten Strukturen .............................. 156

Abfragen von &JSON .............................................................................................................. 162Bewährte Methoden zum Lesen von JSON-Daten ................................................................ 162Extrahieren von Daten aus JSON ...................................................................................... 163Suchen nach Werten in JSON-Arrays ................................................................................. 166Abrufen der Länge und Größe von JSON-Arrays .................................................................. 167

Abfragen von koordinatenbasierten Daten ................................................................................... 168Was ist eine koordinatenbasierte Abfrage? .......................................................................... 169Eingabedatenformate und Geometrie-Datentypen ................................................................. 169

v


Liste der unterstützten koordinatenbasierten Funktionen ........................................................ 170Beispiele: Koordinatenbasierte Abfragen ............................................................................. 178

Die Verwendung von ............................................................................................................... 180Überlegungen und Einschränkungen .................................................................................. 180-Syntax .......................................................................................................................... 181

Abfragen mit UDFs (Vorversion) ................................................................................................ 182Überlegungen und Einschränkungen .................................................................................. 182UDF-Abfragesyntax ......................................................................................................... 183Erstellen und Bereitstellen einer UDF mit Lambda ................................................................ 184

Abfragen von AWS-Serviceprotokollen ........................................................................................ 190Abfragen von AWS CloudTrail-Protokollen .......................................................................... 190Abfragen von Amazon CloudFront-Protokollen ..................................................................... 194Abfragen von Amazon EMR-Protokollen ............................................................................. 196Abfragen von Classic Load Balancer-Protokollen .................................................................. 199Abfragen von Netzwerk-Load-Balancer-Protokollen ............................................................... 200Abfragen von Application Load Balancer-Protokollen ............................................................. 202Abfragen von Amazon VPC-Flow-Protokollen ...................................................................... 204Abfragen von AWS WAF-Protokollen .................................................................................. 206

Sicherheit ....................................................................................................................................... 209Datenschutz ........................................................................................................................... 209

Verschlüsselung im Ruhezustand ...................................................................................... 210Verschlüsselung während der Übertragung ......................................................................... 216Schlüsselverwaltung ........................................................................................................ 216Richtlinie für den Datenverkehr zwischen Netzwerken ........................................................... 216

Identitäts- und Zugriffsverwaltung ............................................................................................... 217Verwaltete Richtlinien für den Benutzerzugriff ...................................................................... 217Zugriff über JDBC- und ODBC-Verbindungen ...................................................................... 221Zugriff auf Amazon S3 ..................................................................................................... 221Differenzierter Zugriff auf Datenbanken und Tabellen ............................................................ 222Zugriff auf verschlüsselte Metadaten im Data Catalog ........................................................... 228Kontoübergreifender Zugriff ............................................................................................... 229Zugriff auf Arbeitsgruppen und Tags .................................................................................. 229So gewähren Sie den Zugriff auf eine : ............................................................................... 230Zulassen des Zugriffs auf ................................................................................................. 232Zulassen des Zugriffs auf ................................................................................................. 234Erlauben des Zugriffs für .................................................................................................. 236Aktivieren des föderierten Zugriffs auf die Athena-API ........................................................... 236

Protokollieren und überwachen .................................................................................................. 239Compliance-Validierung ............................................................................................................ 240Resilienz ................................................................................................................................ 240Sicherheit der Infrastruktur ........................................................................................................ 241

Herstellen einer Verbindung mit Amazon Athena über einen Schnittstellen-VPC-Endpunkt ........... 241Konfigurations- und Schwachstellenanalyse ................................................................................. 243Verwenden von Athena mit Lake Formation ................................................................................ 243

Funktionsweise des Lake Formation-Datenzugriffs ................................................................ 244Überlegungen und Einschränkungen .................................................................................. 245Verwalten von Benutzerberechtigungen .............................................................................. 247Anwenden von Lake Formation-Berechtigungen auf vorhandene Datenbanken und Tabellen ........ 250

Verwendung von Arbeitsgruppen zur Kontrolle des Abfragenzugriffs und der Kosten .................................. 251Verwenden von Arbeitsgruppen zum Ausführen von Abfragen ........................................................ 251

Vorteile der Verwendung von Arbeitsgruppen ...................................................................... 252Funktionsweise von Arbeitsgruppen ................................................................................... 252Einrichten von Arbeitsgruppen ........................................................................................... 253IAM-Richtlinien für den Zugriff auf Arbeitsgruppen ............................................................... 255Beispiel-Arbeitsgruppenrichtlinien ....................................................................................... 256Arbeitsgruppeneinstellungen .............................................................................................. 260Verwalten von Arbeitsgruppen ........................................................................................... 261

vi


Athena-Arbeitsgruppen-APIs ............................................................................................ 268Fehlerbehebung bei Arbeitsgruppen ................................................................................... 268

Kontrollieren von Kosten und Überwachung von Abfragen mit CloudWatch-Metriken .......................... 270Aktivieren von CloudWatch-Abfragemetriken ........................................................................ 271Überwachung von Athena-Abfragen mit CloudWatch-Metriken ................................................ 271Festlegen von Limits zur Kontrolle der Datennutzung ............................................................ 273

Markieren von Arbeitsgruppen ........................................................................................................... 277Grundlagen zu Tags ................................................................................................................ 277Tag-Einschränkungen .............................................................................................................. 278Arbeiten mit Tags in der Konsole .............................................................................................. 278

Anzeigen von Tags für einzelne Arbeitsgruppen ................................................................... 278Hinzufügen und Löschen von Tags für einzelne Arbeitsgruppen .............................................. 279

Arbeiten mit Tags mithilfe der API-Aktionen ................................................................................. 280Tagbasierte IAM-Zugriffssteuerungsrichtlinien .............................................................................. 281

Tag-Richtlinienbeispiele .................................................................................................... 281Überwachungsprotokolle und Fehlerbehebung ..................................................................................... 284

Protokollieren von Amazon Athena-API-Aufrufen mit AWS CloudTrail .............................................. 284Athena-Informationen in CloudTrail .................................................................................... 284Grundlagen zu Athena-Protokolldateieinträgen ..................................................................... 285

Fehlersuche ............................................................................................................................ 287SerDe-Referenz .............................................................................................................................. 288

Verwenden eines SerDe ........................................................................................................... 288SO verwenden Sie SerDe-Abfragen ................................................................................... 288

Unterstützte SerDes- und Daten-Formate .................................................................................... 289Avro SerDe .................................................................................................................... 291RegexSerDe zur Verarbeitung von Apache Webserver-Protokollen .......................................... 293CloudTrail-SerDe ............................................................................................................. 294OpenCSVSerDe für CSV-Verarbeitung ............................................................................... 295Grok SerDe .................................................................................................................... 298JSON SerDe-Bibliotheken ................................................................................................. 301LazySimpleSerDe für CSV- und TSV-Dateien sowie für benutzerdefinierte, durch Trennzeichengetrennte Dateien ............................................................................................................ 304ORC SerDe .................................................................................................................... 309Parquet SerDe ................................................................................................................ 312

Komprimierungsformate ............................................................................................................ 314SQL-Referenz ................................................................................................................................. 316

Unterstützte Datentypen ........................................................................................................... 316DML-Abfragen, -Funktionen und -Operatoren ............................................................................... 317

SELECT ........................................................................................................................ 317INSERT INTO ................................................................................................................. 321Presto-Funktionen ........................................................................................................... 323

DDL-Anweisungen ................................................................................................................... 324Nicht unterstützte DDLs ................................................................................................... 325ALTER DATABASE SET DBPROPERTIES ......................................................................... 326ALTER TABLE ADD PARTITION ....................................................................................... 327ALTER TABLE DROP PARTITION .................................................................................... 328ALTER TABLE RENAME PARTITION ................................................................................ 328ALTER TABLE SET LOCATION ........................................................................................ 329ALTER TABLE SET TBLPROPERTIES .............................................................................. 329CREATE DATABASE ...................................................................................................... 330CREATE TABLE ............................................................................................................. 330CREATE TABLE AS ........................................................................................................ 334CREATE VIEW ............................................................................................................... 336DESCRIBE TABLE .......................................................................................................... 337DESCRIBE VIEW ............................................................................................................ 337DROP DATABASE .......................................................................................................... 338DROP TABLE ................................................................................................................. 338

vii


DROP VIEW .................................................................................................................. 339MSCK REPAIR TABLE .................................................................................................... 339SHOW COLUMNS .......................................................................................................... 339SHOW CREATE TABLE .................................................................................................. 340SHOW CREATE VIEW .................................................................................................... 340SHOW DATABASES ....................................................................................................... 340SHOW PARTITIONS ....................................................................................................... 341SHOW TABLES .............................................................................................................. 341SHOW TBLPROPERTIES ................................................................................................ 342SHOW VIEWS ................................................................................................................ 342

Überlegungen und Einschränkungen .......................................................................................... 343Codebeispiele, Service Limits und vorheriger JDBC-Treiber ................................................................... 344

Codebeispiele ......................................................................................................................... 344Konstanten ..................................................................................................................... 344Erstellen eines Clients für den Zugriff auf Athena ................................................................. 345Starten der Abfrageausführung .......................................................................................... 345Anhalten der Abfrageausführung ........................................................................................ 348Auflisten von Abfrageausführungen .................................................................................... 349Erstellen einer benannten Abfrage ..................................................................................... 350Löschen einer benannten Abfrage ..................................................................................... 350Auflisten benannter Abfragen ............................................................................................ 351

JDBC-Treiber einer früheren Version .......................................................................................... 352Anweisungen zu JDBC-Treiberversion 1.1.0 ........................................................................ 353

Service Limits ......................................................................................................................... 357Dokumentverlauf ............................................................................................................................. 360AWS-Glossar .................................................................................................................................. 368

viii

Amazon Athena BenutzerhandbuchWann sollte ich Athena verwenden?

Was ist Amazon Athena?Amazon Athena ist ein interaktiver Abfrageservice, der die Analyse von Daten direkt in Amazon SimpleStorage Service (Amazon S3) mit Standard-SQL erleichtert. Mit ein paar Aktionen in der AWS ManagementConsole können Sie Athena auf Ihre Daten verweisen, die in Amazon S3 gespeichert sind, und Standard-SQL verwenden, um Ad-hoc-Abfragen auszuführen und innerhalb von Sekunden Ergebnisse zugenerieren.

Athena benötigt keinen Server, daher muss auch keine Infrastruktur eingerichtet oder verwaltet werden. Siezahlen nur für die Abfragen, die Sie tatsächlich ausführen. Athena skaliert automatisch—und führt Abfragenparallel aus—sodass schnell Ergebnisse vorliegen, selbst bei umfangreichen Datasets und komplexenAbfragen.

Themen• Wann sollte ich Athena verwenden? (p. 1)• Zugriff auf Athena (p. 1)• Grundlegendes zu Tabellen, Datenbanken und zum Datenkatalog (p. 2)• AWS-Service-Integrationen mit Athena (p. 3)

Wann sollte ich Athena verwenden?Mit Athena können Sie in Amazon S3 gespeicherte unstrukturierte, semistrukturierte und strukturierte Datenanalysieren. Beispiele hierfür sind CSV und JSON oder spaltenbasierte Datenformate wie Apache Parquetund Apache ORC. Mit Athena lassen sich Ad-hoc-Abfragen über ANSI SQL ausführen; dabei müssen dieDaten weder aggregiert noch in Athena geladen werden.

Für die einfache Datenvisualisierung lässt sich Athena mit Amazon QuickSight integrieren. Sie könnenmit Athena Berichte generieren oder Daten mit Business Intelligence-Tools oder SQL-Clients analysieren,die eine Verbindung über einen JDBC- oder ODBC-Treiber herstellen. Weitere Informationen finden Sieunter Was ist Amazon QuickSight im Amazon QuickSight-Benutzerhandbuch und unter Herstellen einerVerbindung mit Amazon Athena mit ODBC- und JDBC-Treibern (p. 76).

Athena kann mit dem AWS Glue-Datenkatalog integriert werden, der einen dauerhaften Metadatenspeicherfür Ihre Daten in Amazon S3 bietet. Auf diese Weise können Sie in Athena Tabellen erstellen undDaten abfragen, die auf einem zentralen Metadatenspeicher für Ihr AWS-Konto basieren und mit denDatenermittlungs- und ETL-Funktionen von AWS Glue nutzbar sind. Weitere Informationen finden Sie unterIntegration mit AWS Glue (p. 48) und Was ist AWS Glue im AWS Glue-Entwicklerhandbuch.

Eine Liste der AWS-Services, die Athena nutzt bzw. mit denen es integriert werden kann, finden Sie unterthe section called “AWS-Service-Integrationen mit Athena” (p. 3).

Zugriff auf AthenaSie können auf Athena über die AWS Management Console, eine JDBC- oder ODBC-Verbindung, dieAthena-API oder die Athena-CLI zugreifen.

• Informationen zu den ersten Schritten mit der Konsole finden Sie unter Getting Started (p. 25).• Informationen zur Verwendung von JDBC- oder ODBC-Treibern finden Sie unter Verbindung zu Amazon

Athena mit JDBC (p. 76) und Verbindung mit Amazon Athena mit ODBC (p. 78).• Zur Verwendung der Athena-API vgl. das Amazon Athena-API-Referenz.

1

https://docs.aws.amazon.com/quicksight/latest/user/welcome.html

https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html

https://docs.aws.amazon.com/athena/latest/APIReference/

Amazon Athena BenutzerhandbuchGrundlegendes zu Tabellen,

Datenbanken und zum Datenkatalog

• Zur Verwendung der CLI installieren Sie die AWS-CLI und geben dann in die Befehlszeile aws athenahelp ein, um die verfügbaren Befehle anzuzeigen. Weitere Informationen zu den verfügbaren Befehlenfinden Sie in der AWS Athena-Befehlszeilenreferenz.

Grundlegendes zu Tabellen, Datenbanken und zumDatenkatalog

In Athena fungieren Tabellen und Datenbanken als Container für Metadatendefinitionen, die das Schemafür zugrunde liegende Quelldaten definieren. Für jedes Dataset muss in Athena eine Tabelle vorhandensein. Aus den Metadaten in der Tabelle entnimmt Athena den Speicherort der Daten in Amazon S3 und dieStruktur der Daten, z. B. Spaltennamen, Datentypen und Tabellenname. Bei Datenbanken handelt es sichum eine logische Gruppe von Tabellen; sie enthalten daher auch nur Metadaten und Schemainformationenfür ein Dataset.

Für jedes Dataset, für das Sie eine Abfrage ausführen möchten, muss in Athena eine zugrunde liegendeTabelle vorhanden sein, die zum Abruf und zur Rückgabe der Abfrageergebnisse verwendet wird. Dahermuss die Tabelle vor einer Datenabfrage in Athena registriert werden. Die Registrierung erfolgt bei derautomatischen oder manuellen Tabellenerstellung.

Unabhängig davon, wie die Tabellen erstellt werden, wird das Dataset im Rahmen der Tabellenerstellungin Athena registriert. Diese Registrierung erfolgt entweder im AWS Glue-Datenkatalog oder im internenAthena-Datenkatalog und ermöglicht es Athena, Abfragen für diese Daten auszuführen.

• Zur automatischen Tabellenerstellung verwenden Sie einen AWS Glue-Crawler on Athena. WeitereInformationen über AWS Glue und Crawler finden Sie unter Integration mit AWS Glue (p. 48). Wirdeine Tabelle in AWS Glue erstellt, erfolgt die Registrierung im eigenen AWS Glue-Data Catalog. Athenaverwendet den AWS Glue-Data Catalog zum Speichern und Abrufen der enthaltenen Metadaten, die beider Abfrageausführung für die Analyse des zugrunde liegenden Datasets verwendet werden.

Der AWS Glue-Data Catalog ist in Ihrem AWS-Konto zugänglich. Auch andere AWS-Services können denAWS Glue-Data Catalog nutzen, so dass Sie alle in der Organisation erstellten Datenbanken und Tabellenin Athena sehen können – und umgekehrt. Darüber hinaus ermöglicht AWS Glue die automatischeErkennung des Datenschemas sowie das Extrahieren, Transformieren und Laden (ETL) von Daten.

Note

Den internen Athena-Datenkatalog verwenden Sie in Regionen, in denen AWS Glue nichtverfügbar ist und der AWS Glue-Data Catalog nicht genutzt werden kann.

• So erstellen Sie eine Tabelle manuell• Rufen Sie in der Athena-Konsole den Assistenten "Create Table" auf.• Schreiben Sie in der Athena-Konsole Hive DDL-Anweisungen in den Abfrage-Editor.• Führen Sie mithilfe der Athena-API oder der CLI eine SQL-Abfragezeichenfolge mit DDL-Anweisungen

aus.• Verwenden Sie den JDBC- oder ODBC-Treiber von Athena.

Bei der manuellen Tabellen- und Datenbankerstellung setzt Athena im Hintergrund HiveQL DDL-Anweisungen (wie z. B. CREATE TABLE, CREATE DATABASE und DROP TABLE) ein, um die Tabellen undDatenbanken im AWS Glue-Datenkatalog oder (in Regionen, in denen AWS Glue nicht verfügbar ist) iminternen Datenkatalog zu erstellen.

Note

Wenn Sie in Athena mit Tabellen arbeiten, die vor dem 14. August 2017 erstellt wurden,befinden sich diese in einem von Athena verwalteten Datenkatalog, der neben dem AWS Glue-

2

https://docs.aws.amazon.com/cli/latest/userguide/installing.html

https://docs.aws.amazon.com/cli/latest/reference/athena/

Amazon Athena BenutzerhandbuchAWS-Service-Integrationen mit Athena

Datenkatalog besteht, bis Sie ein Update durchführen. Weitere Informationen finden Sie unterUpgrading to the AWS Glue Data Catalog Step-by-Step (p. 60).

Wenn Sie eine Abfrage mit einer bestehenden Tabelle ausführen, setzt Amazon Athena im Hintergrund dieverteilte SQL-Engine Presto ein. Wir haben einige Beispiele mit Beispieldaten innerhalb von Athena, dieIhnen zeigen, wie Sie eine Tabelle erstellen und mithilfe von Athena eine Abfrage dazu übermitteln. Athenaverfügt auf der Konsole außerdem über ein Tutorial, das Sie bei den ersten Schritten der Erstellung vonTabellen auf der Basis von Daten, die in Amazon S3 gespeichert sind, unterstützt.

• Eine Schritt-für-Schritt-Anleitung zum Erstellen einer Tabelle und zum Schreiben von Abfragen imAbfrage-Editor von Athena finden Sie unter Erste Schritte (p. 25).

• Führen Sie das Athena-Tutorial in der Konsole aus. Es wird automatisch gestartet, wenn Sie sich zumersten Mal an der https://console.aws.amazon.com/athena/ anmelden. Sie können in der Konsole auchauf Tutorial klicken, um es zu starten.

AWS-Service-Integrationen mit AthenaSie können Daten aus anderen AWS-Services in Athena abfragen. Athena nutzt verschiedene AWS-Services. Weitere Informationen können Sie der folgenden Tabelle entnehmen.

Note

Die Liste der unterstützten Regionen für jeden Service finden Sie unter Regionen und Endpunkteim Allgemeine Amazon Web Services-Referenz.

AWS-Service Thema Beschreibung

AWS CloudTrail Abfragen von AWS CloudTrail-Protokollen (p. 190)

Die Verwendung von Athenamit CloudTrail-Protokollen bieteteine ausgezeichnete Möglichkeit,die Analyse der AWS-Service-Aktivitäten zu optimieren.Beispielsweise können Siemithilfe von Abfragen Trendsermitteln und Vorgänge nachAttributen (z. B. Quell-IP-Adresseoder Benutzer) trennen.

Sie können automatisch Tabellenfür die direkte Abfrage vonProtokollen aus der CloudTrail-Konsole erstellen und mit diesenTabellen Abfragen in Athenaausführen. Weitere Informationenfinden Sie unter Erstelleneiner Tabelle für CloudTrail-Protokolle in der CloudTrail-Konsole (p. 191).

Amazon CloudFront Abfragen von AmazonCloudFront-Protokollen (p. 194)

Nutzen Sie Athena zur Abfragevon Amazon CloudFront.

Elastic Load Balancing • Abfragen von Application LoadBalancer-Protokollen (p. 202)

• Abfragen von Classic LoadBalancer-Protokollen (p. 199)

Durch das Abfragen vonApplication Load Balancer-Protokollen können Sie dieDatenverkehrsquelle, die

3

https://console.aws.amazon.com/athena/home

https://docs.aws.amazon.com/general/latest/gr/rande.html


AWS-Service Thema BeschreibungLatenz und die Bytes anzeigen,die zwischen Elastic LoadBalancing-Instances undBackend-Anwendungenübermittelt werden. SieheErstellen der Tabelle für ALB-Protokolle (p. 202).

Fragen Sie Classic LoadBalancer-Protokollen ab, umDatenverkehrsmuster von undzu Elastic Load Balancing-Instances und Backend-Anwendungen analysieren undnachvollziehen. Dabei werdenIhnen die Datenverkehrsquelle,die Latenz und die übertragenenBytes angezeigt. SieheErstellen der Tabelle für ELB-Protokolle (p. 199).

Amazon Virtual Private Cloud Abfragen von Amazon VPC-Flow-Protokollen (p. 204)

Amazon Virtual Private Cloud-Flow-Protokolle erfassenInformationen zum IP-Datenverkehr zu und vonNetzwerkschnittstellen in einerVPC. Fragen Sie die Protokollein Athena zur Untersuchung vonNetzwerkdatenverkehrsmusternund zur Identifizierung vonBedrohungen und Risiken inIhrem Amazon VPC-Netzwerkab.

AWS CloudFormation AWS::Athena::NamedQueryim AWS CloudFormation-Benutzerhandbuch.

Erstellen Sie mit AWSCloudFormation benannteAbfragen und führen Siesie in Athena aus. Mithilfevon benannten Abfragenkönnen Sie einer Abfrageeinen Namen zuordnen unddiese Abfrage mehrfach überdiesen Namen aufrufen.Informationen finden Sie unterCreateNamedQuery im AmazonAthena-API-Referenz und unterAWS::Athena::NamedQueryim AWS CloudFormationBenutzerhandbuch.

4

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-athena-namedquery.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateNamedQuery.html



AWS-Service Thema Beschreibung

AWS Glue-Datenkatalog Integration mit AWSGlue (p. 48)

Athena kann mit dem AWSGlue-Datenkatalog integriertwerden, der einen dauerhaftenMetadatenspeicher für IhreDaten in Amazon S3 bietet.Auf diese Weise können Sie inAthena Tabellen erstellen undDaten abfragen, die auf einemzentralen Metadatenspeicherfür Ihr AWS-Konto basierenund mit den Datenermittlungs-und ETL-Funktionen von AWSGlue nutzbar sind. WeitereInformationen finden Sieunter Integration mit AWSGlue (p. 48) und Was istAWS Glue? im AWS Glue-Entwicklerhandbuch.

Amazon QuickSight Herstellen einer Verbindung mitAmazon Athena mit ODBC- undJDBC-Treibern (p. 76)

Für die einfacheDatenvisualisierung lässt sichAthena mit Amazon QuickSightintegrieren. Sie können mitAthena Berichte generierenoder Daten mit BusinessIntelligence-Tools oder SQL-Clients analysieren, die eineVerbindung über einen JDBC-oder ODBC-Treiber herstellen.Weitere Informationen finden Sieunter Was ist Amazon QuickSightim Amazon QuickSight-Benutzerhandbuch und unterHerstellen einer Verbindung mitAmazon Athena mit ODBC- undJDBC-Treibern (p. 76).

IAM Aktionen für Amazon Athena Sie können Athena-API-Aktionenin IAM-Berechtigungsrichtlinienverwenden. Siehe Aktionen fürAmazon Athena und Identitäts-und Zugriffsverwaltung inAthena (p. 217).

5



https://docs.aws.amazon.com/quicksight/latest/user/welcome.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonathena.html




VersionshinweiseHier werden die Funktionen, Verbesserungen und Fehlerbehebungen für Amazon Athena sortiert nach demVeröffentlichungsdatum beschrieben.

Inhalt• 26. Juni 2019 (p. 7)• 24. Mai 2019 (p. 7)• 5. März 2019 (p. 7)• 22. Februar 2019 (p. 8)• 18. Februar 2019 (p. 8)• 20. November 2018 (p. 10)• 15. Oktober 2018 (p. 10)• 10. Oktober 2018 (p. 11)• 6. September 2018 (p. 11)• 23. August 2018 (p. 12)• 16. August 2018 (p. 12)• 7. August 2018 (p. 13)• 5. Juni 2018 (p. 13)

• Unterstützung für Ansichten (p. 13)• Verbesserungen und Aktualisierungen bei Fehlermeldungen (p. 13)• Fehlerbehebungen (p. 14)

• 17. Mai 2018 (p. 14)• 19. April 2018 (p. 14)• 6. April 2018 (p. 15)• 15. März 2018 (p. 15)• 2. Februar 2018 (p. 15)• 19. Januar 2018 (p. 15)• 13. November 2017 (p. 16)• 1. November 2017 (p. 16)• 19. Oktober 2017 (p. 16)• 3. Oktober 2017 (p. 16)• 25. September 2017 (p. 17)• 14. August 2017 (p. 17)• 4. August 2017 (p. 17)• 22. Juni 2017 (p. 17)• 8. Juni 2017 (p. 17)• 19. Mai 2017 (p. 17)

• Verbesserungen (p. 18)• Fehlerbehebungen (p. 18)

• 4. April 2017 (p. 19)• Funktionen (p. 19)• Verbesserungen (p. 19)

6

Amazon Athena Benutzerhandbuch26. Juni 2019

• Fehlerbehebungen (p. 19)• 24. März 2017 (p. 20)

• Funktionen (p. 20)• Verbesserungen (p. 20)• Fehlerbehebungen (p. 20)

• 20. Februar 2017 (p. 20)• Funktionen (p. 20)• Verbesserungen (p. 22)

26. Juni 2019Amazon Athena ist jetzt in der Region Europa (Stockholm) verfügbar. Eine Liste der unterstützten Regionenfinden Sie unter Regionen und Endpunkte von AWS.

24. Mai 2019Veröffentlicht am 24.05.2019

Amazon Athena ist jetzt in den Regionen AWS GovCloud (USA Ost) und AWS GovCloud (US-West)verfügbar. Eine Liste der unterstützten Regionen finden Sie unter Regionen und Endpunkte von AWS.

5. März 2019Veröffentlicht am 05.03.2019

Amazon Athena ist jetzt in der Region Kanada (Zentral) verfügbar. Eine Liste der unterstützten Regionenfinden Sie unter Regionen und Endpunkte von AWS. Veröffentlichung der neuen Version des ODBC-Treibers mit Unterstützung für Athena-Arbeitsgruppen. Weitere Informationen finden Sie unter ODBC LinuxKernel Driver-Versionshinweise.

Informationen zum Herunterladen der ODBC-Treiberversion 1.0.5 und der zugehörigen Dokumentationfinden Sie unter Verbindung zu Amazon Athena mit ODBC (p. 78). Informationen zu dieser Versionfinden Sie unter Versionshinweise für ODBC-Treiber.

Stellen Sie zur Verwendung von Arbeitsgruppen mit dem ODBC-Treiber die neue Verbindungseigenschaft,Workgroup, wie im folgenden Beispiel gezeigt in der Verbindungszeichenfolge ein:

Driver=Simba Athena ODBC Driver;AwsRegion=[Region];S3OutputLocation=[S3Path];AuthenticationType=IAM Credentials;UID=[YourAccessKey];PWD=[YourSecretKey];Workgroup=[WorkgroupName]

Suchen Sie für weitere Informationen nach „Arbeitsgruppe“ in der ODBC-Treiber-Installations- undKonfigurationsanleitung, Version 1.0.5. Wenn Sie Tags für Arbeitsgruppen verwenden, gibt es keineÄnderungen an der ODBC-Treiber-Verbindungszeichenfolge. Um Tags zu verwenden, aktualisieren Sie aufdie neueste Version des ODBC-Treibers (die aktuelle Version).

Diese Treiberversion ermöglicht Ihnen die Verwendung von Athena API-Arbeitsgruppen-Aktionen (p. 268)zum Erstellen und Verwalten von Arbeitsgruppen und Athena-API-Tag-Aktionen (p. 280) zum Hinzufügen,Auflisten oder Entfernen von Tags auf Arbeitsgruppen. Stellen vor Beginn sicher, dass Sie überBerechtigungen auf Ressourcenebene in IAM für Aktionen auf Arbeitsgruppen und Tags verfügen.

7

https://docs.aws.amazon.com/general/latest/gr/rande.html#athena



https://s3.amazonaws.com/athena-downloads/drivers/ODBC/SimbaAthenaODBC_1.0.5/release-notes.txt



https://s3.amazonaws.com/athena-downloads/drivers/ODBC/SimbaAthenaODBC_1.0.5/Simba+Athena+ODBC+Install+and+Configuration+Guide.pdf


Amazon Athena Benutzerhandbuch22. Februar 2019

Weitere Informationen finden Sie unter:

• Verwenden von Arbeitsgruppen zum Ausführen von Abfragen (p. 251) und Beispiel-Arbeitsgruppenrichtlinien (p. 256).

• Markieren von Arbeitsgruppen (p. 277) und Tagbasierte IAM-Zugriffssteuerungsrichtlinien (p. 281).

Wenn Sie den JDBC-Treiber oder das AWS-SDK verwenden, führen Sie ein Upgrade auf die neuesteVersion des Treibers und des SDKs durch, die beide bereits die Unterstützung für Arbeitsgruppen undTags in Athena enthalten. Weitere Informationen finden Sie unter Verwenden von Athena mit dem JDBC-Treiber (p. 76).

22. Februar 2019Veröffentlicht am 22.02.2019

Hinzufügung der Tag-Unterstützung für Arbeitsgruppen in Amazon Athena. Ein Tag besteht aus einemSchlüssel und einem Wert, die Sie beide selbst definieren können. Wenn Sie eine Arbeitsgruppe markieren,weisen Sie ihr benutzerdefinierte Metadaten zu. Sie können Tags zu Arbeitsgruppen hinzufügen, um Siezu kategorisieren; verwenden Sie dazu AWS Tagging – bewährte Methoden. Sie können mit Tags denZugriff auf Arbeitsgruppen einschränken und Kosten nachverfolgen. Erstellen Sie beispielsweise eineArbeitsgruppe für jede Kostenstelle. Wenn Sie diesen Arbeitsgruppen dann Tags hinzufügen, könnenSie Ihre Athena-Ausgaben für jede Kostenstelle nachverfolgen. Weitere Informationen finden Sie unterVerwendung von Tags für die Fakturierung im AWS Billing and Cost Management-Benutzerhandbuch.

Sie können mit Tags arbeiten, indem Sie die Athena-Konsole oder die API-Operationen verwenden.Weitere Informationen finden Sie unter Markieren von Arbeitsgruppen (p. 277).

In der Athena-Konsole können Sie jeder Ihrer Arbeitsgruppen einen oder mehrere Tags hinzufügenund dann nach Tags suchen. Arbeitsgruppen sind eine von IAM kontrollierte Ressource in Athena.Sie können in IAM einschränken, wer Tags auf einer von Ihnen erstellten Arbeitsgruppe hinzufügen,entfernen oder auflisten kann. Sie können auch die API-Operation CreateWorkGroup verwenden, dieden optionalen Tag-Parameter für die Hinzufügung eines oder mehrerer Tags zu der Arbeitsgruppe enthält.Verwenden Sie zum Hinzufügen, Entfernen oder Auflisten von Tags TagResource, UntagResourceund ListTagsForResource. Weitere Informationen finden Sie unter Arbeiten mit Tags mithilfe der API-Aktionen (p. 277).

Um Benutzern zu erlauben, beim Erstellen von Arbeitsgruppen tags hinzuzufügen, stellen Siesicher, dass Sie jedem Benutzer IAM-Berechtigungen für die API-Aktionen TagResource undCreateWorkGroup gewähren. Weitere Informationen und Beispiele finden Sie unter Tagbasierte IAM-Zugriffssteuerungsrichtlinien (p. 281).

Wenn Sie Tags für Arbeitsgruppen verwenden, gibt es keine Änderungen am JDBC-Treiber. Wenn Sieneue Arbeitsgruppen erstellen und den JDBC-Treiber oder das AWS-SDK verwenden, müssen Sie einUpgrade auf die neueste Version des Treibers und des SDK durchführen. Weitere Informationen finden Sieunter Verwenden von Athena mit dem JDBC-Treiber (p. 76).


Hinzufügung der Möglichkeit zur Kontrolle der Abfragekosten durch die Ausführung von Abfragen inArbeitsgruppen. Informationen finden Sie unter Verwendung von Arbeitsgruppen zur Kontrolle desAbfragenzugriffs und der Kosten (p. 251). Verbesserung des JSON OpenX SerDe in Athena, Behebung

8

https://aws.amazon.com/answers/account-management/aws-tagging-strategies/

https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html

Amazon Athena Benutzerhandbuch18. Februar 2019

eines Fehlers, bei dem Athena zur Speicherklasse GLACIER übertragene Objekte nicht ignorierte, undHinzufügung von Beispielen für die Abfrage von Netzwerk-Load-Balancer-Protokollen.

Durchführung der folgenden Änderungen:

• Hinzufügung der Unterstützung für Arbeitsgruppen. Verwenden Sie Arbeitsgruppen zum Trennen vonBenutzern, Teams, Anwendungen oder Workloads sowie zur Einrichtung von Grenzwerten für dieDatenmenge, die jede Abfrage oder die gesamte Arbeitsgruppe verarbeiten kann. Da Arbeitsgruppenals IAM-Ressourcen fungieren, können Sie Berechtigungen auf Ressourcenebene verwenden, umden Zugriff auf eine bestimmte Arbeitsgruppe zu steuern. Sie können auch abfragebezogene Metrikenin Amazon CloudWatch anzeigen, durch die Konfiguration von Limits für die gescannten Daten IhreKosten kontrollieren, Schwellenwerte einrichten und Aktionen auslösen, wie etwa Amazon SNS-Alarmauslösen, wenn diese Schwellenwerte überschritten werden. Weitere Informationen finden Sie unterVerwenden von Arbeitsgruppen zum Ausführen von Abfragen (p. 251) und Kontrollieren von Kostenund Überwachung von Abfragen mit CloudWatch-Metriken (p. 270).

Arbeitsgruppen sind IAM-Ressourcen. Für eine vollständige Liste workgroupbezogener Aktionen,Ressourcen und Bedingungen in IAM vgl. Aktionen, Ressourcen und Bedingungsschlüssel fürAmazon Athena im IAM-Benutzerhandbuch. Bevor Sie neue Arbeitsgruppen erstellen, stellenSie sicher, dass Sie , Arbeitsgruppen-IAM-Richtlinien (p. 255) und die verwaltete RichtlinieAmazonAthenaFullAccess (p. 218) verwenden.

Sie können mit den Arbeitsgruppen-API-Operationen (p. 268) oder mit dem JDBC-Treiberbeginnen, Arbeitsgruppen zu verwenden. Das allgemeine Verfahren finden Sie unter Einrichten vonArbeitsgruppen (p. 253). Für den Download des JDBC-Treibers mit Unterstützung für Arbeitsgruppenvgl. Verwenden von Athena mit dem JDBC-Treiber (p. 76).

Wenn Sie Arbeitsgruppen mit dem JDBC-Treiber verwenden, müssen Sie den Arbeitsgruppennamenin der Verbindungszeichenfolge mithilfe des Workgroup-Konfigurationsparameters wie im folgendenBeispiel dargestellt einrichten:

jdbc:awsathena://AwsRegion=<AWSREGION>;UID=<ACCESSKEY>;PWD=<SECRETKEY>;S3OutputLocation=s3://<athena-output>-<AWSREGION>/;Workgroup=<WORKGROUPNAME>;

Es gibt keine Änderungen bei der Art und Weise, wie Sie SQL-Anweisungen ausführen oder JDBC-API-Aufrufe an den Treiber durchführen. Der Treiber übergibt den Namen der Arbeitsgruppe an Athena.

Informationen über Unterschiede durch Arbeitsgruppen finden Sie unter Athena_Arbeitsgruppen-APIs (p. 268) und Fehlerbehebung für Arbeitsgruppen (p. 268).

• Verbesserung des OpenX JSON SerDe in Athena. Die Verbesserungen beinhalten u. a. Folgendes:• Unterstützung für die Eigenschaft ConvertDotsInJsonKeysToUnderscores. Bei der EinstellungTRUE kann der SerDe die Punkte in Schlüsselnamen durch Unterstriche ersetzen. Wenn derJSON-Datensatz beispielsweise einen Schlüssel mit dem Namen "a.b" enthält, können Sie dieseEigenschaft verwenden, um den Spaltennamen als "a_b" in Athena zu definieren. Der Standardwertist FALSE. Standardmäßig erlaubt Athena keine Punkte in Spaltennamen.

• Unterstützung für die Eigenschaft case.insensitive. Standardmäßig erfordert Athena, dassalle Schlüssel in Ihrem JSON-Datensatz Kleinbuchstaben verwenden. Die Verwendung von WITHSERDE PROPERTIES ("case.insensitive"= FALSE;) ermöglicht Ihnen die Verwendung vonSchlüsselnamen in Ihren Daten, die Groß- und Kleinbuchstaben unterscheiden. Der Standardwert istTRUE. Bei Festlegung auf TRUE wandelt der SerDe alle Großbuchstaben in Kleinbuchstaben um.

Weitere Informationen finden Sie unter the section called “OpenX JSON SerDe” (p. 302).• Behebung eines Problems, bei dem Athena "access denied"-Fehlermeldungen ausgab, wenn es

Amazon S3-Objekte verarbeitete, die durch Amazon S3-Lebenszyklusrichtlinien im Glacier archiviertwurden. Durch das Beheben dieses Problems ignoriert Athena zur GLACIER-Speicherklasse übertrageneObjekte. Athena unterstützt keine Abfragen von Daten aus der GLACIER- Speicherklasse.

9

https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonathena.html#amazonathena-aws_ResourceTag___TagKey_


Amazon Athena Benutzerhandbuch20. November 2018

Weitere Informationen finden Sie unter the section called “Voraussetzungen für Tabellen in Athena undDaten in Amazon S3” (p. 32) und Übertragung zur GLACIER-Speicherklasse (Objektarchivierung) imEntwicklerhandbuch für Amazon Simple Storage Service.

• Hinzufügung von Beispielen für die Abfrage von Netzwerk-Load-Balancer-Zugriffsprotokollen, dieInformationen zu TLS- (Transport Layer Security) Abfragen erhalten. Weitere Informationen finden Sieunter the section called “Abfragen von Netzwerk-Load-Balancer-Protokollen” (p. 200).

20. November 2018Veröffentlicht am 20.11.2018

Die neuen Versionen der JDBC- und ODBC-Treiber mit Unterstützung für Verbundzugriff auf die Athena-API mit AD FS und SAML 2.0 (Security Assertion Markup Language 2.0) wurden veröffentlicht. Detailsfinden Sie in den Versionshinweisen für JDBC-Treiber und den Versionshinweisen für ODBC-Treiber.

Ab dieser Version wird der Verbundzugriff auf Athena für Active Directory Federation Service (AD FS 3.0)unterstützt. Der Zugriff wird durch die Versionen von JDBC- bzw. ODBC-Treibern hergestellt, die SAML 2.0unterstützen. Informationen zur Konfiguration des Verbundzugriffs auf die Athena-API finden Sie unter thesection called “Aktivieren des föderierten Zugriffs auf die Athena-API” (p. 236).

Informationen zum Herunterladen der JDBC-Treiberversion 2.0.6 und der zugehörigen Dokumentationfinden Sie unter Verwenden von Athena mit dem JDBC-Treiber (p. 76). Informationen zu dieser Versionfinden Sie unter Versionshinweise für JDBC-Treiber.

Informationen zum Herunterladen der ODBC-Treiberversion 1.0.4 und der zugehörigen Dokumentationfinden Sie unter Verbindung zu Amazon Athena mit ODBC (p. 78). Informationen zu dieser Versionfinden Sie unter Versionshinweise für ODBC-Treiber.

Weitere Informationen zu SAML 2.0-Unterstützung in AWS finden Sie unter Informationen zum SAML 2.0-Verbund im IAM-Benutzerhandbuch.

15. Oktober 2018Veröffentlicht am 15.10.2018

Wenn Sie ein Upgrade auf AWS Glue-Datenkatalog ausgeführt haben, stehen Ihnen zwei neue Funktionenbereit, die Folgendes unterstützen:

• Verschlüsselung der Data Catalog-Metadaten. Wenn Sie Metadaten in Data Catalog verschlüsselnmöchten, müssen Sie spezifische Richtlinien zu Athena hinzufügen. Weitere Informationen finden Sieunter Zugriff auf verschlüsselte Metadaten in AWS Glue-Datenkatalog (p. 228).

• Differenzierte Berechtigungen für den Zugriff auf Ressourcen in AWS Glue-Datenkatalog. Sie könnenjetzt identitätsbasierte (IAM-)Richtlinien definieren, um den Zugriff auf spezifische Datenbanken undTabellen über den in Athena verwendeten Data Catalog einzuschränken oder zuzulassen. WeitereInformationen finden Sie unter Differenzierter Zugriff auf Datenbanken und Tabellen in AWS Glue-Datenkatalog (p. 222).

Note

Die Daten werden in den Amazon S3-Buckets gespeichert und der Zugriff darauf wird durch dieAmazon S3-Berechtigungen (p. 221) geregelt. Für den Zugriff auf Datenbanken und Tabellenverwenden Sie weiterhin Zugriffskontrollrichtlinien für Amazon S3-Buckets, in denen die Datengespeichert sind.

10

https://docs.aws.amazon.com/AmazonS3/latest/dev/lifecycle-transition-general-considerations.html#before-deciding-to-archive-objects

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.6/docs/release-notes.txt




https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html


Amazon Athena Benutzerhandbuch10. Oktober 2018


Athena unterstützt CREATE TABLE AS SELECT, womit eine Tabelle aus dem Ergebnis einer SELECT-Abfrageanweisung erstellt wird. Weitere Informationen finden Sie unter Erstellen einer Tabelle ausAbfrageergebnissen (CTAS).

Bevor Sie CTAS-Abfragen erstellen, ist es wichtig, mehr über ihr Verhalten in der Athena-Dokumentationzu erfahren. Sie enthält Informationen über den Speicherort für Abfrageergebnisse in Amazon S3, der Listeder unterstützten Formate für das Speichern von CTAS-Abfrageergebnissen, die Anzahl der Partitionen,die Sie erstellen können, und unterstützte Komprimierungsformate. Weitere Informationen finden Sie unterÜberlegungen und Einschränkungen für CTAS-Abfragen (p. 127).

Verwenden Sie CTAS-Abfragen, um:

• Erstellen Sie eine Tabelle von Abfrageergebnisse (p. 126) in einem Schritt.• Erstellen Sie CTAS-Abfragen in der Athena-Konsole (p. 128) unter Verwendung von

Beispielen (p. 132). Weitere Informationen zur Syntax finden Sie unter CREATE TABLE AS (p. 334).• Transformieren Sie Abfrageergebnisse in andere Dateiformate wie PARQUET, ORC, AVRO, JSON

und TEXTFILE. Weitere Informationen finden Sie unter Überlegungen und Einschränkungen für CTAS-Abfragen (p. 127) und Spaltenbasierte Speicherformate (p. 43).

6. September 2018Veröffentlicht am 06.09.2018

Neue Version des ODBC-Treibers (Version 1.0.3) wurde freigegeben. In der neuen Version des ODBC-Treibers werden Ergebnisse standardmäßig gestreamt, anstatt sie zu paginieren. Auf diese Weisekönnen Business Intelligence-Tools schneller große Datensätze abrufen. Diese Version enthält auchVerbesserungen, Fehlerbehebungen und eine aktualisierte Dokumentation für "Verwenden von SSL miteinem Proxy-Server". Weitere Informationen finden Sie in den Versionshinweisen zum Treiber.

Informationen zum Herunterladen der ODBC-Treiberversion 1.0.3 und der zugehörigen Dokumentationfinden Sie unter Verbindung zu Amazon Athena mit ODBC (p. 78).

Die Streamingfunktion für Ergebnisse ist mit dieser neuen Version des ODBC-Treibers verfügbar. Sieist auch mit dem JDBC-Treiber verfügbar. Informationen zum Streaming von Ergebnissen finden Sie im Installations- und Konfigurationshandbuch für ODBC-Treiber unter UseResultsetStreaming.

Die ODBC-Treiberversion 1.0.3 ist ein Drop-In-Ersatz für die vorherige Version des Treibers. Es wirdempfohlen, zum aktuellen Treiber zu migrieren.

Important

Um den ODBC-Treiber der Version 1.0.3 verwenden zu können, müssen Sie die folgendenAnforderungen erfüllen:

• Behalten Sie den Port 444 für ausgehenden Datenverkehr offen.• Fügen Sie die Richtlinienaktion athena:GetQueryResultsStream zur Liste der Richtlinien

für Athena hinzu. Diese Richtlinienaktion wird nicht direkt mit der API verfügbar gemacht undwird nur mit den ODBC- und JDBC-Treibern im Rahmen der Unterstützung für das Streamingvon Ergebnissen verwendet. Eine Beispielrichtlinie finden Sie unter Verwaltete RichtlinieAWSQuicksightAthenaAccess (p. 220).

11

https://docs.aws.amazon.com/athena/latest/ug/ctas.html

https://docs.aws.amazon.com/athena/latest/ug/ctas.html




Amazon Athena Benutzerhandbuch23. August 2018

23. August 2018Veröffentlicht am 23.08.2018

Unterstützung für diese DDL-bezogenen Funktionen hinzugefügt und folgende Fehler behoben:

• Unterstützung für die Datentypen BINARY und DATE für Daten in Parquet sowie für die Datentypen DATEund TIMESTAMP für Daten in Avro hinzugefügt.

• Unterstützung für INT und DOUBLE in DDL-Abfragen hinzugefügt. INTEGER ist ein Alias für INT undDOUBLE PRECISION ist ein Alias für DOUBLE.

• Verbesserung der Leistung von DROP TABLE- und DROP DATABASE-Anfragen.• Entfernung der Erstellung von _$folder$-Objekten in Amazon S3 im Fall von leeren Daten-Buckets.• Behebung eines Problems, bei dem ALTER TABLE ADD PARTITION eine Fehlermeldung ausgab,

wenn kein Partitionswert angegeben wurde.• Behebung eines Problems, bei dem DROP TABLE den Datenbanknamen bei der Überprüfung von

Partitionen ignorierte, nachdem der qualifizierte Name in der Anweisung angegeben wurde.

Weitere Informationen zu den in Athena unterstützten Datentypen finden Sie unter Datentypen (p. 316).

Informationen zu den unterstützten Datentypzuordnungen zwischen den Typen in Athena, demJDBC-Treiber und den Java-Datentypen finden Sie im Abschnitt Datentypen im Installations- undKonfigurationsleitfaden für JDBC-Treiber.


JDBC-Treiberversion 2.0.5 wurde freigegeben. In der neuen Version des JDBC-Treibers werdenErgebnisse standardmäßig gestreamt, anstatt sie zu paginieren. Auf diese Weise können BusinessIntelligence-Tools schneller große Datensätze abrufen. Im Vergleich mit der vorherigen Version des JDBC-Treibers gibt es die folgenden Leistungsverbesserungen:

• Leistungssteigerung um ungefähr das 2-Fache beim Abrufen von weniger als 10.000 Zeilen• Leistungssteigerung um ungefähr das 5- bis 6-Fache beim Abrufen von mehr als 10.000 Zeilen

Die Streamingfunktion für Ergebnisse ist nur für den JDBC-Treiber verfügbar. Für den ODBC-Treiber istsie nicht verfügbar. Eine Verwendung mit der Athena-API ist nicht möglich. Informationen zum Streamingvon Ergebnissen erhalten Sie, wenn Sie im Installations- und Konfigurationsleitfaden für den JDBC-Treibernach UseResultsetStreaming suchen.

Informationen zum Herunterladen der JDBC-Treiberversion 2.0.5 und der zugehörigen Dokumentationfinden Sie unter Verwenden von Athena mit dem JDBC-Treiber (p. 76).

Die JDBC-Treiberversion 2.0.5 ist ein Drop-In-Ersatz für die vorherige Version des Treibers (2.0.2).Um sicherzustellen, dass Sie die JDBC-Treiberversion 2.0.5 verwenden können, fügen Sie dieathena:GetQueryResultsStream-Richtlinienaktion zur Liste der Richtlinien für Athena hinzu. DieseRichtlinienaktion wird nicht direkt mit der API verfügbar gemacht und wird nur mit dem JDBC-Treiberverwendet, im Rahmen des Supports für das Streaming von Ergebnissen. Eine Beispielrichtlinie finden Sieunter Verwaltete Richtlinie AWSQuicksightAthenaAccess (p. 220). Weitere Informationen zur Migrationvon Version 2.0.2 zu Version 2.0.5 des Treibers finden Sie unter Migrationsleitfaden für den JDBC-Treiber.

Wenn Sie von einem 1.x-Treiber zu einem 2.x Treiber migrieren, müssen Sie Ihre bestehendenKonfigurationen zur neuen Konfiguration migrieren. Es wird dringend empfohlen, zur aktuellen

12

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.5/docs/Simba+Athena+JDBC+Driver+Install+and+Configuration+Guide.pdf



https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.5/docs/Simba+Athena+JDBC+Driver+Migration+Guide.pdf

Amazon Athena Benutzerhandbuch7. August 2018

Treiberversion zu migrieren. Weitere Informationen finden Sie unter Verwenden der vorherigen Version desJDBC-Treibers (p. 352) und im Migrationsleitfaden für den JDBC-Treiber.


Sie können jetzt Amazon Virtual Private Cloud-Flow-Protokolle in einem GZIP-Format direkt in AmazonS3 speichern. Hier können Sie die in Athena abfragen. Weitere Informationen finden Sie unter Abfragenvon Amazon VPC-Flow-Protokollen (p. 204) und Amazon VPC Flow Logs können nun an S3 übermitteltwerden.

5. Juni 2018Veröffentlicht am 05.06.2018

Themen• Unterstützung für Ansichten (p. 13)• Verbesserungen und Aktualisierungen bei Fehlermeldungen (p. 13)• Fehlerbehebungen (p. 14)

Unterstützung für AnsichtenUnterstützung für Ansichten hinzugefügt. Sie können jetzt CREATE VIEW (p. 336), DESCRIBEVIEW (p. 337), DROP VIEW (p. 339), SHOW CREATE VIEW (p. 340) und SHOW VIEWS (p. 342)in Athena verwenden. Die Abfrage, die die Ansicht definiert, wird jedes Mal ausgeführt, wenn Siein einer Abfrage auf die Ansicht verweisen. Weitere Informationen finden Sie unter Arbeiten mitAnsichten (p. 121).

Verbesserungen und Aktualisierungen beiFehlermeldungen• Die Bibliothek GSON 2.8.0 wurde in den CloudTrail SerDe aufgenommen, um ein Problem mit dem

CloudTrail SerDe zu lösen und die Verarbeitung von JSON-Zeichenfolgen zu ermöglichen.• Verbesserte Validierung des Partitionsschemas in Athena für Parquet und in einigen Fällen für ORC,

indem die Umsortierung von Spalten ermöglicht wurde. Auf diese Weise kann Athena besser mitÄnderungen bei der Weiterentwicklung des Schemas im Laufe der Zeit sowie mit Tabellen umgehen,die vom AWS Glue Crawler hinzugefügt wurden. Weitere Informationen finden Sie unter Verarbeiten vonSchema-Updates (p. 136).

• Unterstützung zur Verarbeitung für SHOW VIEWS hinzugefügt.• Folgende Verbesserungen an den häufigsten Fehlermeldungen wurden vorgenommen:

• Eine Meldung Internal Error (Interner Fehler) wurde durch eine verständliche Fehlermeldungersetzt, wenn ein SerDe die Spalte in einer Athena-Abfrage nicht verarbeiten kann. Zuvorlöste Athena bei Analysefehlern einen internen Fehler aus. Die neue Fehlermeldung lautet:„HIVE_BAD_DATA: Fehler beim Verarbeiten des Feldwerts für das Feld 0: java.lang.String kann nichtnach org.openx.data.jsonserde.json.JSONObject umgewandelt werden“.

• Verbesserte Fehlermeldungen über unzureichende Berechtigungen durch Hinzufügen weiterer Details.

13


https://aws.amazon.com/about-aws/whats-new/2018/08/amazon-vpc-flow-logs-can-now-be-delivered-to-s3/

https://aws.amazon.com/about-aws/whats-new/2018/08/amazon-vpc-flow-logs-can-now-be-delivered-to-s3/

Amazon Athena BenutzerhandbuchFehlerbehebungen

FehlerbehebungenFolgende Fehler wurden behoben:

• Es wurde ein Problem behoben, das dazu führte, dass die interne Übersetzung der Datentypen REALnach FLOAT ermöglichte. Dies verbessert die Integration mit dem AWS Glue Crawler, der FLOAT-Datentypen zurückgibt.

• Behebung eines Problems, durch das Athena AVRO DECIMAL (einen logischen Typ) nicht in einenDECIMAL-Typ umwandelte.

• Behebung eines Problems, bei dem Athena keine Ergebnisse für Abfragen für Parquet-Daten mit WHERE-Klauseln zurückgab, die auf Werte im TIMESTAMP-Datentyp verwiesen.


Die Obergrenze für gleichzeitige Abfragen in Athena wurde von fünf auf zwanzig angehoben. Das bedeutet:Sie können bis zu 20 DDL-Abfragen und 20 SELECT-Abfragen gleichzeitig absenden und ausführen.Hinweis: Obergrenzen für gleichzeitige Abfragen gelten separat für DDL- und SELECT-Abfragen.

Obergrenzen für gleichzeitige Abfragen in Athena sind definiert als die Anzahl der Abfragen, die gleichzeitigan den Service übermittelt werden können. Sie können bis zu 20 Abfragen des gleichen Typs (DDL oderSELECT) gleichzeitig absenden. Wenn Sie eine Abfrage übermitteln, die die Obergrenze für gleichzeitigeAbfragen überschreitet, wird von der Athena-API eine Fehlermeldung angezeigt: „Sie haben dieObergrenze für die Anzahl an Abfragen, die Sie gleichzeitig ausführen können, überschritten. ReduzierenSie die Anzahl der gleichzeitigen Abfragen, die von diesem Konto abgesendet werden. Wenden Sie sich anden Kundensupport, um eine Erhöhung der Obergrenze für gleichzeitige Abfragen zu beantragen.“

Nachdem Sie die Abfragen an Athena übermittelt haben, werden diese verarbeitet, indem Ressourcen jenach der Gesamtauslastung des Services sowie der Anzahl eingehender Anfragen zugewiesen werden.Wir überwachen den Service fortlaufend und passen ihn an, damit Ihre Abfragen so schnell wie möglichverarbeitet werden.

Weitere Informationen finden Sie unter Service Limits (p. 357). Dies ist ein weiches Limit. Sie können eineErhöhung des Limits für parallele Abfragen beantragen.

19. April 2018Veröffentlicht am 19.04.2018

Es wurde die neue Version des JDBC-Treibers (Version 2.0.2) mit Unterstützung für die Rückgabe derResultSet-Daten als Array-Datentyp sowie mit Verbesserungen und Fehlerbehebungen freigegeben.Weitere Informationen finden Sie in den Versionshinweisen zum Treiber.

Informationen zum Herunterladen der neuen JDBC-Treiberversion 2.0.2 und der zugehörigenDokumentation finden Sie unter Verwenden von Athena mit dem JDBC-Treiber (p. 76).

Die aktuelle Version des JDBC-Treibers ist 2.0.2. Wenn Sie von einem 1.x-Treiber zu einem 2.x Treibermigrieren, müssen Sie Ihre bestehenden Konfigurationen zur neuen Konfiguration migrieren. Es wirddringend empfohlen, zum aktuellen Treiber zu migrieren.

Informationen zu den Änderungen an der neuen Treiberversion, zu den Versionsunterschieden sowieBeispiele finden Sie im Migrationsleitfaden für den JDBC-Treiber.

14

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html




Amazon Athena Benutzerhandbuch6. April 2018

Informationen zur vorherigen Version des JDBC-Treibers finden Sie unter Verwenden von Athena mit dervorherigen Version des JDBC-Treibers (p. 352).


Verwenden Sie die automatische Vervollständigung, um Abfragen in die Athena-Konsole einzugeben.


Möglichkeit, Athena-Tabellen für CloudTrail-Protokolldateien automatisch direkt aus der CloudTrail-Konsole zu erstellen, wurde hinzugefügt. Weitere Informationen finden Sie unter Erstellen einer Tabelle fürCloudTrail-Protokolle in der CloudTrail-Konsole (p. 191).


Es wurde eine Möglichkeit für das Auslagern von Zwischendaten auf Festplatte beiarbeitsspeicherintensiven Abfragen, die die GROUP BY-Klausel verwenden, hinzugefügt. Dadurch wird dieZuverlässigkeit solcher Abfragen verbessert und die Fehlermeldung "Query resource exhausted" (Abfrage-Ressource aufgebraucht) vermieden.

19. Januar 2018Veröffentlicht am 19.01.2018

Athena verwendet Presto, eine Open-Source-basierte verteilte Abfrage-Engine, zum Ausführen vonAbfragen.

Bei Athena sind keine Versionen zu verwalten. Wir haben für die zugrunde liegende Engine in Athena eintransparentes Upgrade auf eine Version ausgeführt, die auf Presto-Version 0.172 basiert. Von Ihrer Seiteaus ist keine Aktion erforderlich.

Mit dem Upgrade können Sie nun Funktionen und Operatoren von Presto 0.172 einschließlich der Lambda-Ausdrücke von Presto 0.172 in Athena nutzen.

Zu den wichtigen Aktualisierungen dieser Version, darunter auch von der Community entwickelteFehlerbehebungen, zählen folgende:

• Unterstützung für das Ignorieren von Headern. Mithilfe der Eigenschaft skip.header.line.countkönnen Sie im Rahmen der Tabellendefinition festlegen, dass Athena die Header ignorieren darf. Dieswird derzeit für Abfragen unterstützt, die den OpenCSV SerDe verwenden, aber nicht für Grok- undRegex-SerDes.

• Unterstützung für den Datentyp CHAR(n) in STRING-Funktionen. Der Bereich für CHAR(n) ist [1.255],wohingegen VARCHAR(n) den Bereich [1,65535] aufweist.

• Unterstützung für korrelierte Unterabfragen.

15

https://prestodb.io/docs/0.172/functions.html

https://prestodb.io/docs/0.172/functions/lambda.html


Amazon Athena Benutzerhandbuch13. November 2017

• Unterstützung für Lambda-Ausdrücke und Funktionen von Presto.• Verbesserte Leistung von DECIMAL-Datentypen und -Operatoren.• Unterstützung für gefilterte Aggregationen, wie z. B. SELECT sum(col_name) FILTER mit id > 0.• Prädikatweitergabe (Predicate Pushdown) für die Datentypen DECIMAL, TINYINT, SMALLINT und REAL.• Unterstützung für quantifizierte Vergleichsprädikate: ALL, ANY und SOME.• Hinzugefügte Funktionen: arrays_overlap(), array_except(), levenshtein_distance(),codepoint(), skewness(), kurtosis() und typeof().

• Variante der Funktion from_unixtime() hinzugefügt, die ein Zeitzonen-Argument annimmt.• Aggregationsfunktionen bitwise_and_agg() und bitwise_or_agg() hinzugefügt.• Funktionen xxhash64() und to_big_endian_64() hinzugefügt.• Unterstützung für die Funktionen json_extract() und json_extract_scalar() hinzugefügt, damit

doppelte Anführungszeichen oder umgekehrte Schrägstriche unter Verwendung eines umgekehrtenSchrägstrichs mit einem JSON-Pfadindex als Escape-Zeichen verwendet werden können. Dadurch wirddie Semantik jedes Aufruf mit einem umgekehrten Schrägstrich geändert, da dieser zuvor als reguläresZeichen galt.

Eine vollständige Liste der Funktionen und Operatoren finden Sie unter SQL Queries, Functions, andOperators (p. 317) in diesem Handbuch sowie unter Presto 0.172 Functions.

Nicht alle Presto-Funktionen werden von Athena unterstützt. Weitere Informationen finden Sie unterLimitations (p. 343).


Unterstützung für die Verbindungserstellung von Athena zum ODBC-Treiber hinzugefügt. WeitereInformationen finden Sie unter Verbindung zu Amazon Athena mit ODBC (p. 78).


Unterstützung für die Abfrage von koordinatenbasierten Daten und für die Regionen Asien-Pazifik (Seoul),Asien-Pazifik (Mumbai) und EU (London) hinzugefügt. Weitere Informationen finden Sie unter Abfragen vonkoordinatenbasierten Daten (p. 168) und Regionen und Endpunkte von AWS.


Unterstützung für EU (Frankfurt) hinzugefügt. Eine Liste der unterstützten Regionen finden Sie unterRegionen und Endpunkte von AWS.


16

https://prestodb.io/docs/0.172/functions/array.html#arrays_overlap

https://prestodb.io/docs/0.172/functions/array.html#array_except

https://prestodb.io/docs/0.172/functions/string.html#levenshtein_distance

https://prestodb.io/docs/0.172/functions/string.html#codepoint

https://prestodb.io/docs/0.172/functions/aggregate.html#skewness

https://prestodb.io/docs/0.172/functions/aggregate.html#kurtosis

https://prestodb.io/docs/0.172/functions/conversion.html#typeof

https://prestodb.io/docs/0.172/functions/datetime.html#from_unixtime

https://prestodb.io/docs/0.172/functions/aggregate.html#bitwise_and_agg

https://prestodb.io/docs/0.172/functions/aggregate.html#bitwise_or_agg

https://prestodb.io/docs/0.172/functions/binary.html#xxhash64

https://prestodb.io/docs/0.172/functions/binary.html#to_big_endian_64

https://prestodb.io/docs/0.172/functions/json.html#json_extract

https://prestodb.io/docs/0.172/functions/json.html#json_extract_scalar




Amazon Athena Benutzerhandbuch25. September 2017

Erstellen von benannten Athena-Abfragen mit CloudFormation. Weitere Informationen finden Sie unterAWS::Athena::NamedQuery im AWS CloudFormation Benutzerhandbuch.

25. September 2017Veröffentlicht am 25.09.2017

Asien-Pazifik (Sydney) wird nun unterstützt. Eine Liste der unterstützten Regionen finden Sie unterRegionen und Endpunkte von AWS.


Integration mit dem AWS Glue-Datenkatalog sowie einen Migrationsassistenten für das Update vomverwalteten Athena-Datenkatalog zum AWS Glue-Datenkatalog hinzugefügt. Weitere Informationen findenSie unter Integration mit AWS Glue (p. 48).


Unterstützung für den Grok-SerDe zum einfachen Mustervergleich von Datensätzen in unstrukturiertenTextdateien (z. B. Protokolle) hinzugefügt. Weitere Informationen finden Sie unter Grok SerDe (p. 298).Tastenkombinationen zum Durchblättern der Abfrageverläufe mithilfe der Konsole hinzugefügt (STRG+⇧/⇩bei Windows, CMD+⇧/⇩ bei Mac).


Unterstützung für Asien-Pazifik (Tokio) und Asien-Pazifik (Singapur) hinzugefügt. Eine Liste derunterstützten Regionen finden Sie unter Regionen und Endpunkte von AWS.


Europa (Irland) wird nun unterstützt. Weitere Informationen finden Sie unter Regionen und Endpunkte vonAWS.


Amazon Athena-API und AWS CLI-Unterstützung für Athena hinzugefügt; JDBC-Treiber auf Version 1.1.0aktualisiert; verschiedene Fehler behoben.

17






Amazon Athena BenutzerhandbuchVerbesserungen

• Amazon Athena ermöglicht die Anwendungsprogrammierung für Athena. Weitere Informationen findenSie unter Amazon Athena-API-Referenz. In den neuesten AWS SDKs ist die Unterstützung für dieAthena-API enthalten. Links zu Dokumentationen und Downloads finden Sie unter SDKs in den Tools fürAmazon Web Services.

• Die AWS-Befehlszeilenschnittstelle (CLI) enthält neue Befehle für Athena. Weitere Informationen findenSie im Amazon Athena-API-Referenz.

• Der neue JDBC-Treiber 1.1.0 ist verfügbar. Er unterstützt die neue Athena-API sowie die neuestenFunktionen und Fehlerbehebungen. Laden Sie den Treiber unter https://s3.amazonaws.com/athena-downloads/drivers/AthenaJDBC41-1.1.0.jar herunter. Es wird empfohlen, auf die neueste Athena-JDBC-Treiberversion zu aktualisieren, Sie können jedoch auch die vorherige Treiberversion verwenden.Vorherige Treiberversionen bieten keine Unterstützung für die Athena-API. Weitere Informationen findenSie unter Verwenden von Athena mit dem JDBC-Treiber (p. 76).

• Die in früheren Athena-Versionen vorhandenen speziellen Aktionen für Richtlinienanweisungensind veraltet. Wenn Sie auf die JDBC-Treiberversion 1.1.0 aktualisieren und kundenverwaltete odereingebundene IAM-Richtlinien den JDBC-Benutzern zugewiesen haben, müssen Sie die IAM-Richtlinienebenfalls aktualisieren. Im Gegensatz dazu wird die Athena-API von früheren JDBC-Treiberversionennicht unterstützt. Daher können Sie in Richtlinien, die Benutzern der vorherigen JDBC-Treiberversionzugewiesen sind, nur veraltete Aktionen angeben. Aus diesem Grund sollte keine Aktualisierung derkundenverwalteten oder eingebundenen IAM-Richtlinien erfolgen.

• Diese richtlinienspezifischen Aktionen wurden in Athena vor Einführung der Athena-API verwendet.Verwenden Sie diese veralteten Aktionen in Richtlinien nur mit JDBC-Treibern vor der Version 1.1.0.Wenn Sie die JDBC-Treiberversion aktualisieren, müssen Sie Richtlinienanweisungen, die veralteteAktionen zulassen oder verweigern, entsprechend durch die nachstehend aufgeführten API-Aktionenersetzen, da andernfalls Fehler auftreten:

Veraltete richtlinienspezifische Aktion Entsprechende Athena-API-Aktion

athena:RunQuery athena:StartQueryExecution

athena:CancelQueryExecution athena:StopQueryExecution

athena:GetQueryExecutions athena:ListQueryExecutions

Verbesserungen• Längenbegrenzung der Abfragezeichenfolge wurde auf 256 KB erhöht.

Fehlerbehebungen• Der Fehler, aufgrund dessen die Abfrageergebnisse beim Blättern durch die Ergebnisse in der Konsole

falsch formatiert wirkten, wurde behoben.• Der Fehler, aufgrund dessen eine \u0000-Zeichenfolge in Amazon S3-Datendateien zu Fehlern führte,

wurde behoben.• Der Fehler, aufgrund dessen der angeforderte Abbruch einer Abfrage vom JDBC-Treiber fehlschlug,

wurde behoben.• Der Fehler, aufgrund dessen der AWS CloudTrail SerDe mit Amazon S3-Daten in USA Ost (Ohio) nicht

ordnungsgemäß ausgeführt werden konnte, wurde behoben.

18


https://aws.amazon.com/tools/



https://s3.amazonaws.com/athena-downloads/drivers/AthenaJDBC41-1.1.0.jar

https://s3.amazonaws.com/athena-downloads/drivers/AthenaJDBC41-1.1.0.jar

Amazon Athena Benutzerhandbuch4. April 2017

• Der Fehler, aufgrund dessen DROP TABLE für eine partitionierte Tabelle nicht ordnungsgemäßausgeführt werden konnte, wurde behoben.


Unterstützung für die Amazon S3-Datenverschlüsselung und Veröffentlichung einer JDBC-Treiberaktualisierung (Version 1.0.1) mit Verschlüsselungsunterstützung sowie Verbesserungen undFehlerbehebungen.

Funktionen• Folgende Verschlüsselungsfunktionen wurden hinzugefügt:

• Unterstützung für Abfragen von verschlüsselten Daten in Amazon S3• Unterstützung für die Verschlüsselung von Athena-Abfrageergebnissen.

• Eine neue Version des Treibers unterstützt neue Verschlüsselungsfunktionen und enthältVerbesserungen sowie Fehlerbehebungen.

• Die Möglichkeit, Spalten mithilfe von ALTER TABLE hinzuzufügen, zu ersetzen und zu ändern, wurdehinzugefügt. Weitere Informationen finden Sie unter Alter Column in der Hive-Dokumentation.

• Unterstützung für die Abfrage von LZO-komprimierten Daten wurde hinzugefügt.

Weitere Informationen finden Sie unter Verschlüsselung im Ruhezustand (p. 210).

Verbesserungen• Bessere JDBC-Abfrageleistung mit verbesserter Seitengröße, sodass anstelle von 100 Zeilen nun 1.000

zurückgegeben werden.• Möglichkeit, eine Abfrage über die JDBC-Treiberschnittstelle abzubrechen, hinzugefügt.• Möglichkeit, JDBC-Optionen in der JDBC-Verbindungs-URL anzugeben, hinzugefügt. Weitere

Informationen finden Sie unter Verwenden von Athena mit der vorherigen Version des JDBC-Treibers (p. 352) für die vorherige Version des Treibers sowie unter Verbindung mit dem JDBC-Treiber (p. 76) für die aktuelle Version.

• PROXY-Einstellung im Treiber hinzugefügt, die mit der Option ClientConfiguration im AWS SDK for Javaeingestellt werden kann.

FehlerbehebungenFolgende Fehler wurden behoben:

• Im Falle mehrerer Abfragen über die JDBC-Treiberschnittstelle traten Ablehnungsfehler auf.• Die Projektion des Datentyps "decimal" führte zu einem Abbruch des JDBC-Treibers.• Der JDBC-Treiber gab jeden Datentyp als Zeichenfolge zurück, und zwar unabhängig von der Definition

des Datentyps in der Tabelle. Wenn Sie beispielsweise eine Spalte, für die der Datentyp INT definiertwar, mit resultSet.GetObject() ausgewählt haben, wurde der Datentyp STRING anstelle von INTzurückgegeben.

• Vom JDBC-Treiber wurden die Anmeldeinformationen zum Zeitpunkt der Verbindungserstellungüberprüft – und nicht zum Zeitpunkt der Abfrageausführung.

• Abfragen über den JDBC-Treiber waren fehlerhaft, sobald zusammen mit der URL ein Schemaangegeben wurde.

19

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-AlterColumn

https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/ClientConfiguration.html

Amazon Athena Benutzerhandbuch24. März 2017


Der AWS CloudTrail-SerDe wurde hinzugefügt, zudem gab es Leistungsverbesserungen undPartitionsfehlerkorrekturen.

Funktionen• AWS CloudTrail SerDe hinzugefügt. Weitere Informationen finden Sie unter CloudTrail-SerDe (p. 294).

Detaillierte Verwendungsbeispiele finden Sie im AWS Big Data-Blogbeitrag unter Analyze Security,Compliance, and Operational Activity Using AWS CloudTrail and Amazon Athena.

Verbesserungen• Verbesserte Leistung beim Scannen einer großen Partitionsanzahl.• Verbesserte Leistung bei dem Vorgang MSCK Repair Table.• Hinzufügung der Möglichkeit, nicht in der primären Region gespeicherte Amazon S3-Daten

abzufragen. Neben den Athena-Standardgebühren fallen auch die Amazon S3-Standardgebühren fürregionenübergreifende Datenübertragung an.

Fehlerbehebungen• Der Fehler, aufgrund dessen ein "table not found error" auftrat, falls keine Partition geladen war, wurde

behoben.• Der Fehler, aufgrund dessen bei Abfragen des Typs ALTER TABLE ADD PARTITION IF NOTEXISTS eine Ausnahme auftrat, wurde behoben.

• Ein Fehler in DROP PARTITIONS wurde behoben.


Hinzufügung der Unterstützung für AvroSerDe und OpenCSVSerDe, die Region USA Ost (Ohio) und dieMassenbearbeitung von Spalten im Konsolenassistenten. Die Leistung bei großen Parquet-Tabellen wurdeverbessert.

Funktionen• Unterstützung für neuen SerDes eingeführt:

• Avro SerDe (p. 291)• OpenCSVSerDe für CSV-Verarbeitung (p. 295)

• Start der Region USA Ost (Ohio) (us-east-2). Sie können nun Abfragen in dieser Region ausführen.• Sie können nun mit dem Assistenten Add Table mehrere Tabellenschemata auf einmal definieren.

Klicken Sie auf Catalog Manager und Add table. Wählen Sie dann in den Schritten für dieTabellendefinition die Option Bulk add columns aus.

20

http://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/


Amazon Athena BenutzerhandbuchFunktionen

Geben Sie im Textfeld Name-Wert-Paare ein und klicken Sie auf Add.

21

Amazon Athena BenutzerhandbuchVerbesserungen

Verbesserungen• Die Leistung bei großen Parquet-Tabellen wurde verbessert.

22

Amazon Athena BenutzerhandbuchAnmelden bei AWS

EinrichtenWenn Sie bereits bei Amazon Web Services (AWS) registriert sind, können Sie Amazon Athena sofortverwenden. Wenn Sie noch nicht bei AWS registriert sind oder Hilfe bei der Datenabfrage mit Athenabenötigen, führen Sie zunächst folgende Aufgaben aus:

Anmelden bei AWSWenn Sie sich bei AWS anmelden, wird Ihr AWS-Konto automatisch für alle Dienste in AWS angemeldet,einschließlich Athena. Berechnet werden Ihnen aber nur die Services, die Sie nutzen. Wenn Sie Athenaverwenden, verwenden Sie Amazon S3 zum Speichern Ihrer Daten. Für Athena ist kein kostenlosesKontingent für AWS vorhanden.

Wenn Sie bereits ein AWS-Konto haben, wechseln Sie zur nächsten Aufgabe. Wenn Sie kein AWS-Kontohaben, befolgen Sie diese Schritte zum Erstellen eines Kontos.

So erstellen Sie ein Amazon-Konto1. Öffnen Sie http://aws.amazon.com/ und klicken Sie auf Erstellen eines AWS-Kontos.2. Folgen Sie den Onlineanweisungen. Der Anmeldeprozess beinhaltet auch einen Telefonanruf und die

Eingabe einer PIN über die Telefontastatur.

Notieren Sie Ihre AWS-Kontonummer. Sie benötigen sie im nächsten Schritt.

Erstellen eines IAM-BenutzersBei einem AWS Identity and Access Management (IAM)-Benutzer handelt es sich um ein Konto, dasSie für den Zugriff auf Services erstellen. Dies ist ein anderer Benutzer als für Ihr AWS-Hauptkonto.Im Sinne bewährter Sicherheitsmethoden wird empfohlen, die Anmeldeinformationen des IAM-Benutzers für den Zugriff auf AWS-Services zu nutzen. Erstellen Sie einen IAM-Benutzer und fügenSie diesen zu einer IAM-Gruppe mit Administratorberechtigungen hinzu oder erteilen Sie ihm dieentsprechenden Administratorberechtigungen. Sie können dann mithilfe einer speziellen URL und denAnmeldeinformationen des IAM-Benutzers auf AWS zugreifen.

Wenn Sie sich zwar bei AWS angemeldet, aber noch keinen eigenen IAM-Benutzer erstellt haben, könnenSie dies mit der IAM-Konsole tun. Falls Sie nicht mit der Verwendung der Konsole vertraut sind, erhaltenSie unter Arbeiten mit der AWS Management Console eine Übersicht.

So erstellen Sie eine Gruppe für Administratoren:1. Melden Sie sich unter https://console.aws.amazon.com/iam/ bei der IAM-Konsole an.2. Wechseln Sie im Navigationsbereich zu Groups und klicken Sie auf Create New Group.3. Geben Sie im Feld Group Name einen Namen für die Gruppe ein (z. B. Administrators) und wählen

Sie Next Step aus.4. Aktivieren Sie in der Liste der Richtlinien das Kontrollkästchen neben der Richtlinie AdministratorAccess.

Über das Menü Filter und das Feld Search können Sie die Richtlinienliste filtern.5. Wählen Sie Next Step und Create Group aus. Ihre neue Gruppe wird unter Group Name aufgeführt.

23

http://aws.amazon.com/

https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/getting-started.html

https://console.aws.amazon.com/iam/

Amazon Athena BenutzerhandbuchSo erstellen Sie einen IAM-Benutzer für sich,fügen ihn der Administratorengruppe hinzuund erstellen ein Passwort für den Benutzer

So erstellen Sie einen IAM-Benutzer für sich, fügenihn der Administratorengruppe hinzu und erstellen einPasswort für den Benutzer1. Wählen Sie im Navigationsbereich Users und dann Create New Users aus.2. Geben Sie für 1 einen Benutzernamen ein.3. Deaktivieren Sie das Kontrollkästchen neben Generate an access key for each user und wählen Sie

Create aus.4. Wählen Sie in der Benutzerliste den Namen – nicht das Kontrollkästchen – für den Benutzer aus, den Sie

gerade erstellt haben. Sie können über das Feld Search nach dem Benutzernamen suchen.5. Wählen Sie Groups und Add User to Groups aus.6. Aktivieren Sie das Kontrollkästchen neben den Administratoren und wählen Sie Add to Groups aus.7. Wechseln Sie zur Registerkarte Security Credentials. Wählen Sie unter Sign-In Credentials die Option

Manage Password aus.8. Klicken Sie auf Assign a custom password. Geben Sie dann ein Passwort in die Felder Passwort und

Confirm Password ein. Wählen Sie danach Apply aus.9. Um sich mit dem neuen IAM-Benutzer anzumelden, müssen Sie sich zunächst von der AWS-

Konsole abmelden. Verwenden Sie dann die folgende URL, wobei your_aws_account_id IhreAWS-Kontonummer ohne Bindestriche darstellt (wenn beispielsweise Ihre AWS-Kontonummer1234-5678-9012 lautet, ist 123456789012 Ihre AWS-Konto-ID):

https://*your_account_alias*.signin.aws.amazon.com/console/

Möglicherweise ist für den Anmeldelink der Kontoname anstelle der Kontonummer erforderlich. Um denAnmeldelink der IAM-Benutzer Ihres Kontos zu verifizieren, öffnen Sie die IAM-Konsole und prüfen dies imDashboard unter IAM users sign-in link.

Anfügen von verwalteten Richtlinien für die Nutzungvon Athena

Weisen Sie dem IAM-Konto, mit dem Sie auf Athena zugreifen, von Athena verwalteteRichtlinien zu. Für Athena gibt es zwei verwaltete Richtlinien: AmazonAthenaFullAccess undAWSQuicksightAthenaAccess. Diese Richtlinien erteilen Athena die Berechtigungen, für Sie Abfragenin Amazon S3 auszuführen und die Abfrageergebnisse in einem eigenen Bucket zu speichern. WeitereInformationen und Schritt-für-Schritt-Anweisungen finden Sie unter Anfügen von verwalteten Richtlinien imAWS Identity and Access Management-Benutzerhandbuch. Weitere Informationen zu Richtlinieninhaltenfinden Sie unter IAM-Richtlinien für den Benutzerzugriff (p. 217).

Note

Möglicherweise sind für den Zugriff auf das zugrunde liegende Dataset in Amazon S3 zusätzlicheBerechtigungen erforderlich. Wenn Sie nicht der Kontoinhaber sind oder Ihr Zugriff auf den Bucketanderweitig eingeschränkt ist, wenden Sie sich an den Bucket-Eigentümer (damit dieser Ihnenmithilfe einer ressourcenbasierten Bucket-Richtlinie Zugriff gewährt) oder an den Administrator(der Ihnen über eine identitätsbasierte Richtlinie Zugriff gewähren kann). Weitere Informationenfinden Sie unter Amazon S3-Berechtigungen (p. 221). Falls das Dataset oder die Athena-Abfrageergebnisse verschlüsselt sind, benötigen Sie möglicherweise weitere Berechtigungen.Weitere Informationen finden Sie unter Konfigurieren von Verschlüsselungsoptionen (p. 210).

24

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html#attach-managed-policy-console

Amazon Athena BenutzerhandbuchVoraussetzungen

Erste SchritteIn diesem Tutorial erfahren Sie, wie Sie Amazon Athena zum Abfragen von Daten verwenden. Sie werdeneine Tabelle basierend auf Beispieldaten aus Amazon Simple Storage Service erstellen, die Tabelleabfragen und die Ergebnisse der Abfrage prüfen.

Für das Tutorial werden Live-Ressourcen verwendet, daher fallen für ausgeführte Abfragen Kostenan. Es entstehen Ihnen keine Kosten für die verwendeten Beispiel-Datasets. Wenn Sie jedoch eigeneDatendateien in Amazon S3 hochladen, fallen dafür Kosten an.

VoraussetzungenSofern Sie dies noch nicht getan haben, erstellen Sie unter Setting Up (p. 23) (Einrichten) ein Konto.

Schritt 1: Erstellen einer DatenbankZunächst müssen Sie eine Datenbank in Athena erstellen.

So erstellen Sie eine Datenbank

1. Öffnen Sie die Athena-Konsole.2. Wenn Sie die Athena-Konsole zum ersten Mal geöffnet haben, wird die Seite "Erste Schritte" geöffnet.

Klicken Sie auf Get Started (Erste Schritte), um den Abfrage-Editor zu öffnen. Wenn dies nicht Ihrerster Besuch ist, wird der Athena-Abfrage-Editor geöffnet.

3. Im Athena-Abfrage-Editor wird ein Abfragebereich mit einer Beispielabfrage angezeigt. Beginnen Sie,im Abfragebereich eine Abfrage einzugeben.

4. Um eine Datenbank namens mydatabase zu erstellen, geben Sie die folgende CREATE DATABASE-Anweisung ein und klicken Sie auf Run Query (Abfrage ausführen):

CREATE DATABASE mydatabase

5. Überprüfen Sie, dass die Kataloganzeige aktualisiert wird und mydatabase in der Liste DATABASE(DATENBANK) im Catalog (Katalog)-Dashboard auf der linken Seite angezeigt wird.

25

Amazon Athena BenutzerhandbuchSchritt 2: Erstellen einer Tabelle

Schritt 2: Erstellen einer TabelleNachdem Sie nun eine Datenbank haben, können Sie eine Tabelle erstellen, die auf der Beispieldatendateibasiert. Sie definieren Spalten, die den Daten zugeordnet sind, geben an, wie die Daten unterteilt sind, undgeben den Speicherort der Datei in Amazon S3 an.

So erstellen Sie eine Tabelle

1. Stellen Sie sicher, dass mydatabase für DATABASE (DATENBANK) ausgewählt ist, und klicken Sieauf New Query (Neue Abfrage).

2. Geben Sie im Abfragebereich die folgende CREATE TABLE-Anweisung ein und klicken Sie auf RunQuery (Abfrage ausführen):

Note

Sie können Daten in anderen Regionen als der Region abfragen, in der Athena ausgeführtwird. Neben den Athena-Standardgebühren fallen auch die Amazon S3-Standardgebührenfür regionenübergreifende Datenübertragung an. Ersetzen Sie zum Senken derDatenübertragungskosten myregion in s3://athena-examples-myregion/path/to/data/ durch die Regions-ID der Region, in der Sie Athena ausführen, z. B. s3://athena-examples-us-east-1/path/to/data/.

CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_logs ( `Date` DATE, Time STRING, Location STRING, Bytes INT, RequestIP STRING, Method STRING, Host STRING, Uri STRING, Status INT, Referrer STRING, os STRING, Browser STRING, BrowserVersion STRING ) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ( "input.regex" = "^(?!#)([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+[^\(]+[\(]([^\;]+).*\%20([^\/]+)[\/](.*)$" ) LOCATION 's3://athena-examples-myregion/cloudfront/plaintext/';

Die table cloudfront_logs wird erstellt und im Catalog (Katalog)-Dashboard für Ihre Datenbankangezeigt.

26

Amazon Athena BenutzerhandbuchSchritt 3: Abfragen von Daten

Schritt 3: Abfragen von DatenNachdem Sie nun die Tabelle cloudfront_logs basierend auf den Daten in Athena in Amazon S3erstellt haben, können Sie die Tabelle abfragen und die Ergebnisse in Athena anzeigen.

So führen Sie eine Abfrage aus

1. Klicken Sie auf New Query (Neue Abfrage), geben Sie die folgende Anweisung im Abfragebereich einund klicken Sie auf Run Query (Abfrage ausführen):

SELECT os, COUNT(*) countFROM cloudfront_logsWHERE date BETWEEN date '2014-07-05' AND date '2014-08-05'GROUP BY os;

Die Ergebnisse werden in etwa wie folgt zurückgegeben:

27

Amazon Athena BenutzerhandbuchSchritt 3: Abfragen von Daten

2. Optional können Sie die Ergebnisse einer Abfrage in einer CSV-Datei speichern. Klicken Sie dazu aufdas Dateisymbol im Bereich Results (Ergebnisse).

Sie können die Ergebnisse von früheren Abfragen oder langfristigen Abfragen ebenfalls anzeigen.Klicken Sie auf History (Verlauf) und suchen Sie entweder nach einer Abfrage oder klicken Sie auf View(Anzeigen) oder Download (Herunterladen), um die Ergebnisse von zuvor abgeschlossenen Abfragenanzuzeigen oder herunterzuladen. Hier wird auch der Status von derzeit ausgeführten Abfragen angezeigt.Der Abfrageverlauf wird 45 Tage vorgehalten. Weitere Informationen finden Sie unter Anzeigen desAbfrageverlaufs (p. 120).

Die Abfrageergebnisse werden auch in Amazon S3 in einem Bucket namens aws-athena-query-results-ACCOUNTID-REGION gespeichert. Sie können den Standardspeicherort in der Konsole sowie dieVerschlüsselungsoptionen über Settings (Einstellungen) oben rechts ändern. Weitere Informationen findenSie unter Abfrageergebnisse (p. 115).

28

Amazon Athena BenutzerhandbuchÜber die Konsole

Zugriff auf Amazon AthenaSie können auf Amazon Athena über die AWS Management Console, die Amazon Athena-API oder dieAWS-CLI zugreifen.

Über die KonsoleÜber die AWS Management Console für Amazon Athena können Sie folgende Aktionen ausführen:

• Erstellen oder Auswählen einer Datenbank• Erstellen, Anzeigen und Löschen von Tabellen• Filtern von Tabellen durch Beginnen der Eingabe der Tabellennamen• Vorschau von Tabellen und Generieren von CREATE TABLE DDL für diese Tabellen• Anzeigen der Tabelleneigenschaften• Ausführen von Abfragen auf Tabellen, Speichern und Formatieren von Abfragen sowie Anzeigen des

Abfrageverlaufs• Erstellen von bis zu zehn Abfragen über verschiedene Abfrage-Registerkarten im Abfrage-Editor. Um

eine neue Registerkarte zu öffnen, klicken Sie auf das Pluszeichen.• Anzeigen, Speichern und Exportieren der Abfrageergebnisse• Zugreifen auf den Datenkatalog von AWS Glue• Anzeigen und Ändern von Einstellungen (z. B. Anzeigen des Speicherorts der Abfrageergebnisse),

Konfigurieren der automatischen Vervollständigung und Verschlüsseln von Abfrageergebnissen

Im rechten Bereich zeigt der Abfrage-Editor einen Begrüßungsbildschirm an, in dem Sie aufgefordertwerden, Ihre erste Tabelle zu erstellen. Sie können Ihre Tabellen unter Tabellen im linken Bereichanzeigen.

Im Folgenden finden Sie eine allgemeine Übersicht über die Aktionen, die für jede Tabelle zur Verfügungstehen:

• Vorschau von Tabellen – Sie können die Abfragesyntax im Abfrage-Editor auf der rechten Seiteanzeigen.

• Anzeigen der Eigenschaften – Sie können den Namen einer Tabelle, ihren Speicherort in Amazon S3, dieEin- und Ausgabeformate, die verwendete Serialisierungsbibliothek (SerDe) anzeigen und einsehen, obdie Tabelle über verschlüsselte Daten verfügt.

• Löschen der Tabelle – Sie können eine Tabelle löschen.• Generieren von CREATE TABLE DDL – Sie können die Abfrage hinter einer Tabelle generieren und im

Abfrage-Editor anzeigen.

Verwenden der APIAmazon Athena ermöglicht die Anwendungsprogrammierung für Athena. Weitere Informationen finden Sieunter Amazon Athena-API-Referenz. Die neuesten AWS SDKs bieten Unterstützung für die Athena-API.

Beispiele für die Verwendung des AWS SDK for Java mit Athena finden Sie unter Codebeispiele (p. 344).

29


Amazon Athena BenutzerhandbuchVerwenden der CLI

Weitere Informationen zur AWS SDK for Java-Dokumentation und zu Downloads finden Sie im AbschnittSDKs unter Tools für Amazon Web Services.

Verwenden der CLISie können über die AWS-CLI auf Amazon Athena zugreifen. Weitere Informationen finden Sie in der AWSCLI-Referenz für Athena.

30




Amazon Athena BenutzerhandbuchTabellen- und Datenbankerstellung in Athena

Erstellen von Tabellen undDatenbanken

Amazon Athena unterstützt ein Subset an DDL (Data Definition Language)-Anweisungen sowie ANSISQL-Funktionen und -Operatoren, um externe Tabellen, deren Daten in Amazon Simple Storage Servicegespeichert sind, zu definieren und abzufragen.

Wenn Sie eine Datenbank und eine Tabelle in Athena erstellen, beschreiben Sie das Schema und denSpeicherort der Daten, damit Sie die darin enthaltenen Daten für Echtzeitabfragen nutzen können.

Zur Optimierung der Abfrageleistung und zur Kostensenkung wird empfohlen, die Daten zu partitionierenund spaltenbasierte Open-Source-Formate wie Apache Parquet oder ORC zum Speichern in Amazon S3zu verwenden.

Themen• Tabellen- und Datenbankerstellung in Athena (p. 31)• Namen für Tabellen, Datenbanken und Spalten (p. 35)• Reservierte Schlüsselwörter (p. 36)• Tabellenspeicherort in Amazon S3 (p. 38)• Partitionieren von Daten (p. 39)• Spaltenbasierte Speicherformate (p. 43)• Konvertieren in spaltenbasierte Formate (p. 44)

Tabellen- und Datenbankerstellung in AthenaSie können DDL-Anweisungen in der Athena-Konsole mithilfe eines JDBC- oder ODBC-Treibers oder mitdem Athena-Assistenten Create Table (Tabelle erstellen) ausführen.

Wenn Sie ein neues Tabellenschema in Athena erstellen, speichert Athena das Schema in einemDatenkatalog und verwendet es zum Ausführen von Abfragen.

Athena verwendet einen als schema-on-read bezeichneten Ansatz. Dabei wird ein Schema bei jedemAusführen einer Abfrage auf Ihre Daten projiziert. Dadurch müssen Daten nicht geladen oder umgewandeltwerden.

Athena bearbeitet Ihre Daten in Amazon S3 nicht.

Athena definiert mithilfe von Apache Hive Tabellen und erstellt Datenbanken, die an sich ein logischerNamespace von Tabellen sind.

Wenn Sie eine Datenbank und Tabelle in Athena erstellen, beschreiben Sie einfach das Schema undden Speicherort, an dem die Tabellendaten in Amazon S3 für Abfragen beim Lesen gespeichert sind. DieBegriffe Datenbank und Tabelle haben daher eine etwas abweichende Bedeutung als in traditionellenrelationalen Datenbanksystemen, da die Daten nicht zusammen mit der Schemadefinition für dieDatenbank und Tabelle gespeichert werden.

31

https://parquet.apache.org

https://orc.apache.org/

Amazon Athena BenutzerhandbuchVoraussetzungen für Tabellen inAthena und Daten in Amazon S3

Wenn Sie Daten abfragen, tun Sie dies mit Standard-SQL und die Daten werden zum Zeitpunkt derAbfrage gelesen. Eine Anleitung zum Erstellen von Datenbanken und Tabellen finden Sie in der ApacheHive-Dokumentation. Nachfolgend finden Sie jedoch eine Anleitung speziell für Athena.

Die maximale Länge der Abfragezeichenfolge beträgt 256 KB.

Hive unterstützt mehrere Datenformate mithilfe von SerDe (Serializer/Deserializer)-Bibliotheken. Siekönnen auch komplexe Schemata mit regulären Ausdrücken definieren. Eine Liste der unterstützten SerDe-Bibliotheken finden Sie unter Supported Data Formats, SerDes, and Compression Formats (p. 289).

Voraussetzungen für Tabellen in Athena und Daten inAmazon S3Beim Erstellen einer Tabelle geben Sie einen Amazon S3-Bucket-Speicherort für die zugrunde liegendenDaten mit der Klausel LOCATION an. Berücksichtigen Sie dabei Folgendes:

• Athena kann nur die neueste Version der Daten in einem versionierten Amazon S3-Bucket und keinevorherigen Versionen der Daten abfragen.

• Sie benötigen die entsprechenden Berechtigungen zum Arbeiten mit Daten im Amazon S3-Speicherort.Weitere Informationen finden Sie unter Zugriff auf Amazon S3 (p. 221).

• Wenn die Daten in Amazon S3 nicht verschlüsselt sind, können sie in einer anderen Region alsder primären Region, in der Sie Athena ausführen, gespeichert werden. Neben den Athena-Standardgebühren fallen auch die Amazon S3-Standardgebühren für regionenübergreifendeDatenübertragung an.

• Wenn die Daten in Amazon S3 verschlüsselt sind, müssen sie in derselben Region gespeichert werdenund die Benutzer oder Prinzipale, die die Tabelle in Athena erstellen, müssen über die entsprechendenBerechtigungen zum Entschlüsseln der Daten verfügen. Weitere Informationen finden Sie unterKonfigurieren von Verschlüsselungsoptionen (p. 210).

• Athena unterstützt das Abfragen von Objekten, die mit verschiedenen Speicherklassen im gleichen vonder LOCATION-Klausel angegebenen Bucket gespeichert werden. Beispielsweise können Sie Daten inObjekten abfragen, die in verschiedenen Speicherklassen in Amazon S3 gespeichert sind (Standard,Standard IA und Intelligent-Tiering).

• Athena unterstützt Buckets mit Zahlung durch den Anforderer. Weitere Informationen zum Aktivieren derZahlung durch den Anforderer für Buckets mit Quelldaten, die Sie in Athena abfragen möchten, findenSie unter Erstellen einer Arbeitsgruppe (p. 262).

• Athena unterstützt keine Abfragen für Daten in der Speicherklasse GLACIER. Auf der Basis einerAmazon S3-Lebenszyklusrichtlinie zur Speicherklasse GLACIER übertragene Objekte werden ignoriert.

Weitere Informationen finden Sie unter Speicherklassen, Ändern der Speicherklasse eines Objekts inAmazon S3, Übergang in die Speicherklasse GLACIER (Objektarchivierung) und Buckets mit Zahlungdurch den Anforderer im Entwicklerhandbuch für Amazon Simple Storage Service.

• Wenn Sie Abfragen gegen Amazon S3-Buckets mit einer großen Anzahl von Objekten ausgebenund die Daten nicht partitioniert sind, können sich solche Abfragen auf die Grenzwerte für die Get-Anforderungsrate in Amazon S3 auswirken und zu Amazon S3-Ausnahmen führen. Um Fehlerzu vermeiden, partitionieren Sie Ihre Daten. Überlegen Sie zusätzlich, ob Sie Ihre Amazon S3-Anforderungsraten optimieren möchten. Weitere Informationen finden Sie unter Anfragerate undLeistungsaspekte.

Unterstützte FunktionenIn Athena-Abfragen werden die Funktionen aus Presto unterstützt. Weitere Informationen finden Sie unterFunktionen und Operatoren in Presto 0.172 in der Presto-Dokumentation.

32

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL


https://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/ChgStoClsOfObj.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/ChgStoClsOfObj.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/lifecycle-transition-general-considerations.html#before-deciding-to-archive-objects



https://docs.aws.amazon.com/AmazonS3/latest/dev/request-rate-perf-considerations.html



Amazon Athena BenutzerhandbuchUmwandlungen von Transaktionsdaten

werden nicht unterstützt

Umwandlungen von Transaktionsdaten werden nichtunterstütztAthena bietet keine Unterstützung für transaktionsbasierte Operationen (wie in Hive oder Presto) fürTabellendaten. Eine vollständige Liste der nicht unterstützten Schlüsselwörter finden Sie unter Nichtunterstützte DDLs (p. 325).

Operationen, die Tabellenstatus ändern, sind ACIDDie Operationen zum Erstellen, Aktualisieren und Löschen von Tabellen sind garantiert ACID-kompatibel.Wenn beispielsweise mehrere Benutzer oder Clients gleichzeitig versuchen, eine vorhandene Tabelle zuerstellen oder zu bearbeiten, ist nur einer erfolgreich.

Alle Tabellen sind EXTERNALWenn Sie CREATE TABLE ohne das Schlüsselwort EXTERNAL verwenden, gibt Athena eine Fehlermeldungaus. Nur Tabellen mit dem Schlüsselwort EXTERNAL können erstellt werden. Wir empfehlen, dasSchlüsselwort EXTERNAL immer zu verwenden. Wenn Sie eine Tabelle in Athena löschen, werden nur dieTabellenmetadaten gelöscht. Die Daten verbleiben in Amazon S3.

So erstellen Sie eine Tabelle mit dem AWS Glue-Datenkatalog:1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie AWS GlueData Catalog. Jetzt können Sie eine Tabelle mit dem AWS Glue-Crawler

erstellen. Weitere Informationen finden Sie unter Verwenden von AWS Glue-Crawlern (p. 52).

So erstellen Sie eine Tabelle mit dem Assistenten:1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.

33



Amazon Athena BenutzerhandbuchSo erstellen Sie eine Datenbank mit Hive DDL

2. Klicken Sie unter der Datenbankanzeige im Abfrage-Editor auf Add table (Tabelle hinzufügen), um einenAssistenten zu öffnen.

3. Befolgen Sie die Schritte zum Erstellen einer Tabelle.

So erstellen Sie eine Datenbank mit Hive DDLEine Datenbank in Athena ist eine logische Gruppierung für Tabellen, die Sie darin erstellen.

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Klicken Sie auf Query Editor (Abfrage-Editor).3. Geben Sie CREATE DATABASE myDataBase ein und klicken Sie auf Run Query (Abfrage ausführen).

4. Wählen Sie Ihre Datenbank aus dem Menü aus. Sie ist wahrscheinlich leer.

34


Amazon Athena BenutzerhandbuchSo erstellen Sie eine Tabelle mit Hive DDL

So erstellen Sie eine Tabelle mit Hive DDLDer Athena-Abfrage-Editor zeigt die aktuelle Datenbank an. Wenn Sie eine Tabelle erstellen, ohneeine Datenbank anzugeben, wird die Tabelle in der im Abschnitt Databases (Datenbanken) auf derRegisterkarte Catalog (Katalog) angegebenen Datenbank erstellt.

1. Erstellen Sie in der erstellten Datenbank eine Tabelle, indem Sie die folgende Anweisung eingeben undauf Run Query (Abfrage ausführen) klicken:

CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_logs ( `Date` Date, Time STRING, Location STRING, Bytes INT, RequestIP STRING, Method STRING, Host STRING, Uri STRING, Status INT, Referrer STRING, OS String, Browser String, BrowserVersion String) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'WITH SERDEPROPERTIES ("input.regex" = "^(?!#)([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+[^\(]+[\(]([^\;]+).*\%20([^\/]+)[\/](.*)$") LOCATION 's3://athena-examples/cloudfront/plaintext/';

2. Nachdem die Tabelle erfolgreich erstellt wurde, können Sie die darin enthaltenen Daten abfragen.

Namen für Tabellen, Datenbanken und SpaltenBefolgen Sie diese Hinweise zur Benennung von Elementen in Athena.

Tabellen- und Tabellenspaltennamen in Athena dürfennur Kleinbuchstaben enthalten.Wenn Sie mit Apache Spark interagieren, dürfen Ihre Tabellen- und Tabellenspaltennamen nurKleinbuchstaben enthalten. Athena unterscheidet nicht zwischen Groß- und Kleinschreibung und wandeltTabellen- und Spaltennamen in Kleinbuchstaben um. Für Spark sind jedoch Kleinbuchstaben bei Tabellen-und Spaltennamen erforderlich.

Abfragen für Spaltennamen mit einer Mischung aus Groß- und Kleinbuchstaben, z. B. profileURI, sowiefür Spaltennamen in Großbuchstaben schlagen fehl.

Für Tabellen-, Ansichts-, Datenbank- undSpaltennamen in Athena sind als Sonderzeichen nurder Unterstrich zulässigTabellen-, Ansichts-, Datenbank- und Spaltennamen in Athena dürfen als einziges Sonderzeichen einenUnterstrich (_) enthalten.

35

Amazon Athena BenutzerhandbuchNamen, die mit einem Unterstrich beginnen

Namen, die mit einem Unterstrich beginnenVerwenden Sie einfache umgekehrte Anführungszeichen, um Tabellen-, Ansichts- oder Spaltennamen zuumschließen, die mit einem Unterstrich beginnen. Beispiel:

CREATE TABLE `_myunderscoretable` (`_id` string,`_index`string,...

Tabellen- oder Ansichtsnamen mit ZahlenSchließen Sie Tabellennamen, die Zahlen enthalten, in Anführungszeichen ein. Beispiel:

CREATE TABLE "table123"`_id` string,`_index` string,...

Reservierte SchlüsselwörterWenn Sie Abfragen in Athena ausführen, die reservierte Schlüsselwörter enthalten, müssen Sie sie alsEscapezeichen mit Sonderzeichen umgeben, um ihre Verarbeitung zu verhindern. Überprüfen Sie anhandder Listen in diesem Thema, welche Schlüsselwörter in Athena reserviert sind.

Um reservierte Schlüsselwörter in DDL-Anweisungen mit Escapezeichen zu versehen, schließen Sie sie ineinfache umgekehrte Anführungszeichen (`) ein. Um reservierte Schlüsselwörter in SELECT-Anweisungenvon SQL und in Abfragen in Arbeiten mit Ansichten (p. 121) mit Escapezeichen zu versehen, schließenSie sie in doppelte Anführungszeichen (") ein.

• Liste reservierter Schlüsselwörter in DDL-Anweisungen (p. 36)• Liste reservierter Schlüsselwörter in SQL-SELECT-Anweisungen (p. 37)• Beispiele für Abfragen mit reservierten Schlüsselwörtern (p. 37)

Liste reservierter Schlüsselwörter in DDL-AnweisungenAthena verwendet die folgende Liste reservierter Schlüsselwörter in seinen DDL-Anweisungen. Wenn Siesie verwenden, ohne sie mit einem Escapezeichen zu versehen, gibt Athena eine Fehlermeldung aus. Umsie mit Escapezeichen zu versehen, schließen Sie sie in einfache umgekehrte Anführungszeichen (`) ein.

Sie können DDL-reservierte Schlüsselwörter als Bezeichnernamen in DDL-Anweisungen nur verwenden,wenn Sie sie in einfache umgekehrte Anführungszeichen (`) einschließen.

ALL, ALTER, AND, ARRAY, AS, AUTHORIZATION, BETWEEN, BIGINT, BINARY, BOOLEAN, BOTH, BY, CASE, CASHE, CAST, CHAR, COLUMN, CONF, CONSTRAINT, COMMIT, CREATE, CROSS, CUBE, CURRENT, CURRENT_DATE, CURRENT_TIMESTAMP, CURSOR, DATABASE, DATE, DAYOFWEEK, DECIMAL, DELETE, DESCRIBE, DISTINCT, DOUBLE, DROP, ELSE, END, EXCHANGE, EXISTS, EXTENDED, EXTERNAL, EXTRACT, FALSE, FETCH, FLOAT, FLOOR, FOLLOWING, FOR, FOREIGN, FROM, FULL, FUNCTION, GRANT, GROUP, GROUPING, HAVING, IF, IMPORT, IN, INNER, INSERT, INT, INTEGER,

36

Amazon Athena BenutzerhandbuchListe reservierter Schlüsselwörter

in SQL-SELECT-Anweisungen

INTERSECT, INTERVAL, INTO, IS, JOIN, LATERAL, LEFT, LESS, LIKE, LOCAL, MACRO, MAP, MORE, NONE, NOT, NULL, NUMERIC, OF, ON, ONLY, OR, ORDER, OUT, OUTER, OVER, PARTIALSCAN, PARTITION, PERCENT, PRECEDING, PRECISION, PRESERVE, PRIMARY, PROCEDURE, RANGE, READS, REDUCE, REGEXP,REFERENCES, REVOKE, RIGHT, RLIKE, ROLLBACK, ROLLUP, ROW, ROWS, SELECT, SET, SMALLINT, START,TABLE, TABLESAMPLE, THEN, TIME, TIMESTAMP, TO, TRANSFORM, TRIGGER, TRUE, TRUNCATE, UNBOUNDED,UNION, UNIQUEJOIN, UPDATE, USER, USING, UTC_TIMESTAMP, VALUES, VARCHAR, VIEWS, WHEN, WHERE, WINDOW, WITH

Liste reservierter Schlüsselwörter in SQL-SELECT-AnweisungenAthena verwendet die folgende Liste reservierter Schlüsselwörter in SELECT-Anweisungen von SQL und inAbfragen in Ansichten.

Wenn Sie diese Schlüsselwörter als Bezeichner verwenden, müssen Sie sie in Ihren Abfrageanweisungenin doppelte Anführungszeichen (") einschließen.

ALTER, AND, AS, BETWEEN, BY, CASE, CAST,CONSTRAINT, CREATE, CROSS, CUBE, CURRENT_DATE, CURRENT_PATH, CURRENT_TIME, CURRENT_TIMESTAMP, CURRENT_USER, DEALLOCATE, DELETE, DESCRIBE, DISTINCT, DROP, ELSE, END, ESCAPE, EXCEPT, EXECUTE, EXISTS, EXTRACT, FALSE, FIRST, FOR, FROM, FULL, GROUP, GROUPING, HAVING, IN, INNER, INSERT, INTERSECT, INTO, IS, JOIN, LAST, LEFT, LIKE, LOCALTIME, LOCALTIMESTAMP, NATURAL, NORMALIZE, NOT, NULL, ON, OR, ORDER, OUTER, PREPARE, RECURSIVE, RIGHT, ROLLUP, SELECT, TABLE, THEN, TRUE, UNESCAPE, UNION, UNNEST, USING, VALUES, WHEN, WHERE, WITH

Beispiele für Abfragen mit reservierten WörternDie Abfrage im folgenden Beispiel verwendet einfache umgekehrte Anführungszeichen (`), um die DDL-bezogenen reservierten Schlüsselwörter partition und date, die für einen Tabellennamen und einen derSpaltennamen verwendet werden, mit Escapezeichen zu versehen:

CREATE EXTERNAL TABLE `partition` (`date` INT, col2 STRING)PARTITIONED BY (year STRING)STORED AS TEXTFILELOCATION 's3://test_bucket/test_examples/';

Die Abfragen im folgenden Beispiel enthalten einen Spaltennamen mit den DDL-bezogenen reserviertenSchlüsselwörtern in ALTER TABLE ADD PARTITION- und ALTER TABLE DROP PARTITION-Anweisungen. Die DDL-reservierten Schlüsselwörter stehen in einfachen umgekehrten Anführungszeichen(`):

ALTER TABLE test_table ADD PARTITION (`date` = '2018-05-14')

ALTER TABLE test_table DROP PARTITION (`partition` = 'test_partition_value')

37

Amazon Athena BenutzerhandbuchTabellenspeicherort in Amazon S3

Die Abfrage im folgenden Beispiel enthält ein reserviertes Schlüsselwort (End) als Bezeichner in einerSELECT-Anweisung. Das Schlüsselwort ist als Escapezeichen mit doppelten Anführungszeichen versehen:

SELECT * FROM TestTableWHERE "end" != nil;

Die Abfrage im folgenden Beispiel enthält ein reserviertes Schlüsselwort (first) als Bezeichner in einerSELECT-Anweisung. Das Schlüsselwort ist als Escapezeichen mit doppelten Anführungszeichen versehen:

SELECT "itemId"."first" FROM testTable LIMIT 10;

Tabellenspeicherort in Amazon S3Wenn Sie eine CREATE TABLE-Abfrage in Athena ausführen, registrieren Sie die Tabelle für den AWSGlue Data Catalog. Wenn Sie den Athena eigenen Katalog verwenden, empfehlen wir nachdrücklich einUpgrade (p. 60) auf AWS Glue Data Catalog. Sie geben den Pfad zu Ihrer Daten in der LOCATION-Eigenschaft an, wie im folgenden abekürzten Beispiel gezeigt.

CREATE EXTERNAL TABLE `test_table`(...)ROW FORMAT ...STORED AS INPUTFORMAT ...OUTPUTFORMAT ...LOCATION s3://bucketname/prefix/

Dieser Speicherort in Amazon S3 umfasst alle Dateien, die Ihre Tabelle darstellen. Weitere Informationenfinden Sie unter Verwenden von ordnern im Konsolenbenutzerhandbuch für Amazon Simple StorageService.

Important

Athena liest alle unter 's3://bucketname/prefix/' gespeicherten Daten. Wenn Sie überDaten verfügen, die Athena nicht lesen soll, speichern Sie sie nicht mit demselben Amazon S3-Präfix wie die Daten, die Athena lesen soll. Wenn Sie die Partitionierung nutzen, muss Ihr WHERE-Filter die Partition enthalten, damit Athena die Daten darin scannen kann. Weitere Informationenfinden Sie unter Tabellenspeicherort und Partitionen (p. 39).

Verwenden Sie die folgenden Tipps und Beispiele für die Angabe des Amazon S3-Speicherort Ihrer Datenin der Athena CREATE TABLE-Anweisung:

• Geben Sie in der LOCATION-Klausel einen nachgestellten Schrägstrich an.

Verwenden:

s3://bucketname/prefix/

• Verwenden Sie keines der folgenden Elemente für die Angabe des Speicherorts für Ihre Daten.• Verwenden Sie keine Dateinamen, Unterstriche, Platzhalter oder „glob“-Muster, um Dateispeicherorte

anzugeben.• Fügen Sie nicht die vollständige HTTP-Notation (z. B. s3.amazon.com) zum Amazon S3-Bucket-Pfad

hinzu.

38

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/using-folders.html

Amazon Athena BenutzerhandbuchTabellenspeicherort und Partitionen

• Verwenden Sie keine leeren Präfixe (mit zusätzlichem /) in dem Pfad wie folgt: S3://bucketname/prefix//prefix/. Dies ist zwar ein gültiger Amazon S3-Pfad, Athena lässt ihn jedoch nicht zu undändert ihn zu s3://bucketname/prefix/prefix/, wobei der zusätzliche / entfernt wird.

Nicht verwenden:

s3://path_to_buckets3://path_to_bucket/*s3://path_to_bucket/mySpecialFile.dats3://bucketname/prefix/filename.csvs3://test-bucket.s3.amazon.comS3://bucket/prefix//prefix/arn:aws:s3:::bucketname/prefix

Tabellenspeicherort und PartitionenIhre Quelldaten können mit Amazon S3-Präfixen (auch als Partitionen bezeichnet) auf der Grundlage einerReihe von Spalten gruppiert werden. Beispielsweise können diese Spalten das Jahr, den Monat und denTag der Erstellung des jeweiligen Datensatzes repräsentieren.

Wenn Sie eine Tabelle erstellen, können Sie wählen, ob sie partitioniert sein soll. Wenn Athena Sie eineSQL-Abfrage gegen eine nicht-partitionierte Tabelle ausführt, verwendet es die LOCATION-Eigenschaftaus der Tabellendefinition als Basispfad zum Auflisten und anschließenden Scannen aller verfügbarenDateien. Bevor eine partitionierte Tabelle abgefragt werden kann, müssen Sie zunächst AWS GlueData Catalog mit den Partitionsinformationen aktualisieren. Diese Informationen stellen das Schemader Dateien innerhalb der bestimmten Partition und die LOCATION der Dateien in Amazon S3 für diePartition dar. Informationen dazu, wie der AWS Glue-Crawler Partitionen hinzufügt, finden Sie unter Wielegt ein Crawler fest, wann Partitionen zu erstellen sind? im AWS Glue-Entwicklerhandbuch. WeitereInformationen zum Konfigurieren des Crawlers, so dass er Tabellen für Daten in vorhandenen Partitionenerstellt, finden Sie unter Verwenden mehrerer Datenquellen mit Crawlern (p. 53). Sie können auchPartitionen in einer Tabelle direkt in Athena erstellen. Weitere Informationen finden Sie unter Partitionierenvon Daten (p. 39).

Bei der Ausführung einer Abfrage auf einer partitionierten Tabelle prüft Athena zunächst, ob allepartitionierten Spalten in der WHERE-Klausel der Abfrage verwendet wurden. Wenn partitionierteSpalten verwendet wurden, fordert Athena von AWS Glue Data Catalog die Rücksendung derPartitionsspezifikation an, die den angegebenen Partitionsspalten entspricht. Die Partitionsspezifikationenthält die LOCATION-Eigenschaft, die Athena mitteilt, welches Amazon S3-Präfix beim lesen der Daten zuverwenden ist. In diesem Fall werden nur mit diesem Präfix gespeicherte Daten gescannt. Wenn Sie keinepartitionierten Spalten in der WHERE -Klausel verwenden, scannt Athena alle Dateien beginnend mit dem inder LOCATION-Eigenschaft in der Haupt-Tabellendefinition angegebenen Basis-Amazon S3-Pfad.

Beispiele für die Verwendung von Partitionierung mit Athena zur Verbesserung der Abfrageleistung undReduzierung der Abfragekosten finden Sie unter Top-Leistungsoptimierungstipps für Amazon Athena.

Partitionieren von DatenDurch eine Datenpartitionierung können Sie die pro Abfrage durchsuchte Datenmenge eingrenzen undso die Leistung verbessern und Kosten senken. Athena nutzt Hive für die Partitionierung der Daten.Sie können Ihre Daten nach jedem beliebigen Schlüssel partitionieren. In der Regel werden die Datenzeitbasiert partitioniert und das führt häufig zu einem Multi-Level-Partitionierungsschema. Beispielsweisekann ein Kunde, bei dem stündlich Daten eingehen, diese nach Jahr, Monat, Datum und Stundepartitionieren. Ein anderer Kunde, bei dem zwar Daten aus vielen verschiedenen Quellen eingehen, dieaber nur einmal pro Tag geladen werden, wird die Partition wohl eher nach Datenquellen-ID und Datumvornehmen.

39

https://docs.aws.amazon.com//glue/latest/dg/add-crawler.html#crawler-s3-folder-table-partition

https://docs.aws.amazon.com//glue/latest/dg/add-crawler.html#crawler-s3-folder-table-partition

http://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-AlterPartition

Amazon Athena BenutzerhandbuchSzenario 1: Daten sind bereits partitioniert

und im Hive-Format in S3 gespeichert.

Wenn Sie Abfragen gegen Amazon S3-Buckets mit einer großen Anzahl von Objekten ausgeben und dieDaten nicht partitioniert sind, können sich solche Abfragen auf die Grenzwerte für die Get-Anforderungsratein Amazon S3 auswirken und zu Amazon S3-Ausnahmen führen. Um Fehler zu vermeiden, partitionierenSie Ihre Daten. Überlegen Sie zusätzlich, ob Sie Ihre Amazon S3-Anforderungsraten optimieren möchten.Weitere Informationen finden Sie unter Anfragerate und Leistungsaspekte.

Note

Wenn Sie eine partitionierte Tabelle abfragen und die Partition in der WHERE-Klausel angeben,scannt Athena nur die Daten aus dieser Partition. Weitere Informationen finden Sie unterTabellenort und Partitionen (p. 39).

Um eine Tabelle mit Partitionen zu erstellen, müssen Sie sie im Rahmen der Anweisung CREATE TABLEdefinieren. Definieren Sie mithilfe von PARTITIONED BY die Schlüssel, nach denen die Daten partitioniertwerden sollen. Es gibt zwei Szenarien, die in den folgenden Abschnitten besprochen werden:

1. Die Daten sind bereits partitioniert und in Amazon S3 gespeichert und Sie möchten in Athena auf dieseDaten zugreifen.

2. Die Daten sind nicht partitioniert.

Szenario 1: Daten sind bereits partitioniert und imHive-Format in S3 gespeichert.Speichern von partitionierten DatenDie Partitionen werden in Amazon S3 in separaten Ordnern gespeichert. Nachstehend sehen Sie denAusschnitt einer Liste mit Ad Impressions-Beispielen:

aws s3 ls s3://elasticmapreduce/samples/hive-ads/tables/impressions/

PRE dt=2009-04-12-13-00/ PRE dt=2009-04-12-13-05/ PRE dt=2009-04-12-13-10/ PRE dt=2009-04-12-13-15/ PRE dt=2009-04-12-13-20/ PRE dt=2009-04-12-14-00/ PRE dt=2009-04-12-14-05/ PRE dt=2009-04-12-14-10/ PRE dt=2009-04-12-14-15/ PRE dt=2009-04-12-14-20/ PRE dt=2009-04-12-15-00/ PRE dt=2009-04-12-15-05/

Die Protokolle werden hier mit dem Spaltennamen (dt) gespeichert, der auf Datums- und Uhrzeitangabengesetzt ist. Wenn Sie eine DDL mit dem Speicherort des übergeordneten Ordners, dem Schema und demNamen der partitionierten Spalte angeben, kann Athena Abfragen für die Daten in diesen Unterordnernausführen.

Erstellen einer TabelleUm aus diesen Daten eine Tabelle zu erzeugen, erstellen Sie wie in der folgenden Athena-DDL-Anweisungeine Partition für "dt":

CREATE EXTERNAL TABLE impressions ( requestBeginTime string, adId string,

40


Amazon Athena BenutzerhandbuchSzenario 2: Daten sind nicht partitioniert.

impressionId string, referrer string, userAgent string, userCookie string, ip string, number string, processId string, browserCookie string, requestEndTime string, timers struct<modelLookup:string, requestTime:string>, threadId string, hostname string, sessionId string)PARTITIONED BY (dt string)ROW FORMAT serde 'org.apache.hive.hcatalog.data.JsonSerDe' with serdeproperties ( 'paths'='requestBeginTime, adId, impressionId, referrer, userAgent, userCookie, ip' )LOCATION 's3://elasticmapreduce/samples/hive-ads/tables/impressions/' ;

Diese Tabelle nutzt den Hive-eigenen JSON-SerDe (Serializer/Deserializer) zum Lesen der in AmazonS3 gespeicherten JSON-Daten. Weitere Informationen zu den unterstützten Formaten finden Sie unterUnterstützte Datenformate, SerDes und Komprimierungsformate (p. 289).

Wenn Sie diese Anweisung in Athena ausgeführt haben, klicken Sie auf New Query und führen SieFolgendes aus:

MSCK REPAIR TABLE impressions

Athena lädt die Daten in den Partitionen.

Abfragen der DatenNun führen Sie mithilfe der partitionierten Spalte eine Datenabfrage für die Tabelle "impressions" aus. EinBeispiel:

SELECT dt,impressionid FROM impressions WHERE dt<'2009-04-12-14-00' and dt>='2009-04-12-13-00' ORDER BY dt DESC LIMIT 100

Das Ergebnis dieser Abfrage sollte folgende Daten enthalten:

2009-04-12-13-20 ap3HcVKAWfXtgIPu6WpuUfAfL0DQEc2009-04-12-13-20 17uchtodoS9kdeQP1x0XThKl5IuRsV2009-04-12-13-20 JOUf1SCtRwviGw8sVcghqE5h0nkgtp2009-04-12-13-20 NQ2XP0J0dvVbCXJ0pb4XvqJ5A4QxxH2009-04-12-13-20 fFAItiBMsgqro9kRdIwbeX60SROaxr2009-04-12-13-20 V4og4R9W6G3QjHHwF7gI1cSqig5D1G2009-04-12-13-20 hPEPtBwk45msmwWTxPVVo1kVu4v11b2009-04-12-13-20 v0SkfxegheD90gp31UCr6FplnKpx6i2009-04-12-13-20 1iD9odVgOIi4QWkwHMcOhmwTkWDKfj2009-04-12-13-20 b31tJiIA25CK8eDHQrHnbcknfSndUk

Szenario 2: Daten sind nicht partitioniert.Ein Layout wie das folgende ist jedoch nicht geeignet, um Partitionsdaten mit MSCK REPAIR TABLEautomatisch hinzuzufügen:

aws s3 ls s3://athena-examples/elb/plaintext/ --recursive

41

Amazon Athena BenutzerhandbuchSzenario 2: Daten sind nicht partitioniert.

2016-11-23 17:54:46 11789573 elb/plaintext/2015/01/01/part-r-00000-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:46 8776899 elb/plaintext/2015/01/01/part-r-00001-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:46 9309800 elb/plaintext/2015/01/01/part-r-00002-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:47 9412570 elb/plaintext/2015/01/01/part-r-00003-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:47 10725938 elb/plaintext/2015/01/01/part-r-00004-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:46 9439710 elb/plaintext/2015/01/01/part-r-00005-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:47 0 elb/plaintext/2015/01/01_$folder$2016-11-23 17:54:47 9012723 elb/plaintext/2015/01/02/part-r-00006-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:47 7571816 elb/plaintext/2015/01/02/part-r-00007-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:47 9673393 elb/plaintext/2015/01/02/part-r-00008-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:48 11979218 elb/plaintext/2015/01/02/part-r-00009-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:48 9546833 elb/plaintext/2015/01/02/part-r-00010-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:48 10960865 elb/plaintext/2015/01/02/part-r-00011-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:48 0 elb/plaintext/2015/01/02_$folder$2016-11-23 17:54:48 11360522 elb/plaintext/2015/01/03/part-r-00012-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:48 11211291 elb/plaintext/2015/01/03/part-r-00013-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:48 8633768 elb/plaintext/2015/01/03/part-r-00014-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:49 11891626 elb/plaintext/2015/01/03/part-r-00015-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:49 9173813 elb/plaintext/2015/01/03/part-r-00016-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:49 11899582 elb/plaintext/2015/01/03/part-r-00017-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:49 0 elb/plaintext/2015/01/03_$folder$2016-11-23 17:54:50 8612843 elb/plaintext/2015/01/04/part-r-00018-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:50 10731284 elb/plaintext/2015/01/04/part-r-00019-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:50 9984735 elb/plaintext/2015/01/04/part-r-00020-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:50 9290089 elb/plaintext/2015/01/04/part-r-00021-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:50 7896339 elb/plaintext/2015/01/04/part-r-00022-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 8321364 elb/plaintext/2015/01/04/part-r-00023-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 0 elb/plaintext/2015/01/04_$folder$2016-11-23 17:54:51 7641062 elb/plaintext/2015/01/05/part-r-00024-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 10253377 elb/plaintext/2015/01/05/part-r-00025-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 8502765 elb/plaintext/2015/01/05/part-r-00026-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 11518464 elb/plaintext/2015/01/05/part-r-00027-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 7945189 elb/plaintext/2015/01/05/part-r-00028-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 7864475 elb/plaintext/2015/01/05/part-r-00029-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 0 elb/plaintext/2015/01/05_$folder$

42

Amazon Athena BenutzerhandbuchSpaltenbasierte Speicherformate

2016-11-23 17:54:51 11342140 elb/plaintext/2015/01/06/part-r-00030-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:51 8063755 elb/plaintext/2015/01/06/part-r-00031-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:52 9387508 elb/plaintext/2015/01/06/part-r-00032-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:52 9732343 elb/plaintext/2015/01/06/part-r-00033-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:52 11510326 elb/plaintext/2015/01/06/part-r-00034-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:52 9148117 elb/plaintext/2015/01/06/part-r-00035-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:52 0 elb/plaintext/2015/01/06_$folder$2016-11-23 17:54:52 8402024 elb/plaintext/2015/01/07/part-r-00036-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:52 8282860 elb/plaintext/2015/01/07/part-r-00037-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:52 11575283 elb/plaintext/2015/01/07/part-r-00038-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:53 8149059 elb/plaintext/2015/01/07/part-r-00039-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:53 10037269 elb/plaintext/2015/01/07/part-r-00040-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:53 10019678 elb/plaintext/2015/01/07/part-r-00041-ce65fca5-d6c6-40e6-b1f9-190cc4f93814.txt2016-11-23 17:54:53 0 elb/plaintext/2015/01/07_$folder$2016-11-23 17:54:53 0 elb/plaintext/2015/01_$folder$2016-11-23 17:54:53 0 elb/plaintext/2015_$folder$

In diesem Fall fügen Sie jede Partition manuell mit ALTER TABLE ADD PARTITION hinzu.

Um beispielsweise die Daten in s3://athena-examples/elb/plaintext/2015/01/01/ zu laden, führen SieFolgendes aus:

ALTER TABLE elb_logs_raw_native_part ADD PARTITION (year='2015',month='01',day='01') location 's3://athena-examples/elb/plaintext/2015/01/01/'

Sie können auch den JDBC-Treiber (p. 76) verwenden, um das Hinzufügen von Partitionen zuautomatisieren.

Spaltenbasierte SpeicherformateApache Parquet und ORC sind spaltenbasierte Speicherformate, die für den schnellen Abruf von Datenoptimiert sind und in analytischen AWS-Anwendungen verwendet werden.

Spaltenbasierte Speicherformate haben die folgenden Eigenschaften, wodurch sie sich für die Verwendungmit Athena eignen:

• Komprimierung nach Spalte mit dem für den Spaltendatentyp ausgewählten Komprimierungsalgorithmus,um Speicherplatz in Amazon S3 zu sparen und Festplattenspeicher und die E/A-Vorgänge während derAbfrageverarbeitung zu reduzieren.

• Prädikat-Pushdown in Parquet und ORC ermöglicht Athena-Abfragen, um nur die tatsächlich benötigtenBlöcke abzurufen, wobei die Abfrageleistung verbessert wird. Wenn eine Athena-Abfrage Werte ausbestimmten Spalten von Ihren Daten erhält, verwendet es Statistiken von Datenblockprädikaten, wie z. B.Max.-/Min.-Werte, um festzustellen, ob der Block zu lesen oder zu überspringen ist.

• Das Aufteilen von Daten in Parquet und ORC ermöglicht Athena das Lesen von Daten an mehrere Leserund die Erhöhung der Parallelität während der Abfrageverarbeitung.

43



Amazon Athena BenutzerhandbuchKonvertieren in spaltenbasierte Formate

Um Ihre vorhandenen Rohdaten von anderen Speicherformaten für Parquet oder ORC zu konvertieren,können Sie CREATE TABLE AS SELECT (CTAS) (p. 126)-Abfragen in Athena ausführen und einDatenspeicherformat als Parquet oder ORC angeben, oder verwenden Sie den AWS Glue-Crawler.

Konvertieren in spaltenbasierte FormateSie können die Leistung von Amazon Athena-Abfragen verbessern, indem Sie Ihre Daten in einspaltenbasiertes Open-Source-Format wie Apache Parquet oder ORC konvertieren.

Note

Mithilfe der CREATE TABLE AS (CTAS) (p. 134)-Abfragen können Sie die Konvertierung inSpaltenformate wie Parquet und ORC in einem einzigen Schritt ausführen.

Dies können Sie für vorhandene Amazon S3-Datenquellen tun, indem Sie ein Cluster in Amazon EMRerstellen und dieses mithilfe von Hive konvertieren. Im folgenden Beispiel wird die AWS CLI verwendet undgezeigt, wie Sie hierfür mit in Amazon S3gespeicherten Skript und dort gespeicherten Daten vorgehen.

ÜbersichtKonvertieren Sie Daten mit einem EMR-Cluster wie folgt in ein spaltenbasiertes Format:

1. Erstellen Sie ein EMR-Cluster mit installiertem Hive.2. Geben Sie im Step-Bereich der Anweisung zum Erstellen des Clusters ein in Amazon S3 gespeichertes

Skript an, das auf Ihre Eingabedaten verweist und Ausgabedaten im spaltenbasierten Format in einemAmazon S3-Speicherort erstellt. In diesem Beispiel wird das Cluster automatisch beendet.

Note

Das Skript basiert auf Amazon EMR Version 4.7 und muss auf die aktuelle Version aktualisiertwerden. Informationen zu den Versionen erhalten Sie unter Amazon EMR-Versionshinweise.

Das vollständige Skript finden Sie in Amazon S3 unter:

s3://athena-examples/conversion/write-parquet-to-s3.q

Nachfolgend finden Sie ein Beispielskript, das mit dem CREATE TABLE-Snippet beginnt:

ADD JAR /usr/lib/hive-hcatalog/share/hcatalog/hive-hcatalog-core-1.0.0-amzn-5.jar;CREATE EXTERNAL TABLE impressions ( requestBeginTime string, adId string, impressionId string, referrer string, userAgent string, userCookie string, ip string, number string, processId string, browserCookie string, requestEndTime string, timers struct<modelLookup:string, requestTime:string>, threadId string, hostname string, sessionId string)PARTITIONED BY (dt string)ROW FORMAT serde 'org.apache.hive.hcatalog.data.JsonSerDe'with serdeproperties ( 'paths'='requestBeginTime, adId, impressionId, referrer, userAgent, userCookie, ip' )

44



https://docs.aws.amazon.com/emr/latest/ReleaseGuide/

Amazon Athena BenutzerhandbuchÜbersicht

LOCATION 's3://${REGION}.elasticmapreduce/samples/hive-ads/tables/impressions/' ;

Note

Ersetzen Sie REGION in der LOCATION-Klausel durch die Region, in der Sie Abfragenausführen. Wenn Sie Ihre Konsole beispielsweise in der Region us-east-1 verwenden, ersetzenSie REGION durch s3://us-east-1.elasticmapreduce/samples/hive-ads/tables/.

Hierdurch wird die Tabelle in Hive auf dem Cluster erstellt, das Beispiele im Amazon EMR-Beispiel-Bucket verwendet.

3. Fügen Sie für Amazon EMR Version 4.7.0 die Zeile ADD JAR hinzu, um den passenden JsonSerDe zufinden. Die bereinigten Beispieldaten sehen wie folgt aus:

{ "number": "977680", "referrer": "fastcompany.com", "processId": "1823", "adId": "TRktxshQXAHWo261jAHubijAoNlAqA", "browserCookie": "mvlrdwrmef", "userCookie": "emFlrLGrm5fA2xLFT5npwbPuG7kf6X", "requestEndTime": "1239714001000", "impressionId": "1I5G20RmOuG2rt7fFGFgsaWk9Xpkfb", "userAgent": "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; SLCC1; .NET CLR 2.0.50727; Media Center PC 5.0; .NET CLR 3.0.04506; InfoPa", "timers": { "modelLookup": "0.3292", "requestTime": "0.6398" }, "threadId": "99", "ip": "67.189.155.225", "modelId": "bxxiuxduad", "hostname": "ec2-0-51-75-39.amazon.com", "sessionId": "J9NOccA3dDMFlixCuSOtl9QBbjs6aS", "requestBeginTime": "1239714000000"}

4. Laden Sie in Hive die Daten aus den Partitionen, um das Skript wie folgt auszuführen:

MSCK REPAIR TABLE impressions;

Das Skript erstellt eine Tabelle, in der Ihre Daten in einer Parquet-formatierten Datei in Amazon S3gespeichert werden:

CREATE EXTERNAL TABLE parquet_hive ( requestBeginTime string, adId string, impressionId string, referrer string, userAgent string, userCookie string, ip string) STORED AS PARQUETLOCATION 's3://myBucket/myParquet/';

Die Daten werden von der Tabelle impressions in parquet_hive eingefügt:

INSERT OVERWRITE TABLE parquet_hiveSELECTrequestbegintime,adid,

45

Amazon Athena BenutzerhandbuchBevor Sie beginnen

impressionid,referrer,useragent,usercookie,ip FROM impressions WHERE dt='2009-04-14-04-05';

Das Skript speichert die Spalten der oben genannten Tabelle impressions des Datums2009-04-14-04-05 in einer Parquet-formatierten Datei unter s3://myBucket/myParquet/.

5. Nachdem das EMR-Cluster beendet wurde, erstellen Sie Ihre Tabelle in Athena, das die Daten in demvon dem Cluster erstellten Format verwendet.

Bevor Sie beginnen• Sie müssen EMR-Cluster erstellen. Weitere Informationen zu Amazon EMRfinden Sie im Management

Guide für Amazon EMR.• Befolgen Sie die Anleitung unter Setting Up (p. 23) (Einrichten).

Beispiel: Konvertieren von Daten in Parquet mit einemEMR-Cluster1. Verwenden Sie die AWS CLI zum Erstellen eines Clusters. Eine Anleitung zum Installieren der AWS

CLI finden Sie unter Installieren der AWS Command Line Interface im Benutzerhandbuch für AWSCommand Line Interface.

2. Zur Verwendung von Amazon EMR benötigen Sie Rollen. Falls Sie Amazon EMR noch nicht verwendethaben, erstellen Sie die Standardrollen mit dem folgenden Befehl:

aws emr create-default-roles

3. Erstellen Sie einen Amazon EMR-Cluster mit emr-4.7.0, um die Daten mit dem folgenden AWS CLI-Befehl emr create-cluster zu konvertieren:

export REGION=us-east-1export SAMPLEURI=s3://${REGION}.elasticmapreduce/samples/hive-ads/tables/impressions/export S3BUCKET=myBucketName

aws emr create-cluster --applications Name=Hadoop Name=Hive Name=HCatalog \--ec2-attributes KeyName=myKey,InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-mySubnetId \--service-role EMR_DefaultRole --release-label emr-4.7.0 --instance-type \m4.large --instance-count 1 --steps Type=HIVE,Name="Convert to Parquet",\ActionOnFailure=CONTINUE,ActionOnFailure=TERMINATE_CLUSTER,Args=[-f,\s3://athena-examples/conversion/write-parquet-to-s3.q,-hiveconf,INPUT=${SAMPLEURI},-hiveconf,OUTPUT=s3://${S3BUCKET}/myParquet,-hiveconf,REGION=${REGION}] \--region ${REGION} --auto-terminate

46

https://docs.aws.amazon.com/emr/latest/ManagementGuide/

https://docs.aws.amazon.com/emr/latest/ManagementGuide/

https://docs.aws.amazon.com/cli/latest/userguide/installing.html

Amazon Athena BenutzerhandbuchBeispiel: Konvertieren von Daten

in Parquet mit einem EMR-Cluster

Weitere Informationen finden Sie unter Erstellen und Verwenden von IAM-Rollen für Amazon EMR imManagement Guide für Amazon EMR.

Ist die Anforderung erfolgreich, erhalten Sie eine Cluster-ID.4. Überwachen Sie den Fortschritt Ihres Clusters mit der AWS-Managementkonsole oder verwenden Sie

die Cluster-ID mit dem Unterbefehl list-steps in der AWS CLI:

aws emr list-steps --cluster-id myClusterID

Suchen Sie nach dem Schrittstatus des Skripts. Sobald der Status COMPLETED lautet, ist dieKonvertierung abgeschlossen und Sie können die Daten abfragen.

5. Erstellen Sie dieselbe Tabelle, die Sie schon für den EMR-Cluster erstellt haben.

Sie können dieselbe Anweisung wie oben verwenden. Melden Sie sich bei Athena an und geben Sie dieAnweisung im Fenster Query Editor (Abfrage-Editor) ein:

CREATE EXTERNAL TABLE parquet_hive ( requestBeginTime string, adId string, impressionId string, referrer string, userAgent string, userCookie string, ip string) STORED AS PARQUETLOCATION 's3://myBucket/myParquet/';

Klicken Sie auf Run Query (Abfrage ausführen).6. Führen Sie die folgende Abfrage aus, um zu überprüfen, ob Sie diese Daten abfragen können:

SELECT * FROM parquet_hive LIMIT 10;

Alternativ können Sie auch auf das Anzeigesymbol (Auge) neben dem Tabellennamen in Catalog(Katalog) klicken:

Die Ergebnisausgabe sollte in etwa wie folgt aussehen:

47

https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles-creatingroles.html

Amazon Athena BenutzerhandbuchIntegration mit AWS Glue

Herstellen von Verbindungen mitDatenquellen

Sie können mittels Amazon Athena Daten abfragen, die in einem Datensatz an verschiedenenSpeicherorten und in verschiedenen Formaten gespeichert sind. Dieser Datensatz kann im CSV-, JSON-,Avro-, Parquet- oder anderen Formaten vorliegen.

Die Tabellen und Datenbanken, die Sie in Athena zum Ausführen von Abfragen verwenden, basieren aufMetadaten. Metadaten sind Daten zu den Daten im Datensatz. Die Form, in der diese Metadaten denDatensatz beschreiben, wird Schema genannt. Beispielsweise stellen ein Tabellenname, die Namen derSpalten der Tabelle und die Datentypen der einzelnen Spalten als Metadaten gespeicherte Schemasdar, die den zugrunde liegende Datensatz beschreiben. In Athena wird das System zum Organisierenvon Metadaten als Datenkatalog oder Metastore bezeichnet. Die Kombination aus Datensatz und demDatenkatalog, der diesen Datensatz beschreibt, wird als Datenquelle bezeichnet.

Die Art der Beziehung zwischen den Metadaten und dem zugrunde liegenden Datensatz ist vom Typder Datenquelle abhängig, mit der Sie arbeiten. Relationale Datenquellen wie MySQL, PostgreSQL undSQL Server integrieren Metadaten eng mit dem Datensatz. Sehr häufig werden in diesen Systemen dieMetadaten geschrieben, wenn die Daten geschrieben werden. Andere Datenquellen, beispielsweise mitHive erstellte Datenquellen, ermöglichen Ihnen das Definieren von Metadaten, während der Datensatzgelesen wird. Der Datensatz kann in einer Vielzahl von Formaten vorliegen, zum Beispiel CSV, JSON,Parquet oder Avro.

Athena unterstützt den AWS Glue-Datenkatalog nativ. Der AWS Glue-Datenkatalog ist ein Datenkatalog,der auf anderen Datensätzen und Datenquellen wie Amazon S3, Amazon Redshift und AmazonDynamoDB aufbaut. Sie können Athena über Konnektoren mit anderen Datenquellen verbinden.

Themen• Integration mit AWS Glue (p. 48)• Die Verwendung von (p. 65)• Die Verwendung von (p. 66)• Herstellen einer Verbindung zu Amazon Athena mit ODBC- und JDBC-Treibern (p. 76)

Integration mit AWS GlueAWS Glue ist ein vollständig verwalteter Service zum Extrahieren, Transformieren und Laden (ETL), derIhre Daten kategorisieren, bereinigen, ergänzen und zuverlässig zwischen verschiedenen Datenspeichernverschieben kann. AWS Glue-Crawler leiten automatisch Datenbank- und Tabellenschema aus demDatensatz ab und speichern die zugehörigen Metadaten im AWS Glue-Datenkatalog.

Athena unterstützt nativ das Abfragen von Datensätzen und Datenquellen, die beim AWS Glue-Datenkatalog registriert sind. Wenn Sie in Athena Data Manipulation Language (DML)-Abfragen mit DataCatalog als Quelle ausführen, wird das Data Catalog-Schema verwendet, um aus dem zugrunde liegendenDatensatz Einsichten abzuleiten. Wenn Sie Data Definition Language (DDL)-Abfragen ausführen, wird dasvon Ihnen definierte Schema in AWS Glue-Datenkatalog definiert. Sie können aus Athena heraus auch

48

https://hive.apache.org


Amazon Athena BenutzerhandbuchVerwenden von AWS Glue zum Herstellen einer

Verbindung mit Datenquellen in Amazon S3

einen AWS Glue-Crawler für eine Datenquelle ausführen, um im AWS Glue-Datenkatalog ein Schema zuerstellen.

In Regionen mit AWS Glue-Unterstützung verwendet Athena den AWS Glue-Datenkatalog als zentralenSpeicherort, um Tabellenmetadaten für ein AWS-Konto zu speichern und abzurufen. Die Ausführungs-Engine von Athena zieht aus den Tabellenmetadaten die Anweisungen, wo und wie die Daten gelesenwerden sollen, sowie weitere Informationen, die für die Verarbeitung der Daten erforderlich sind. DerAWS Glue-Datenkatalog stellt ein einheitliches Metadaten-Repository für verschiedene Datenquellen undDatenformate bereit und kann nicht nur in Athena, sondern auch in Amazon S3, Amazon RDS, AmazonRedshift, Amazon Redshift Spectrum, Amazon EMR sowie alle anderen Anwendungen integriert werden,die mit dem Apache Hive-Metastore kompatibel sind.

Weitere Informationen zum AWS Glue-Datenkatalog finden Sie unter Füllen des AWS Glue-Datenkatalogsim AWS Glue-Entwicklerhandbuch. Eine Liste der Regionen, in denen AWS Glue verfügbar ist, finden Sieunter Regionen und Endpunkte von AWS in der Allgemeinen AWS-Referenz.

Für AWS Glue gelten separate Gebühren. Weitere Informationen finden Sie unter AWS Glue-Preisberechnung und Fallen für AWS Glue separate Gebühren an? (p. 63) Weitere Informationen zuden Vorteilen einer Nutzung von AWS Glue mit Athena finden Sie unter Warum sollte ich ein Upgrade aufden AWS Glue-Datenkatalog durchführen? (p. 62)

Themen• Verwenden von AWS Glue zum Herstellen einer Verbindung mit Datenquellen in Amazon S3 (p. 49)• Bewährte Methoden beim Verwenden von Athena mit AWS Glue (p. 51)• Schrittweises Upgrade auf den AWS Glue-Datenkatalog (p. 60)• Häufig gestellte Fragen: Upgrade auf den AWS Glue-Datenkatalog (p. 62)

Verwenden von AWS Glue zum Herstellen einerVerbindung mit Datenquellen in Amazon S3Athena kann eine Verbindung mit den in Amazon S3 gespeicherten Daten herstellen, um mit AWS Glue-Datenkatalog Metadaten wie Tabellen- und Spaltennamen zu speichern. Nachdem die Verbindunghergestellt wurde, werden Ihre Datenbanken, Tabellen und Ansichten im Athena-Abfrage-Editor angezeigt.

49

https://docs.aws.amazon.com/glue/latest/dg/populate-data-catalog.html

https://docs.aws.amazon.com/general/latest/gr/rande.html#glue_region

https://aws.amazon.com/glue/pricing




Um Schemainformationen zur Verwendung durch AWS Glue zu definieren, können Sie einen AWS Glue-Crawler einrichten, um die Informationen abzurufen, oder Sie können eine Tabelle manuell hinzufügen unddie Schemainformationen eingeben.

Einrichten eines CrawlersSie richten einen Crawler ein, indem Sie in der Athena-Konsole beginnen und dann die AWS Glue-Konsolein integrierter Weise verwenden. Wenn Sie einen Crawler erstellen, können Sie Datenspeicher zumDurchsuchen auswählen oder den Crawler auf vorhandene Katalogtabellen verweisen.

So richten Sie einen Crawler in AWS Glue ein, um Schemainformationen automatisch abzurufen

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) die Option AWS GlueData

Catalog aus.4. Klicken Sie auf Next (Weiter).5. Wählen Sie auf der Seite Connection details (Verbindungsdetails) die Option Set up crawler in

AWS Glueto retrieve schema infomation automatically (Crawler zum automatischen Abrufen vonSchemainformationen einrichten).

6. Klicken Sie auf Connect to AWS (Mit AWS verbinden) AWS Glue.7. Führen Sie auf der AWS Glue-Konsolenseite Add crawler (Crawler hinzufügen) die Schritte zum

Erstellen eines Crawlers aus. Weitere Informationen finden Sie unter Auffüllen des AWS Glue-Datenkatalog.

Manuelles Hinzufügen einer SchematabelleIm folgenden Verfahren wird gezeigt, wie Sie mithilfe der Athena-Konsole eine Tabelle manuell hinzufügen.

So fügen Sie eine Tabelle hinzu und geben Schemainformationen manuell ein:

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) die Option AWS GlueData

Catalog aus.4. Klicken Sie auf Next (Weiter).5. Wählen Sie auf der Seite Connection details (Verbindungsdetails) die Option Add a table and enter

schema information manually (Tabelle hinzufügen und Schemainformationen manuell eingeben).6. Klicken Sie auf Continue to add table (Weiter, um eine Tabelle hinzuzufügen).7. Wählen Sie auf der Seite Add table (Tabelle hinzufügen) der Athena-Konsole für Database

(Datenbank) eine vorhandene Datenbank aus, oder erstellen Sie eine neue Datenbank.8. Geben Sie einen Tabellennamen ein, oder wählen Sie diesen aus.9. Geben Sie unter Location of Input Data Set (Speicherort des Eingabedatensatzes) den Pfad in dem

Ordner Amazon S3 an, der den zu verarbeitende Datensatz enthält.10. Klicken Sie auf Next (Weiter).11. Wählen Sie für Data Format (Datenformat) ein Datenformat aus (Apache Web Logs, CSV, TSV,

Textdatei mit benutzerdefinierten Trennzeichen, JSON, Parquet, oder ORC).

• Für die Option Apache Web Logs müssen Sie auch einen Regex-Ausdruck in das Feld Regexeingeben.

• Geben Sie für die Option Textdatei mit benutzerdefinierten Trennzeichen einen Field terminator(Feldtrennzeichen) an (d. h. ein Spaltentrennzeichen). Optional können Sie einen Collection

50





Amazon Athena BenutzerhandbuchBewährte Methoden beim Verwenden

von Athena mit AWS Glue

terminator (Abschlusszeichen für die Sammlung) für Array-Typen oder einen Map key terminator(Abschlusszeichen für Map-Schlüssel) angeben.

12. Geben Sie unter Columns (Spalten) einen Spaltennamen und den Spaltendatentyp an.

• Um mehrere Spalten einzeln hinzuzufügen, wählen Sie Add a column (Spalte hinzufügen).• Um schnell weitere Spalten hinzuzufügen, wählen Sie Bulk add columns (Massenhinzufügung

von Spalten). Geben Sie in das Textfeld eine durch Kommata getrennte Liste von Spalten imFormat column_name data_type, column_name data_type[,...] ein, und wählen Sie dann Add(Hinzufügen).

13. Wählen Sie Next.14. (Optional) Klicken Sie unter Partitions (Partitionen) auf Add a partition (Partition hinzufügen), um

Spaltennamen und Datentypen hinzuzufügen.15. Wählen Sie Create table aus. Die DDL für die angegebene Tabelle wird im Abfrage-Editorangezeigt.

Das folgende Beispiel zeigt die DDL, die für eine zweispaltige Tabelle im CSV-Format generiert wurde:

CREATE EXTERNAL TABLE IF NOT EXISTS MyManualDB.MyManualTable ( `cola` string, `colb` string )ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'WITH SERDEPROPERTIES ( 'serialization.format' = ',', 'field.delim' = ',') LOCATION 's3://bucket_name/'TBLPROPERTIES ('has_encrypted_data'='false');

16. Wählen Sie Run query (Abfrage ausführen), um die Tabelle zu erstellen.

Bewährte Methoden beim Verwenden von Athena mitAWS GlueWenn Sie Athena mit dem AWS Glue-Datenkatalog verwenden, können Sie mit AWS Glue Datenbankenund Tabellen (Schemata) erstellen, die in Athena abgefragt werden können. Sie können auch mit AthenaSchemata erstellen und diese in AWS Glue und verwandten Dienstleistungen verwenden. In diesemThema werden Überlegungen und bewährte Methoden für beide Methoden vorgestellt.

Im Hintergrund verwendet Athena Presto zum Ausführen von DML-Anweisungen und Hive zum Ausführenvon DDL-Anweisungen beim Erstellen und Bearbeiten von Schemata. Bei diesen Technologien müsseneinige Konventionen befolgt werden, damit Athena und AWS Glue gut zusammen funktionieren.

In diesem Thema

• Datenbank-, Tabellen- und Spaltennamen (p. 52)• Verwenden von AWS Glue-Crawlern (p. 52)

• Planen eines Crawlers zur Synchronisierung des AWS Glue-Datenkatalogs mit AmazonS3 (p. 52)

• Verwenden mehrerer Datenquellen mit Crawlern (p. 53)• Synchronisieren von Partitionsschemata zur Vermeidung von -Benutzer haben, die Daten

abfragen, "HIVE_PARTITION_SCHEMA_MISMATCH" (p. 55)• Aktualisieren von Tabellenmetadaten (p. 55)

• Arbeiten mit CSV-Dateien (p. 56)• CSV-Daten in Anführungszeichen (p. 56)• CSV-Dateien mit Überschriften (p. 58)

51



• Arbeiten mit Geodaten (p. 58)• Verwenden von AWS Glue-Aufträgen für ETL mit Athena (p. 58)

• Erstellen von Tabellen mit Athena für AWS Glue-ETL-Aufträge (p. 58)• Verwenden von ETL-Aufträgen zur Optimierung der Abfrageleistung (p. 59)• Konvertieren der Datentypen SMALLINT und TINYINT in INT bei der Konvertierung nach

ORC (p. 60)• Automatisieren von AWS Glue-Aufträgen für ETL (p. 60)

Datenbank-, Tabellen- und SpaltennamenBeachten Sie beim Erstellen von Schemata in AWS Glue für Abfragen in Athena folgende Punkte:

• Datenbanknamen dürfen nicht länger als 252 Zeichen sein.• Tabellennamen dürfen nicht länger als 255 Zeichen sein.• Spaltennamen dürfen nicht länger als 128 Zeichen sein.• Für Datenbank-, Tabellen- und Spaltennamen dürfen nur Kleinbuchstaben, Zahlen und Unterstriche

verwendet werden.

Sie können mit dem AWS Glue Catalog Manager Spalten umbenennen. Das Umbenennen vonTabellen- und Datenbanknamen wird jedoch derzeit in der AWS Glue-Konsole nicht unterstützt. UmDatenbanknamen zu ändern, müssen Sie eine neue Datenbank erstellen und die Tabellen in diese neueDatenbank kopieren (also die Metadaten in eine neue Entity kopieren). Für Tabellen können Sie einenähnlichen Ansatz wählen. Dafür können Sie das AWS Glue SDK oder die AWS CLI verwenden.

Verwenden von AWS Glue-CrawlernAWS Glue-Crawler finden und registrieren das Schema für Datasets im AWS Glue-Datenkatalog. Crawlerdurchsuchen die Daten und untersuchen bestimmte Abschnitte, um das Schema zu bestimmen. Darüberhinaus können Crawler Partitionen erkennen und registrieren. Weitere Informationen finden Sie unterKatalogisieren von Daten mit einem Crawler im AWS Glue-Entwicklerhandbuch.

Planen eines Crawlers zur Synchronisierung des AWS Glue-Datenkatalogs mitAmazon S3

AWS Glue-Crawler können so eingerichtet werden, dass sie nach einem bestimmten Zeitplan oder beiBedarf ausgeführt werden. Weitere Informationen finden Sie unter Zeitpläne für Aufträge und Crawler imAWS Glue-Entwicklerhandbuch.

Wenn Sie über Daten verfügen, die zu einem festen Zeitpunkt für eine partitionierte Tabelle eingehen,können Sie einen AWS Glue-Crawler so einrichten, dass er geplant ausgeführt wird, um dieTabellenpartitionen zu erkennen und zu aktualisieren. So müssen Sie keinen potenziell langen undaufwändigen MSCK REPAIR-Befehl oder manuell einen ALTER TABLE ADD PARTITION-Befehlausführen. Weitere Informationen finden Sie unter Tabellenpartitionen im AWS Glue-Entwicklerhandbuch.

52

https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html

https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html

https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition



Verwenden mehrerer Datenquellen mit Crawlern

Wenn ein AWS Glue-Crawler Amazon S3 scannt und mehrere Verzeichnisse findet, bestimmt er mithilfeeiner heuristischen Suche das Stammverzeichnis einer Tabelle und bestimmt, welche VerzeichnissePartitionen dieser Tabelle sind. In einigen Fällen, wenn in zwei oder mehr Verzeichnissen ein ähnlichesSchema erkannt wird, kann es vorkommen, dass der Crawler diese als Partitionen statt als eigenständigeTabellen behandelt. Eine Möglichkeit sicherzustellen, dass der Crawler eigenständige Tabellen erkennt,besteht darin, das Stammverzeichnis jeder Tabelle als Datenspeicher für den Crawler hinzuzufügen.

Nachfolgend finden Sie ein Beispiel für Partitionen in Amazon S3:

s3://bucket01/folder1/table1/partition1/file.txts3://bucket01/folder1/table1/partition2/file.txts3://bucket01/folder1/table1/partition3/file.txts3://bucket01/folder1/table2/partition4/file.txts3://bucket01/folder1/table2/partition5/file.txt

Wenn die Schemata für table1 und table2 sich ähneln und in AWS Glue eine einzelne Datenquellefür s3://bucket01/folder1/ festgelegt ist, kann es vorkommen, dass der Crawler eine einzelneTabelle mit zwei Partitionsspalten erstellt: eine Partitionsspalte mit table1 und table2 und eine zweitePartitionsspalte mit partition1 bis partition5.

Damit der AWS Glue-Crawler zwei getrennte Tabellen erstellt, richten Sie den Crawler so ein, dass erzwei Datenquellen, s3://bucket01/folder1/table1/ und s3://bucket01/folder1/table2verwendet, wie in der folgenden Anleitung gezeigt.

So fügen Sie einem vorhandenen Crawler in AWS Glue einen weiterenDatenspeicher hinzu

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die AWS Glue-Konsole unterhttps://console.aws.amazon.com/glue/.

2. Klicken Sie auf Crawlers, wählen Sie Ihren Crawler aus und klicken Sie auf Action (Aktion) und Editcrawler (Crawler bearbeiten).

53

https://console.aws.amazon.com/glue/



3. Nehmen Sie unter Add information about your crawler nach Bedarf weitere Einstellungen vor und klickenSie auf Next.

4. Ändern Sie unter Add a data store die Einstellung Include path auf das Verzeichnis auf Tabellenebene.Im obigen Beispiel würden Sie das Verzeichnis beispielsweise von s3://bucket01/folder1 tos3://bucket01/folder1/table1/ ändern. Wählen Sie Next.

5. Klicken Sie für Add another data store auf Yes und Next.

54



6. Geben Sie unter Include path (Pfad einschließen) Ihr Verzeichnis auf Tabellenebene ein (z. B. s3://bucket01/folder1/table2/) und wählen Sie Next (Weiter).a. Wiederholen Sie die Schritte 3 bis 5 für weitere Verzeichnisse auf Tabellenebene und schließen Sie

die Crawler-Konfiguration ab.

Die neuen Werte für Include locations (Speicherorte einschließen) werden folgendermaßen unterDatenspeicher angezeigt.

Synchronisieren von Partitionsschemata zur Vermeidung von -Benutzer haben,die Daten abfragen, "HIVE_PARTITION_SCHEMA_MISMATCH"

Das Schema wird für jede Tabelle innerhalb des AWS Glue-Datenkatalogs mit Partitionsspalten aufTabellenebene und für jede individuelle Partition innerhalb der Tabelle gespeichert. Das Schema fürPartitionen wird von einem AWS Glue-Crawler basierend auf der Datenstichprobe ausgefüllt, die innerhalbder Partition ausgelesen wird. Weitere Informationen finden Sie unter Verwenden mehrerer Datenquellenmit Crawlern (p. 53).

Wenn Athena eine Abfrage ausführt, werden das Schema der Tabelle und das Schema der für die Abfrageerforderlichen Partitionen geprüft. Dabei werden die Spaltendatentypen der Reihe nach verglichen undes wird sichergestellt, dass sie für überlappende Spalten übereinstimmen. So wird verhindert, dass eszu unerwartetem Hinzufügen oder Entfernen von Spalten in der Mitte der Tabelle kommt. Wenn Athenaerkennt, dass das Schema einer Partition vom Schema der Tabelle abweicht, kann Athena die Abfragenicht verarbeiten und bricht mit dem Fehler HIVE_PARTITION_SCHEMA_MISMATCH ab.

Es gibt mehrere Möglichkeiten, dieses Problem zu beheben. Wenn die Daten versehentlich hinzugefügtwurden, können Sie die Datendateien, die zu der Schemaabweichung geführt haben, entfernen, diePartition verwerfen und die Daten erneut durchsuchen. Sie können auch die einzelne Partition verwerfenund dann mit Athena MSCK REPAIR ausführen, um die Partition mit dem Schema der Tabelle neu zuerstellen. Diese zweite Option funktioniert jedoch nur, wenn Sie sicher sind, dass das angewendeteSchema die Daten weiterhin korrekt ausliest.

Aktualisieren von Tabellenmetadaten

Nach dem Durchsuchen weist der AWS Glue-Crawler automatisch bestimmte Tabellenmetadaten zu, umeine Kompatibilität mit anderen externen Technologien wie Apache Hive, Presto und Spark sicherzustellen.Es kann vorkommen, dass der Crawler dabei Metadateneigenschaften falsch zuweist. KorrigierenSie die Eigenschaften in AWS Glue manuell, bevor Sie mit Athena Abfragen für die Tabelle senden.Weitere Informationen finden Sie unter Anzeigen und Bearbeiten von Tabellendetails im AWS Glue-Entwicklerhandbuch.

55

https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details



Es kann vorkommen, dass AWS Glue Metadaten falsch zuweist, wenn eine CSV-Datei einzelneDatenfelder in Anführungszeichen einschließt. Hierdurch kann die Eigenschaft serializationLib falschabgerufen werden. Weitere Informationen finden Sie unter CSV-Daten in Anführungszeichen (p. 56).

Arbeiten mit CSV-DateienCSV-Dateien enthalten gelegentlich Anführungszeichen um die Datenwerte der einzelnen Spalten.Außerdem können sie Überschriften enthalten, die nicht Bestandteil der zu analysierenden Daten sind.Wenn Sie mit AWS Glue ein Schema für diese Dateien erstellen, befolgen Sie die Anleitung in diesemAbschnitt.

CSV-Daten in Anführungszeichen

Wenn Sie eine Abfrage in Athena für eine Tabelle ausführen, die aus einer CSV-Datei mit Datenwerten inAnführungszeichen erstellt wurde, aktualisieren Sie die Tabellendefinition in AWS Glue, um die korrektenSerDe und SerDe-Eigenschaften festzulegen. So kann die Tabellendefinition den OpenCSVSerDeverwenden. Weitere Informationen zum OpenCSV SerDe finden Sie unter OpenCSVSerDe für CSV-Verarbeitung (p. 295).

Führen Sie in diesem Fall die folgenden Änderungen durch:

• Ändern Sie die Eigenschaft serializationLib unter dem Feld im SerDeInfo-Feld der Tabelle auforg.apache.hadoop.hive.serde2.OpenCSVSerde.

• Geben Sie passende Werte für separatorChar, quoteChar und escapeChar ein. DerseparatorChar-Wert ist ein Komma, der quoteChar-Wert sind doppelte Anführungszeichen (``) undder escapeChar-Wert ist der Backslash (\).

Beispiel für eine CSV-Datei mit Datensätzen wie den folgenden:

"John","Doe","123-555-1231","John said \"hello\"""Jane","Doe","123-555-9876","Jane said \"hello\""

Sie können mit der AWS Glue-Konsole Tabellendetails wie in diesem Beispiel gezeigt bearbeiten:

56



Alternativ können Sie die Tabellendefinition in AWS Glue um einen SerDeInfo-Block wie folgt aktualisieren:

"SerDeInfo": { "name": "",

57



"serializationLib": "org.apache.hadoop.hive.serde2.OpenCSVSerde", "parameters": { "separatorChar": "," "quoteChar": """ "escapeChar": "\\" }},

Weitere Informationen finden Sie unter Anzeigen und Bearbeiten von Tabellendetails im AWS Glue-Entwicklerhandbuch.

CSV-Dateien mit Überschriften

Wenn Sie CSV-Dateien in AWS Glue schreiben, die für Abfragen mit Athena verwendet werden sollen,müssen Sie die CSV-Überschriften entfernen, damit diese Informationen nicht in den Abfrageergebnissenvon Athena enthalten sind. Hierfür können Sie beispielsweise AWS Glue-Aufträge zum Extrahieren,Umwandeln und Laden (Extract, Transform, Load; ETL) verwenden. Sie können in AWS Glue Skripte ineiner Sprache schreiben, die eine Erweiterung des PySpark Python-Dialekts ist. Weitere Informationenfinden Sie unter Autorisieren von Aufträgen in Glue im AWS Glue-Entwicklerhandbuch.

Das folgende Beispiel zeigt eine Funktion in einem AWS Glue-Skript, mit der ein dynamischer Framemit from_options geschrieben und die Formatoption writeHeader auf "false" gesetzt wird, um dieÜberschriften zu entfernen:

glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": "s3://MYBUCKET/MYTABLEDATA/"}, format = "csv", format_options = {"writeHeader": False}, transformation_ctx = "datasink2")

Arbeiten mit GeodatenAWS Glue unterstützt Well-Known Text (WKT), Well-Known Binary (WKB) oder andere PostGIS-Datentypen nicht nativ. Der AWS Glue-Classifier analysiert Geodaten und klassifiziert sie mithilfeunterstützter Datentypen für das Format, z. B. varchar für CSV. Wie bei anderen AWS Glue-Tabellenmüssen Sie möglicherweise die Eigenschaften von Tabellen aktualisieren, die aus Geodaten erstelltwurden, damit Athena diese Datentypen im Ist-Zustand Fall analysieren kann. Weitere Informationen findenSie unter Verwenden von AWS Glue-Crawlern (p. 52) und Arbeiten mit CSV-Dateien (p. 56). Athenakann einige Geodatentypen in AWS Glue-Tabellen nicht im Ist-Zustand analysieren. Weitere Informationenzum Arbeiten mit Geodaten in Athena finden Sie unter Abfragen von koordinatenbasierten Daten (p. 168).

Verwenden von AWS Glue-Aufträgen für ETL mit AthenaAWS Glue-Aufträge führen ETL-Operationen aus. Ein AWS Glue-Auftrag führt ein Skript aus, mit demDaten aus Quellen extrahiert, umgewandelt und in das Ziel hochgeladen werden. Weitere Informationenfinden Sie unter Autorisieren von Aufträgen in Glue im AWS Glue-Entwicklerhandbuch.

Erstellen von Tabellen mit Athena für AWS Glue-ETL-Aufträge

Innerhalb von Athena erstellte Tabellen benötigen eine Tabelleneigenschaft namens classification,über die das Format der Daten identifiziert wird. Damit kann AWS Glue die Tabellen für ETL-Aufträgeverwenden. Die Klassifizierungswerte können csv, parquet, orc, avro oder json sein. Es folgt einBeispiel für eine CREATE TABLE-Anweisung in Athena:

CREATE EXTERNAL TABLE sampleTable ( column1 INT, column2 INT ) STORED AS PARQUET

58


https://docs.aws.amazon.com/glue/latest/dg/busisadd-job.html




TBLPROPERTIES ( 'classification'='parquet')

Wenn die Tabelleneigenschaft beim Erstellen der Tabelle nicht hinzugefügt wurde, können Sie sie mithilfeder AWS Glue-Konsole hinzufügen.

So ändern Sie die Klassifizierungseigenschaft in der Konsole

1. Klicken Sie auf Edit Table.

2. Wählen Sie unter Classification den Dateityp aus und klicken Sie auf Apply.

Weitere Informationen finden Sie unter Arbeiten mit Tabellen im AWS Glue-Entwicklerhandbuch.

Verwenden von ETL-Aufträgen zur Optimierung der Abfrageleistung

Mithilfe von AWS Glue-Aufträgen können Sie Daten zur Optimierung der Abfrageleistung in Athenain ein anderes Format umwandeln. Datenformate wirken sich erheblich auf die Abfrageleistung undAbfragekosten in Athena aus.

59

https://docs.aws.amazon.com/glue/latest/dg/console-tables.html

Amazon Athena BenutzerhandbuchSchrittweises Upgrade auf den AWS Glue-Datenkatalog

Wir empfehlen, die Datenformate Parquet und ORC zu verwenden. AWS Glue unterstützt Schreibvorgängein beide Datenformate, was die Umwandlung von Daten in ein für Athena optimales Format einfacherund schneller macht. Weitere Informationen zu diesen Formaten und anderen Möglichkeiten zurLeistungsverbesserung finden Sie unter Top Performance Tuning-Tipps für Amazon Athena.

Konvertieren der Datentypen SMALLINT und TINYINT in INT bei derKonvertierung in ORC

Um möglichst zu vermeiden, dass Athena die Datentypen SMALLINT und TINYINT, die von AWS Glue-ETL-Aufträgen generiert werden, nicht lesen kann, sollten Sie SMALLINT und TINYINT entweder mit demAssistenten oder einem eigenen Skript für einen ETL-Auftrag in INT umwandeln.

Automatisieren von AWS Glue-Aufträgen für ETL

Sie können AWS Glue-ETL-Aufträge so konfigurieren, dass sie automatisch ausgeführt werden, wennsie ausgelöst werden. Diese Funktion ist ideal, wenn Daten von außerhalb von AWS in einem Format,das für Abfragen in Amazon S3 nicht optimal ist, in einen Athena-Bucket gespeichert werden. WeitereInformationen finden Sie unter Auslösen von AWS Glue-Aufträgen im AWS Glue-Entwicklerhandbuch.

Schrittweises Upgrade auf den AWS Glue-DatenkatalogAmazon Athena verwaltet seinen eigenen Datenkatalog, bis AWS Glue in der Athena-Region veröffentlichtwird. Sofern Sie zuvor Datenbanken und Tabellen mit Athena oder Amazon Redshift Spectrum erstellthaben, können Sie zu diesem Zeitpunkt wählen, ob Sie Athena auf den AWS Glue-Datenkatalog upgradenmöchten. Falls Sie Athena erstmalig verwenden, müssen Sie keine Änderungen vornehmen. Datenbankenund Tabellen sind in Athena über den AWS Glue-Datenkatalog und umgekehrt verfügbar. WeitereInformationen zu den Vorteilen des AWS Glue-Datenkatalogs finden Sie unter Häufig gestellte Fragen:Upgrade auf den AWS Glue-Datenkatalog (p. 62). Eine Liste der Regionen, in denen AWS Glueverfügbar ist, finden Sie unter Regionen und Endpunkte von AWS in der Allgemeinen AWS-Referenz.

Bis zum Upgrade speichert der von Athena verwaltete Datenkatalog weiterhin Ihre Tabellen- undDatenbankmetadaten und die Option zum Upgrade wird oben in der Konsole angezeigt. Die Metadatenim von Athena verwalteten Katalog sind im AWS Glue-Datenkatalog (und umgekehrt) nicht verfügbar.Beide Kataloge sind zwar parallel vorhanden, Sie können jedoch keine Tabellen oder Datenbanken mitdemselben Namen erstellen. Die Erstellung in AWS Glue oder Athena schlägt in diesem Fall fehl.

Wir haben einen Assistenten in der Athena-Konsole bereitgestellt, der Sie beim Upgrade auf die AWSGlue-Konsole Schritt für Schritt anleitet. Das Upgrade dauert nur wenige Minuten und kann jederzeitunterbrochen werden. Weitere Informationen zu den einzelnen Upgrade-Schritten finden Sie in denThemen in diesem Abschnitt. Weitere Informationen zur Arbeit mit Daten und Tabellen im AWS Glue-Datenkatalog finden Sie in den Richtlinien unter Bewährte Methoden beim Verwenden von &ATE; mit AWSGlue (p. 51).

Schritt 1 – Einem Benutzer erlauben, das Upgrade auszuführenStandardmäßig ist die Aktion zum Ausführen des Upgrade in keiner Richtlinie, einschließlich verwalteterRichtlinien, erlaubt. Da der AWS Glue-Datenkatalog innerhalb eines Kontos gemeinsam verwendet wird,verhindert diese Vorsichtsmaßnahme, dass der Katalog versehentlich migriert wird.

Bevor Sie mit dem Upgrade beginnen können, müssen Sie dem Benutzer, der die Migration durchführt,eine benutzerverwaltete IAM-Richtlinie mit einer Richtlinienanweisung, die die Upgrade-Aktion zulässt,anfügen.

Nachfolgend finden Sie eine Beispielrichtlinienanweisung.

60


https://docs.aws.amazon.com/glue/latest/dg/trigger-job.html



{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "glue:ImportCatalogToGlue " ], "Resource": [ "*" ] } ] }

Schritt 2 – Benutzerverwaltete/eingebundene Richtlinien derAthena-Benutzer aktualisierenWenn Sie benutzerverwaltete oder eingebundene IAM-Richtlinien für Athena-Benutzer verwenden, müssenSie die Richtlinie(n) aktualisieren, um die für AWS Glue erforderlichen Aktionen zu erlauben. Wenn Sie dieverwaltete Richtlinie verwenden, wird diese automatisch aktualisiert. In der nachfolgenden Beispielrichtliniesind die erforderlichen AWS Glue-Richtlinienaktionen aufgelistet. Die vollständige Richtlinienanweisungfinden Sie unter IAM-Richtlinien für den Benutzerzugriff (p. 217).

{ "Effect":"Allow", "Action":[ "glue:CreateDatabase", "glue:DeleteDatabase", "glue:GetDatabase", "glue:GetDatabases", "glue:UpdateDatabase", "glue:CreateTable", "glue:DeleteTable", "glue:BatchDeleteTable", "glue:UpdateTable", "glue:GetTable", "glue:GetTables", "glue:BatchCreatePartition", "glue:CreatePartition", "glue:DeletePartition", "glue:BatchDeletePartition", "glue:UpdatePartition", "glue:GetPartition", "glue:GetPartitions", "glue:BatchGetPartition" ], "Resource":[ "*" ]}

Schritt 3 – Das Upgrade in der Athena-Konsole auswählenNachdem Sie die erforderlichen IAM-Richtlinien aktualisiert haben, klicken Sie in der Athena-Konsole aufUpgrade. Athena verschiebt Ihre Metadaten in den AWS Glue-Datenkatalog. Das Upgrade dauert nurwenige Minuten. Nach dem Upgrade enthält die Athena-Konsole einen Link, über den Sie den AWS Glue-Katalogmanager aus Athena öffnen können.

61

Amazon Athena BenutzerhandbuchHäufig gestellte Fragen: Upgradeauf den AWS Glue-Datenkatalog

Wenn Sie eine Tabelle in der Konsole erstellen, können Sie nun eine Tabelle mit einem AWS Glue-Crawlererstellen. Weitere Informationen finden Sie unter Verwenden von AWS Glue-Crawlern (p. 52).

Häufig gestellte Fragen: Upgrade auf den AWS Glue-DatenkatalogWenn Sie mit Athena Datenbanken und Tabellen in einer Region erstellt haben, bevor AWS Glue indieser verfügbar war, sind die Metadaten in einem von Athena verwalteten Datenkatalog gespeichert,auf den nur Athena und Amazon Redshift Spectrum zugreifen können. Um die AWS Glue-Funktionenzusammen mit Athena und Redshift Spectrum nutzen zu können, müssen Sie ein Upgrade auf den AWSGlue-Datenkatalog durchführen. Athena kann zusammen mit dem AWS Glue-Datenkatalog nur in Regionenverwendet werden, in denen AWS Glue verfügbar ist. Eine Liste der Regionen finden Sie unter Regionenund Endpunkte in der Allgemeinen AWS-Referenz.

Warum sollte ich ein Upgrade auf den AWS Glue-Datenkatalogdurchführen?AWS Glue ist ein vollständig verwalteter Service zum Extrahieren, Transformieren und Laden (ETL). Erbesteht aus drei Hauptkomponenten:

• Ein AWS Glue Crawler kann automatisch Ihre Datenquellen scannen, Datenformate bestimmen undSchemata ableiten.

62




• Ein vollständig verwalteter ETL-Service ermöglicht Ihnen das Transformieren und Verschieben von Datenin verschiedene Ziele.

• Der AWS Glue-Datenkatalog speichert Metadaten zu Datenbanken und Tabellen, die auf einenDatenspeicher in Amazon S3 oder einen JDBC-kompatiblen Datenspeicher zeigen.

Weitere Informationen finden Sie auf der Seite zu den AWS Glue-Konzepten.

Das Upgrade auf den AWS Glue-Datenkatalog hat folgende Vorteile.

Einheitlicher Metadaten-RepositoryDer AWS Glue-Datenkatalog stellt einen einheitlichen Metadaten-Repository für eine Vielzahl vonDatenquellen und Datenformaten bereit. Er ermöglicht eine unmittelbare Integration in Amazon SimpleStorage Service (Amazon S3), Amazon Relational Database Service (Amazon RDS), Amazon Redshift,Amazon Redshift Spectrum, Athena, Amazon EMR und alle anderen Anwendungen, die mit dem ApacheHive-Metastore kompatibel sind. Sie müssen Ihre Tabellendefinitionen nur einmal erstellen und könnendann eine Engine-übergreifende Abfrage durchführen.

Weitere Informationen finden Sie auf der Seite zum Füllen des AWS Glue-Datenkatalogs.

Automatische Schema- und Partitions-ErkennungAWS Glue-Crawler durchsuchen automatisch Ihre Datenquellen, bestimmen Datenformate und empfehlenSchemata und Transformationen. Crawler unterstützen Sie bei der Automatisierung der Tabellenerstellungund dem automatischen Laden von Partitionen, die Sie mit Athena, Amazon EMR und Redshift Spectrumabfragen können. Sie können Tabellen und Partitionen auch direkt mit der AWS Glue-API, den AWS SDKsund der AWS CLI erstellen.

Weitere Informationen finden Sie auf der Seite zum Katalogisieren von Tabellen mit einem Crawler.

Einfach zu erstellende PipelinesDie AWS Glue ETL-Engine generiert Python-Code, der vollständig anpassbar, wiederverwendbar undportabel ist. Sie können den Code mit Ihrer bevorzugten IDE oder Ihrem Notebook bearbeiten und überGitHub für andere freigeben. Nachdem Ihr ETL-Auftrag erstellt wurde, können Sie ihn so planen, dass erauf der vollständig verwalteten, skalierbaren Spark-Infrastruktur von AWS Glue ausgeführt wird. AWS Glueübernimmt das Bereitstellen, Konfigurieren und Skalieren der Ressourcen, die zum Ausführen Ihrer ETL-Aufträge erforderlich sind, sodass Sie ETL eng in Ihren Workflow integrieren können.

Weitere Informationen finden Sie auf der Seite zum Autorisieren von AWS Glue-Aufträgen im AWS Glue-Entwicklerhandbuch.

Fallen für AWS Glue separate Gebühren an?Ja. Für AWS Glue zahlen Sie monatlich eine Gebühr für das Speichern und Zugreifen auf Metadaten, dieim AWS Glue-Datenkatalog enthalten sind. Zudem zahlen Sie einen Stundensatz, der sekundengenau fürAWS Glue ETL-Aufträge und die Crawler-Laufzeit berechnet wird. Darüber hinaus fällt ein Stundensatzan, der sekundengenau für jeden bereitgestellten Entwicklungsendpunkt berechnet wird. Der AWS Glue-Datenkatalog ermöglicht Ihnen die gebührenfreie Speicherung von bis zu einer Million Objekten. WennSie mehr als eine Million Objekte speichern, fällt eine Gebühr von 1 USD für jeweils 100.000 zusätzlicheObjekte an. Ein Objekt im AWS Glue-Datenkatalog ist eine Tabelle, Partition oder Datenbank. WeitereInformationen finden Sie auf der Seite zur AWS Glue-Preisberechnung.

Upgrade-Prozess – Häufig gestellte Fragen• Wer kann das Upgrade durchführen? (p. 64)• Meine Benutzer verwenden eine verwaltete Richtlinie mit Athena und Redshift Spectrum. Welche Schritte

muss ich für das Upgrade durchführen? (p. 64)

63

https://docs.aws.amazon.com/glue/latest/dg/components-key-concepts.html

https://aws.amazon.com/s3/


https://aws.amazon.com/rds/

https://aws.amazon.com/redshift/

https://aws.amazon.com/redshift/spectrum/

https://aws.amazon.com/emr/



https://docs.aws.amazon.com/glue/latest/dg/author-job.html



• Was passiert, wenn ich kein Upgrade durchführe? (p. 64)• Warum muss ich AWS Glue-Richtlinien zu Athena-Benutzern hinzufügen? (p. 64)• Was geschieht, wenn ich keine AWS Glue-Richtlinien für Athena-Benutzer zulasse? (p. 64)• Besteht während des Upgrades das Risiko eines Datenverlusts? (p. 64)• Werden meine Daten während des Upgrades ebenfalls verschoben? (p. 64)

Wer kann das Upgrade durchführen?

Sie müssen eine vom Benutzer verwaltete IAM-Richtlinie mit einer Richtlinienanweisung anfügen, die demBenutzer, der die Migration durchführt, die Upgrade-Aktion erlaubt. Diese zusätzliche Prüfung verhinderteine unbeabsichtigte Migration des Katalogs für das gesamte Konto. Weitere Informationen finden Sie aufder Seite zu Schritt 1 – Einem Benutzer das Durchführen des Upgrades erlauben (p. 60).

Meine Benutzer verwenden eine verwaltete Richtlinie mit Athena und RedshiftSpectrum. Welche Schritte muss ich für das Upgrade durchführen?

Die von Athena verwaltete Richtlinie wurde automatisch mit den neuen Richtlinienaktionen aktualisiert, dieAthena-Benutzern den Zugriff auf AWS Glue gestatten. Sie müssen jedoch dem Benutzer, der das Upgradedurchführt, die Upgrade-Aktion explizit erlauben. Um ein unbeabsichtigtes Upgrade zu verhindern, lässt dieverwaltete Richtlinie diese Aktion nicht zu.

Was passiert, wenn ich kein Upgrade durchführe?

Wenn Sie kein Upgrade durchführen, können Sie die AWS Glue-Funktionen nicht mit Datenbankenund Tabellen verwenden, die Sie in Athena erstellt haben, oder umgekehrt. Sie können diese Servicesunabhängig voneinander verwenden. Während dieser Zeit verhindern sowohl Athena als auch AWS Glue,dass Sie Datenbanken und Tabellen erstellen können, die dieselben Namen im anderen Katalog haben.Dadurch werden beim Upgrade Namensüberschneidungen verhindert.

Warum muss ich AWS Glue-Richtlinien zu Athena-Benutzern hinzufügen?

Vor dem Upgrade verwaltet Athena den Datenkatalog, sodass Athena-Aktionen für Benutzer zugelassenwerden müssen, damit diese Abfragen durchführen können. Nachdem Sie ein Upgrade auf den AWS Glue-Datenkatalog durchgeführt haben, sind Athena-Aktionen nicht mehr für den Zugriff auf den AWS Glue-Datenkatalog zulässig. Deshalb müssen AWS Glue-Aktionen für Benutzer zugelassen werden. Denken Siedaran, dass die verwaltete Richtlinie für Athena bereits aktualisiert wurde, um die erforderlichen AWS Glue-Aktionen zuzulassen. Wenn Sie diese verwaltete Richtlinie verwenden, müssen Sie nichts unternehmen.

Was geschieht, wenn ich keine AWS Glue-Richtlinien für Athena-Benutzerzulasse?

Wenn Sie ein Upgrade auf den AWS Glue-Datenkatalog durchführen und die benutzerverwaltete Richtlinieeines Benutzers oder die eingebundenen IAM-Richtlinien des Benutzers nicht aktualisieren, schlagenAthena-Abfragen fehl, da der Benutzer dann keine Aktionen in AWS Glue durchführen darf. Informationenzu den bestimmten Aktionen, die zugelassen werden müssen, finden Sie auf der Seite zu Schritt 2 –Aktualisieren von benutzerverwalteten/eingebundenen Richtlinien, die mit Athena-Benutzern verknüpftsind (p. 61).

Besteht während des Upgrades das Risiko eines Datenverlusts?

Nein.

Werden meine Daten während des Upgrades ebenfalls verschoben?

Nein. Die Migration betrifft nur Metadaten.

64

Amazon Athena BenutzerhandbuchVerwenden eines Hive-Metastores

Die Verwendung vonSie können die verwenden, um Datensätze in Amazon S3 abzufragen, in denen ein Apache Hive-Metastoreverwendet wird. Es ist keine Migration von Metadaten zu AWS Glue-Datenkatalog erforderlich. In derAthena-Verwaltungskonsole konfigurieren Sie eine Lambda-Funktion für die Kommunikation mit dem Hive-Metastore in Ihrer privaten VPC und verbinden sie dann. Für den Lambda-Funktionscode können Sie dieStandardimplementierung von Athena verwenden, den Athena-Datenquellenkonnektor für den externenHive-Metastore, oder eine eigene Implementierung bereitstellen.

Überlegungen und EinschränkungenVorab erstellte und benutzerdefinierte Datenkonnektoren benötigen möglicherweise Zugriff auf diefolgenden Ressourcen, um ordnungsgemäß zu funktionieren. Überprüfen Sie die Informationen für denvon Ihnen verwendeten Konnektor, um sicherzustellen, dass die VPC korrekt konfiguriert ist. Informationenzu den erforderlichen IAM-Berechtigungen zum Ausführen von Abfragen und zum Erstellen einesDatenquellenkonnektors in Athena finden Sie unter So gewähren Sie den Zugriff auf eine : (p. 230).

• AmazonAthenaPreviewFunctionality-Arbeitsgruppe –• Amazon S3 – Zusätzlich zum Schreiben von Abfrageergebnissen zum Athena-

Abfrageergebnisspeicherort in Amazon S3 schreiben Datenkonnektoren auch zu einem Spill-Bucket inAmazon S3. Konnektivität und Berechtigungen für diesen Amazon S3-Standort sind erforderlich.

• Athena – Zum Überprüfen des Abfragestatus und zum Verhindern übermäßigen Scannens.• AWS Secrets Manager• AWS Glue wenn Ihr KonnektorAWS Glue für ergänzende oder primäre Metadaten verwendet.• AWS Key Management Service• Richtlinien – Hive-Metastore, Athena Query Federation und UDFs erfordern zusätzlich zu Verwaltete

Richtlinie AmazonAthenaFullAccess (p. 218) weitere Richtlinien. Weitere Informationen finden Sie unterIdentitäts- und Zugriffsverwaltung in Athena (p. 217).

Verbinden von Athena mit einem Apache HiveMetastoreUm eine Verbindung von Athena zu einem Apache Hive Metastore herzustellen, müssen Sie eineLambda-Funktion erstellen und konfigurieren. Für eine grundlegende Implementierung können Sie alleerforderlichen Schritte von der Athena-Verwaltungskonsole aus ausführen.

So stellen Sie eine Verbindung von Athena zu einem Hive-Metastore her:

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) unter Choose a metadata

catalog (Metadatenkatalog auswählen) die Option Apache Hive-Metastore aus.4. Wählen Sie Next.5. Klicken Sie auf der Seite Connection details (Verbindungsdetails) für Lambda function (Funktion) auf

Create Lambda function (Funktion erstelle)n.6. Geben Sie im Dialogfeld Create Lambda function (Funktion erstellen) die folgenden Informationen

für die Lambda-Funktion ein. Um die Standardimplementierung zu verwenden, übernehmen Sie dieStandardwerte für den Funktionscodespeicherort in Amazon S3 und den Lambda-Handler.

• Lambda function name (Funktionsname) – Geben Sie einen Namen für die Funktion an. ZumBeispiel myHiveMetastore.

65


Amazon Athena BenutzerhandbuchDie Verwendung von

• Lambda execution role (Ausführungsrolle) – Wählen Sie eine IAM-Rolle aus, oder klicken Sie aufCreate a new role (Neue Rolle erstellen), um eine zu erstellen.

• Function code (Funktionscode) – Der Speicherort in Amazon S3 der Lambda-Funktion-JAR-Datei.Verwenden Sie die Standardeinstellung, oder geben Sie den Speicherort Ihrer benutzerdefiniertenJAR-Datei ein.

• Lambda Handler – Die Methode in der JAR-Datei, die den Hive-Konnektor implementiert. VerwendenSie die Standardeinstellung oder ersetzen Sie sie in Ihrem benutzerdefinierten Code durch denHandler.

• Hive-Metastore (HMS) URI – Geben Sie den Namen Ihres Hive-Metastore-Hosts ein, der das Thrift-Protokoll an Port 9083 mit der Syntax thrift://<host_name>:9083 verwendet.

• Spill location in S3 (Überlaufort in S3) – Geben Sie einen Amazon S3-Ort in diesem Konto fürSpillover-Metadaten an, wenn die Antwortgröße der Lambda-Funktion 4 MB überschreitet.

• Virtual Private (VPC) – Wählen Sie die VPC aus, die Ihren Hive-Metastore enthält.• Subnets (Subnetze) – Wählen Sie die VPC-Subnetze aus, die Lambda zum Einrichten der VPC-

Konfiguration verwenden soll.• Security groups (Sicherheitsgruppen) – Wählen Sie die VPC-Sicherheitsgruppen aus, die Lambda

zum Einrichten der VPC-Konfiguration verwenden soll.• Memory (Speicher) – Geben Sie einen Wert zwischen 128 MB und 3008 MB an. Der Lambda-

Funktion werden CPU-Zyklen proportional zur von Ihnen konfigurierten Speichermenge zugewiesen.• Timeout – Geben Sie einen Wert von 1 Sekunde bis 15 Minuten 59 Sekunden an. Standardmäßig ist

ein Zeitraum von 3 Sekunden festgelegt.7. Klicken Sie auf Create. Die Seite Connection details (Verbindungsdetails) informiert Sie darüber, dass

die Funktion erstellt wird. Wenn der Vorgang abgeschlossen ist, steht Ihr Funktionsname im FeldChoose a function name (Funktionsname auswählen) bereit, und Ihr Lambda-Funktions-ARN wirdangezeigt.

8. Geben Sie unter Catalog name (Katalogname) einen eindeutigen Namen ein, der für die Datenquellein Ihren SQL-Abfragen verwendet werden soll. Der Name kann bis zu 127 Zeichen lang sein undmuss innerhalb Ihres Kontos eindeutig sein. Er kann nach der Erstellung nicht mehr geändertwerden. Gültige Zeichen sind a-z, A-z, 0-9, _ (Unterstrich), @ (kaufmännisches Und-Zeichen) und -(Bindestrich).

9. Klicken Sie auf Connect (Verbinden) um eine Verbindung von Athena mit der Datenquelle herzustellen.

Auf der Seite Data sources (Datenquellen) wird der Konnektor in der Liste der Katalognamenangezeigt. Sie können nun den Catalog name (Katalognamen) verwenden, den Sie angegebenhaben, um auf den Hive-Metastore in Ihren SQL-Abfragen zu verweisen. Verwenden Sie die Syntax imfolgenden Beispiel, wobei MyHiveMetastore der Katalogname ist, den Sie zuvor angegeben haben.

SELECT * FROM MyHiveMetastore.CustomerData.customers;

Die Verwendung vonWenn Daten in anderen Quellen als Amazon S3 vorliegen, können Sie verwenden, um die Daten direktin diesen Quellen abzufragen oder um Pipelines zu erstellen, die Daten aus mehreren Datenquellenextrahieren und in Amazon S3 speichern. ermöglicht Ihnen die Ausführung von SQL-Abfragen für Daten,die in relationalen, nicht relationalen, benutzerdefinierten und Objektdatenquellen gespeichert sind.

Athena verwendet zum Ausführen von Verbundabfragen Datenquellenkonnektoren, die in AWS Lambdaausgeführt werden. Ein Datenquellenkonnektor ist ein Codestück, das zwischen der Zieldatenquelle undAthena übersetzen kann. Sie können sich einen Konnektor als eine Erweiterung der Abfrage-Enginevon Athena vorstellen. Es gibt vorab entwickelte Athena-Datenquellenkonnektoren für Datenquellen wieAmazon CloudWatch-Protokolle, Amazon DynamoDB, Amazon DocumentDB, Amazon RDS, JDBC-kompatible relationale Datenquellen wie MySQL sowie PostgreSQL unter der Apache 2.0-Lizenz. Sie

66

Amazon Athena BenutzerhandbuchÜberlegungen und Einschränkungen

können auch den verwenden, um Konnektoren zu schreiben. Um einen Datenquellenkonnektor fürIhr Konto auszuwählen, zu konfigurieren und bereitzustellen, können Sie die Athena- und Lambda-Konsole oder AWS Serverless Application Repository verwenden. Nach der Bereitstellung wird derDatenquellenkonnektor einem Katalog zugeordnet, den Sie in SQL-Abfragen angeben können. Sie könnenSQL-Anweisungen aus mehreren Katalogen kombinieren und mehrere Datenquellen mit einer einzigenAbfrage abfragen.

Wenn für eine Datenquelle eine Abfrage ausgeführt wird, ruft Athena den entsprechenden Konnektorauf, um die Teile der Tabellen zu identifizieren, die gelesen werden müssen, verwaltet die Parallelitätund schiebt Filterprädikate nach unten. Basierend auf dem Benutzer, der die Abfrage übermittelt, könnenKonnektoren den Zugriff auf bestimmte Datenelemente zulassen oder einschränken. Konnektorenverwenden Apache Arrow als Format für die von einer Abfrage angeforderten zurückgegebenen Daten.Dies ermöglicht die Implementierung von Konnektoren in Sprachen wie C, C++, Java, Python und Rust.Da Konnektoren in Lambda ausgeführt werden, können sie für den Zugriff auf Daten aus beliebigen Cloud-oder On-Premise-Datenquellen verwendet werden, auf die Lambda zugreifen kann.

Um einen eigenen Datenquellenkonnektor zu schreiben, können Sie mittels des einen der vorabentwickelten Konnektoren anpassen, die Amazon Athena bereitstellt und verwaltet. Sie können eine Kopiedes Quellcodes aus dem GitHub-Repository kopieren und anschließend das Connector Publish Toolverwenden, um ein eigenes AWS Serverless Application Repository-Paket zu erstellen.

Die Liste der verfügbaren Athena-Datenquellenkonnektoren finden Sie unter Verwenden von Athena-Datenquellenkonnektoren (p. 69).

Informationen zum Schreiben eines eigenen Datenquellenkonnektors finden Sie unter Athena-Beispielkonnektor auf GitHub.

Überlegungen und EinschränkungenDatenquellenkonnektoren benötigen möglicherweise Zugriff auf die folgenden Ressourcen, umordnungsgemäß zu funktionieren. Wenn Sie einen vorab erstellten Konnektor verwenden, müssen Siedie Informationen für den Konnektor prüfen, um sicherzustellen, dass Ihre VPC korrekt konfiguriert ist. Siemüssen außerdem sicherstellen, dass IAM-Prinzipale, die Abfragen ausführen und Konnektoren erstellen,die nötigen Berechtigungen für die erforderlichen Aktionen besitzen. Weitere Informationen finden Sie unterBeispiel für IAM-Berechtigungsrichtlinien, die zulassen (p. 232).

• Aktuelle Informationen zu bekannten Problemen und Einschränkungen finden Sie unter Einschränkungenund Probleme im GitHub-Repository aws-athena-query-federation.

• AmazonAthenaPreviewFunctionality-Arbeitsgruppe –• Amazon S3 – Zusätzlich zum Schreiben von Abfrageergebnissen zum Athena-Speicherort für

Abfrageergebnisse in Amazon S3 schreiben Datenkonnektoren auch einen Spill-Bucket in Amazon S3.Für diesen Amazon S3-Speicherort sind entsprechende Verbindungen und Berechtigungen erforderlich.

• Athena – Datenquellen benötigen Konnektivität mit Athena und umgekehrt, um den Abfragestatus zuprüfen und ein übermäßiges Scannen zu verhindern.

• AWS Glue-Datenkatalog – Es sind Verbindungen und Berechtigungen erforderlich, wenn Ihr KonnektorData Catalog für ergänzende oder primäre Metadaten verwendet.

Bereitstellen von Konnektoren und Herstellen vonVerbindungen mit DatenquellenDie Vorbereitung der Erstellung von Verbundabfragen stellt einen zweiteiligen Prozess dar: Bereitstellungeines Lambda-Funktions-Datenquellenkonnektors und Verbindung der Lambda-Funktion mit einerDatenquelle. Im ersten Teil geben Sie der Lambda-Funktion einen Namen, den Sie später in der Athena-Konsole auswählen können. Im zweiten Teil geben Sie dem Konnektor einen Namen, auf den Sie in IhrenSQL-Abfragen verweisen können.

67

https://github.com/awslabs/aws-athena-query-federation/wiki/Available-Connectors

https://github.com/awslabs/aws-athena-query-federation/wiki/Connector_Publish_Tool

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-example


https://github.com/awslabs/aws-athena-query-federation/wiki/Limitations_And_Issues


Amazon Athena BenutzerhandbuchBereitstellen von Konnektoren und Herstellen

von Verbindungen mit Datenquellen

Teil 1: Bereitstellen von DatenquellenkonnektorenUm einen Datenquellenkonnektor auszuwählen, zu benennen und bereitzustellen, verwenden Sie dieAthena- und Lambda-Konsolen in einem integrierten Prozess.

Note

So stellen Sie einen Datenquellenkonnektor bereit

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) die Option Query a data

source (Datenquelle abfragen) aus.4. Wählen Sie in Choose a data source (Datenquelle auswählen) die Datenquelle aus, für die Sie mit

Athena Abfragen ausführen möchten, z. B. Amazon CloudWatch Logs.5. Wählen Sie Next.6. Wählen Sie für Lambda function (Funktion) die Option Configure new function (Neue Funktion

konfigurieren). Anschließend wird die Funktionsseite für den von Ihnen ausgewählten Konnektor in derLambda-Konsole geöffnet. Die Seite enthält detaillierte Informationen zum Konnektor.

7. Geben Sie unter Application settings (Anwendungseinstellungen) die erforderlichen Informationen ein.Dazu gehören mindestens:

• AthenaCatalogName – Ein Name für die Lambda-Funktion, der die Datenquelle angibt, auf die siegerichtet ist, etwa cloudwatchlogs.

• SpillBucket – Ein Amazon S3-Bucket in Ihrem Konto zum Speichern von Daten, die die Begrenzungder Antwortgröße der Lambda-Funktion überschreiten.

8. Wählen Sie I acknowledge that this app creates custom IAM roles (Ich bestätige, dass dieseAnwendung benutzerdefinierte IAM-Rollen erstellt). Um weitere Informationen zu erhalten, wählen Sieden Link Info .

9. Wählen Sie Deploy (Bereitstellen) aus. Der Abschnitt Resources (Ressourcen) der Lambda-Konsolezeigt den Bereitstellungsstatus des Konnektors an und informiert Sie, wenn die Bereitstellungabgeschlossen ist.

Teil 2: Herstellen einer Verbindung mit einer DatenquelleNachdem Sie den Datenquellenkonnektor für Ihr Konto bereitgestellt haben, können Sie ihn mit einerDatenquelle verbinden.

So stellen Sie mithilfe eines Konnektors eine Verbindung zu einer Datenquelle her, die Sie für IhrKonto bereitgestellt haben

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie Query a data source (Datenquelle abfragen).4. Wählen Sie die Datenquelle für den Konnektor aus, den Sie gerade bereitgestellt haben, z. B. Amazon

CloudWatch Logs. Wenn Sie den verwendet haben, um einen eigenen Konnektor zu erstellen,und diesen in Ihrem Konto bereitgestellt haben, wählen Sie All other data sources (Alle anderenDatenquellen) aus.

5. Wählen Sie Next.6. Wählen Sie unter Choose Lambda function (Funktion auswählen) die Funktion aus, die Sie benannt

haben. Der ARN der Lambda-Funktion wird angezeigt.

68



Amazon Athena BenutzerhandbuchVerwendung des AWS Serverless Application Repository

7. Geben Sie unter Catalog name (Katalogname) einen eindeutigen Namen ein, der für die Datenquellein Ihren SQL-Abfragen verwendet werden soll, z. B. cloudwatchlogs. Der Name kann bis zu 127Zeichen lang sein und muss innerhalb Ihres Kontos eindeutig sein. Er kann nach der Erstellung nichtmehr geändert werden. Gültige Zeichen sind a-z, A-z, 0-9, _ (Unterstrich), @ (kaufmännisches Und-Zeichen) und - (Bindestrich).

8. Wählen Sie Connect (Verbinden) aus. Auf der Seite Data sources (Datenquellen) wird nun derKonnektor in der Liste der Katalognamen angezeigt. Sie können den Konnektor jetzt in Ihren Abfragenverwenden.

Informationen zum Schreiben von Abfragen mit Datenkonnektoren finden Sie unter Schreiben vonVerbundabfragen (p. 71).

Bereitstellen eines Datenquellenkonnektors mit AWSServerless Application RepositorySie können auch den AWS Serverless Application Repository verwenden, um einen Athena-Datenquellenkonnektor bereitzustellen. Sie suchen den Konnektor, den Sie verwenden möchten, geben dieParameter an, die der Konnektor benötigt, und stellen den Konnektor dann für Ihr Konto bereit.

Note

So verwenden Sie den AWS Serverless Application Repository zum Bereitstellen einesDatenquellenkonnektors für Ihr Konto:

1. Öffnen Sie die Serverless App Repository-Konsole. .2. Wählen Sie die Option Show apps that create custom IAM roles or resource policies (Apps anzeigen,

die benutzerdefinierte Rollen oder Ressourcenrichtlinien erstellen).3. Geben Sie im Suchfeld den Namen des Konnektors ein oder suchen Sie nach Anwendungen, die mit

dem Autorennamen Amazon Athena Federation veröffentlicht wurden. Dieser Autorenname ist fürAnwendungen reserviert, die das Amazon Athena-Team geschrieben, getestet und validiert hat.

4. Wählen Sie den Namen des Konnektors aus. Dadurch wird die Seite Application details(Anwendungsdetails) der Lambda-Funktion in der AWS Lambda-Konsole geöffnet.

5. Geben Sie auf der rechten Seite der Detailseite für SpillBucket einen Amazon S3-Bucket an, um Datenvon großen Antwort-Nutzlasten zu empfangen. Informationen zu den verbleibenden konfigurierbarenOptionen finden Sie im entsprechenden Thema Verfügbare Konnektoren auf GitHub.

6. Wählen Sie unten rechts auf der Seite „ Application details (Anwendungsdetails) die Option Deploy(Bereitstellen).

Verwenden von Athena-DatenquellenkonnektorenIn diesem Abschnitt werden vorab erstellte Athena-Datenquellenkonnektoren aufgeführt, mit denen Siezahlreiche Datenquellen außerhalb von Amazon S3 abfragen können. Um einen Konnektor in IhrenAthena-Abfragen zu verwenden, konfigurieren Sie ihn und stellen ihn in Ihrem Konto bereit.

Note

Weitere Informationen finden Sie im folgenden Thema:

• Hinweise zum Bereitstellen eines Athena-Datenquellenkonnektors finden Sie unter Bereitstellen vonKonnektoren und Herstellen von Verbindungen mit Datenquellen (p. 67).

• Hinweise zum Schreiben von Abfragen, die Athena-Datenquellenkonnektoren verwenden, finden Sieunter Schreiben von Verbundabfragen (p. 71).

69

https://aws.amazon.com/serverless/serverlessrepo/


Amazon Athena BenutzerhandbuchAthena-Datenquellenkonnektoren

• Ausführliche Informationen zu den Athena-Datenquellenkonnektoren finden Sie unter VerfügbareKonnektoren auf GitHub.

Themen• Athena AWS CMDB-Konnektor (p. 70)• Amazon Athena CloudWatch-Konnektor (p. 70)• Amazon Athena CloudWatch Metrics-Konnektor (p. 70)• Amazon Athena DocumentDB-Konnektor (p. 70)• Amazon Athena DynamoDB-Konnektor (p. 71)• Amazon Athena HBase-Konnektor (p. 71)• Amazon Athena-Konnektor für JDBC-kompatible Datenquellen (p. 71)• Amazon Athena Redis-Konnektor (p. 71)• Amazon Athena TPC-Benchmark DS (TPC-DS)-Konnektor (p. 71)

Athena AWS CMDB-KonnektorDer Amazon Athena AWS CMDB-Konnektor ermöglicht Amazon Athena die Kommunikation mitverschiedenen AWS-Services, sodass Sie diese mit SQL abfragen können.

Informationen zu unterstützten Services, Parametern, Berechtigungen, Bereitstellung, Leistung undLizenzierung finden Sie unter Amazon Athena AWS CMDB Connector auf GitHub.

Amazon Athena CloudWatch-KonnektorDer Amazon Athena CloudWatch-Konnektor ermöglicht Amazon Athena die Kommunikation mitCloudWatch, sodass Sie Ihre Protokolldaten mit SQL abfragen können.

Der Konnektor ordnet Ihre LogGroups als Schemas und jeden LogStream als Tabelle zu. Der Konnektorordnet auch eine spezielle all_log_streams-Ansicht zu, die alle LogStreams in der LogGroup enthält.Diese Ansicht ermöglicht es Ihnen, alle Protokolle in einer LogGroup gleichzeitig abzufragen, anstatt jedenLogStream einzeln zu durchsuchen.

Weitere Informationen zu Konfigurationsoptionen, Ablehnungssteuerung, Tabellenzuweisungsschema,Berechtigungen, Bereitstellung, Leistungsüberlegungen und Lizenzierung finden Sie unter Amazon AthenaCloudWatch Connector auf GitHub.

Amazon Athena CloudWatch Metrics-KonnektorDer Amazon Athena CloudWatch Metrics-Konnektor ermöglicht Amazon Athena die Kommunikation mitCloudWatch-Metriken, sodass Sie Ihre Metrikdaten mit SQL abfragen können.

Informationen zu Konfigurationsoptionen, Tabellenzuweisung, Berechtigungen, Bereitstellung,Leistungsüberlegungen und Lizenzierung finden Sie unter Amazon Athena Cloudwatch Metrics Connectorauf GitHub.

Amazon Athena DocumentDB-KonnektorDer Amazon Athena Amazon DocumentDB-Konnektor ermöglicht Amazon Athena die Kommunikation mitIhren Amazon DocumentDB-Instances, sodass Sie Ihre Amazon DocumentDB-Daten mit SQL abfragenkönnen. Der Konnektor funktioniert auch mit jedem Endpunkt, der mit MongoDB kompatibel ist.

Informationen dazu, wie der Konnektor Schemas generiert, sowie zu Konfigurationsoptionen,Berechtigungen, Bereitstellung und Leistung finden Sie unter Amazon Athena DocumentDB Connector aufGitHub.

70



https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-aws-cmdb

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch


https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch-metrics#amazon-athena-cloudwatch-metrics-connector

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-docdb

Amazon Athena BenutzerhandbuchSchreiben von Verbundabfragen

Amazon Athena DynamoDB-KonnektorDer Amazon Athena DynamoDB-Konnektor ermöglicht Amazon Athena die Kommunikation mit DynamoDB,sodass Sie Ihre Tabellen mit SQL abfragen können.

Informationen zu Konfigurationsoptionen, Berechtigungen, Bereitstellung und Leistung finden Sie unterAmazon Athena DynamoDB Connector auf GitHub.

Amazon Athena HBase-KonnektorDer Amazon Athena HBase-Konnektor ermöglicht Amazon Athena die Kommunikation mit Ihren HBase-Instances, sodass Sie Ihre HBase-Daten mit SQL abfragen können.

Informationen zu Konfigurationsoptionen, Datentypen, Berechtigungen, Bereitstellung, Leistung undLizenzierung finden Sie unter Amazon Athena HBase Connector auf GitHub.

Amazon Athena-Konnektor für JDBC-kompatible DatenquellenDer Amazon Athena Lambda-JDBC-Konnektor ermöglicht Amazon Athena den Zugriff auf Ihre JDBC-kompatible Datenbank. Derzeit unterstützte Datenbanken sind u.a. MySQL, PostgreSQL und AmazonRedshift.

Informationen zu unterstützten Datenbanken, Konfigurationsparametern, unterstützten Datentypen, JDBC-Treiberversionen, Einschränkungen und anderen Informationen finden Sie unter Amazon Athena LambdaJDBC Connector auf GitHub.

Amazon Athena Redis-KonnektorDer Amazon Athena Redis-Konnektor ermöglicht Amazon Athena die Kommunikation mit Ihren Redis-Instances, sodass Sie Ihre Redis-Daten mit SQL abfragen können. Sie können die AWS Glue-Datenkatalogverwenden, um Ihre Redis-Schlüssel-Wert-Paare virtuellen Tabellen zuzuordnen.

Informationen zu Konfigurationsoptionen, zum Einrichten von Datenbanken und Tabellen, Datentypen,Berechtigungen, Bereitstellung, Leistung und Lizenzierung finden Sie unter Amazon Athena RedisConnector auf GitHub.

Amazon Athena TPC-Benchmark DS (TPC-DS)-KonnektorDer Amazon Athena TPC-DS-Konnektor ermöglicht Amazon Athena die Kommunikation mit einer Quellezufällig erzeugter TPC-Benchmark-DS-Daten für Benchmarking und Funktionstests. Der Athena TPC-DS-Konnektor generiert eine TPC-DS-konforme Datenbank mit einem von vier Skalierungsfaktoren.

Informationen zu Konfigurationsoptionen, Datenbanken und Tabellen, Berechtigungen, Bereitstellung,Leistung und Lizenzierung finden Sie unter Amazon Athena TPC-DS Connector auf GitHub.

Schreiben von VerbundabfragenWenn Sie einen oder mehrere Datenkonnektoren konfiguriert und in Ihrem Konto bereitgestellt haben,können Sie diese in Ihren Athena-Abfragen verwenden.

Abfragen einer einzelnen DatenquelleIn den Beispielen in diesem Abschnitt wird davon ausgegangen, dass Sie den Athena CloudWatch-Konnektor für Ihr Konto konfiguriert und bereitgestellt haben. Sie verwenden den gleichen Ansatz fürAbfragen für andere Konnektoren.

71

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-dynamodb

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-hbase

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-jdbc


https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-redis


https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-tpcds


So erstellen Sie eine Athena-Abfrage, die den CloudWatch-Konnektor verwendet

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Erstellen Sie im Athena-Abfrage-Editor eine SQL-Abfrage mit der folgenden Syntax in der FROM-

Klausel.

MyCloudwatchCatalog.database_name.table_name

BeispieleIm folgenden Beispiel wird der Athena CloudWatch-Konnektor verwendet, um eine Verbindung mit derAnsicht all_log_streams in der /var/ecommerce-engine/order-processor CloudWatch LogsProtokollgruppe herzustellen. Die Ansicht all_log_streams ist eine Ansicht aller Protokollstreams in derProtokollgruppe. Die Beispielabfrage begrenzt die Anzahl der zurückgegebenen Zeilen auf 100.

Example

SELECT * FROM "MyCloudwatchCatalog"."/var/ecommerce-engine/order-processor".all_log_streams limit 100;

Im folgenden Beispiel werden Informationen aus derselben Ansicht wie im vorherigen Beispiel analysiert.Im Beispiel werden die Bestellnummer und die Protokollebene extrahiert und alle Nachrichten mit derEbene INFO herausgefiltert.

Example

SELECT log_stream as ec2_instance, Regexp_extract(message '.*orderId=(\d+) .*', 1) AS orderId, message AS order_processor_log, Regexp_extract(message, '(.*):.*', 1) AS log_level FROM "MyCloudwatchCatalog"."/var/ecommerce-engine/order-processor".all_log_streams WHERE Regexp_extract(message, '(.*):.*', 1) != 'INFO'

Die folgende Abbildung zeigt ein Beispielergebnis.Note

Dieses Beispiel zeigt eine Abfrage, in der die Datenquelle bei Athena als Katalog registriertwurde. Sie können auf die Lambda-Funktion eines Datenquellenkonnektors auch im Formatlambda:MyLambdaFunctionName. verweisen.

Abfragen mehrerer DatenquellenUm ein komplexeres Beispiel zu zeigen, stellen Sie sich ein E-Commerce-Unternehmen vor, das eineAnwendungsinfrastruktur wie die im folgenden Diagramm gezeigte besitzt.

72


https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html


Die folgenden Beschreibungen erklären die nummerierten Elemente im Diagramm.

1. Zahlungsabwicklung in einer sicheren VPC mit Transaktionsdatensätzen, die in HBase auf Amazon EMRgespeichert sind

2. Redis zum Speichern aktiver Bestellungen, damit die Verarbeitungs-Engine schnell auf sie zugreifenkann

3. Amazon DocumentDB für Kundenkontodaten wie E-Mail- und Versandadressen4. Ein Produktkatalog in Amazon Aurora für eine E-Commerce-Website, die automatische Skalierung auf

Fargate verwendet5. CloudWatch Logs zum Speichern der Protokollereignisse des Bestellverarbeiters6. Ein Data Warehouse des Typs „Write-Once-Read-Many“ auf Amazon RDS7. DynamoDB zum Speichern von Sendungsverfolgungsdaten

Angenommen, ein Datenanalyst für diese E-Commerce-Anwendung stellt fest, dass der Zustand einigerBestellungen falsch gemeldet wird. Einige Bestellungen werden als ausstehend angezeigt, obwohl siezugestellt wurden. Andere Bestellungen werden als zugestellt angezeigt, obwohl sie nicht versendetwurden.

Der Analyst möchte wissen, wie viele Bestellungen verzögert werden und was den betroffenenBestellungen in der E-Commerce-Infrastruktur gemeinsam ist. Anstatt die Informationsquellen getrenntzu untersuchen, verbindet der Analyst die Datenquellen und ruft die notwendigen Informationen mit einereinzigen Abfrage ab. Die Daten müssen nicht zu einem einzelnen Speicherort extrahiert werden.

Die Abfrage des Analysten verwendet die folgenden Athena-Datenkonnektoren:

• CloudWatch Logs – Ruft Protokolle aus dem Bestellverarbeitungsservice ab und verwendet Regex-Abgleich und -Extraktion, um nach Bestellungen mit WARN- oder ERROR-Ereignissen zu filtern.

73



• Redis – Ruft die aktiven Bestellungen aus der Redis-Instance ab.• CMDB – Ruft die ID und den Status der Amazon EC2-Instance ab, die den Bestellverarbeitungsservice

ausgeführt und die ERROR-oder WARN-Meldung protokolliert hat.• DocumentDB – Ruft E-Mail und Adresse des Kunden für die betroffenen Bestellungen aus Amazon

DocumentDB ab.• DynamoDB – Ruft den Versandstatus und die Nachverfolgungsdetails aus der Versandtabelle ab, um

mögliche Abweichungen zwischen gemeldetem und tatsächlichem Status zu identifizieren.• HBase – Ruft den Zahlungsstatus für die betroffenen Bestellungen aus dem

Zahlungsverarbeitungsservice ab.

ExampleNote

Dieses Beispiel zeigt eine Abfrage, in der die Datenquelle bei Athena als Katalog registriertwurde. Sie können auf die Lambda-Funktion eines Datenquellenkonnektors auch im Formatlambda:MyLambdaFunctionName. verweisen.

--Sample query using multiple Athena data connectors.WITH logs AS (SELECT log_stream, message AS order_processor_log, Regexp_extract(message, '.*orderId=(\d+) .*', 1) AS orderId, Regexp_extract(message, '(.*):.*', 1) AS log_level FROM "MyCloudwatchCatalog"."/var/ecommerce-engine/order-processor".all_log_streams WHERE Regexp_extract(message, '(.*):.*', 1) != 'INFO'), active_orders AS (SELECT * FROM redis.redis_db.redis_customer_orders), order_processors AS (SELECT instanceid, publicipaddress, state.NAME FROM awscmdb.ec2.ec2_instances), customer AS (SELECT id, email FROM docdb.customers.customer_info), addresses AS (SELECT id, is_residential, address.street AS street FROM docdb.customers.customer_addresses), shipments AS ( SELECT order_id, shipment_id, from_unixtime(cast(shipped_date as double)) as shipment_time, carrier FROM lambda_ddb.default.order_shipments), payments AS ( SELECT "summary:order_id", "summary:status", "summary:cc_id", "details:network" FROM "hbase".hbase_payments.transactions) SELECT _key_ AS redis_order_id, customer_id, customer.email AS cust_email, "summary:cc_id" AS credit_card,

74






Amazon Athena BenutzerhandbuchSchreiben eines Datenquellenkonnektors

"details:network" AS CC_type, "summary:status" AS payment_status, status AS redis_status, addresses.street AS street_address, shipments.shipment_time as shipment_time, shipments.carrier as shipment_carrier, publicipaddress AS ec2_order_processor, NAME AS ec2_state, log_level, order_processor_log FROM active_orders LEFT JOIN logs ON logs.orderid = active_orders._key_ LEFT JOIN order_processors ON logs.log_stream = order_processors.instanceid LEFT JOIN customer ON customer.id = customer_id LEFT JOIN addresses ON addresses.id = address_id LEFT JOIN shipments ON shipments.order_id = active_orders._key_ LEFT JOIN payments ON payments."summary:order_id" = active_orders._key_

Die folgende Abbildung zeigt Beispielergebnisse für die Abfrage.

Schreiben eines Datenquellenkonnektors mithilfe desUm eigene Datenquellenkonnektoren (p. 66) zu schreiben, können Sie den https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk verwenden. Der definiert einenSatz von Schnittstellen und Wire-Protokollen, mit denen Sie Athena ermöglichen können, Teile desAbfrageausführungsplans an Code zu delegieren, den Sie schreiben und bereitstellen. Das SDK enthälteine Konnektor-Suite und einen Beispielkonnektor.

Sie können die von Amazon Athena vorab erstellten Konnektoren für Ihren eigenen Gebrauch anpassen.Sie können eine Kopie des Quellcodes aus GitHub ändern und dann das Connector Publish Toolverwenden, um ein eigenes AWS Serverless Application Repository-Paket zu erstellen. Nachdem Sie denKonnektor auf diese Weise bereitgestellt haben, können Sie ihn in Ihren Athena-Abfragen verwenden.

Note

Informationen zum Herunterladen des SDK und detaillierte Anweisungen zum Schreiben eines eigenenKonnektors finden Sie unter Athena-Beispielkonnektor auf GitHub.

Verwalten von DatenquellenSie können die Seite Data sources (Datenquellen) der Athena-Konsole verwenden, um die vonIhnen erstellten Datenquellen anzuzeigen, zu bearbeiten oder zu löschen, einschließlich des Athena-Datenquellenkonnektors, AWS Glue-Datenkatalog, und Hive Metastore-Katalogtypen.

75

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk





Amazon Athena BenutzerhandbuchHerstellen einer Verbindung zu AmazonAthena mit ODBC- und JDBC-Treibern

So zeigen Sie eine Datenquelle an:

• Wählen Sie den Katalognamen der Datenquelle, oder klicken Sie auf die Schaltfläche daneben, undwählen Sie View details (Details anzeigen). Die Detailseite enthält die Optionen Edit (Bearbeiten) undDelete (Löschen) der Datenquelle.

So bearbeiten Sie eine Datenquelle:

1. Wählen Sie den Katalognamen der Datenquelle, oder klicken Sie auf die Schaltfläche neben demKatalognamen.

2. Wählen Sie Edit aus.3. Auf der Seite Edit (Bearbeiten) für den Metastore können Sie eine andere Lambda-Funktion für

die Datenquelle auswählen oder die Beschreibung der vorhandenen Funktion ändern. Wenn Sieeinen AWS Glue-Katalog bearbeiten, öffnet die AWS Glue-Konsole den entsprechenden Katalog zurBearbeitung.

4. Wählen Sie Save (Speichern) aus.

So löschen Sie eine Datenquelle:

1. Wählen Sie die Schaltfläche neben der Datenquelle oder dem Namen der Datenquelle, und wählenSie dann Delete (Löschen). Sie werden gewarnt, dass beim Löschen einer Metastore-Datenquelleder entsprechende Datenkatalog, Tabellen und Ansichten aus dem Abfrage-Editor entfernt werden.Gespeicherte Abfragen, die den Metastore verwendet haben, werden nicht mehr in Athena ausgeführt.

2. Wählen Sie Delete (Löschen).

Herstellen einer Verbindung zu Amazon Athena mitODBC- und JDBC-Treibern

Wenn Sie Ihre Daten mit Business-Intelligence-Tools durchsuchen und darstellen möchten, müssenSie einen ODBC (Open Database Connectivity)- oder JDBC (Java Database Connectivity)-Treiberherunterladen, installieren und konfigurieren.

Themen• Verwenden von Athena mit dem JDBC-Treiber (p. 76)• Verbindung zu Amazon Athena mit ODBC (p. 78)

Verwenden von Athena mit dem JDBC-TreiberSie können eine JDBC-Verbindung verwenden, um Athena mit Business-Intelligence-Tools und anderenAnwendungen wie SQL Workbench zu verbinden. Hierfür müssen Sie den Athena-JDBC-Treiber über diefolgenden Links in Amazon S3 herunterladen, installieren und konfigurieren.

Links zum Herunterladen des JDBC-TreibersDie JDBC-Treiberversion 2.0.9 ist mit den Datenstandards JDBC API 4.1 und 4.2 kompatibel. Bevor Sieden Treiber herunterladen, überprüfen Sie, welche Version der Java Runtime Environment (JRE) Sieverwenden. Die JRE-Version hängt von der Version der JDBC-API ab, die Sie mit dem Treiber einsetzen.Wenn Sie sich nicht sicher sind, laden Sie die neueste Version des Treibers herunter.

Laden Sie den Treiber für Ihre JDK-Version und Ihre Version der JDBC-Datenstandards herunter:

76

http://www.sql-workbench.eu/downloads.html

Amazon Athena BenutzerhandbuchVerwenden von Athena mit dem JDBC-Treiber

• AthenaJDBC41-2.0.9.jar ist mit JDBC 4.1 kompatibel und erfordert JDK 7.0 oder höher.• AthenaJDBC42-2.0.9.jar ist mit JDBC 4.2 kompatibel und erfordert JDK 8.0 oder höher.

JDBC-Treiber – Versionshinweise, Lizenzvereinbarung und Anmerkungen

Nachdem Sie die benötigte Version heruntergeladen haben, lesen Sie die Versionshinweise undüberprüfen Sie die Lizenzvereinbarung und Anmerkungen.

• Versionshinweise• Lizenzvereinbarung• Hinweise• Drittanbieterlizenzen

Dokumentation zum JDBC-Treiber

Laden Sie die folgende Dokumentation für den Treiber herunter:

• Installations- und Konfigurationshandbuch für JDBC-Treiber. Verwenden Sie dieses Handbuch für dieInstallation und Konfiguration des Treibers.

• Migrationsleitfaden für den JDBC-Treiber. Verwenden Sie dieses Handbuch für die Migration vonfrüheren Versionen auf die aktuelle Version.

Links zum Herunterladen des JDBC-Treibers fürVorversionsfunktionenDiese Treiber unterstützen Athena-Vorversionsfunktionen. Laden Sie den Treiber für Ihre JDK-Version undIhre Version der JDBC-Datenstandards herunter:

• The AthenaJDBC41_preview.jar ist mit JDBC 4.1 kompatibel und erfordert JDK 7.0 oder neuer.• Der AthenaJDBC42_preview.jar ist mit JDBC 4.2 kompatibel und erfordert JDK 8.0 oder neuer.

JDBC-Treiber-Versionshinweise, Lizenzvereinbarung und Hinweise fürVorversionstreiber

Nachdem Sie die benötigte Version heruntergeladen haben, lesen Sie die Versionshinweise undüberprüfen Sie die Lizenzvereinbarung und Anmerkungen.

• Versionshinweise• Lizenzvereinbarung• Hinweise• Drittanbieterlizenzen

JDBC-Treiberdokumentation für Vorversionstreiber


• Installations- und Konfigurationshandbuch für JDBC-Treiber. Verwenden Sie dieses Handbuch für dieInstallation und Konfiguration des Treibers.

• Migrationsleitfaden für den JDBC-Treiber. Verwenden Sie dieses Handbuch für die Migration vonfrüheren Versionen auf die aktuelle Version.

77

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/SimbaAthenaJDBC_2.0.9/AthenaJDBC41_2.0.9.jar

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.9/AthenaJDBC42_2.0.9.jar


https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.9/docs/LICENSE.txt

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.9/docs/NOTICES.txt

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.9/docs/third-party-licenses.txt



https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/AthenaJDBC41_preview.jar


https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/release-notes.txt

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/LICENSE.txt

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/NOTICES.txt

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/third-party-licenses.txt

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/Simba+Athena+JDBC+Driver+Install+and+Configuration+Guide.pdf

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/Simba+Athena+JDBC+Driver+Migration+Guide.pdf

Amazon Athena BenutzerhandbuchVerbindung zu Amazon Athena mit ODBC

Migrieren von der vorherigen Version des JDBC-TreibersBei der aktuellen JDBC-Treiberversion 2.0.9 handelt es sich um einen Drop-In-Ersatz für die vorherigeJDBC-Treiberversion 2.0.8. Sie ist abwärtskompatibel mit der JDBC-Treiberversion 2.0.8, wobei Sie denfolgenden Schritt ausführen müssen, damit der Treiber sicher funktioniert.

Important

Um die JDBC-Treiberversion 2.0.5 oder höher zu verwenden, fügen Sie eineBerechtigungsrichtlinie an IAM-Prinzipale an, die den JDBC-Treiber verwenden, der dieathena:GetQueryResultsStream-Richtlinienaktion zulässt. Diese Richtlinienaktion wird nichtdirekt mit der API bereitgestellt. Sie wird nur mit dem JDBC-Treiber als Teil der Unterstützung vonStreaming-Ergebnissen verwendet. Eine Beispielrichtlinie finden Sie unter Verwaltete RichtlinieAWSQuicksightAthenaAccess (p. 220). Stellen Sie außerdem sicher, dass Port (444) für denausgehenden Datenverkehr geöffnet ist. Weitere Informationen zum Upgrade von Version 2.0.2auf Version 2.0.5 oder höher finden Sie im Migrationsleitfaden für den JDBC-Treiber.

Informationen zu den vorherigen Versionen des JDBC-Treibers finden Sie unter Verwenden der vorherigenVersion des JDBC-Treibers (p. 352).

Wenn Sie von einem 1.x-Treiber zu einem 2.x Treiber migrieren, müssen Sie Ihre bestehendenKonfigurationen zur neuen Konfiguration migrieren. Es wird dringend empfohlen, zur Treiberversion 2.x zumigrieren. Weitere Informationen finden Sie im Migrationsleitfaden für den JDBC-Treiber.

Verbindung zu Amazon Athena mit ODBCLaden Sie den ODBC-Treiber, die Amazon Athena-ODBC-Treiberlizenzvereinbarung und dieDokumentation für den Treiber über die folgenden Links herunter.

Amazon Athena-ODBC-TreiberlizenzvereinbarungLizenzvereinbarung

Windows

Treiberversion Download-Link

ODBC 1.0.5 für Windows 32-Bit Windows 32-Bit ODBC-Treiber 1.0.5


Linux


ODBC 1.0.5 für Linux 32-Bit Linux 32-Bit ODBC-Treiber 1.0.5


OSX


ODBC 1.0.5 für OSX OSX ODBC-Treiber 1.0.5

78



https://s3.amazonaws.com/athena-downloads/agreement/ODBC/Amazon+Athena+ODBC+Driver+License+Agreement.pdf

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/SimbaAthenaODBC_1.0.5/Windows/Simba+Athena+1.0+32-bit.msi


https://s3.amazonaws.com/athena-downloads/drivers/ODBC/SimbaAthenaODBC_1.0.5/Linux/simbaathena-1.0.5.1006-1.i686.rpm

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/SimbaAthenaODBC_1.0.5/Linux/simbaathena-1.0.5.1006-1.x86_64.rpm

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/SimbaAthenaODBC_1.0.5/OSX/Simba+Athena+1.0.dmg


Dokumentation zum ODBC-Treiber


Dokumentation für ODBC 1.0.5 Installations- und Konfigurationshandbuch fürODBC-Treiber Version 1.0.5.

Versionshinweise für ODBC 1.0.5 ODBC-Treiberversionshinweise für Version 1.0.5

Migrieren von der vorherigen Version des ODBC-TreibersDie aktuelle ODBC-Treiberversion 1.0.5 ist ein Drop-In-Ersatz für die vorherige Version der ODBC-Treiberversion 1.0.4. Sie ist darüber hinaus mit der ODBC-Treiberversion 1.0.3 abwärtskompatibel, wennSie die folgenden erforderlichen Schritte ausführen, um sicherzustellen, dass der Treiber funktioniert.

Important

Um den ODBC-Treiber in Version 1.0.3 und höher verwenden zu können, müssen Sie diefolgenden Anforderungen erfüllen:

• Behalten Sie den Port 444 für ausgehenden Datenverkehr offen.• Fügen Sie die Richtlinienaktion athena:GetQueryResultsStream zur Liste der Richtlinien

für Athena hinzu. Diese Richtlinienaktion wird nicht direkt mit der API-Operation verfügbargemacht und ausschließlich mit den ODBC- und JDBC-Treibern als Teil der Unterstützung fürdas Streamen von Ergebnissen verwendet. Eine Beispielrichtlinie finden Sie unter VerwalteteRichtlinie AWSQuicksightAthenaAccess (p. 220).

Vorherige Versionen des ODBC-Treibers

Treiberversion 1.0.4 Download-Link












79

















ODBC 1.0.3 für OSX OSX ODBC-Treiber 1.0







ODBC 1.0 für OSX OSX ODBC-Treiber 1.0


80




https://s3.amazonaws.com/athena-downloads/drivers/ODBC/Windows/Simba+Athena+1.0+32-bit.msi


https://s3.amazonaws.com/athena-downloads/drivers/ODBC/Linux/simbaathena-1.0.2.1003-1.i686.rpm

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/Linux/simbaathena-1.0.2.1003-1.x86_64.rpm

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/OSX/Simba+Athena+1.0.dmg

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/Simba+Athena+ODBC+Install+and+Configuration+Guide.pdf


Amazon Athena BenutzerhandbuchIntegration mit AWS Glue

Ausführen von SQL-Abfragen mitAmazon Athena

Sie können SQL-Abfragen mithilfe von Amazon Athena auf Datenquellen ausführen, die bei AWS Glue-Datenkatalog registriert sind, sowie auf Datenquellen, mit denen Sie mithilfe von Athena Query Federation(Vorversion) eine Verbindung herstellen, z. B. Hive-Metastores und Amazon DocumentDB-Instances.Weitere Hinweise zum Arbeiten mit Datenquellen finden Sie unter

Sie können mittels Amazon Athena Daten abfragen, die in einem Datensatz an verschiedenenSpeicherorten und in verschiedenen Formaten gespeichert sind. Dieser Datensatz kann imCSV-, JSON-, Avro-, Parquet- oder anderen Formaten vorliegen.

Die Tabellen und Datenbanken, die Sie in Athena zum Ausführen von Abfragen verwenden,basieren auf Metadaten. Metadaten sind Daten zu den Daten im Datensatz. Die Form, in derdiese Metadaten den Datensatz beschreiben, wird Schema genannt. Beispielsweise stellen einTabellenname, die Namen der Spalten der Tabelle und die Datentypen der einzelnen Spaltenals Metadaten gespeicherte Schemas dar, die den zugrunde liegende Datensatz beschreiben.In Athena wird das System zum Organisieren von Metadaten als Datenkatalog oder Metastorebezeichnet. Die Kombination aus Datensatz und dem Datenkatalog, der diesen Datensatzbeschreibt, wird als Datenquelle bezeichnet.

Die Art der Beziehung zwischen den Metadaten und dem zugrunde liegenden Datensatz istvom Typ der Datenquelle abhängig, mit der Sie arbeiten. Relationale Datenquellen wie MySQL,PostgreSQL und SQL Server integrieren Metadaten eng mit dem Datensatz. Sehr häufigwerden in diesen Systemen die Metadaten geschrieben, wenn die Daten geschrieben werden.Andere Datenquellen, beispielsweise mit Hive erstellte Datenquellen, ermöglichen Ihnen dasDefinieren von Metadaten, während der Datensatz gelesen wird. Der Datensatz kann in einerVielzahl von Formaten vorliegen, zum Beispiel CSV, JSON, Parquet oder Avro.

Athena unterstützt den AWS Glue-Datenkatalog nativ. Der AWS Glue-Datenkatalog ist einDatenkatalog, der auf anderen Datensätzen und Datenquellen wie Amazon S3, AmazonRedshift und Amazon DynamoDB aufbaut. Sie können Athena über Konnektoren mit anderenDatenquellen verbinden.

Themen• Integration mit AWS Glue (p. 48)• Die Verwendung von (p. 65)• Die Verwendung von (p. 66)• Herstellen einer Verbindung zu Amazon Athena mit ODBC- und JDBC-Treibern (p. 76)

Integration mit AWS GlueAWS Glue ist ein vollständig verwalteter Service zum Extrahieren, Transformieren undLaden (ETL), der Ihre Daten kategorisieren, bereinigen, ergänzen und zuverlässig zwischenverschiedenen Datenspeichern verschieben kann. AWS Glue-Crawler leiten automatischDatenbank- und Tabellenschema aus dem Datensatz ab und speichern die zugehörigenMetadaten im AWS Glue-Datenkatalog.

Athena unterstützt nativ das Abfragen von Datensätzen und Datenquellen, die beim AWS Glue-Datenkatalog registriert sind. Wenn Sie in Athena Data Manipulation Language (DML)-Abfragenmit Data Catalog als Quelle ausführen, wird das Data Catalog-Schema verwendet, um ausdem zugrunde liegenden Datensatz Einsichten abzuleiten. Wenn Sie Data Definition Language

81

https://hive.apache.org




(DDL)-Abfragen ausführen, wird das von Ihnen definierte Schema in AWS Glue-Datenkatalogdefiniert. Sie können aus Athena heraus auch einen AWS Glue-Crawler für eine Datenquelleausführen, um im AWS Glue-Datenkatalog ein Schema zu erstellen.

In Regionen mit AWS Glue-Unterstützung verwendet Athena den AWS Glue-Datenkatalog alszentralen Speicherort, um Tabellenmetadaten für ein AWS-Konto zu speichern und abzurufen.Die Ausführungs-Engine von Athena zieht aus den Tabellenmetadaten die Anweisungen, wound wie die Daten gelesen werden sollen, sowie weitere Informationen, die für die Verarbeitungder Daten erforderlich sind. Der AWS Glue-Datenkatalog stellt ein einheitliches Metadaten-Repository für verschiedene Datenquellen und Datenformate bereit und kann nicht nur inAthena, sondern auch in Amazon S3, Amazon RDS, Amazon Redshift, Amazon RedshiftSpectrum, Amazon EMR sowie alle anderen Anwendungen integriert werden, die mit demApache Hive-Metastore kompatibel sind.

Weitere Informationen zum AWS Glue-Datenkatalog finden Sie unter Füllen des AWS Glue-Datenkatalogs im AWS Glue-Entwicklerhandbuch. Eine Liste der Regionen, in denen AWSGlue verfügbar ist, finden Sie unter Regionen und Endpunkte von AWS in der AllgemeinenAWS-Referenz.

Für AWS Glue gelten separate Gebühren. Weitere Informationen finden Sie unter AWSGlue-Preisberechnung und Fallen für AWS Glue separate Gebühren an? (p. 63) WeitereInformationen zu den Vorteilen einer Nutzung von AWS Glue mit Athena finden Sie unterWarum sollte ich ein Upgrade auf den AWS Glue-Datenkatalog durchführen? (p. 62)

Themen

• Verwenden von AWS Glue zum Herstellen einer Verbindung mit Datenquellen in AmazonS3 (p. 49)

• Bewährte Methoden beim Verwenden von Athena mit AWS Glue (p. 51)• Schrittweises Upgrade auf den AWS Glue-Datenkatalog (p. 60)• Häufig gestellte Fragen: Upgrade auf den AWS Glue-Datenkatalog (p. 62)

Verwenden von AWS Glue zum Herstellen einerVerbindung mit Datenquellen in Amazon S3Athena kann eine Verbindung mit den in Amazon S3 gespeicherten Daten herstellen, um mitAWS Glue-Datenkatalog Metadaten wie Tabellen- und Spaltennamen zu speichern. Nachdem

82








die Verbindung hergestellt wurde, werden Ihre Datenbanken, Tabellen und Ansichten imAthena-Abfrage-Editor angezeigt.

Um Schemainformationen zur Verwendung durch AWS Glue zu definieren, können Sie einenAWS Glue-Crawler einrichten, um die Informationen abzurufen, oder Sie können eine Tabellemanuell hinzufügen und die Schemainformationen eingeben.

Einrichten eines CrawlersSie richten einen Crawler ein, indem Sie in der Athena-Konsole beginnen und dann die AWSGlue-Konsole in integrierter Weise verwenden. Wenn Sie einen Crawler erstellen, können SieDatenspeicher zum Durchsuchen auswählen oder den Crawler auf vorhandene Katalogtabellenverweisen.

So richten Sie einen Crawler in AWS Glue ein, um Schemainformationen automatisch

abzurufen

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) die Option AWS

GlueData Catalog aus.4. Klicken Sie auf Next (Weiter).5. Wählen Sie auf der Seite Connection details (Verbindungsdetails) die Option Set

up crawler in AWS Glueto retrieve schema infomation automatically (Crawler zumautomatischen Abrufen von Schemainformationen einrichten).

6. Klicken Sie auf Connect to AWS (Mit AWS verbinden) AWS Glue.7. Führen Sie auf der AWS Glue-Konsolenseite Add crawler (Crawler hinzufügen) die Schritte

zum Erstellen eines Crawlers aus. Weitere Informationen finden Sie unter Auffüllen desAWS Glue-Datenkatalog.

Manuelles Hinzufügen einer SchematabelleIm folgenden Verfahren wird gezeigt, wie Sie mithilfe der Athena-Konsole eine Tabelle manuellhinzufügen.

So fügen Sie eine Tabelle hinzu und geben Schemainformationen manuell ein:

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) die Option AWS

GlueData Catalog aus.4. Klicken Sie auf Next (Weiter).5. Wählen Sie auf der Seite Connection details (Verbindungsdetails) die Option Add a table

and enter schema information manually (Tabelle hinzufügen und Schemainformationenmanuell eingeben).

6. Klicken Sie auf Continue to add table (Weiter, um eine Tabelle hinzuzufügen).7. Wählen Sie auf der Seite Add table (Tabelle hinzufügen) der Athena-Konsole für Database

(Datenbank) eine vorhandene Datenbank aus, oder erstellen Sie eine neue Datenbank.8. Geben Sie einen Tabellennamen ein, oder wählen Sie diesen aus.9. Geben Sie unter Location of Input Data Set (Speicherort des Eingabedatensatzes) den

Pfad in dem Ordner Amazon S3 an, der den zu verarbeitende Datensatz enthält.

83







10. Klicken Sie auf Next (Weiter).

11. Wählen Sie für Data Format (Datenformat) ein Datenformat aus (Apache Web Logs, CSV,TSV, Textdatei mit benutzerdefinierten Trennzeichen, JSON, Parquet, oder ORC).• Für die Option Apache Web Logs müssen Sie auch einen Regex-Ausdruck in das Feld

Regex eingeben.• Geben Sie für die Option Textdatei mit benutzerdefinierten Trennzeichen einen Field

terminator (Feldtrennzeichen) an (d. h. ein Spaltentrennzeichen). Optional können Sieeinen Collection terminator (Abschlusszeichen für die Sammlung) für Array-Typen odereinen Map key terminator (Abschlusszeichen für Map-Schlüssel) angeben.

12. Geben Sie unter Columns (Spalten) einen Spaltennamen und den Spaltendatentyp an.• Um mehrere Spalten einzeln hinzuzufügen, wählen Sie Add a column (Spalte

hinzufügen).• Um schnell weitere Spalten hinzuzufügen, wählen Sie Bulk add columns

(Massenhinzufügung von Spalten). Geben Sie in das Textfeld eine durch Kommatagetrennte Liste von Spalten im Format column_name data_type, column_namedata_type[,...] ein, und wählen Sie dann Add (Hinzufügen).

13. Wählen Sie Next.14. (Optional) Klicken Sie unter Partitions (Partitionen) auf Add a partition (Partition

hinzufügen), um Spaltennamen und Datentypen hinzuzufügen.15. Wählen Sie Create table aus. Die DDL für die angegebene Tabelle wird im Abfrage-

Editorangezeigt. Das folgende Beispiel zeigt die DDL, die für eine zweispaltige Tabelle imCSV-Format generiert wurde:

CREATE EXTERNAL TABLE IF NOT EXISTS MyManualDB.MyManualTable ( `cola` string, `colb` string )ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'WITH SERDEPROPERTIES ( 'serialization.format' = ',', 'field.delim' = ',') LOCATION 's3://bucket_name/'TBLPROPERTIES ('has_encrypted_data'='false');

16. Wählen Sie Run query (Abfrage ausführen), um die Tabelle zu erstellen.

Bewährte Methoden beim Verwenden vonAthena mit AWS GlueWenn Sie Athena mit dem AWS Glue-Datenkatalog verwenden, können Sie mit AWS GlueDatenbanken und Tabellen (Schemata) erstellen, die in Athena abgefragt werden können.Sie können auch mit Athena Schemata erstellen und diese in AWS Glue und verwandtenDienstleistungen verwenden. In diesem Thema werden Überlegungen und bewährte Methodenfür beide Methoden vorgestellt.

Im Hintergrund verwendet Athena Presto zum Ausführen von DML-Anweisungen und Hive zumAusführen von DDL-Anweisungen beim Erstellen und Bearbeiten von Schemata. Bei diesenTechnologien müssen einige Konventionen befolgt werden, damit Athena und AWS Glue gutzusammen funktionieren.

In diesem Thema

• Datenbank-, Tabellen- und Spaltennamen (p. 52)

84



• Verwenden von AWS Glue-Crawlern (p. 52)• Planen eines Crawlers zur Synchronisierung des AWS Glue-Datenkatalogs mit

Amazon S3 (p. 52)

• Verwenden mehrerer Datenquellen mit Crawlern (p. 53)• Synchronisieren von Partitionsschemata zur Vermeidung von -Benutzer haben, die

Daten abfragen, "HIVE_PARTITION_SCHEMA_MISMATCH" (p. 55)• Aktualisieren von Tabellenmetadaten (p. 55)

• Arbeiten mit CSV-Dateien (p. 56)• CSV-Daten in Anführungszeichen (p. 56)• CSV-Dateien mit Überschriften (p. 58)

• Arbeiten mit Geodaten (p. 58)• Verwenden von AWS Glue-Aufträgen für ETL mit Athena (p. 58)

• Erstellen von Tabellen mit Athena für AWS Glue-ETL-Aufträge (p. 58)• Verwenden von ETL-Aufträgen zur Optimierung der Abfrageleistung (p. 59)• Konvertieren der Datentypen SMALLINT und TINYINT in INT bei der Konvertierung

nach ORC (p. 60)• Automatisieren von AWS Glue-Aufträgen für ETL (p. 60)

Datenbank-, Tabellen- und SpaltennamenBeachten Sie beim Erstellen von Schemata in AWS Glue für Abfragen in Athena folgendePunkte:

• Datenbanknamen dürfen nicht länger als 252 Zeichen sein.

• Tabellennamen dürfen nicht länger als 255 Zeichen sein.• Spaltennamen dürfen nicht länger als 128 Zeichen sein.• Für Datenbank-, Tabellen- und Spaltennamen dürfen nur Kleinbuchstaben, Zahlen und

Unterstriche verwendet werden.Sie können mit dem AWS Glue Catalog Manager Spalten umbenennen. Das Umbenennen vonTabellen- und Datenbanknamen wird jedoch derzeit in der AWS Glue-Konsole nicht unterstützt.Um Datenbanknamen zu ändern, müssen Sie eine neue Datenbank erstellen und die Tabellenin diese neue Datenbank kopieren (also die Metadaten in eine neue Entity kopieren). FürTabellen können Sie einen ähnlichen Ansatz wählen. Dafür können Sie das AWS Glue SDKoder die AWS CLI verwenden.

Verwenden von AWS Glue-CrawlernAWS Glue-Crawler finden und registrieren das Schema für Datasets im AWS Glue-Datenkatalog. Crawler durchsuchen die Daten und untersuchen bestimmte Abschnitte, um dasSchema zu bestimmen. Darüber hinaus können Crawler Partitionen erkennen und registrieren.Weitere Informationen finden Sie unter Katalogisieren von Daten mit einem Crawler im AWSGlue-Entwicklerhandbuch.

Planen eines Crawlers zur Synchronisierung des AWS Glue-Datenkatalogs mit Amazon S3

AWS Glue-Crawler können so eingerichtet werden, dass sie nach einem bestimmten Zeitplanoder bei Bedarf ausgeführt werden. Weitere Informationen finden Sie unter Zeitpläne fürAufträge und Crawler im AWS Glue-Entwicklerhandbuch.

85






Wenn Sie über Daten verfügen, die zu einem festen Zeitpunkt für eine partitionierte Tabelleeingehen, können Sie einen AWS Glue-Crawler so einrichten, dass er geplant ausgeführtwird, um die Tabellenpartitionen zu erkennen und zu aktualisieren. So müssen Sie keinenpotenziell langen und aufwändigen MSCK REPAIR-Befehl oder manuell einen ALTER TABLEADD PARTITION-Befehl ausführen. Weitere Informationen finden Sie unter Tabellenpartitionenim AWS Glue-Entwicklerhandbuch.

Verwenden mehrerer Datenquellen mit Crawlern

Wenn ein AWS Glue-Crawler Amazon S3 scannt und mehrere Verzeichnisse findet, bestimmter mithilfe einer heuristischen Suche das Stammverzeichnis einer Tabelle und bestimmt,welche Verzeichnisse Partitionen dieser Tabelle sind. In einigen Fällen, wenn in zwei odermehr Verzeichnissen ein ähnliches Schema erkannt wird, kann es vorkommen, dass derCrawler diese als Partitionen statt als eigenständige Tabellen behandelt. Eine Möglichkeitsicherzustellen, dass der Crawler eigenständige Tabellen erkennt, besteht darin, dasStammverzeichnis jeder Tabelle als Datenspeicher für den Crawler hinzuzufügen.

Nachfolgend finden Sie ein Beispiel für Partitionen in Amazon S3:

s3://bucket01/folder1/table1/partition1/file.txt





Wenn die Schemata für table1 und table2 sich ähneln und in AWS Glue eine einzelneDatenquelle für s3://bucket01/folder1/ festgelegt ist, kann es vorkommen, dass derCrawler eine einzelne Tabelle mit zwei Partitionsspalten erstellt: eine Partitionsspalte mittable1 und table2 und eine zweite Partitionsspalte mit partition1 bis partition5.

Damit der AWS Glue-Crawler zwei getrennte Tabellen erstellt, richten Sie den Crawler so ein,dass er zwei Datenquellen, s3://bucket01/folder1/table1/ und s3://bucket01/folder1/table2 verwendet, wie in der folgenden Anleitung gezeigt.

So fügen Sie einem vorhandenen Crawler in AWS Glue einen weiterenDatenspeicher hinzu

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die AWS Glue-Konsole unter https://console.aws.amazon.com/glue/.

2. Klicken Sie auf Crawlers, wählen Sie Ihren Crawler aus und klicken Sie auf Action (Aktion)und Edit crawler (Crawler bearbeiten).

86

https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition

https://console.aws.amazon.com/glue/



3. Nehmen Sie unter Add information about your crawler nach Bedarf weitere Einstellungen vorund klicken Sie auf Next.

4. Ändern Sie unter Add a data store die Einstellung Include path auf das Verzeichnis aufTabellenebene. Im obigen Beispiel würden Sie das Verzeichnis beispielsweise von s3://bucket01/folder1 to s3://bucket01/folder1/table1/ ändern. Wählen Sie Next.

5. Klicken Sie für Add another data store auf Yes und Next.6. Geben Sie unter Include path (Pfad einschließen) Ihr Verzeichnis auf Tabellenebene ein

(z. B. s3://bucket01/folder1/table2/) und wählen Sie Next (Weiter).a. Wiederholen Sie die Schritte 3 bis 5 für weitere Verzeichnisse auf Tabellenebene und

schließen Sie die Crawler-Konfiguration ab.

87



Die neuen Werte für Include locations (Speicherorte einschließen) werden folgendermaßenunter Datenspeicher angezeigt.

Synchronisieren von Partitionsschemata zur Vermeidung von -Benutzerhaben, die Daten abfragen, "HIVE_PARTITION_SCHEMA_MISMATCH"

Das Schema wird für jede Tabelle innerhalb des AWS Glue-Datenkatalogs mit Partitionsspaltenauf Tabellenebene und für jede individuelle Partition innerhalb der Tabelle gespeichert. DasSchema für Partitionen wird von einem AWS Glue-Crawler basierend auf der Datenstichprobeausgefüllt, die innerhalb der Partition ausgelesen wird. Weitere Informationen finden Sie unterVerwenden mehrerer Datenquellen mit Crawlern (p. 53).

Wenn Athena eine Abfrage ausführt, werden das Schema der Tabelle und das Schema der fürdie Abfrage erforderlichen Partitionen geprüft. Dabei werden die Spaltendatentypen der Reihenach verglichen und es wird sichergestellt, dass sie für überlappende Spalten übereinstimmen.So wird verhindert, dass es zu unerwartetem Hinzufügen oder Entfernen von Spalten in derMitte der Tabelle kommt. Wenn Athena erkennt, dass das Schema einer Partition vom Schemader Tabelle abweicht, kann Athena die Abfrage nicht verarbeiten und bricht mit dem FehlerHIVE_PARTITION_SCHEMA_MISMATCH ab.

Es gibt mehrere Möglichkeiten, dieses Problem zu beheben. Wenn die Daten versehentlichhinzugefügt wurden, können Sie die Datendateien, die zu der Schemaabweichung geführthaben, entfernen, die Partition verwerfen und die Daten erneut durchsuchen. Sie könnenauch die einzelne Partition verwerfen und dann mit Athena MSCK REPAIR ausführen, um diePartition mit dem Schema der Tabelle neu zu erstellen. Diese zweite Option funktioniert jedochnur, wenn Sie sicher sind, dass das angewendete Schema die Daten weiterhin korrekt ausliest.

Aktualisieren von Tabellenmetadaten

Nach dem Durchsuchen weist der AWS Glue-Crawler automatisch bestimmteTabellenmetadaten zu, um eine Kompatibilität mit anderen externen Technologien wieApache Hive, Presto und Spark sicherzustellen. Es kann vorkommen, dass der Crawler dabeiMetadateneigenschaften falsch zuweist. Korrigieren Sie die Eigenschaften in AWS Gluemanuell, bevor Sie mit Athena Abfragen für die Tabelle senden. Weitere Informationen findenSie unter Anzeigen und Bearbeiten von Tabellendetails im AWS Glue-Entwicklerhandbuch.

Es kann vorkommen, dass AWS Glue Metadaten falsch zuweist, wenn eine CSV-Dateieinzelne Datenfelder in Anführungszeichen einschließt. Hierdurch kann die EigenschaftserializationLib falsch abgerufen werden. Weitere Informationen finden Sie unter CSV-Daten in Anführungszeichen (p. 56).

88




Arbeiten mit CSV-DateienCSV-Dateien enthalten gelegentlich Anführungszeichen um die Datenwerte der einzelnenSpalten. Außerdem können sie Überschriften enthalten, die nicht Bestandteil der zuanalysierenden Daten sind. Wenn Sie mit AWS Glue ein Schema für diese Dateien erstellen,befolgen Sie die Anleitung in diesem Abschnitt.

CSV-Daten in Anführungszeichen

Wenn Sie eine Abfrage in Athena für eine Tabelle ausführen, die aus einer CSV-Datei mitDatenwerten in Anführungszeichen erstellt wurde, aktualisieren Sie die Tabellendefinitionin AWS Glue, um die korrekten SerDe und SerDe-Eigenschaften festzulegen. So kann dieTabellendefinition den OpenCSVSerDe verwenden. Weitere Informationen zum OpenCSVSerDe finden Sie unter OpenCSVSerDe für CSV-Verarbeitung (p. 295).

Führen Sie in diesem Fall die folgenden Änderungen durch:

• Ändern Sie die Eigenschaft serializationLib unter dem Feld im SerDeInfo-Feld derTabelle auf org.apache.hadoop.hive.serde2.OpenCSVSerde.

• Geben Sie passende Werte für separatorChar, quoteChar und escapeCharein. Der separatorChar-Wert ist ein Komma, der quoteChar-Wert sind doppelteAnführungszeichen (``) und der escapeChar-Wert ist der Backslash (\).

Beispiel für eine CSV-Datei mit Datensätzen wie den folgenden:

"John","Doe","123-555-1231","John said \"hello\""

"Jane","Doe","123-555-9876","Jane said \"hello\""

Sie können mit der AWS Glue-Konsole Tabellendetails wie in diesem Beispiel gezeigtbearbeiten:

89



Alternativ können Sie die Tabellendefinition in AWS Glue um einen SerDeInfo-Block wie folgtaktualisieren:

"SerDeInfo": {

"name": "",

"serializationLib": "org.apache.hadoop.hive.serde2.OpenCSVSerde",

"parameters": {

"separatorChar": ","

"quoteChar": """

"escapeChar": "\\"

90



}

},

Weitere Informationen finden Sie unter Anzeigen und Bearbeiten von Tabellendetails im AWSGlue-Entwicklerhandbuch.

CSV-Dateien mit Überschriften

Wenn Sie CSV-Dateien in AWS Glue schreiben, die für Abfragen mit Athena verwendet werdensollen, müssen Sie die CSV-Überschriften entfernen, damit diese Informationen nicht in denAbfrageergebnissen von Athena enthalten sind. Hierfür können Sie beispielsweise AWS Glue-Aufträge zum Extrahieren, Umwandeln und Laden (Extract, Transform, Load; ETL) verwenden.Sie können in AWS Glue Skripte in einer Sprache schreiben, die eine Erweiterung des PySparkPython-Dialekts ist. Weitere Informationen finden Sie unter Autorisieren von Aufträgen in Glueim AWS Glue-Entwicklerhandbuch.

Das folgende Beispiel zeigt eine Funktion in einem AWS Glue-Skript, mit der ein dynamischerFrame mit from_options geschrieben und die Formatoption writeHeader auf "false"gesetzt wird, um die Überschriften zu entfernen:

glueContext.write_dynamic_frame.from_options(frame = applymapping1,

connection_type = "s3", connection_options = {"path": "s3://MYBUCKET/

MYTABLEDATA/"}, format = "csv", format_options = {"writeHeader": False},

transformation_ctx = "datasink2")

Arbeiten mit GeodatenAWS Glue unterstützt Well-Known Text (WKT), Well-Known Binary (WKB) oder anderePostGIS-Datentypen nicht nativ. Der AWS Glue-Classifier analysiert Geodaten und klassifiziertsie mithilfe unterstützter Datentypen für das Format, z. B. varchar für CSV. Wie beianderen AWS Glue-Tabellen müssen Sie möglicherweise die Eigenschaften von Tabellenaktualisieren, die aus Geodaten erstellt wurden, damit Athena diese Datentypen im Ist-ZustandFall analysieren kann. Weitere Informationen finden Sie unter Verwenden von AWS Glue-Crawlern (p. 52) und Arbeiten mit CSV-Dateien (p. 56). Athena kann einige Geodatentypen inAWS Glue-Tabellen nicht im Ist-Zustand analysieren. Weitere Informationen zum Arbeiten mitGeodaten in Athena finden Sie unter Abfragen von koordinatenbasierten Daten (p. 168).

Verwenden von AWS Glue-Aufträgen für ETL mit AthenaAWS Glue-Aufträge führen ETL-Operationen aus. Ein AWS Glue-Auftrag führt ein Skript aus,mit dem Daten aus Quellen extrahiert, umgewandelt und in das Ziel hochgeladen werden.Weitere Informationen finden Sie unter Autorisieren von Aufträgen in Glue im AWS Glue-Entwicklerhandbuch.

Erstellen von Tabellen mit Athena für AWS Glue-ETL-Aufträge

Innerhalb von Athena erstellte Tabellen benötigen eine Tabelleneigenschaft namensclassification, über die das Format der Daten identifiziert wird. Damit kann AWS Glue dieTabellen für ETL-Aufträge verwenden. Die Klassifizierungswerte können csv, parquet, orc,avro oder json sein. Es folgt ein Beispiel für eine CREATE TABLE-Anweisung in Athena:

CREATE EXTERNAL TABLE sampleTable (

column1 INT,

column2 INT

) STORED AS PARQUET

91






TBLPROPERTIES (

'classification'='parquet')

Wenn die Tabelleneigenschaft beim Erstellen der Tabelle nicht hinzugefügt wurde, können Siesie mithilfe der AWS Glue-Konsole hinzufügen.

So ändern Sie die Klassifizierungseigenschaft in der Konsole

1. Klicken Sie auf Edit Table.

2. Wählen Sie unter Classification den Dateityp aus und klicken Sie auf Apply.

Weitere Informationen finden Sie unter Arbeiten mit Tabellen im AWS Glue-Entwicklerhandbuch.

Verwenden von ETL-Aufträgen zur Optimierung der Abfrageleistung

Mithilfe von AWS Glue-Aufträgen können Sie Daten zur Optimierung der Abfrageleistungin Athena in ein anderes Format umwandeln. Datenformate wirken sich erheblich auf dieAbfrageleistung und Abfragekosten in Athena aus.

Wir empfehlen, die Datenformate Parquet und ORC zu verwenden. AWS Glue unterstütztSchreibvorgänge in beide Datenformate, was die Umwandlung von Daten in ein für Athenaoptimales Format einfacher und schneller macht. Weitere Informationen zu diesen Formaten

92

https://docs.aws.amazon.com/glue/latest/dg/console-tables.html


und anderen Möglichkeiten zur Leistungsverbesserung finden Sie unter Top PerformanceTuning-Tipps für Amazon Athena.

Konvertieren der Datentypen SMALLINT und TINYINT in INT bei derKonvertierung in ORC

Um möglichst zu vermeiden, dass Athena die Datentypen SMALLINT und TINYINT, die vonAWS Glue-ETL-Aufträgen generiert werden, nicht lesen kann, sollten Sie SMALLINT undTINYINT entweder mit dem Assistenten oder einem eigenen Skript für einen ETL-Auftrag inINT umwandeln.

Automatisieren von AWS Glue-Aufträgen für ETL

Sie können AWS Glue-ETL-Aufträge so konfigurieren, dass sie automatisch ausgeführt werden,wenn sie ausgelöst werden. Diese Funktion ist ideal, wenn Daten von außerhalb von AWSin einem Format, das für Abfragen in Amazon S3 nicht optimal ist, in einen Athena-Bucketgespeichert werden. Weitere Informationen finden Sie unter Auslösen von AWS Glue-Aufträgenim AWS Glue-Entwicklerhandbuch.

Schrittweises Upgrade auf den AWS Glue-DatenkatalogAmazon Athena verwaltet seinen eigenen Datenkatalog, bis AWS Glue in der Athena-Regionveröffentlicht wird. Sofern Sie zuvor Datenbanken und Tabellen mit Athena oder AmazonRedshift Spectrum erstellt haben, können Sie zu diesem Zeitpunkt wählen, ob Sie Athenaauf den AWS Glue-Datenkatalog upgraden möchten. Falls Sie Athena erstmalig verwenden,müssen Sie keine Änderungen vornehmen. Datenbanken und Tabellen sind in Athena überden AWS Glue-Datenkatalog und umgekehrt verfügbar. Weitere Informationen zu den Vorteilendes AWS Glue-Datenkatalogs finden Sie unter Häufig gestellte Fragen: Upgrade auf den AWSGlue-Datenkatalog (p. 62). Eine Liste der Regionen, in denen AWS Glue verfügbar ist, findenSie unter Regionen und Endpunkte von AWS in der Allgemeinen AWS-Referenz.

Bis zum Upgrade speichert der von Athena verwaltete Datenkatalog weiterhin Ihre Tabellen-und Datenbankmetadaten und die Option zum Upgrade wird oben in der Konsole angezeigt.Die Metadaten im von Athena verwalteten Katalog sind im AWS Glue-Datenkatalog (undumgekehrt) nicht verfügbar. Beide Kataloge sind zwar parallel vorhanden, Sie können jedochkeine Tabellen oder Datenbanken mit demselben Namen erstellen. Die Erstellung in AWS Glueoder Athena schlägt in diesem Fall fehl.

Wir haben einen Assistenten in der Athena-Konsole bereitgestellt, der Sie beim Upgrade aufdie AWS Glue-Konsole Schritt für Schritt anleitet. Das Upgrade dauert nur wenige Minutenund kann jederzeit unterbrochen werden. Weitere Informationen zu den einzelnen Upgrade-Schritten finden Sie in den Themen in diesem Abschnitt. Weitere Informationen zur Arbeit mitDaten und Tabellen im AWS Glue-Datenkatalog finden Sie in den Richtlinien unter BewährteMethoden beim Verwenden von &ATE; mit AWS Glue (p. 51).

Schritt 1 – Einem Benutzer erlauben, das UpgradeauszuführenStandardmäßig ist die Aktion zum Ausführen des Upgrade in keiner Richtlinie, einschließlichverwalteter Richtlinien, erlaubt. Da der AWS Glue-Datenkatalog innerhalb eines Kontosgemeinsam verwendet wird, verhindert diese Vorsichtsmaßnahme, dass der Katalogversehentlich migriert wird.

93



https://docs.aws.amazon.com/glue/latest/dg/trigger-job.html



Bevor Sie mit dem Upgrade beginnen können, müssen Sie dem Benutzer, der die Migrationdurchführt, eine benutzerverwaltete IAM-Richtlinie mit einer Richtlinienanweisung, die dieUpgrade-Aktion zulässt, anfügen.

Nachfolgend finden Sie eine Beispielrichtlinienanweisung.

{

"Version": "2012-10-17",

"Statement": [

{

"Effect": "Allow",

"Action": [

"glue:ImportCatalogToGlue "

],

"Resource": [ "*" ]

}

]

}

Schritt 2 – Benutzerverwaltete/eingebundene Richtliniender Athena-Benutzer aktualisierenWenn Sie benutzerverwaltete oder eingebundene IAM-Richtlinien für Athena-Benutzerverwenden, müssen Sie die Richtlinie(n) aktualisieren, um die für AWS Glue erforderlichenAktionen zu erlauben. Wenn Sie die verwaltete Richtlinie verwenden, wird diese automatischaktualisiert. In der nachfolgenden Beispielrichtlinie sind die erforderlichen AWS Glue-Richtlinienaktionen aufgelistet. Die vollständige Richtlinienanweisung finden Sie unter IAM-Richtlinien für den Benutzerzugriff (p. 217).

{

"Effect":"Allow",

"Action":[

"glue:CreateDatabase",

"glue:DeleteDatabase",

"glue:GetDatabase",

"glue:GetDatabases",

"glue:UpdateDatabase",

"glue:CreateTable",

"glue:DeleteTable",

"glue:BatchDeleteTable",

"glue:UpdateTable",

"glue:GetTable",

"glue:GetTables",

"glue:BatchCreatePartition",

"glue:CreatePartition",

"glue:DeletePartition",

"glue:BatchDeletePartition",

"glue:UpdatePartition",

"glue:GetPartition",

"glue:GetPartitions",

"glue:BatchGetPartition"

],

"Resource":[

"*"

]

}

94


Schritt 3 – Das Upgrade in der Athena-Konsole auswählenNachdem Sie die erforderlichen IAM-Richtlinien aktualisiert haben, klicken Sie in der Athena-Konsole auf Upgrade. Athena verschiebt Ihre Metadaten in den AWS Glue-Datenkatalog. DasUpgrade dauert nur wenige Minuten. Nach dem Upgrade enthält die Athena-Konsole einenLink, über den Sie den AWS Glue-Katalogmanager aus Athena öffnen können.

Wenn Sie eine Tabelle in der Konsole erstellen, können Sie nun eine Tabelle mit einem AWSGlue-Crawler erstellen. Weitere Informationen finden Sie unter Verwenden von AWS Glue-Crawlern (p. 52).

Häufig gestellte Fragen: Upgrade auf den AWSGlue-DatenkatalogWenn Sie mit Athena Datenbanken und Tabellen in einer Region erstellt haben, bevorAWS Glue in dieser verfügbar war, sind die Metadaten in einem von Athena verwaltetenDatenkatalog gespeichert, auf den nur Athena und Amazon Redshift Spectrum zugreifenkönnen. Um die AWS Glue-Funktionen zusammen mit Athena und Redshift Spectrum nutzenzu können, müssen Sie ein Upgrade auf den AWS Glue-Datenkatalog durchführen. Athenakann zusammen mit dem AWS Glue-Datenkatalog nur in Regionen verwendet werden, indenen AWS Glue verfügbar ist. Eine Liste der Regionen finden Sie unter Regionen undEndpunkte in der Allgemeinen AWS-Referenz.

95




Warum sollte ich ein Upgrade auf den AWS Glue-Datenkatalog durchführen?AWS Glue ist ein vollständig verwalteter Service zum Extrahieren, Transformieren und Laden(ETL). Er besteht aus drei Hauptkomponenten:

• Ein AWS Glue Crawler kann automatisch Ihre Datenquellen scannen, Datenformatebestimmen und Schemata ableiten.

• Ein vollständig verwalteter ETL-Service ermöglicht Ihnen das Transformieren undVerschieben von Daten in verschiedene Ziele.

• Der AWS Glue-Datenkatalog speichert Metadaten zu Datenbanken und Tabellen, die aufeinen Datenspeicher in Amazon S3 oder einen JDBC-kompatiblen Datenspeicher zeigen.

Weitere Informationen finden Sie auf der Seite zu den AWS Glue-Konzepten.

Das Upgrade auf den AWS Glue-Datenkatalog hat folgende Vorteile.

Einheitlicher Metadaten-Repository

Der AWS Glue-Datenkatalog stellt einen einheitlichen Metadaten-Repository für eine Vielzahlvon Datenquellen und Datenformaten bereit. Er ermöglicht eine unmittelbare Integrationin Amazon Simple Storage Service (Amazon S3), Amazon Relational Database Service(Amazon RDS), Amazon Redshift, Amazon Redshift Spectrum, Athena, Amazon EMR und alleanderen Anwendungen, die mit dem Apache Hive-Metastore kompatibel sind. Sie müssen IhreTabellendefinitionen nur einmal erstellen und können dann eine Engine-übergreifende Abfragedurchführen.

Weitere Informationen finden Sie auf der Seite zum Füllen des AWS Glue-Datenkatalogs.

Automatische Schema- und Partitions-Erkennung

AWS Glue-Crawler durchsuchen automatisch Ihre Datenquellen, bestimmen Datenformate undempfehlen Schemata und Transformationen. Crawler unterstützen Sie bei der Automatisierungder Tabellenerstellung und dem automatischen Laden von Partitionen, die Sie mit Athena,Amazon EMR und Redshift Spectrum abfragen können. Sie können Tabellen und Partitionenauch direkt mit der AWS Glue-API, den AWS SDKs und der AWS CLI erstellen.

Weitere Informationen finden Sie auf der Seite zum Katalogisieren von Tabellen mit einemCrawler.

Einfach zu erstellende Pipelines

Die AWS Glue ETL-Engine generiert Python-Code, der vollständig anpassbar,wiederverwendbar und portabel ist. Sie können den Code mit Ihrer bevorzugten IDE oderIhrem Notebook bearbeiten und über GitHub für andere freigeben. Nachdem Ihr ETL-Auftragerstellt wurde, können Sie ihn so planen, dass er auf der vollständig verwalteten, skalierbarenSpark-Infrastruktur von AWS Glue ausgeführt wird. AWS Glue übernimmt das Bereitstellen,Konfigurieren und Skalieren der Ressourcen, die zum Ausführen Ihrer ETL-Aufträge erforderlichsind, sodass Sie ETL eng in Ihren Workflow integrieren können.

Weitere Informationen finden Sie auf der Seite zum Autorisieren von AWS Glue-Aufträgen imAWS Glue-Entwicklerhandbuch.

Fallen für AWS Glue separate Gebühren an?Ja. Für AWS Glue zahlen Sie monatlich eine Gebühr für das Speichern und Zugreifenauf Metadaten, die im AWS Glue-Datenkatalog enthalten sind. Zudem zahlen Sie einen

96

https://docs.aws.amazon.com/glue/latest/dg/components-key-concepts.html




https://aws.amazon.com/redshift/

https://aws.amazon.com/redshift/spectrum/

https://aws.amazon.com/emr/




https://docs.aws.amazon.com/glue/latest/dg/author-job.html


Stundensatz, der sekundengenau für AWS Glue ETL-Aufträge und die Crawler-Laufzeitberechnet wird. Darüber hinaus fällt ein Stundensatz an, der sekundengenau für jedenbereitgestellten Entwicklungsendpunkt berechnet wird. Der AWS Glue-Datenkatalog ermöglichtIhnen die gebührenfreie Speicherung von bis zu einer Million Objekten. Wenn Sie mehr als eineMillion Objekte speichern, fällt eine Gebühr von 1 USD für jeweils 100.000 zusätzliche Objektean. Ein Objekt im AWS Glue-Datenkatalog ist eine Tabelle, Partition oder Datenbank. WeitereInformationen finden Sie auf der Seite zur AWS Glue-Preisberechnung.

Upgrade-Prozess – Häufig gestellte Fragen• Wer kann das Upgrade durchführen? (p. 64)

• Meine Benutzer verwenden eine verwaltete Richtlinie mit Athena und Redshift Spectrum.Welche Schritte muss ich für das Upgrade durchführen? (p. 64)

• Was passiert, wenn ich kein Upgrade durchführe? (p. 64)• Warum muss ich AWS Glue-Richtlinien zu Athena-Benutzern hinzufügen? (p. 64)• Was geschieht, wenn ich keine AWS Glue-Richtlinien für Athena-Benutzer zulasse? (p. 64)• Besteht während des Upgrades das Risiko eines Datenverlusts? (p. 64)• Werden meine Daten während des Upgrades ebenfalls verschoben? (p. 64)Wer kann das Upgrade durchführen?

Sie müssen eine vom Benutzer verwaltete IAM-Richtlinie mit einer Richtlinienanweisunganfügen, die dem Benutzer, der die Migration durchführt, die Upgrade-Aktion erlaubt. Diesezusätzliche Prüfung verhindert eine unbeabsichtigte Migration des Katalogs für das gesamteKonto. Weitere Informationen finden Sie auf der Seite zu Schritt 1 – Einem Benutzer dasDurchführen des Upgrades erlauben (p. 60).

Meine Benutzer verwenden eine verwaltete Richtlinie mit Athenaund Redshift Spectrum. Welche Schritte muss ich für das Upgradedurchführen?

Die von Athena verwaltete Richtlinie wurde automatisch mit den neuen Richtlinienaktionenaktualisiert, die Athena-Benutzern den Zugriff auf AWS Glue gestatten. Sie müssen jedochdem Benutzer, der das Upgrade durchführt, die Upgrade-Aktion explizit erlauben. Um einunbeabsichtigtes Upgrade zu verhindern, lässt die verwaltete Richtlinie diese Aktion nicht zu.

Was passiert, wenn ich kein Upgrade durchführe?

Wenn Sie kein Upgrade durchführen, können Sie die AWS Glue-Funktionen nicht mitDatenbanken und Tabellen verwenden, die Sie in Athena erstellt haben, oder umgekehrt.Sie können diese Services unabhängig voneinander verwenden. Während dieser Zeitverhindern sowohl Athena als auch AWS Glue, dass Sie Datenbanken und Tabellen erstellenkönnen, die dieselben Namen im anderen Katalog haben. Dadurch werden beim UpgradeNamensüberschneidungen verhindert.

Warum muss ich AWS Glue-Richtlinien zu Athena-Benutzernhinzufügen?

Vor dem Upgrade verwaltet Athena den Datenkatalog, sodass Athena-Aktionen für Benutzerzugelassen werden müssen, damit diese Abfragen durchführen können. Nachdem Sie einUpgrade auf den AWS Glue-Datenkatalog durchgeführt haben, sind Athena-Aktionen nichtmehr für den Zugriff auf den AWS Glue-Datenkatalog zulässig. Deshalb müssen AWS Glue-Aktionen für Benutzer zugelassen werden. Denken Sie daran, dass die verwaltete Richtlinie für

97


Amazon Athena BenutzerhandbuchVerwenden eines Hive-Metastores

Athena bereits aktualisiert wurde, um die erforderlichen AWS Glue-Aktionen zuzulassen. WennSie diese verwaltete Richtlinie verwenden, müssen Sie nichts unternehmen.

Was geschieht, wenn ich keine AWS Glue-Richtlinien für Athena-Benutzer zulasse?

Wenn Sie ein Upgrade auf den AWS Glue-Datenkatalog durchführen und diebenutzerverwaltete Richtlinie eines Benutzers oder die eingebundenen IAM-Richtliniendes Benutzers nicht aktualisieren, schlagen Athena-Abfragen fehl, da der Benutzer dannkeine Aktionen in AWS Glue durchführen darf. Informationen zu den bestimmten Aktionen,die zugelassen werden müssen, finden Sie auf der Seite zu Schritt 2 – Aktualisieren vonbenutzerverwalteten/eingebundenen Richtlinien, die mit Athena-Benutzern verknüpftsind (p. 61).

Besteht während des Upgrades das Risiko eines Datenverlusts?

Nein.

Werden meine Daten während des Upgrades ebenfalls verschoben?

Nein. Die Migration betrifft nur Metadaten.

Die Verwendung vonSie können die verwenden, um Datensätze in Amazon S3 abzufragen, in denen ein ApacheHive-Metastore verwendet wird. Es ist keine Migration von Metadaten zu AWS Glue-Datenkatalog erforderlich. In der Athena-Verwaltungskonsole konfigurieren Sie eine Lambda-Funktion für die Kommunikation mit dem Hive-Metastore in Ihrer privaten VPC und verbindensie dann. Für den Lambda-Funktionscode können Sie die Standardimplementierung vonAthena verwenden, den Athena-Datenquellenkonnektor für den externen Hive-Metastore, odereine eigene Implementierung bereitstellen.

Überlegungen und EinschränkungenVorab erstellte und benutzerdefinierte Datenkonnektoren benötigen möglicherweise Zugriffauf die folgenden Ressourcen, um ordnungsgemäß zu funktionieren. Überprüfen Sie dieInformationen für den von Ihnen verwendeten Konnektor, um sicherzustellen, dass die VPCkorrekt konfiguriert ist. Informationen zu den erforderlichen IAM-Berechtigungen zum Ausführenvon Abfragen und zum Erstellen eines Datenquellenkonnektors in Athena finden Sie unter Sogewähren Sie den Zugriff auf eine : (p. 230).

• AmazonAthenaPreviewFunctionality-Arbeitsgruppe –• Amazon S3 – Zusätzlich zum Schreiben von Abfrageergebnissen zum Athena-

Abfrageergebnisspeicherort in Amazon S3 schreiben Datenkonnektoren auch zu einem Spill-Bucket in Amazon S3. Konnektivität und Berechtigungen für diesen Amazon S3-Standort sinderforderlich.

• Athena – Zum Überprüfen des Abfragestatus und zum Verhindern übermäßigen Scannens.• AWS Secrets Manager• AWS Glue wenn Ihr KonnektorAWS Glue für ergänzende oder primäre Metadaten verwendet.• AWS Key Management Service• Richtlinien – Hive-Metastore, Athena Query Federation und UDFs erfordern zusätzlich

zu Verwaltete Richtlinie AmazonAthenaFullAccess (p. 218) weitere Richtlinien. WeitereInformationen finden Sie unter Identitäts- und Zugriffsverwaltung in Athena (p. 217).

98

Amazon Athena BenutzerhandbuchVerbinden von Athena mit einem Apache Hive Metastore

Verbinden von Athena mit einem Apache HiveMetastoreUm eine Verbindung von Athena zu einem Apache Hive Metastore herzustellen, müssen Sieeine Lambda-Funktion erstellen und konfigurieren. Für eine grundlegende Implementierungkönnen Sie alle erforderlichen Schritte von der Athena-Verwaltungskonsole aus ausführen.

So stellen Sie eine Verbindung von Athena zu einem Hive-Metastore her:

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) unter Choose a

metadata catalog (Metadatenkatalog auswählen) die Option Apache Hive-Metastore aus.4. Wählen Sie Next.5. Klicken Sie auf der Seite Connection details (Verbindungsdetails) für Lambda function

(Funktion) auf Create Lambda function (Funktion erstelle)n.6. Geben Sie im Dialogfeld Create Lambda function (Funktion erstellen) die folgenden

Informationen für die Lambda-Funktion ein. Um die Standardimplementierung zuverwenden, übernehmen Sie die Standardwerte für den Funktionscodespeicherort inAmazon S3 und den Lambda-Handler.• Lambda function name (Funktionsname) – Geben Sie einen Namen für die Funktion an.

Zum Beispiel myHiveMetastore.• Lambda execution role (Ausführungsrolle) – Wählen Sie eine IAM-Rolle aus, oder klicken

Sie auf Create a new role (Neue Rolle erstellen), um eine zu erstellen.• Function code (Funktionscode) – Der Speicherort in Amazon S3 der Lambda-Funktion-

JAR-Datei. Verwenden Sie die Standardeinstellung, oder geben Sie den SpeicherortIhrer benutzerdefinierten JAR-Datei ein.

• Lambda Handler – Die Methode in der JAR-Datei, die den Hive-Konnektorimplementiert. Verwenden Sie die Standardeinstellung oder ersetzen Sie sie in Ihrembenutzerdefinierten Code durch den Handler.

• Hive-Metastore (HMS) URI – Geben Sie den Namen Ihres Hive-Metastore-Hosts ein,der das Thrift-Protokoll an Port 9083 mit der Syntax thrift://<host_name>:9083verwendet.

• Spill location in S3 (Überlaufort in S3) – Geben Sie einen Amazon S3-Ort in diesemKonto für Spillover-Metadaten an, wenn die Antwortgröße der Lambda-Funktion 4 MBüberschreitet.

• Virtual Private (VPC) – Wählen Sie die VPC aus, die Ihren Hive-Metastore enthält.• Subnets (Subnetze) – Wählen Sie die VPC-Subnetze aus, die Lambda zum Einrichten

der VPC-Konfiguration verwenden soll.• Security groups (Sicherheitsgruppen) – Wählen Sie die VPC-Sicherheitsgruppen aus, die

Lambda zum Einrichten der VPC-Konfiguration verwenden soll.• Memory (Speicher) – Geben Sie einen Wert zwischen 128 MB und 3008 MB an.

Der Lambda-Funktion werden CPU-Zyklen proportional zur von Ihnen konfiguriertenSpeichermenge zugewiesen.

• Timeout – Geben Sie einen Wert von 1 Sekunde bis 15 Minuten 59 Sekunden an.Standardmäßig ist ein Zeitraum von 3 Sekunden festgelegt.

7. Klicken Sie auf Create. Die Seite Connection details (Verbindungsdetails) informiert Siedarüber, dass die Funktion erstellt wird. Wenn der Vorgang abgeschlossen ist, steht IhrFunktionsname im Feld Choose a function name (Funktionsname auswählen) bereit, undIhr Lambda-Funktions-ARN wird angezeigt.

99



8. Geben Sie unter Catalog name (Katalogname) einen eindeutigen Namen ein, der für dieDatenquelle in Ihren SQL-Abfragen verwendet werden soll. Der Name kann bis zu 127Zeichen lang sein und muss innerhalb Ihres Kontos eindeutig sein. Er kann nach derErstellung nicht mehr geändert werden. Gültige Zeichen sind a-z, A-z, 0-9, _ (Unterstrich),@ (kaufmännisches Und-Zeichen) und - (Bindestrich).

9. Klicken Sie auf Connect (Verbinden) um eine Verbindung von Athena mit der Datenquelleherzustellen.Auf der Seite Data sources (Datenquellen) wird der Konnektor in der Liste derKatalognamen angezeigt. Sie können nun den Catalog name (Katalognamen) verwenden,den Sie angegeben haben, um auf den Hive-Metastore in Ihren SQL-Abfragen zuverweisen. Verwenden Sie die Syntax im folgenden Beispiel, wobei MyHiveMetastoreder Katalogname ist, den Sie zuvor angegeben haben.

SELECT * FROM MyHiveMetastore.CustomerData.customers;

Die Verwendung vonWenn Daten in anderen Quellen als Amazon S3 vorliegen, können Sie verwenden,um die Daten direkt in diesen Quellen abzufragen oder um Pipelines zu erstellen, dieDaten aus mehreren Datenquellen extrahieren und in Amazon S3 speichern. ermöglichtIhnen die Ausführung von SQL-Abfragen für Daten, die in relationalen, nicht relationalen,benutzerdefinierten und Objektdatenquellen gespeichert sind.

Athena verwendet zum Ausführen von Verbundabfragen Datenquellenkonnektoren, diein AWS Lambda ausgeführt werden. Ein Datenquellenkonnektor ist ein Codestück, daszwischen der Zieldatenquelle und Athena übersetzen kann. Sie können sich einen Konnektorals eine Erweiterung der Abfrage-Engine von Athena vorstellen. Es gibt vorab entwickelteAthena-Datenquellenkonnektoren für Datenquellen wie Amazon CloudWatch-Protokolle,Amazon DynamoDB, Amazon DocumentDB, Amazon RDS, JDBC-kompatible relationaleDatenquellen wie MySQL sowie PostgreSQL unter der Apache 2.0-Lizenz. Sie können auchden verwenden, um Konnektoren zu schreiben. Um einen Datenquellenkonnektor für Ihr Kontoauszuwählen, zu konfigurieren und bereitzustellen, können Sie die Athena- und Lambda-Konsole oder AWS Serverless Application Repository verwenden. Nach der Bereitstellung wirdder Datenquellenkonnektor einem Katalog zugeordnet, den Sie in SQL-Abfragen angebenkönnen. Sie können SQL-Anweisungen aus mehreren Katalogen kombinieren und mehrereDatenquellen mit einer einzigen Abfrage abfragen.

Wenn für eine Datenquelle eine Abfrage ausgeführt wird, ruft Athena den entsprechendenKonnektor auf, um die Teile der Tabellen zu identifizieren, die gelesen werden müssen,verwaltet die Parallelität und schiebt Filterprädikate nach unten. Basierend auf dem Benutzer,der die Abfrage übermittelt, können Konnektoren den Zugriff auf bestimmte Datenelementezulassen oder einschränken. Konnektoren verwenden Apache Arrow als Format für die voneiner Abfrage angeforderten zurückgegebenen Daten. Dies ermöglicht die Implementierungvon Konnektoren in Sprachen wie C, C++, Java, Python und Rust. Da Konnektoren in Lambdaausgeführt werden, können sie für den Zugriff auf Daten aus beliebigen Cloud- oder On-Premise-Datenquellen verwendet werden, auf die Lambda zugreifen kann.

Um einen eigenen Datenquellenkonnektor zu schreiben, können Sie mittels des einen dervorab entwickelten Konnektoren anpassen, die Amazon Athena bereitstellt und verwaltet. Siekönnen eine Kopie des Quellcodes aus dem GitHub-Repository kopieren und anschließend dasConnector Publish Tool verwenden, um ein eigenes AWS Serverless Application Repository-Paket zu erstellen.

Die Liste der verfügbaren Athena-Datenquellenkonnektoren finden Sie unter Verwenden vonAthena-Datenquellenkonnektoren (p. 69).

100




Informationen zum Schreiben eines eigenen Datenquellenkonnektors finden Sie unter Athena-Beispielkonnektor auf GitHub.

Überlegungen und EinschränkungenDatenquellenkonnektoren benötigen möglicherweise Zugriff auf die folgenden Ressourcen,um ordnungsgemäß zu funktionieren. Wenn Sie einen vorab erstellten Konnektor verwenden,müssen Sie die Informationen für den Konnektor prüfen, um sicherzustellen, dass IhreVPC korrekt konfiguriert ist. Sie müssen außerdem sicherstellen, dass IAM-Prinzipale,die Abfragen ausführen und Konnektoren erstellen, die nötigen Berechtigungen für dieerforderlichen Aktionen besitzen. Weitere Informationen finden Sie unter Beispiel für IAM-Berechtigungsrichtlinien, die zulassen (p. 232).

• Aktuelle Informationen zu bekannten Problemen und Einschränkungen finden Sie unterEinschränkungen und Probleme im GitHub-Repository aws-athena-query-federation.

• AmazonAthenaPreviewFunctionality-Arbeitsgruppe –• Amazon S3 – Zusätzlich zum Schreiben von Abfrageergebnissen zum Athena-Speicherort

für Abfrageergebnisse in Amazon S3 schreiben Datenkonnektoren auch einen Spill-Bucketin Amazon S3. Für diesen Amazon S3-Speicherort sind entsprechende Verbindungen undBerechtigungen erforderlich.

• Athena – Datenquellen benötigen Konnektivität mit Athena und umgekehrt, um denAbfragestatus zu prüfen und ein übermäßiges Scannen zu verhindern.

• AWS Glue-Datenkatalog – Es sind Verbindungen und Berechtigungen erforderlich, wenn IhrKonnektor Data Catalog für ergänzende oder primäre Metadaten verwendet.

Bereitstellen von Konnektoren und Herstellenvon Verbindungen mit DatenquellenDie Vorbereitung der Erstellung von Verbundabfragen stellt einen zweiteiligen Prozess dar:Bereitstellung eines Lambda-Funktions-Datenquellenkonnektors und Verbindung der Lambda-Funktion mit einer Datenquelle. Im ersten Teil geben Sie der Lambda-Funktion einen Namen,den Sie später in der Athena-Konsole auswählen können. Im zweiten Teil geben Sie demKonnektor einen Namen, auf den Sie in Ihren SQL-Abfragen verweisen können.

Teil 1: Bereitstellen von DatenquellenkonnektorenUm einen Datenquellenkonnektor auszuwählen, zu benennen und bereitzustellen, verwendenSie die Athena- und Lambda-Konsolen in einem integrierten Prozess.

Note

So stellen Sie einen Datenquellenkonnektor bereit

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie auf der Seite Connect data source (Datenquelle verbinden) die Option Query a

data source (Datenquelle abfragen) aus.4. Wählen Sie in Choose a data source (Datenquelle auswählen) die Datenquelle aus, für die

Sie mit Athena Abfragen ausführen möchten, z. B. Amazon CloudWatch Logs.5. Wählen Sie Next.6. Wählen Sie für Lambda function (Funktion) die Option Configure new function (Neue

Funktion konfigurieren). Anschließend wird die Funktionsseite für den von Ihnen

101





Amazon Athena BenutzerhandbuchVerwendung des AWS Serverless Application Repository

ausgewählten Konnektor in der Lambda-Konsole geöffnet. Die Seite enthält detaillierteInformationen zum Konnektor.

7. Geben Sie unter Application settings (Anwendungseinstellungen) die erforderlichenInformationen ein. Dazu gehören mindestens:• AthenaCatalogName – Ein Name für die Lambda-Funktion, der die Datenquelle angibt,

auf die sie gerichtet ist, etwa cloudwatchlogs.• SpillBucket – Ein Amazon S3-Bucket in Ihrem Konto zum Speichern von Daten, die die

Begrenzung der Antwortgröße der Lambda-Funktion überschreiten.8. Wählen Sie I acknowledge that this app creates custom IAM roles (Ich bestätige, dass

diese Anwendung benutzerdefinierte IAM-Rollen erstellt). Um weitere Informationen zuerhalten, wählen Sie den Link Info .

9. Wählen Sie Deploy (Bereitstellen) aus. Der Abschnitt Resources (Ressourcen) derLambda-Konsole zeigt den Bereitstellungsstatus des Konnektors an und informiert Sie,wenn die Bereitstellung abgeschlossen ist.

Teil 2: Herstellen einer Verbindung mit einer DatenquelleNachdem Sie den Datenquellenkonnektor für Ihr Konto bereitgestellt haben, können Sie ihn miteiner Datenquelle verbinden.

So stellen Sie mithilfe eines Konnektors eine Verbindung zu einer Datenquelle her, die

Sie für Ihr Konto bereitgestellt haben

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie Connect data source (Datenquelle verbinden) aus.3. Wählen Sie Query a data source (Datenquelle abfragen).4. Wählen Sie die Datenquelle für den Konnektor aus, den Sie gerade bereitgestellt haben,

z. B. Amazon CloudWatch Logs. Wenn Sie den verwendet haben, um einen eigenenKonnektor zu erstellen, und diesen in Ihrem Konto bereitgestellt haben, wählen Sie Allother data sources (Alle anderen Datenquellen) aus.

5. Wählen Sie Next.6. Wählen Sie unter Choose Lambda function (Funktion auswählen) die Funktion aus, die Sie

benannt haben. Der ARN der Lambda-Funktion wird angezeigt.7. Geben Sie unter Catalog name (Katalogname) einen eindeutigen Namen ein, der für die

Datenquelle in Ihren SQL-Abfragen verwendet werden soll, z. B. cloudwatchlogs. DerName kann bis zu 127 Zeichen lang sein und muss innerhalb Ihres Kontos eindeutig sein.Er kann nach der Erstellung nicht mehr geändert werden. Gültige Zeichen sind a-z, A-z,0-9, _ (Unterstrich), @ (kaufmännisches Und-Zeichen) und - (Bindestrich).

8. Wählen Sie Connect (Verbinden) aus. Auf der Seite Data sources (Datenquellen) wird nunder Konnektor in der Liste der Katalognamen angezeigt. Sie können den Konnektor jetzt inIhren Abfragen verwenden.Informationen zum Schreiben von Abfragen mit Datenkonnektoren finden Sie unterSchreiben von Verbundabfragen (p. 71).

Bereitstellen eines Datenquellenkonnektors mitAWS Serverless Application RepositorySie können auch den AWS Serverless Application Repository verwenden, um einen Athena-Datenquellenkonnektor bereitzustellen. Sie suchen den Konnektor, den Sie verwenden

102


https://aws.amazon.com/serverless/serverlessrepo/


möchten, geben die Parameter an, die der Konnektor benötigt, und stellen den Konnektor dannfür Ihr Konto bereit.

Note

So verwenden Sie den AWS Serverless Application Repository zum Bereitstellen eines

Datenquellenkonnektors für Ihr Konto:

1. Öffnen Sie die Serverless App Repository-Konsole. .2. Wählen Sie die Option Show apps that create custom IAM roles or resource policies (Apps

anzeigen, die benutzerdefinierte Rollen oder Ressourcenrichtlinien erstellen).3. Geben Sie im Suchfeld den Namen des Konnektors ein oder suchen Sie nach

Anwendungen, die mit dem Autorennamen Amazon Athena Federation veröffentlichtwurden. Dieser Autorenname ist für Anwendungen reserviert, die das Amazon Athena-Team geschrieben, getestet und validiert hat.

4. Wählen Sie den Namen des Konnektors aus. Dadurch wird die Seite Application details(Anwendungsdetails) der Lambda-Funktion in der AWS Lambda-Konsole geöffnet.

5. Geben Sie auf der rechten Seite der Detailseite für SpillBucket einen Amazon S3-Bucketan, um Daten von großen Antwort-Nutzlasten zu empfangen. Informationen zu denverbleibenden konfigurierbaren Optionen finden Sie im entsprechenden Thema VerfügbareKonnektoren auf GitHub.

6. Wählen Sie unten rechts auf der Seite „ Application details (Anwendungsdetails) die OptionDeploy (Bereitstellen).

Verwenden von Athena-DatenquellenkonnektorenIn diesem Abschnitt werden vorab erstellte Athena-Datenquellenkonnektoren aufgeführt, mitdenen Sie zahlreiche Datenquellen außerhalb von Amazon S3 abfragen können. Um einenKonnektor in Ihren Athena-Abfragen zu verwenden, konfigurieren Sie ihn und stellen ihn inIhrem Konto bereit.

Note

Weitere Informationen finden Sie im folgenden Thema:

• Hinweise zum Bereitstellen eines Athena-Datenquellenkonnektors finden Sie unterBereitstellen von Konnektoren und Herstellen von Verbindungen mit Datenquellen (p. 67).

• Hinweise zum Schreiben von Abfragen, die Athena-Datenquellenkonnektoren verwenden,finden Sie unter Schreiben von Verbundabfragen (p. 71).

• Ausführliche Informationen zu den Athena-Datenquellenkonnektoren finden Sie unterVerfügbare Konnektoren auf GitHub.

Themen• Athena AWS CMDB-Konnektor (p. 70)• Amazon Athena CloudWatch-Konnektor (p. 70)• Amazon Athena CloudWatch Metrics-Konnektor (p. 70)• Amazon Athena DocumentDB-Konnektor (p. 70)• Amazon Athena DynamoDB-Konnektor (p. 71)

103





• Amazon Athena HBase-Konnektor (p. 71)

• Amazon Athena-Konnektor für JDBC-kompatible Datenquellen (p. 71)• Amazon Athena Redis-Konnektor (p. 71)• Amazon Athena TPC-Benchmark DS (TPC-DS)-Konnektor (p. 71)

Athena AWS CMDB-KonnektorDer Amazon Athena AWS CMDB-Konnektor ermöglicht Amazon Athena die Kommunikation mitverschiedenen AWS-Services, sodass Sie diese mit SQL abfragen können.

Informationen zu unterstützten Services, Parametern, Berechtigungen, Bereitstellung, Leistungund Lizenzierung finden Sie unter Amazon Athena AWS CMDB Connector auf GitHub.

Amazon Athena CloudWatch-KonnektorDer Amazon Athena CloudWatch-Konnektor ermöglicht Amazon Athena die Kommunikation mitCloudWatch, sodass Sie Ihre Protokolldaten mit SQL abfragen können.

Der Konnektor ordnet Ihre LogGroups als Schemas und jeden LogStream als Tabelle zu. DerKonnektor ordnet auch eine spezielle all_log_streams-Ansicht zu, die alle LogStreams inder LogGroup enthält. Diese Ansicht ermöglicht es Ihnen, alle Protokolle in einer LogGroupgleichzeitig abzufragen, anstatt jeden LogStream einzeln zu durchsuchen.

Weitere Informationen zu Konfigurationsoptionen, Ablehnungssteuerung,Tabellenzuweisungsschema, Berechtigungen, Bereitstellung, Leistungsüberlegungen undLizenzierung finden Sie unter Amazon Athena CloudWatch Connector auf GitHub.

Amazon Athena CloudWatch Metrics-KonnektorDer Amazon Athena CloudWatch Metrics-Konnektor ermöglicht Amazon Athena dieKommunikation mit CloudWatch-Metriken, sodass Sie Ihre Metrikdaten mit SQL abfragenkönnen.

Informationen zu Konfigurationsoptionen, Tabellenzuweisung, Berechtigungen, Bereitstellung,Leistungsüberlegungen und Lizenzierung finden Sie unter Amazon Athena Cloudwatch MetricsConnector auf GitHub.

Amazon Athena DocumentDB-KonnektorDer Amazon Athena Amazon DocumentDB-Konnektor ermöglicht Amazon Athena dieKommunikation mit Ihren Amazon DocumentDB-Instances, sodass Sie Ihre AmazonDocumentDB-Daten mit SQL abfragen können. Der Konnektor funktioniert auch mit jedemEndpunkt, der mit MongoDB kompatibel ist.

Informationen dazu, wie der Konnektor Schemas generiert, sowie zu Konfigurationsoptionen,Berechtigungen, Bereitstellung und Leistung finden Sie unter Amazon Athena DocumentDBConnector auf GitHub.

Amazon Athena DynamoDB-KonnektorDer Amazon Athena DynamoDB-Konnektor ermöglicht Amazon Athena die Kommunikation mitDynamoDB, sodass Sie Ihre Tabellen mit SQL abfragen können.

Informationen zu Konfigurationsoptionen, Berechtigungen, Bereitstellung und Leistung findenSie unter Amazon Athena DynamoDB Connector auf GitHub.

104









Amazon Athena HBase-KonnektorDer Amazon Athena HBase-Konnektor ermöglicht Amazon Athena die Kommunikation mit IhrenHBase-Instances, sodass Sie Ihre HBase-Daten mit SQL abfragen können.

Informationen zu Konfigurationsoptionen, Datentypen, Berechtigungen, Bereitstellung, Leistungund Lizenzierung finden Sie unter Amazon Athena HBase Connector auf GitHub.

Amazon Athena-Konnektor für JDBC-kompatibleDatenquellenDer Amazon Athena Lambda-JDBC-Konnektor ermöglicht Amazon Athena den Zugriff auf IhreJDBC-kompatible Datenbank. Derzeit unterstützte Datenbanken sind u.a. MySQL, PostgreSQLund Amazon Redshift.

Informationen zu unterstützten Datenbanken, Konfigurationsparametern, unterstütztenDatentypen, JDBC-Treiberversionen, Einschränkungen und anderen Informationen finden Sieunter Amazon Athena Lambda JDBC Connector auf GitHub.

Amazon Athena Redis-KonnektorDer Amazon Athena Redis-Konnektor ermöglicht Amazon Athena die Kommunikation mitIhren Redis-Instances, sodass Sie Ihre Redis-Daten mit SQL abfragen können. Sie können dieAWS Glue-Datenkatalog verwenden, um Ihre Redis-Schlüssel-Wert-Paare virtuellen Tabellenzuzuordnen.

Informationen zu Konfigurationsoptionen, zum Einrichten von Datenbanken und Tabellen,Datentypen, Berechtigungen, Bereitstellung, Leistung und Lizenzierung finden Sie unterAmazon Athena Redis Connector auf GitHub.

Amazon Athena TPC-Benchmark DS (TPC-DS)-KonnektorDer Amazon Athena TPC-DS-Konnektor ermöglicht Amazon Athena die Kommunikationmit einer Quelle zufällig erzeugter TPC-Benchmark-DS-Daten für Benchmarking undFunktionstests. Der Athena TPC-DS-Konnektor generiert eine TPC-DS-konforme Datenbankmit einem von vier Skalierungsfaktoren.

Informationen zu Konfigurationsoptionen, Datenbanken und Tabellen, Berechtigungen,Bereitstellung, Leistung und Lizenzierung finden Sie unter Amazon Athena TPC-DS Connectorauf GitHub.

Schreiben von VerbundabfragenWenn Sie einen oder mehrere Datenkonnektoren konfiguriert und in Ihrem Konto bereitgestellthaben, können Sie diese in Ihren Athena-Abfragen verwenden.

Abfragen einer einzelnen DatenquelleIn den Beispielen in diesem Abschnitt wird davon ausgegangen, dass Sie den AthenaCloudWatch-Konnektor für Ihr Konto konfiguriert und bereitgestellt haben. Sie verwenden dengleichen Ansatz für Abfragen für andere Konnektoren.

So erstellen Sie eine Athena-Abfrage, die den CloudWatch-Konnektor verwendet

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.

105




https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-tpcds



2. Erstellen Sie im Athena-Abfrage-Editor eine SQL-Abfrage mit der folgenden Syntax in derFROM-Klausel.

MyCloudwatchCatalog.database_name.table_name

Beispiele

Im folgenden Beispiel wird der Athena CloudWatch-Konnektor verwendet, um eine Verbindungmit der Ansicht all_log_streams in der /var/ecommerce-engine/order-processorCloudWatch Logs Protokollgruppe herzustellen. Die Ansicht all_log_streams ist eineAnsicht aller Protokollstreams in der Protokollgruppe. Die Beispielabfrage begrenzt die Anzahlder zurückgegebenen Zeilen auf 100.

Example

SELECT * FROM "MyCloudwatchCatalog"."/var/ecommerce-engine/order-

processor".all_log_streams limit 100;

Im folgenden Beispiel werden Informationen aus derselben Ansicht wie im vorherigen Beispielanalysiert. Im Beispiel werden die Bestellnummer und die Protokollebene extrahiert und alleNachrichten mit der Ebene INFO herausgefiltert.

Example

SELECT log_stream as ec2_instance,

Regexp_extract(message '.*orderId=(\d+) .*', 1) AS

orderId,

message AS

order_processor_log,

Regexp_extract(message, '(.*):.*', 1) AS

log_level

FROM

"MyCloudwatchCatalog"."/var/ecommerce-engine/order-

processor".all_log_streams

WHERE Regexp_extract(message, '(.*):.*', 1) != 'INFO'

Die folgende Abbildung zeigt ein Beispielergebnis.

Note

Dieses Beispiel zeigt eine Abfrage, in der die Datenquelle bei Athena als Katalogregistriert wurde. Sie können auf die Lambda-Funktion eines Datenquellenkonnektorsauch im Format lambda:MyLambdaFunctionName. verweisen.

Abfragen mehrerer DatenquellenUm ein komplexeres Beispiel zu zeigen, stellen Sie sich ein E-Commerce-Unternehmen vor,das eine Anwendungsinfrastruktur wie die im folgenden Diagramm gezeigte besitzt.

106

https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html


Die folgenden Beschreibungen erklären die nummerierten Elemente im Diagramm.

1. Zahlungsabwicklung in einer sicheren VPC mit Transaktionsdatensätzen, die in HBase aufAmazon EMR gespeichert sind

2. Redis zum Speichern aktiver Bestellungen, damit die Verarbeitungs-Engine schnell auf siezugreifen kann

3. Amazon DocumentDB für Kundenkontodaten wie E-Mail- und Versandadressen4. Ein Produktkatalog in Amazon Aurora für eine E-Commerce-Website, die automatische

Skalierung auf Fargate verwendet5. CloudWatch Logs zum Speichern der Protokollereignisse des Bestellverarbeiters6. Ein Data Warehouse des Typs „Write-Once-Read-Many“ auf Amazon RDS7. DynamoDB zum Speichern von SendungsverfolgungsdatenAngenommen, ein Datenanalyst für diese E-Commerce-Anwendung stellt fest, dass derZustand einiger Bestellungen falsch gemeldet wird. Einige Bestellungen werden als ausstehendangezeigt, obwohl sie zugestellt wurden. Andere Bestellungen werden als zugestellt angezeigt,obwohl sie nicht versendet wurden.

Der Analyst möchte wissen, wie viele Bestellungen verzögert werden und was den betroffenenBestellungen in der E-Commerce-Infrastruktur gemeinsam ist. Anstatt die Informationsquellengetrennt zu untersuchen, verbindet der Analyst die Datenquellen und ruft die notwendigenInformationen mit einer einzigen Abfrage ab. Die Daten müssen nicht zu einem einzelnenSpeicherort extrahiert werden.

Die Abfrage des Analysten verwendet die folgenden Athena-Datenkonnektoren:

• CloudWatch Logs – Ruft Protokolle aus dem Bestellverarbeitungsservice ab und verwendetRegex-Abgleich und -Extraktion, um nach Bestellungen mit WARN- oder ERROR-Ereignissenzu filtern.

• Redis – Ruft die aktiven Bestellungen aus der Redis-Instance ab.

107




• CMDB – Ruft die ID und den Status der Amazon EC2-Instance ab, die denBestellverarbeitungsservice ausgeführt und die ERROR-oder WARN-Meldung protokolliert hat.

• DocumentDB – Ruft E-Mail und Adresse des Kunden für die betroffenen Bestellungen ausAmazon DocumentDB ab.

• DynamoDB – Ruft den Versandstatus und die Nachverfolgungsdetails aus der Versandtabelleab, um mögliche Abweichungen zwischen gemeldetem und tatsächlichem Status zuidentifizieren.

• HBase – Ruft den Zahlungsstatus für die betroffenen Bestellungen aus demZahlungsverarbeitungsservice ab.

Example

Note

Dieses Beispiel zeigt eine Abfrage, in der die Datenquelle bei Athena als Katalogregistriert wurde. Sie können auf die Lambda-Funktion eines Datenquellenkonnektorsauch im Format lambda:MyLambdaFunctionName. verweisen.

--Sample query using multiple Athena data connectors.

WITH logs

AS (SELECT log_stream,

message AS

order_processor_log,

Regexp_extract(message, '.*orderId=(\d+) .*', 1) AS orderId,

Regexp_extract(message, '(.*):.*', 1) AS log_level

FROM

"MyCloudwatchCatalog"."/var/ecommerce-engine/order-

processor".all_log_streams

WHERE Regexp_extract(message, '(.*):.*', 1) != 'INFO'),

active_orders

AS (SELECT *

FROM redis.redis_db.redis_customer_orders),

order_processors

AS (SELECT instanceid,

publicipaddress,

state.NAME

FROM awscmdb.ec2.ec2_instances),

customer

AS (SELECT id,

email

FROM docdb.customers.customer_info),

addresses

AS (SELECT id,

is_residential,

address.street AS street

FROM docdb.customers.customer_addresses),

shipments

AS ( SELECT order_id,

shipment_id,

from_unixtime(cast(shipped_date as double)) as shipment_time,

carrier

FROM lambda_ddb.default.order_shipments),

payments

AS ( SELECT "summary:order_id",

"summary:status",

"summary:cc_id",

"details:network"

FROM "hbase".hbase_payments.transactions)

SELECT _key_ AS redis_order_id,

customer_id,

108





Amazon Athena BenutzerhandbuchSchreiben eines Datenquellenkonnektors

customer.email AS cust_email,

"summary:cc_id" AS credit_card,

"details:network" AS CC_type,

"summary:status" AS payment_status,

status AS redis_status,

addresses.street AS street_address,

shipments.shipment_time as shipment_time,

shipments.carrier as shipment_carrier,

publicipaddress AS ec2_order_processor,

NAME AS ec2_state,

log_level,

order_processor_log

FROM active_orders

LEFT JOIN logs

ON logs.orderid = active_orders._key_

LEFT JOIN order_processors

ON logs.log_stream = order_processors.instanceid

LEFT JOIN customer

ON customer.id = customer_id

LEFT JOIN addresses

ON addresses.id = address_id

LEFT JOIN shipments

ON shipments.order_id = active_orders._key_

LEFT JOIN payments

ON payments."summary:order_id" = active_orders._key_

Die folgende Abbildung zeigt Beispielergebnisse für die Abfrage.

Schreiben eines Datenquellenkonnektorsmithilfe desUm eigene Datenquellenkonnektoren (p. 66) zu schreiben, können Sie den https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk verwenden. Derdefiniert einen Satz von Schnittstellen und Wire-Protokollen, mit denen Sie Athena ermöglichenkönnen, Teile des Abfrageausführungsplans an Code zu delegieren, den Sie schreiben undbereitstellen. Das SDK enthält eine Konnektor-Suite und einen Beispielkonnektor.

Sie können die von Amazon Athena vorab erstellten Konnektoren für Ihren eigenen Gebrauchanpassen. Sie können eine Kopie des Quellcodes aus GitHub ändern und dann das ConnectorPublish Tool verwenden, um ein eigenes AWS Serverless Application Repository-Paket zuerstellen. Nachdem Sie den Konnektor auf diese Weise bereitgestellt haben, können Sie ihn inIhren Athena-Abfragen verwenden.

Note

Informationen zum Herunterladen des SDK und detaillierte Anweisungen zum Schreiben eineseigenen Konnektors finden Sie unter Athena-Beispielkonnektor auf GitHub.

109







Amazon Athena BenutzerhandbuchVerwalten von Datenquellen

Verwalten von DatenquellenSie können die Seite Data sources (Datenquellen) der Athena-Konsole verwenden, um die vonIhnen erstellten Datenquellen anzuzeigen, zu bearbeiten oder zu löschen, einschließlich desAthena-Datenquellenkonnektors, AWS Glue-Datenkatalog, und Hive Metastore-Katalogtypen.

So zeigen Sie eine Datenquelle an:

• Wählen Sie den Katalognamen der Datenquelle, oder klicken Sie auf die Schaltflächedaneben, und wählen Sie View details (Details anzeigen). Die Detailseite enthält dieOptionen Edit (Bearbeiten) und Delete (Löschen) der Datenquelle.

So bearbeiten Sie eine Datenquelle:

1. Wählen Sie den Katalognamen der Datenquelle, oder klicken Sie auf die Schaltflächeneben dem Katalognamen.

2. Wählen Sie Edit aus.3. Auf der Seite Edit (Bearbeiten) für den Metastore können Sie eine andere Lambda-

Funktion für die Datenquelle auswählen oder die Beschreibung der vorhandenen Funktionändern. Wenn Sie einen AWS Glue-Katalog bearbeiten, öffnet die AWS Glue-Konsole denentsprechenden Katalog zur Bearbeitung.

4. Wählen Sie Save (Speichern) aus.So löschen Sie eine Datenquelle:

1. Wählen Sie die Schaltfläche neben der Datenquelle oder dem Namen der Datenquelle,und wählen Sie dann Delete (Löschen). Sie werden gewarnt, dass beim Löschen einerMetastore-Datenquelle der entsprechende Datenkatalog, Tabellen und Ansichten aus demAbfrage-Editor entfernt werden. Gespeicherte Abfragen, die den Metastore verwendethaben, werden nicht mehr in Athena ausgeführt.

2. Wählen Sie Delete (Löschen).

Herstellen einer Verbindung zu AmazonAthena mit ODBC- und JDBC-Treibern

Wenn Sie Ihre Daten mit Business-Intelligence-Tools durchsuchen und darstellen möchten,müssen Sie einen ODBC (Open Database Connectivity)- oder JDBC (Java DatabaseConnectivity)-Treiber herunterladen, installieren und konfigurieren.

Themen

• Verwenden von Athena mit dem JDBC-Treiber (p. 76)• Verbindung zu Amazon Athena mit ODBC (p. 78)

Verwenden von Athena mit dem JDBC-TreiberSie können eine JDBC-Verbindung verwenden, um Athena mit Business-Intelligence-Toolsund anderen Anwendungen wie SQL Workbench zu verbinden. Hierfür müssen Sie denAthena-JDBC-Treiber über die folgenden Links in Amazon S3 herunterladen, installieren undkonfigurieren.

110

http://www.sql-workbench.eu/downloads.html

Amazon Athena BenutzerhandbuchVerwenden von Athena mit dem JDBC-Treiber

Links zum Herunterladen des JDBC-TreibersDie JDBC-Treiberversion 2.0.9 ist mit den Datenstandards JDBC API 4.1 und 4.2 kompatibel.Bevor Sie den Treiber herunterladen, überprüfen Sie, welche Version der Java RuntimeEnvironment (JRE) Sie verwenden. Die JRE-Version hängt von der Version der JDBC-APIab, die Sie mit dem Treiber einsetzen. Wenn Sie sich nicht sicher sind, laden Sie die neuesteVersion des Treibers herunter.

Laden Sie den Treiber für Ihre JDK-Version und Ihre Version der JDBC-Datenstandardsherunter:

• AthenaJDBC41-2.0.9.jar ist mit JDBC 4.1 kompatibel und erfordert JDK 7.0 oder höher.

• AthenaJDBC42-2.0.9.jar ist mit JDBC 4.2 kompatibel und erfordert JDK 8.0 oder höher.JDBC-Treiber – Versionshinweise, Lizenzvereinbarung undAnmerkungen

Nachdem Sie die benötigte Version heruntergeladen haben, lesen Sie die Versionshinweiseund überprüfen Sie die Lizenzvereinbarung und Anmerkungen.

• Versionshinweise

• Lizenzvereinbarung• Hinweise• DrittanbieterlizenzenDokumentation zum JDBC-Treiber


• Installations- und Konfigurationshandbuch für JDBC-Treiber. Verwenden Sie diesesHandbuch für die Installation und Konfiguration des Treibers.

• Migrationsleitfaden für den JDBC-Treiber. Verwenden Sie dieses Handbuch für die Migrationvon früheren Versionen auf die aktuelle Version.

Links zum Herunterladen des JDBC-Treibers fürVorversionsfunktionenDiese Treiber unterstützen Athena-Vorversionsfunktionen. Laden Sie den Treiber für Ihre JDK-Version und Ihre Version der JDBC-Datenstandards herunter:

• The AthenaJDBC41_preview.jar ist mit JDBC 4.1 kompatibel und erfordert JDK 7.0 oderneuer.

• Der AthenaJDBC42_preview.jar ist mit JDBC 4.2 kompatibel und erfordert JDK 8.0 oderneuer.

JDBC-Treiber-Versionshinweise, Lizenzvereinbarung und Hinweise fürVorversionstreiber

Nachdem Sie die benötigte Version heruntergeladen haben, lesen Sie die Versionshinweiseund überprüfen Sie die Lizenzvereinbarung und Anmerkungen.

• Versionshinweise

111

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/SimbaAthenaJDBC_2.0.9/AthenaJDBC41_2.0.9.jar





https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.9/docs/third-party-licenses.txt





https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/release-notes.txt


• Lizenzvereinbarung

• Hinweise• DrittanbieterlizenzenJDBC-Treiberdokumentation für Vorversionstreiber


• Installations- und Konfigurationshandbuch für JDBC-Treiber. Verwenden Sie diesesHandbuch für die Installation und Konfiguration des Treibers.

• Migrationsleitfaden für den JDBC-Treiber. Verwenden Sie dieses Handbuch für die Migrationvon früheren Versionen auf die aktuelle Version.

Migrieren von der vorherigen Version des JDBC-TreibersBei der aktuellen JDBC-Treiberversion 2.0.9 handelt es sich um einen Drop-In-Ersatzfür die vorherige JDBC-Treiberversion 2.0.8. Sie ist abwärtskompatibel mit der JDBC-Treiberversion 2.0.8, wobei Sie den folgenden Schritt ausführen müssen, damit der Treibersicher funktioniert.

Important

Um die JDBC-Treiberversion 2.0.5 oder höher zu verwenden, fügen Sie eineBerechtigungsrichtlinie an IAM-Prinzipale an, die den JDBC-Treiber verwenden,der die athena:GetQueryResultsStream-Richtlinienaktion zulässt. DieseRichtlinienaktion wird nicht direkt mit der API bereitgestellt. Sie wird nur mitdem JDBC-Treiber als Teil der Unterstützung von Streaming-Ergebnissenverwendet. Eine Beispielrichtlinie finden Sie unter Verwaltete RichtlinieAWSQuicksightAthenaAccess (p. 220). Stellen Sie außerdem sicher, dass Port (444)für den ausgehenden Datenverkehr geöffnet ist. Weitere Informationen zum Upgradevon Version 2.0.2 auf Version 2.0.5 oder höher finden Sie im Migrationsleitfaden fürden JDBC-Treiber.

Informationen zu den vorherigen Versionen des JDBC-Treibers finden Sie unter Verwenden dervorherigen Version des JDBC-Treibers (p. 352).

Wenn Sie von einem 1.x-Treiber zu einem 2.x Treiber migrieren, müssen Sie Ihre bestehendenKonfigurationen zur neuen Konfiguration migrieren. Es wird dringend empfohlen, zurTreiberversion 2.x zu migrieren. Weitere Informationen finden Sie im Migrationsleitfaden für denJDBC-Treiber.

Verbindung zu Amazon Athena mit ODBCLaden Sie den ODBC-Treiber, die Amazon Athena-ODBC-Treiberlizenzvereinbarung und dieDokumentation für den Treiber über die folgenden Links herunter.

Amazon Athena-ODBC-TreiberlizenzvereinbarungLizenzvereinbarung

WindowsODBC 1.0.5 für Windows 32-Bit Windows 32-Bit ODBC-Treiber 1.0.5

112

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/LICENSE.txt

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/NOTICES.txt

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/third-party-licenses.txt

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/Simba+Athena+JDBC+Driver+Install+and+Configuration+Guide.pdf

https://athena-downloads.s3.amazonaws.com/drivers/JDBC/athena-preview/SimbaAthenaJDBC_2.0.11_preview/docs/Simba+Athena+JDBC+Driver+Migration+Guide.pdf





https://s3.amazonaws.com/athena-downloads/agreement/ODBC/Amazon+Athena+ODBC+Driver+License+Agreement.pdf





LinuxODBC 1.0.5 für Linux 32-Bit Linux 32-Bit ODBC-Treiber 1.0.5



OSXODBC 1.0.5 für OSX OSX ODBC-Treiber 1.0.5


Dokumentation zum ODBC-TreiberDokumentation für ODBC 1.0.5 Installations- und Konfigurationshandbuch für

ODBC-Treiber Version 1.0.5.

Versionshinweise für ODBC 1.0.5 ODBC-Treiberversionshinweise fürVersion 1.0.5


Migrieren von der vorherigen Version des ODBC-TreibersDie aktuelle ODBC-Treiberversion 1.0.5 ist ein Drop-In-Ersatz für die vorherige Versionder ODBC-Treiberversion 1.0.4. Sie ist darüber hinaus mit der ODBC-Treiberversion1.0.3 abwärtskompatibel, wenn Sie die folgenden erforderlichen Schritte ausführen, umsicherzustellen, dass der Treiber funktioniert.

Important

Um den ODBC-Treiber in Version 1.0.3 und höher verwenden zu können, müssen Siedie folgenden Anforderungen erfüllen:

• Behalten Sie den Port 444 für ausgehenden Datenverkehr offen.• Fügen Sie die Richtlinienaktion athena:GetQueryResultsStream zur Liste

der Richtlinien für Athena hinzu. Diese Richtlinienaktion wird nicht direkt mitder API-Operation verfügbar gemacht und ausschließlich mit den ODBC- undJDBC-Treibern als Teil der Unterstützung für das Streamen von Ergebnissenverwendet. Eine Beispielrichtlinie finden Sie unter Verwaltete RichtlinieAWSQuicksightAthenaAccess (p. 220).

113










Vorherige Versionen des ODBC-TreibersODBC 1.0.4 für Windows 32-Bit Windows 32-Bit ODBC-Treiber 1.0.4











ODBC 1.0.3 für OSX OSX ODBC-Treiber 1.0







ODBC 1.0 für OSX OSX ODBC-Treiber 1.0


Treiberversion 1.0.2 Download-Link (p. 48). Wenn Sie eine DDL-Abfrage (Data Definition Language) ausführen, die das Schema ändert,schreibt Athena die Metadaten in den Metastore, der der Datenquelle zugeordnet ist. Darüber hinauskönnen einige Abfragen, z. B. CREATE TABLE AS und INSERT INTO, Datensätze in den Datensatzschreiben— und etwa einen CSV-Datensatz zu einem Amazon S3-Speicherort hinzufügen. BeimAusführen einer Abfrage werden die Ergebnisse einer Abfrage an einem von Ihnen angegebenenAbfrageergebnisspeicherort von Athena gespeichert. Auf diese Weise können Sie den Abfrageverlaufanzeigen und Abfrageergebnissätze herunterladen und anzeigen.

114

















https://s3.amazonaws.com/athena-downloads/drivers/ODBC/Linux/simbaathena-1.0.2.1003-1.i686.rpm

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/Linux/simbaathena-1.0.2.1003-1.x86_64.rpm

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/OSX/Simba+Athena+1.0.dmg



Amazon Athena BenutzerhandbuchAbfrageergebnisse und Abfrageverlauf

Dieser Abschnitt enthält Anleitungen zum Ausführen von Athena-Abfragen für gängige Datenquellenund Datentypen mit einer Vielzahl von SQL-Anweisungen. Es werden allgemeine Leitlinien für dieArbeit mit gemeinsamen Strukturen und Operatoren gegeben,—zum Beispiel für die Arbeit mit Arrays,Verkettung, Filterung, Abflachung und Sortierung. Weitere Beispiele sind Abfragen von Daten in Tabellenmit verschachtelten Strukturen und Karten, Tabellen auf Basis von JSON-codierten Datasets und Datasets,die mit AWS-Services wie AWS CloudTrail-Protokollen und Amazon EMR-Protokollen verknüpft sind.

Themen• Arbeiten mit Abfrageergebnissen, Ausgabedateien und dem Abfrageverlauf (p. 115)• Arbeiten mit Ansichten (p. 121)• Erstellen einer Tabelle aus Abfrageergebnissen (CTAS) (p. 126)• Verarbeiten von Schema-Updates (p. 136)• Abfragen von Arrays (p. 145)• Abfragen von &JSON (p. 162)• Abfragen von koordinatenbasierten Daten (p. 168)• Die Verwendung von (p. 180)• Abfragen mit benutzerdefinierten Funktionen (User Defined Functions, UDFs) (Vorversion) (p. 182)• Abfragen von AWS-Serviceprotokollen (p. 190)

Arbeiten mit Abfrageergebnissen, Ausgabedateienund dem Abfrageverlauf

Amazon Athena speichert automatisch Abfrageergebnisse und Metadateninformationen für jede Abfrage,die an einem Speicherort des Abfrageergebnisses ausgeführt wird, den Sie in Amazon S3 angebenkönnen. Falls erforderlich, können Sie auf die Dateien an diesem Speicherort zugreifen, um mit ihnen zuarbeiten. Sie können Abfrageergebnisdateien auch direkt von der Athena-Konsole herunterladen.

Ausgabedateien werden automatisch für jede Abfrage gespeichert, die ausgeführt wird, unabhängig davon,ob die Abfrage selbst gespeichert wurde oder nicht. Um auf Abfrageausgabedateien zuzugreifen unddiese anzuzeigen, benötigen IAM-Prinzipale (Benutzer und Rollen) die Berechtigung für die Amazon S3GetObject-Aktion für den Speicherort des Abfrageergebnisses sowie die Berechtigung für die AthenaGetQueryResults-Aktion. Der Speicherort des Abfrageergebnisses kann verschlüsselt werden. Wenn derSpeicherort verschlüsselt ist, müssen Benutzer über die entsprechenden Schlüsselberechtigungen zumVer- und Entschlüsseln des Speicherorts des Abfrageergebnisses verfügen.

Important

IAM-Prinzipale mit Berechtigung für die Amazon S3 GetObject-Aktion für den Speicherort desAbfrageergebnisses können Abfrageergebnisse auch dann von Amazon S3 abrufen, wenn dieBerechtigung für die Athena GetQueryResults-Aktion verweigert wird.

Abrufen einer Abfrage-IDJede ausgeführte Abfrage wird als Abfrageausführung bezeichnet. Die Abfrageausführung hateine eindeutige Kennung, die als Abfrage-ID oder Abfrageausführungs-ID bezeichnet wird. Um mitAbfrageergebnisdateien zu arbeiten und Abfrageergebnisdateien schnell zu finden, benötigen Sie dieAbfrage-ID. Wir bezeichnen die Abfrage-ID in diesem Thema als QueryID.

So verwenden Sie die Athena-Konsole, um die QueryID einer Abfrage abzurufen, die ausgeführtwurde

1. Wählen Sie in der Navigationsleiste History (Verlauf) aus.

115

https://docs.aws.amazon.com/

https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryResults.html

Amazon Athena BenutzerhandbuchIdentifizieren von Abfrageausgabedateien

2. Wählen Sie in der Liste der Abfragen den Abfragestatus unter State (Status) aus, z. B. Failed(Fehlgeschlagen).

3. Klicken Sie auf das Symbol neben Query ID (Abfrage-ID), um die ID in die Zwischenablage zukopieren.

Identifizieren von AbfrageausgabedateienDateien werden basierend auf dem Namen der Abfrage, der Abfrage-ID und dem Datum, an dem dieAbfrage ausgeführt wurde, am Speicherort des Abfrageergebnisses in Amazon S3 gespeichert. Die Dateienfür jede Abfrage werden mit der QueryID benannt. Dabei handelt es sich um eine eindeutige Kennung, dieAthena jeder Abfrage zuweist, wenn sie ausgeführt wird.

Die folgenden Dateitypen werden gespeichert:

Dateityp Dateibenennungsmuster Beschreibung

Abfrageergebnisdateien QueryID.csv Abfrageergebnisdateien werdenim CSV-Format (durch Kommagetrennte Werte) gespeichert. Sieenthalten das Tabellenergebnisjeder Abfrage. Sie können dieseDateien über die Konsole imBereich Results (Ergebnisse)herunterladen, wenn Sie dieKonsole verwenden oderüber den Verlauf der Abfrage.Weitere Informationen findenSie unter Herunterladen vonAbfrageergebnisdateien mithilfeder Athena-Konsole (p. 118).

Abfragemetadatendateien QueryID.csv.metadata Abfragemetadatendateienwerden im Binärformatgespeichert und sind nichtlesbar. Athena verwendet dieMetadaten beim Lesen derAbfrageergebnisse mit derGetQueryResults-Aktion.Obwohl diese Dateien gelöschtwerden können, empfehlenwir dies nicht, da wichtigeInformationen über die Abfrageverloren gehen.

Datenmanifestdateien QueryID-manifest.csv Datenmanifestdateienwerden generiert, umDateien nachzuverfolgen,die Athena in Amazon S3-Datenquellenspeicherortenerstellt, wenn eine INSERTINTO (p. 321)-Abfrageausgeführt wird. Wenn eineAbfrage fehlschlägt, verfolgtdas Manifest auch Dateien,die die Abfrage schreibenwollte. Das Manifest ist

116

Amazon Athena BenutzerhandbuchIdentifizieren von Abfrageausgabedateien

Dateityp Dateibenennungsmuster Beschreibungnützlich für die Identifizierungverwaister Dateien, die auseiner fehlgeschlagenen Abfrageresultieren.

Abfrageausgabedateien werden nach dem folgenden Muster in Unterordnern gespeichert.

QueryResultsLocationInS3/[QueryName|Unsaved/yyyy/mm/dd/]

• QueryResultsLocationInS3 ist der Speicherort des Abfrageergebnisses, der entweder durchArbeitsgruppeneinstellungen oder clientseitige Einstellungen angegeben wird. Weitere Informationenfinden Sie unter the section called “Angeben eines Speicherorts des Abfrageergebnisses” (p. 118)weiter unten in diesem Dokument.

• Die folgenden Unterordner werden nur für Abfragen erstellt, die über die Konsole ausgeführt werden.Abfragen, die über die AWS CLI oder mithilfe der Athena-API ausgeführt werden, werden direkt inQueryResultsLocationInS3 gespeichert.• QueryName ist der Name der Abfrage, deren Ergebnisse gespeichert wurden. Wenn die Abfrage

ausgeführt, aber nicht gespeichert wurde, wird Unsaved verwendet.• yyyy/mm/dd (jjjj/mm/tt) ist das Datum, an dem die Abfrage ausgeführt wurde.

Dateien, die einer CREATE TABLE AS SELECT-Abfrage zugeordnet sind, werden in einem tables-Unterordner des obigen Musters gespeichert.

So identifizieren Sie den Abfrageausgabespeicherort und die Abfrageergebnisdateien mithilfe derAWS CLI

• Verwenden Sie den Befehl aws athena get-query-execution wie im folgenden Beispiel gezeigt.Ersetzen Sie abc1234d-5efg-67hi-jklm-89n0op12qr34 durch die Abfrage-ID.

aws athena get-query-execution --query-execution-id abc1234d-5efg-67hi-jklm-89n0op12qr34

Daraufhin erhalten Sie ein Ergebnis, das dem hier dargestellten entspricht. Beschreibungen dereinzelnen Ausgabeparameter finden Sie unter get-query-execution im AWS CLI Command Reference.

{ "QueryExecution": { "Status": { "SubmissionDateTime": 1565649050.175, "State": "SUCCEEDED", "CompletionDateTime": 1565649056.6229999 }, "Statistics": { "DataScannedInBytes": 5944497, "DataManifestLocation": "s3://aws-athena-query-results-123456789012-us-west-1/MyInsertQuery/2019/08/12/abc1234d-5efg-67hi-jklm-89n0op12qr34-manifest.csv", "EngineExecutionTimeInMillis": 5209 }, "ResultConfiguration": { "EncryptionConfiguration": { "EncryptionOption": "SSE_S3" }, "OutputLocation": "s3://aws-athena-query-results-123456789012-us-west-1/MyInsertQuery/2019/08/12/abc1234d-5efg-67hi-jklm-89n0op12qr34"

117

https://docs.aws.amazon.com/cli/latest/reference/athena/get-query-execution.html

Amazon Athena BenutzerhandbuchHerunterladen von Abfrageergebnisdateien

mithilfe der Athena-Konsole

}, "QueryExecutionId": "abc1234d-5efg-67hi-jklm-89n0op12qr34", "QueryExecutionContext": {}, "Query": "INSERT INTO mydb.elb_log_backup SELECT * FROM mydb.elb_logs LIMIT 100", "StatementType": "DML", "WorkGroup": "primary" }}

Herunterladen von Abfrageergebnisdateien mithilfe derAthena-KonsoleSie können die CSV-Datei der Abfrageergebnisse direkt nach der Ausführung einer Abfrage oder über denVerlauf der Abfrage aus dem Abfragebereich herunterladen.

So laden Sie die Abfrageergebnisdatei der letzten Abfrage herunter

1. Geben Sie Ihre Abfrage in den Abfrage-Editor ein und wählen Sie dann Run query (Abfrage ausführen)aus.

Wenn die Ausführung der Abfrage abgeschlossen ist, zeigt der Bereich Results (Ergebnisse) dieAbfrageergebnisse an.

2. Um die Abfrageergebnisdatei herunterzuladen, wählen Sie das Dateisymbol im Bereich derAbfrageergebnisse aus. Je nach Browser- und Browserkonfiguration müssen Sie möglicherweise denDownload bestätigen.

So laden Sie eine Abfrageergebnisdatei für eine frühere Abfrage herunter

1. Wählen Sie History (Verlauf) aus.2. Blättern Sie durch die Liste der Abfragen, bis Sie die Abfrage finden, und wählen Sie dann Download

results (Ergebnisse herunterladen) unter Action (Aktion) für diese Abfrage aus.

Angeben eines Speicherorts des AbfrageergebnissesDer Speicherort des Abfrageergebnisses, den Athena verwendet, wird durch eine Kombination ausArbeitsgruppeneinstellungen und clientseitigen Einstellungen bestimmt. Die clientseitigen Einstellungenbasieren darauf, wie Sie die Abfrage ausführen. Wenn Sie die Abfrage über die Athena-Konsoleausführen, bestimmt der Speicherort des Abfrageergebnisses, der unter Settings (Einstellungen) in derNavigationsleiste eingegeben wurde, die clientseitige Einstellung. Wenn Sie die Abfrage mit der Athena-APIausführen, bestimmt der OutputLocation-Parameter der StartQueryExecution-Aktion die clientseitige

118

https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html

Amazon Athena BenutzerhandbuchAngeben eines Speicherorts des Abfrageergebnisses

Einstellung. Wenn Sie die ODBC- oder JDBC-Treiber zum Ausführen von Abfragen verwenden, bestimmtdie in der Verbindungs-URL angegebene S3OutputLocation-Eigenschaft die clientseitige Einstellung.

Jede Arbeitsgruppenkonfiguration verfügt über eine Option Override client-side settings (ClientseitigeEinstellungen überschreiben), die aktiviert werden kann. Wenn diese Option aktiviert ist, haben dieArbeitsgruppeneinstellungen Vorrang vor den anwendbaren clientseitigen Einstellungen, wenn ein IAM-Prinzipal, der dieser Arbeitsgruppe zugeordnet ist, die Abfrage ausführt.

Angeben eines Speicherorts des Abfrageergebnisses mithilfe derAthena-KonsoleAthena verfügt über einen Standard-Speicherort des Abfrageergebnisses für die Athena-Konsole. Athenaverwendet den Standard nur, wenn Sie in der Konsole keinen anderen Speicherort des Abfrageergebnissesangegeben haben, wie unten beschrieben, und Ihre Arbeitsgruppe clientseitige Einstellungen nichtüberschreibt.

Das folgende Muster wird für den Standard-Speicherort des Abfrageergebnisses der Konsole verwendet.MyAcctID ist die AWS-Konto-ID des IAM-Prinzipals, der die Abfrage ausgeführt hat, und MyRegion ist dieRegion, in der die Abfrage ausgeführt wurde, z. B. us-west-1.

aws-athena-query-results-MyAcctID-MyRegion

Important

Wenn Sie eine Abfrage mit der API oder mit dem ODBC- oder JDBC-Treiber ausführen, giltdie Konsoleneinstellung nicht. Der Speicherort des Abfrageergebnisses muss entweder durchArbeitsgruppeneinstellungen oder clientseitige Einstellungen angegeben werden. Wenn keinAbfragespeicherort angegeben ist, schlägt die Abfrage mit einem Fehler fehl.

So ändern Sie den Speicherort des Abfrageergebnisses für eine Abfrage mithilfe der Athena-Konsole

1. Wählen Sie in der Navigationsleiste Settings (Einstellungen) aus.2. Geben Sie einen Speicherort des Abfrageergebnisses ein. Der von Ihnen eingegebene Speicherort

wird für nachfolgende Abfragen verwendet, es sei denn, Sie ändern ihn später.

Wenn Sie Mitglied einer Arbeitsgruppe sind, die einen Speicherort des Abfrageergebnisses mitaktivierter Option Override client-side settings (Clientseitige Einstellungen überschreiben) angibt, sinddie Option zum Ändern des Speicherorts des Abfrageergebnisses und die Verschlüsselungsoptionennicht verfügbar, wie unten gezeigt:

119

Amazon Athena BenutzerhandbuchAnzeigen des Abfrageverlaufs

Angeben eines Speicherorts des Abfrageergebnisses mithilfeeiner ArbeitsgruppeSie können den Speicherort des Abfrageergebnisses in einer Arbeitsgruppenkonfiguration mithilfe der AWSManagement Console, derAWS CLI oder der Athena-API angeben.

Wenn Sie die AWS CLI verwenden, geben Sie den Speicherort des Abfrageergebnisses mit demOutputLocation-Parameter der --configuration-Option an, wenn Sie den Befehl aws athena create-work-group oder aws athena update-work-group ausführen.

So geben Sie den Speicherort des Abfrageergebnisses für eine Arbeitsgruppe mithilfe der Athena-Konsole an

1. Wählen Sie Workgroup (Arbeitsgruppe):CurrentWorkgroupName in der Navigationsleiste aus.2. Führen Sie eine der folgenden Aufgaben aus:

• Wenn Sie eine vorhandene Arbeitsgruppe bearbeiten, wählen Sie sie aus der Liste aus, klicken Sieauf View details (Details anzeigen) und wählen Sie dann Edit Workgroup (Arbeitsgruppe bearbeiten)aus.

• Wenn Sie eine neue Arbeitsgruppe erstellen, wählen Sie Create workgroup (Arbeitsgruppe erstellen)aus.

3. Wählen Sie für Query result location (Speicherort des Abfrageergebnisses) den Ordner Select(Auswählen) aus.

4. Wählen Sie in der Liste der S3-Speicherorte nacheinander den blauen Pfeil aus, bis der Bucket undder Ordner, die Sie verwenden möchten, in der oberen Zeile angezeigt werden. Wählen Sie Select(Auswählen) aus.

5. Führen Sie unter Settings (Einstellungen) einen der folgenden Schritte aus:

• Wählen Sie Override client-side settings (Clientseitige Einstellungen überschreiben) aus, umAbfragedateien an dem Speicherort zu speichern, den Sie oben für alle Abfragen angegeben haben,die Mitglieder dieser Arbeitsgruppe ausführen.

• Deaktivieren Sie Override client-side settings (Clientseitige Einstellungen überschreiben), umAbfragedateien an dem Speicherort zu speichern, den Sie oben angegeben haben, und zwar nurdann, wenn Arbeitsgruppenmitglieder Abfragen mithilfe der Athena-API, des ODBC-Treibers oderdes JDBC-Treibers ausführen, ohne einen Ausgabespeicherort in Amazon S3 anzugeben.

6. Wenn Sie eine Arbeitsgruppe bearbeiten, wählen Sie Save (Speichern) aus. Wenn Sie eineArbeitsgruppe erstellen, wählen Sie Create workgroup (Arbeitsgruppe erstellen) aus.

Anzeigen des AbfrageverlaufsAthena hält den Abfrageverlauf 45 Tage lang vor. Um den Abfrageverlauf länger beizubehalten, könnenSie den Abfrageverlauf abrufen und ihn in einem Datenspeicher wie Amazon S3 mit den folgendenAthena-API-Aktionen speichern. Sie können diesen Prozess automatisieren, indem Sie die Vorgängeprogrammieren oder skripten, oder Sie können sie bei Bedarf mit AWS CLI ausführen. Sie können denAbfrageverlauf in der Athena-Konsole verwenden, um Fehler für fehlgeschlagene Abfragen anzuzeigenoder Abfrageergebnisdateien für erfolgreiche Abfragen herunterzuladen.

1. Rufen Sie die Abfrage-IDs mit ListQueryExecutions ab.2. Rufen Sie Informationen zu den einzelnen Abfragen basierend auf deren ID mit GetQueryExecution ab.3. Speichern Sie die erhaltenen Informationen in einem Datenspeicher wie beispielsweise Amazon S3.

Verwenden Sie hierfür die Aktion put-object aus der Amazon S3-API.

120

https://docs.aws.amazon.com/cli/latest/reference/athena/create-work-group.html

https://docs.aws.amazon.com/cli/latest/reference/athena/create-work-group.html

https://docs.aws.amazon.com/cli/latest/reference/athena/update-work-group.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_ListQueryExecutions.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryExecution.html

https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html

Amazon Athena BenutzerhandbuchArbeiten mit Ansichten

Anzeigen des Abfrageverlaufs1. Um die Athena-Konsole zum Anzeigen des Abfrageverlaufs zu verwenden, wählen Sie History (Verlauf)

und eine Abfrage aus. Hier sehen Sie auch, welche Abfragen erfolgreich ausgeführt wurden und welchefehlgeschlagen sind. Außerdem können Sie die Ergebnisse herunterladen und die Abfrage-ID durcheinen Klick auf den Statuswert anzeigen.

Arbeiten mit AnsichtenEine Ansicht in Amazon Athena ist eine logische, keine physische Tabelle. Die Abfrage, die eine Ansichtdefiniert, wird jedes Mal ausgeführt, wenn in einer Abfrage auf die Ansicht verwiesen wird.

Sie können eine Ansicht aus einer SELECT-Abfrage erstellen und dann in zukünftigen Abfragen auf dieseAnsicht verweisen. Weitere Informationen finden Sie unter CREATE VIEW (p. 336).

Themen• Einsetzen von Ansichten – wann sinnvoll? (p. 121)• Unterstützte Aktionen für Ansichten in Athena (p. 122)• Überlegungen für Ansichten (p. 122)• Einschränkungen für Ansichten (p. 123)• Arbeiten mit Ansichten in der Konsole (p. 123)• Erstellen von Ansichten (p. 124)• Beispiele für Ansichten (p. 125)• Aktualisieren von Ansichten (p. 126)• Löschen von Ansichten (p. 126)

Einsetzen von Ansichten – wann sinnvoll?Sie können Ansichten für folgende Zwecke erstellen:

• Abfrage einer Teilmenge von Daten. Sie können beispielsweise eine Tabelle mit einer Teilmenge derSpalten aus der ursprünglichen Tabelle erstellen. Dadurch werden Abfragen von Daten vereinfacht.

• Kombinieren mehrerer Tabellen in einer Abfrage. Wenn Sie mehrere Tabellen haben und sie mit UNIONALL kombinieren möchten, können Sie mit diesem Ausdruck eine Ansicht erstellen, um Abfragen für diekombinierten Tabellen zu vereinfachen.

121

Amazon Athena BenutzerhandbuchUnterstützte Aktionen für Ansichten in Athena

• Blenden Sie die Komplexität der vorhandenen Basis-Abfragen aus und vereinfachen Sie die Abfragen,die die Benutzer ausführen. Basis-Abfragen sind häufig Joins zwischen Tabellen, Ausdrücke in derSpaltenliste und andere SQL-Syntax, die schwer zu verstehen und zu debuggen ist. Sie können eineAnsicht erstellen, mit der die Komplexität ausgeblendet wird und die Abfragen vereinfacht werden.

• Experimentieren mit Optimierungstechniken und erstellen optimierter Abfragen. Wenn Sie beispielsweiseeine Kombination von WHERE-Bedingungen, JOIN-Reihenfolge oder andere Ausdrücke finden, die eineoptimale Leistung zeigen, erstellen Sie eine Ansicht mit diesen Klauseln und Ausdrücken. Anwendungenkönnen anschließend relativ einfache Abfragen für diese Ansicht ausführen. Wenn Sie zu einem späterenZeitpunkt eine bessere Möglichkeit finden, die ursprüngliche Abfrage zu optimieren, wenn Sie die Ansichtneu erstellen, profitieren alle Anwendungen sofort von den Vorteilen der optimierten Basis-Abfrage.

• Ausblenden zugrunde liegender Tabellen- und Spaltennamen und Minimieren von Wartungsproblemen,wenn sich diese Namen ändern. In diesem Fall erstellen Sie die Ansicht mit den neuen Namen. AlleAbfragen, die die Ansicht anstelle der zugrunde liegenden Tabellen verwenden, werden weiterhin ohneÄnderungen ausgeführt.

Unterstützte Aktionen für Ansichten in AthenaAthena unterstützt die folgenden Aktionen für Ansichten. Sie können diese Befehle im Abfrage-Editorausführen.

Statement Beschreibung

CREATE VIEW (p. 336) Erstellt eine neue Ansicht aus einer angegebenen SELECT-Abfrage. WeitereInformationen finden Sie unter Erstellen von Ansichten (p. 124).

Mit der optionalen OR REPLACE-Klausel können Sie die vorhandeneAnsicht aktualisieren, indem Sie sie ersetzen.

DESCRIBEVIEW (p. 337)

Zeigt die Liste der Spalten für die benannte Ansicht an. Auf diese Weisekönnen Sie die Attribute einer komplexen Ansicht untersuchen.

DROP VIEW (p. 339) Löscht eine vorhandene Ansicht. Mit der optionalen IF EXISTS-Klauselwird der Fehler unterdrückt, falls die Ansicht nicht existiert. WeitereInformationen finden Sie unter Löschen von Ansichten (p. 126).

SHOW CREATEVIEW (p. 340)

Zeigt die SQL-Anweisung an, die die angegebene Ansicht erstellt.

SHOW VIEWS (p. 342) Listet die Ansichten in der angegebenen Datenbank oder in der aktuellenDatenbank auf, wenn Sie den Datenbanknamen weglassen. Verwenden Siedie optionale LIKE-Klausel mit einem regulären Ausdruck, um die Liste derAnsichtsnamen einzugrenzen. Im linken Bereich der Konsole sehen Sie dieListe der Ansichten ebenfalls.

SHOWCOLUMNS (p. 339)

Führt die Spalten im Schema für eine Ansicht auf.

Überlegungen für AnsichtenDie folgenden Überlegungen beziehen sich auf das Erstellen und Verwenden von Ansichten in Athena:

• Das Anzeigen der Vorschau sowie die Arbeit mit Ansichten ist in Athena für Ansichten möglich, die Siein der Athena Konsole im AWS Glue-Datenkatalog erstellt haben (falls Sie darauf umgestellt haben),oder mit Presto bei Ausführung auf dem Amazon EMR-Cluster, der mit dem gleichen Katalog verbunden

122

Amazon Athena BenutzerhandbuchEinschränkungen für Ansichten

ist. Sie können keine Vorschau für Ansichten anzeigen oder diese zu Athena hinzufügen, wenn sie aufandere Weise erstellt wurden.

• Beim Erstellen von Ansichten durch den AWS Glue Data Catalog müssen Sie den PartitionKeys-Parameter einschließen und als seinen Wert wie folgt eine leere Liste angeben: "PartitionKeys":[].Andernfalls schlägt die Ansichtsabfrage in Athena fehl. Im folgenden Beispiel ist eine Ansicht dargestellt,die aus dem Data Catalog mit "PartitionKeys":[] erstellt wurde:

aws glue create-table --database-name mydb --table-input '{"Name":"test", "TableType": "EXTERNAL_TABLE", "Owner": "hadoop", "StorageDescriptor":{ "Columns":[{ "Name":"a","Type":"string"},{"Name":"b","Type":"string"}], "Location":"s3://xxxxx/Oct2018/25Oct2018/", "InputFormat":"org.apache.hadoop.mapred.TextInputFormat", "OutputFormat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat", "SerdeInfo":{"SerializationLibrary":"org.apache.hadoop.hive.serde2.OpenCSVSerde", "Parameters":{"separatorChar": "|", "serialization.format": "1"}}},"PartitionKeys":[]}'

• Wenn Sie Athena-Ansichten in der Data Catalog erstellt haben, behandelt Data Catalog Ansichten alsTabellen. Sie können die feinkörnige Zugriffskontrolle auf Tabellenebene in Data Catalog verwenden, umden Zugriff auf diese Ansichten einzuschränken (p. 222).

• Athena verhindert, dass Sie rekursive Ansichten ausführen, und zeigt in solchen Fällen eineFehlermeldung an. Eine rekursive Ansicht ist eine Abfrage, die auf sich selbst verweist.

• Athena erkennt veraltete Ansichten und zeigt in solchen Fällen eine Fehlermeldung an. Eine veralteteAnsicht ist eine Abfrage, die auf Tabellen oder Datenbanken verweist, die nicht vorhanden sind.

• Sie können verschachtelte Ansichten erstellen und ausführen, solange die Abfrage hinter derverschachtelten Ansicht gültig ist und die Tabellen und Datenbanken vorhanden ist.

Einschränkungen für Ansichten• Athena-Ansichtsnamen dürfen keine Sonderzeichen enthalten außer Unterstriche (_). Weitere

Informationen finden Sie unter Namen für Tabellen, Datenbanken und Spalten (p. 35).• Vermeiden Sie reservierte Schlüsselwörter für die Benennung von Ansichten. Wenn Sie reservierte

Schlüsselwörter verwenden, umschließen Sie sie in Ihren Abfragen in Ansichten mit doppeltenAnführungszeichen. Siehe Reservierte Schlüsselwörter (p. 36).

• Sie können keine Ansichten mit raumbezogenen Funktionen verwenden.• Sie können keine Ansichten zum Verwalten der Zugriffskontrolle auf Daten in Amazon S3 verwenden.

Um eine Ansicht abzufragen, benötigen Sie Berechtigungen für den Zugriff auf die in Amazon S3gespeicherten Daten. Weitere Informationen finden Sie unter Zugriff auf Amazon S3 (p. 221).

Arbeiten mit Ansichten in der KonsoleIn der Athena-Konsole stehen Ihnen folgende Funktionen zur Verfügung:

• Zugriff auf alle Ansichten über den linken Bereich, in dem Tabellen aufgelistet sind. Athena führt eineSHOW VIEWS (p. 342)-Operation aus, um diese Liste anzuzeigen.

• Filtern von Ansichten.• Ansichten in der Vorschau anzeigen, ihre Eigenschaften anzeigen, Ansichten bearbeiten oder löschen.

123

Amazon Athena BenutzerhandbuchErstellen von Ansichten

So listen Sie die Ansichtsaktionen in der Konsole auf

Eine Ansicht wird nur dann in der Konsole sichtbar, wenn Sie sie bereits erstellt haben.

1. Wählen Sie in der Athena-Konsole Views (Ansichten), klicken Sie auf eine Ansicht und erweitern Siesie.

Die Ansicht erscheint samt den enthaltenen Spalten wie im folgenden Beispiel zu sehen:

2. Wählen Sie in der Liste der Ansichten eine Ansicht aus und öffnen Sie das Kontextmenü (rechteMaustaste). Das Symbol für das Aktionsmenü (⋮) wird für die ausgewählte Ansicht markiert. Die Listeder Aktionen wird geöffnet, wie im folgenden Beispiel gezeigt:

3. Wählen Sie eine Option aus. Beispielsweise rufen Sie mit Show properties (Eigenschaften anzeigen)den Namen der Ansicht, den Namen der Datenbank, in der die Tabelle der Ansicht in Athena erstelltwurde, sowie den Zeitstempel der Erstellung ab:

Erstellen von AnsichtenSie können eine Ansicht aus einer beliebigen SELECT-Abfrage erstellen.

So erstellen Sie eine Ansicht in der Konsole

Bevor Sie eine Ansicht erstellen, wählen Sie eine Datenbank und eine Tabelle aus. Führen Sie eineSELECT-Abfrage für eine Tabelle aus und erstellen Sie dann eine Ansicht daraus.

1. Wählen Sie in der Athena-Konsole Create View (Ansicht erstellen).

124

Amazon Athena BenutzerhandbuchBeispiele für Ansichten

Im Abfrage-Editor erscheint eine Abfrage für eine Beispielansicht.2. Bearbeiten Sie die Abfrage der Beispielansicht. Geben Sie den Tabellennamen an und fügen Sie

weitere Syntax hinzu. Weitere Informationen finden Sie unter CREATE VIEW (p. 336) und Beispielefür Ansichten (p. 125).

Ansichtsnamen dürfen keine Sonderzeichen enthalten außer Unterstriche (_). Siehe Namen fürTabellen, Datenbanken und Spalten (p. 35). Vermeiden Sie Reservierte Schlüsselwörter (p. 36) für dieBenennung von Ansichten.

3. Führen Sie die Ansichtsabfrage aus, debuggen Sie sie bei Bedarf, und speichern Sie sie.

Alternativ erstellen Sie eine Abfrage im Abfrage-Editor und verwenden Sie dann Ansicht aus Abfrageerstellen.

Wenn Sie eine Ansicht ausführen, die nicht gültig ist, wird in Athena eine Fehlermeldung angezeigt.

Wenn Sie eine Tabelle löschen, von der aus die Ansicht erstellt wurde, wird in Athena eine Fehlermeldungangezeigt, wenn Sie versuchen, die Ansicht auszuführen.

Sie können eine verschachtelte Ansicht erstellen. Dabei handelt es sich um eine Ansicht auf einevorhandene Ansicht. Athena verhindert, dass Sie eine rekursive Ansicht ausführen, die auf sich selbstverweist.

Beispiele für AnsichtenVerwenden Sie zum Anzeigen der Syntax für die Ansichtsabfrage SHOW CREATE VIEW (p. 340).

Example Beispiel 1

Stellen Sie sich folgende zwei Tabellen vor: eine Tabelle employees mit zwei Spalten, id und name, undeine Tabelle salaries mit zwei Spalten, id und salary.

In diesem Beispiel erstellen wir eine Ansicht mit dem Namen name_salary als SELECT-Abfrage, die eineListe mit IDs abruft, die Gehältern aus den Tabellen employees und salaries zugeordnet sind:

CREATE VIEW name_salary ASSELECT employees.name, salaries.salary FROM employees, salaries WHERE employees.id = salaries.id

Example Beispiel 2

Im folgenden Beispiel erstellen wir eine Ansicht mit dem Namen view1 , mit der Sie die komplexereAbfrage-Syntax ausblenden.

125

Amazon Athena BenutzerhandbuchAktualisieren von Ansichten

Diese Ansicht läuft auf zwei Tabellen, table1 und table2, wobei jede Tabelle eine andere SELECT-Abfrage ist. Die Ansicht wählt alle Spalten aus table1 und fügt die Ergebnisse mit table2 zusammen.Der Join basiert auf der Spalte a, die in beiden Tabellen vorhanden ist.

CREATE VIEW view1 ASWITH table1 AS ( SELECT a, MAX(b) AS b FROM x GROUP BY a ), table2 AS ( SELECT a, AVG(d) AS d FROM y GROUP BY a)SELECT table1.*, table2.*FROM table1JOIN table2 ON table1.a = table2.a;

Aktualisieren von AnsichtenNachdem Sie eine Ansicht erstellt haben, erscheint sie in der Liste Ansichten im linken Bereich.

Zum Bearbeiten der Ansicht markieren Sie sie, klicken Sie mit der rechten Maustaste darauf und wählenSie dann Abfrage anzeigen/bearbeiten aus. Sie können die Ansicht auch im Abfrage-Editor bearbeiten.Weitere Informationen finden Sie unter CREATE VIEW (p. 336).

Löschen von AnsichtenZum Löschen einer Ansicht markieren Sie sie, klicken Sie mit der rechten Maustaste darauf und wählen Siedann Abfrage löschen aus. Weitere Informationen finden Sie unter DROP VIEW (p. 339).

Erstellen einer Tabelle aus Abfrageergebnissen(CTAS)

Eine CREATE TABLE AS SELECT (CTAS)-Abfrage erstellt eine neue Tabelle in Athena aus denErgebnissen einer SELECT-Anweisung aus einer anderen Abfrage. Athena speichert Datendateien,die von einer CTAS-Anweisung erstellt wurden, in einer angegebenen Position in Amazon S3. WeitereInformationen zur Syntax finden Sie unter CREATE TABLE AS (p. 334).

Verwenden Sie CTAS-Abfragen, um:

• Tabellen aus Abfrageergebnissen in einem Schritt zu erstellen, ohne wiederholt Rohdatensetsabzufragen. Dies vereinfacht die Arbeit mit Rohdatensets.

• Abfrageergebnisse in andere Dateiformate wie Parquet und ORC zu transformieren. Dies verbessertdie Abfrageleistung und reduziert die Abfragekosten in Athena. Weitere Informationen finden Sie unterSpaltenbasierte Speicherformate (p. 43).

• Kopien von vorhandenen Tabellen zu erstellen, die nur die Daten enthalten, die Sie benötigen.

Themen• Überlegungen und Einschränkungen für CTAS-Abfragen (p. 127)

126

Amazon Athena BenutzerhandbuchÜberlegungen und Einschränkungen für CTAS-Abfragen

• Ausführen von CTAS-Abfragen in der Konsole (p. 128)• Bucketing im Vergleich zur Partitionierung (p. 131)• Beispiele für CTAS-Abfragen (p. 132)

Überlegungen und Einschränkungen für CTAS-AbfragenIn der folgenden Tabelle wird beschrieben, was Sie über CTAS-Abfragen in Athena wissen müssen:

Item Wichtige Informationen

CTAS-Abfragesyntax

Die CTAS-Abfragesyntax unterscheidet sich von der Syntax CREATE [EXTERNAL]TABLE für das Erstellen von Tabellen. Siehe CREATE TABLE AS (p. 334).

Note

Die Namen von Tabellen, Datenbanken oder Spalten für CTAS-Abfragen dürfen keine Anführungszeichen oder einfache umgekehrteAnführungszeichen enthalten. Um dies sicherzustellen, überprüfen Sie,ob die Namen Ihrer Tabellen, Datenbanken oder Spalten reservierteWörter (p. 36) darstellen oder Sonderzeichen enthalten (die das Einschließenin Anführungszeichen oder einfache umgekehrte Anführungszeichen erfordernwürden). Weitere Informationen finden Sie unter Namen für Tabellen,Datenbanken und Spalten (p. 35).

CTAS-Abfragen imVergleich zuAnsichten

CTAS-Abfragen schreiben neue Daten in einen bestimmten Speicherort in Amazon S3,während Ansichten keine Daten schreiben.

Speicherortder CTAS-Abfrageergebnisse

Der Speicherort für CTAS-Abfrageergebnisse in Amazon S3 muss leer sein. EineCTAS-Abfrage überprüft, ob der Pfadspeicherort (Präfix) im Bucket leer ist undüberschreibt niemals die Daten, wenn der Speicherort bereits Daten enthält. Umden gleichen Speicherort erneut zu verwenden, löschen Sie die Daten in demSchlüsselpräfix-Speicherort im Bucket, andernfalls schlägt die CTAS-Abfrage fehl.

Sie können den Speicherort für das Speichern Ihrer CTAS-Abfrageergebnisseangeben. Wenn dieser nicht angegeben wird und Ihre Arbeitsgruppe keineclientseitigen Einstellungen überschreiben (p. 261), verwendet Athenastandardmäßig den folgenden Speicherort: s3://aws-athena-query-results-<account>-<region>/<query-name-or-unsaved>/<year>/<month/<date>/<query-id>/.

Wenn Ihre Arbeitsgruppe clientseitige Einstellungen überschreibt, bedeutet das, dassfür Ihre CTAS-Abfragen der Abfragenergebnisspeicherort der Arbeitsgruppe verwendetwird. Wenn Sie einen anderen Ergebnisspeicherort angeben, schlägt die Abfrage fehl.Um den für die Arbeitsgruppe angegebenen Ergebnisspeicherort zu erhalten, zeigenSie die Arbeitsgruppendetails an (p. 265).

Wenn die Arbeitsgruppe, in der eine Abfrage ausgeführt werden wird, miteinem erzwungenen Speicherort für Abfrageergebnisse (p. 261) konfiguriertist, dürfen Sie keinen external_location für die CTAS-Abfrage angeben.Wenn dies der Fall ist, gibt Athena eine Fehlermeldung aus und Abfragen,die einen external_location angibt, schlagen fehl. Die folgende Abfrageschlägt beispielsweise fehl, wenn Sie die clientseitigen Einstellungen für den

127

Amazon Athena BenutzerhandbuchAusführen von CTAS-Abfragen in der Konsole

Item Wichtige InformationenAbfrageergebnisspeicherort überschreiben und die Verwendung eines eigenenSpeicherorts für die Arbeitsgruppe erzwingen: CREATE TABLE <DB>.<TABLE1>WITH (format='Parquet', external_location='s3://my_test/test/')AS SELECT * FROM <DB>.<TABLE2> LIMIT 10;

Formatefür dasSpeichern vonAbfrageergebnissen

Die Ergebnisse der CTAS-Abfragen werden standardmäßig in Parquet gespeichert,wenn Sie kein Datenspeicherformat angeben. Sie können CTAS-Ergebnisse inPARQUET, ORC, AVRO, JSON und TEXTFILE speichern. CTAS-Abfragen erfordern keineAngabe eines SerDe, um Formatumwandlungen zu interpretieren. Siehe Beispiel:Schreiben von Abfrageergebnissen in ein anderes Format (p. 134).

KomprimierungsformateGZIP-Komprimierung wird für CTAS-Abfrageergebnisse standardmäßig verwendet. FürParquet und ORC können Sie auch SNAPPY angeben. Siehe Beispiel: Festlegen vonDatenspeicher- und Komprimierungsformaten (p. 133).

Partitions- undBucket-Limits

Sie können die Ergebnisdaten einer CTAS-Abfrage partitionieren und in Bucketsspeichern. Weitere Informationen finden Sie unter Bucketing im Vergleich zurPartitionierung (p. 131). Athena unterstützt das Schreiben in 100 eindeutigePartitions- und Bucket-Kombinationen. Wenn beispielsweise keine Buckets in derZieltabelle definiert sind, können Sie maximal 100 Partitionen angeben. Wenn Sie fünfBuckets angeben, sind 20 Partitionen (jeweils mit fünf Buckets) zulässig. Wenn Siediese Anzahl überschreiten, tritt ein Fehler auf.

Fügen Sie Partitionierungs- und Bucketing-Prädikate am Ende der WITH-Klauselein, die Eigenschaften der Zieltabelle angibt. Weitere Informationen finden Sie unterBeispiel: Erstellen von Tabellen mit Bucketing und Partitionierung (p. 135) undBucketing im Vergleich zur Partitionierung (p. 131).

Verschlüsselung Sie können CTAS-Abfrageergebnisse in Amazon S3 verschlüsseln, so wie Sie auchandere Abfrageergebnisse in Athena verschlüsseln. Weitere Informationen finden Sieunter Konfigurieren von Verschlüsselungsoptionen (p. 210).

Datentypen Spaltendatentypen für eine CTAS-Abfrage sind dieselben wie für die ursprünglicheAbfrage angegeben.

Ausführen von CTAS-Abfragen in der KonsoleIn der Athena-Konsole stehen Ihnen folgende Funktionen zur Verfügung:

• Erstellen einer CTAS-Abfrage aus einer anderen Abfrage (p. 128)• Von Grund auf neu Erstellen einer CTAS-Abfrage (p. 128)

So erstellen Sie eine CTAS-Abfrage aus einer anderen Abfrage

1. Führen Sie die Abfrage aus, klicken Sie auf Erstellen und wählen Sie dann Tabelle aus Abfrageerstellen aus.

128


2. Füllen Sie im Formular Erstellen einer neuen Tabelle aus den Ergebnissen einer Abfrage die Felderwie folgt aus:

a. Wählen Sie im Feld Datenbank die Datenbank aus, in der die Abfrage ausgeführt wurde.b. Geben Sie im Feld Tabellenname den Namen für Ihre neue Tabelle an. Verwenden Sie nur

Kleinbuchstaben und Unterstriche, wie z. B. my_select_query_parquet.c. Fügen Sie optional im Feld Beschreibung einen Kommentar ein, um Ihre Abfrage zu beschreiben.d. Geben Sie für Ausgabespeicherort optional den Speicherort in Amazon S3 an, z. B.

s3://my_athena_results/mybucket/. Wenn Sie keinen Speicherort angebenund Ihre Arbeitsgruppe keine clientseitigen Einstellungen überschreibt (p. 261),wird der folgende vordefinierte Speicherort verwendet: s3://aws-athena-query-results-<account>-<region>/<query-name-or-unsaved>/year/month/date/<query-id>/.

e. Wählen Sie für Ausgabedatenformat aus der Liste der unterstützten Formate aus. Wenn Sie keinFormat angeben, wird Parquet verwendet. Siehe Spaltenbasierte Speicherformate (p. 43).

f. Klicken Sie auf Weiter, um Ihre Abfrage zu überprüfen und überarbeiten Sie diese bei Bedarf.Weitere Informationen zur Abfragesyntax finden Sie unter CREATE TABLE AS (p. 334). DasVorschaufenster wird geöffnet, wie im folgenden Beispiel gezeigt:

129


g. Wählen Sie Create aus.3. Klicken Sie auf Abfrage ausführen.

So erstellen Sie eine CTAS-Abfrage von Grund auf neu

Verwenden Sie die CREATE TABLE AS SELECT-Vorlage zum von Grund auf neu Erstellen einer CTAS-Abfrage.

1. Wählen Sie in der Athena-Konsole die Option Tabelle erstellen und dann CREATE TABLE ASSELECT aus.

2. Bearbeiten Sie im Abfrageeditor die Abfrage nach Bedarf. Weitere Informationen zur Abfragesyntaxfinden Sie unter CREATE TABLE AS (p. 334).

130

Amazon Athena BenutzerhandbuchBucketing im Vergleich zur Partitionierung

3. Klicken Sie auf Abfrage ausführen.4. Optional können Sie die Option Speichern unter auswählen, um die Abfrage zu speichern.

Weitere Informationen finden Sie auch unter Beispiele für CTAS-Abfragen (p. 132).

Bucketing im Vergleich zur PartitionierungSie können die Partitionierung und das Bucketing zum Speichern von Daten von CTAS-Abfrageergebnissen in Amazon S3 angeben. Weitere Informationen zu CTAS-Abfragen finden Sie unterCREATE TABLE AS SELECT (CTAS) (p. 126).

In diesem Abschnitt werden die Partitionierung und das Bucketing vorgestellt, da sie nur für CTAS-Abfragen gelten. Allgemeine Hinweise zur Verwendung der Partitionierung in CREATE TABLE-Abfragenfinden Sie unter Top Performance Tuning-Tipps für Amazon Athena.

Verwenden Sie die folgenden Tipps, um zu entscheiden, ob Sie partitionieren und/oder das Bucketingkonfigurieren möchten, und ob Sie Spalten in Ihren CTAS-Abfragen auswählen möchten, nach denenpartitioniert werden soll:

• Die Partitionierung von CTAS-Abfrageergebnissen funktioniert gut, wenn die Anzahl der Partitionen, überdie Sie verfügen möchten, begrenzt ist. Wenn Sie eine CTAS-Abfrage ausführen, schreibt Athena dieErgebnisse in einen bestimmten Speicherort in Amazon S3. Wenn Sie Partitionen angeben, werden sieerstellt und jede Partition in einem separaten Partitionierungsordner im selben Speicherort gespeichert.Die maximale Anzahl von Partitionen, die Sie mit CTAS-Abfrageergebnissen konfigurieren können, ist100.

Partitionen in Amazon S3 unterstützen die Athena-Abfrageleistung, da dies Ihnen hilft, gezielte Abfragennur für bestimmte Partitionen auszuführen. Athena scannt dann nur die Partitionen. Auf diese Weisesparen Sie Abfragezeit und -kosten. Für Informationen über die Partitionierungssyntax suchen Sie nachpartition_by in CREATE TABLE AS (p. 334).

Partitionieren Sie Daten nach den Spalten, die über ähnliche Eigenschaften verfügen, wie z. B.Datensätze aus der gleichen Abteilung, und die über eine begrenzte Anzahl von möglichen Wertenverfügen können, wie z. B. eine begrenzte Anzahl von eindeutigen Abteilungen in einer Organisation.Diese Eigenschaft ist bekannt als Datenkardinalität. Wenn Sie beispielsweise nach der Spaltedepartment partitionieren und diese Spalte nur über eine begrenzte Anzahl eindeutiger Werte verfügt,funktioniert die Partitionierung nach department gut und verringert die Abfragelatenz.

• Das Bucketing von CTAS-Abfrageergebnissen funktioniert gut, wenn Sie Daten nach der Spaltegruppieren, die über eine hohe Kardinalität verfügt und Werte gleichmäßig verteilt.

Beispiel: Spalten, die timestamp-Daten speichern, können möglicherweise über eine sehr großeAnzahl bestimmter Werte verfügen und ihre Daten sind gleichmäßig im gesamten Datenset verteilt. Diesbedeutet, dass eine Spalte, die timestamp-Typ-Daten speichert, üblicherweise über Werte verfügt undnicht über Null-Werte. Dies bedeutet auch, dass die Daten aus einer solchen Spalte in viele Bucketseingefügt werden können, wobei jeder Bucket ungefähr über die gleiche Menge an Daten verfügt, die inAmazon S3 gespeichert sind.

Um die Spalte auszuwählen, nach der das CTAS-Abfrageergebnisse gruppiert werden soll, verwendenSie die Spalte mit einer hohen Anzahl von Werten (hohe Kardinalität) und deren Daten für dieSpeicherung in vielen Buckets aufgeteilt werden kann, die ungefähr die gleiche Menge an Datenenthalten. Spalten, die kaum mit Werten ausgefüllt werden, sind keine guten Kandidaten für dasBucketing. Dies liegt daran, dass Sie Buckets erhalten, die über weniger Daten verfügen und andereBuckets, die über große Mengen an Daten verfügen. Im Vergleich dazu eignen sich Spalten, von denenSie voraussagen, dass sie fast immer über Werte verfügen, wie z. B. timestamp-Typ-Werte, gut für dasBucketing. Dies liegt daran, dass ihre Daten über eine hohe Kardinalität verfügen und in etwa gleicheBlöcke gespeichert werden können.

131


Amazon Athena BenutzerhandbuchBeispiele für CTAS-Abfragen

Für weitere Informationen über die Bucketing-Syntax suchen Sie nach bucketed_by in CREATETABLE AS (p. 334).

Schließlich können Sie das Bucketing partitionieren und zum Speichern von Ergebnissen der gleichenCTAS-Abfrage verwenden. Diese Techniken zum Schreiben von Daten schließen einander nicht aus. Inder Regel unterscheiden sich die Spalten, die Sie für das Bucketing verwenden, von denen, die Sie für diePartitionierung verwenden.

Beispiel: Wenn Ihr Dataset die Spalten department, sales_quarter und ts (zum Speichernvon timestamp Daten) enthält, können Sie Ihre CTAS-Abfrageergebnisse nach department undsales_quarter partitionieren. Diese Spalten weisen eine relativ niedrige Kardinalität von Werten auf:eine begrenzte Anzahl von Abteilungen und Umsätzen. Außerdem spielt es für Partitionen keine Rolle,wenn einige Datensätze in Ihrem Datenset Null-Werte oder keine Werte besitzen, die für diese Spaltenzugewiesen wurden. Es geht darum, dass sich die Daten mit den gleichen Merkmalen, z. B. Daten auseiner Abteilung, in einer Partition befinden, die Sie in Athena abfragen können.

Da zugleich alle Ihre Daten über timestamp-Typ-Werte verfügen, die in einer ts-Spalte gespeichert sind,können Sie das Bucketing für die gleichen Abfrageergebnisse anhand der Spalte ts konfigurieren. DieseSpalte weist eine hohe Kardinalität auf. Sie können ihre Daten in mehr als einem Bucket in Amazon S3speichern. Erwägen Sie ein entgegengesetztes Szenario: Wenn Sie keine Buckets für Zeitstempel-Typ-Daten erstellen und eine Abfrage für bestimmte Datums- oder Zeitwerte ausführen, dann müssen Sie einesehr große Datenmenge in einem einzelnen Speicherort in Amazon S3 scannen. Wenn Sie stattdessenBuckets zum Speichern von datums- und zeitbezogenen Ergebnissen konfigurieren, können Sie nurBuckets scannen und abfragen, die über Ihren Wert verfügen, und lang andauernde Abfragen vermeiden,die eine große Menge an Daten scannen.

Beispiele für CTAS-AbfragenVerwenden Sie die folgenden Beispiele zum Erstellen von CTAS-Abfragen. Weitere Information zur CTAS-Syntax finden Sie unter CREATE TABLE AS (p. 334).

In diesem Abschnitt:

• Beispiel: Duplizieren einer Tabelle durch Auswahl aller Spalten (p. 132)• Beispiel: Auswählen bestimmter Spalten aus einer oder mehreren Tabellen (p. 133)• Beispiel: Erstellen einer leeren Kopie einer vorhandenen Tabelle (p. 133)• Beispiel: Festlegen von Datenspeicher- und Komprimierungsformaten (p. 133)• Beispiel: Schreiben von Abfrageergebnissen in ein anderes Format (p. 134)• Beispiel: Erstellen von nicht partitionierten Tabellen (p. 134)• Beispiel: Erstellen partitionierter Tabellen (p. 135)• Beispiel: Erstellen von Tabellen mit Bucketing und Partitionierung (p. 135)

Example Beispiel: Duplizieren einer Tabelle durch Auswählen aller Spalten

Das folgende Beispiel erstellt eine Tabelle durch Kopieren aller Spalten aus einer Tabelle:

CREATE TABLE new_table AS SELECT * FROM old_table;

In der folgenden Variante des gleichen Beispiels enthält Ihre SELECT-Anweisung auch eine WHERE-Klausel.In diesem Fall wählt die Abfrage nur die Zeilen aus der Tabelle aus, die die WHERE-Klausel erfüllen:

132


CREATE TABLE new_table AS SELECT * FROM old_table WHERE condition;

Example Beispiel: Auswählen bestimmter Spalten aus einer oder mehreren Tabellen

Das folgende Beispiel erstellt eine neue Abfrage, die auf einer Reihe von Spalten aus einer anderenTabelle ausgeführt wird:

CREATE TABLE new_table AS SELECT column_1, column_2, ... column_n FROM old_table;

Diese Variation des gleichen Beispiels erstellt eine neue Tabelle aus bestimmten Spalten aus mehrerenTabellen:

CREATE TABLE new_table ASSELECT column_1, column_2, ... column_n FROM old_table_1, old_table_2, ... old_table_n;

Example Beispiel: Erstellen einer leeren Kopie einer vorhandenen Tabelle

Das folgende Beispiel verwendet WITH NO DATA, um eine neue Tabelle zu erstellen, die leer ist und dasgleiche Schema wie die ursprüngliche Tabelle aufweist:

CREATE TABLE new_table AS SELECT * FROM old_tableWITH NO DATA;

Example Beispiel: Festlegen von Datenspeicher- und Komprimierungsformaten

Im folgenden Beispiel wird eine CTAS-Abfrage verwendet, um eine neue Tabelle mit Parquet-Daten auseiner Quelltabelle in einem anderen Format zu erstellen. Sie können PARQUET, ORC, AVRO, JSON undTEXTFILE auf ähnliche Art und Weise angeben.

In diesem Beispiel wird die Komprimierung auch als SNAPPY festgelegt. Wenn nichts angegeben ist,wird GZIP verwendet. GZIP und SNAPPY sind die unterstützten Kompressionsformate für CTAS-Abfrageergebnisse in Parquet und ORC.

CREATE TABLE new_tableWITH ( format = 'Parquet', parquet_compression = 'SNAPPY')AS SELECT *FROM old_table;

Das folgende Beispiel ist ähnlich, aber es speichert die CTAS-Abfrageergebnisse in ORC und verwendetden orc_compression-Parameter zum Angeben des Komprimierungsformats. Wenn Sie dasKomprimierungsformat weglassen, verwendet Athena standardmäßig GZIP.

CREATE TABLE new_tableWITH (format = 'ORC', orc_compression = 'SNAPPY')AS SELECT *

133


FROM old_table ;

Example Beispiel: Schreiben von Abfrageergebnissen in ein anderes Format

Die folgende CTAS-Abfrage wählt alle Datensätze aus old_table aus, die in CSV oder einem anderenFormat gespeichert werden können, und erstellt eine neue Tabelle, wobei die zugrunde liegenden Daten imORC-Format in Amazon S3 gespeichert sind:

CREATE TABLE my_orc_ctas_tableWITH ( external_location = 's3://my_athena_results/my_orc_stas_table/', format = 'ORC')AS SELECT * FROM old_table;

Example Beispiel: Erstellen von nicht partitionierten Tabellen

Die folgenden Beispiele erstellen Tabellen, die nicht partitioniert werden. Die Tabellendaten werden inverschiedenen Formaten gespeichert. Einige dieser Beispiele geben den externen Speicherort an.

Das folgende Beispiel erstellt eine CTAS-Abfrage, die die Ergebnisse als Textdatei speichert:

CREATE TABLE ctas_csv_unpartitioned WITH ( format = 'TEXTFILE', external_location = 's3://my_athena_results/ctas_csv_unpartitioned/') AS SELECT key1, name1, address1, comment1FROM table1;

Im folgenden Beispiel werden die Ergebnisse in Parquet gespeichert und der standardmäßigeErgebnisspeicherort wird verwendet:

CREATE TABLE ctas_parquet_unpartitioned WITH (format = 'PARQUET') AS SELECT key1, name1, comment1FROM table1;

In der folgenden Abfrage wird die Tabelle in JSON gespeichert und bestimmte Spalten aus denErgebnissen der ursprünglichen Tabelle ausgewählt:

CREATE TABLE ctas_json_unpartitioned WITH ( format = 'JSON', external_location = 's3://my_athena_results/ctas_json_unpartitioned/') AS SELECT key1, name1, address1, comment1FROM table1;

Im folgenden Beispiel lautet das Format ORC:

CREATE TABLE ctas_orc_unpartitioned WITH ( format = 'ORC') AS SELECT key1, name1, comment1 FROM table1;

Im folgenden Beispiel lautet das Format Avro:

134


CREATE TABLE ctas_avro_unpartitioned WITH ( format = 'AVRO', external_location = 's3://my_athena_results/ctas_avro_unpartitioned/') AS SELECT key1, name1, comment1FROM table1;

Example Beispiel: Erstellen partitionierter Tabellen

Die folgenden Beispiele zeigen CREATE TABLE AS SELECT-Abfragen für partitionierte Tabellenin verschiedenen Datenspeicherformaten unter Verwendung von partitioned_by und anderenEigenschaften in der WITH-Klausel. Weitere Informationen zur Syntax finden Sie unter CTAS-Tabelleneigenschaften (p. 335). Weitere Informationen zur Auswahl der Spalten für die Partitionierungfinden Sie unter Bucketing im Vergleich zur Partitionierung (p. 131).

Note

Auflisten von Partitionsspalten am Ende der Liste der Spalten in der SELECT-Anweisung. Siekönnen in mehrere Spalten partitionieren und über bis zu 100 eindeutige Partitions- und Bucket-Kombinationen verfügen. Sie können beispielsweise 100 Partitionen haben, wenn keine Bucketsangegeben sind.

CREATE TABLE ctas_csv_partitioned WITH ( format = 'TEXTFILE', external_location = 's3://my_athena_results/ctas_csv_partitioned/', partitioned_by = ARRAY['key1']) AS SELECT name1, address1, comment1, key1FROM tables1;

CREATE TABLE ctas_json_partitioned WITH ( format = 'JSON', external_location = 's3://my_athena_results/ctas_json_partitioned/', partitioned_by = ARRAY['key1']) AS select name1, address1, comment1, key1 FROM table1;

Example Beispiel: Erstellen von Tabellen mit Bucketing und Partitionierung

Das folgende Beispiel zeigt eine CREATE TABLE AS SELECT-Abfrage, die sowohl die Partitionierungals auch das Bucketing zum Speichern von Abfrageergebnissen in Amazon S3 verwendet. DieTabellenergebnisse werden nach verschiedenen Spalten partitioniert und auf Buckets aufgeteilt. Athenaunterstützt maximal 100 eindeutige Bucket- und Partitionskombinationen. Wenn Sie beispielsweiseeine Tabelle mit fünf Buckets erstellen, werden 20 Partitionen mit je fünf Buckets unterstützt. WeitereInformationen zur Syntax finden Sie unter CTAS-Tabelleneigenschaften (p. 335).

Weitere Informationen zur Auswahl der Spalten für das Bucketing finden Sie unter Bucketing im Vergleichzur Partitionierung (p. 131).

CREATE TABLE ctas_avro_bucketed WITH ( format = 'AVRO', external_location = 's3://my_athena_results/ctas_avro_bucketed/', partitioned_by = ARRAY['nationkey'], bucketed_by = ARRAY['mktsegment'], bucket_count = 3)

135

Amazon Athena BenutzerhandbuchVerarbeiten von Schema-Updates

AS SELECT key1, name1, address1, phone1, acctbal, mktsegment, comment1, nationkey FROM table1;

Verarbeiten von Schema-UpdatesIn diesem Abschnitt finden Sie Anleitungen zum Umgang mit Schema-Updates für verschiedeneDatenformate. Athena ist eine Schema-on-Read-Abfrage-Engine. Dies bedeutet, dass beim Anlegen einerTabelle in Athena Schemata beim Lesen der Daten angewendet werden. Dabei werden die zugrundeliegenden Daten nicht geändert oder überschrieben.

Wenn Sie Änderungen in Tabellenschemata vorweg nehmen, sollten Sie diese in einem für IhreBedürfnisse geeigneten Datenformat anlegen. Ihr Ziel ist es, vorhandene Athena-Abfragen bei sichweiterentwickelnden Schemata wiederzuverwenden und beim Abfragen von Tabellen mit Partitionen Fehleraufgrund von Schemakonflikten zu vermeiden.

Important

Schema-Updates, die in diesem Abschnitt beschrieben sind, funktionieren nicht mit Tabellen mitkomplexen oder verschachtelten Datentypen, wie Arrays und Strukturen.

Um diese Ziele zu erreichen, wählen Sie das Datenformat basierend auf der Tabelle im folgenden Thema.

Themen• Zusammenfassung: Updates und Datenformate in Athena (p. 136)• Index-Zugriff in ORC und Parquet (p. 138)• Arten von Updates (p. 139)• Updates in Tabellen mit Partitionen (p. 144)

Zusammenfassung: Updates und Datenformate inAthenaDie folgende Tabelle enthält eine Übersicht über die Datenspeicherungsformate und ihre unterstütztenSchema-Manipulationen. Verwenden Sie diese Tabelle, um das Format zu wählen, mit dem Sie weiterhinAthena-Abfragen verwenden können, auch wenn sich Ihre Schemata im Lauf der Zeit ändern.

Beachten Sie, dass Parquet und ORC in dieser Tabelle Spaltenformate mit unterschiedlichen Standard-Spaltenzugriffsmethoden sind. Standardmäßig greift Parquet dem Namen nach auf Spalten zu, ORC demIndex nach (Ordnungswert). Aus diesem Grund stellt Athena eine SerDe-Eigenschaft bereit, die definiertwird, wenn eine Tabelle erstellt wird, um die Standard-Spaltenzugriffsmethode umzustellen. Dies ermöglichteine größere Flexibilität bei der Schema-Entwicklung.

Für Parquet kann die parquet.column.index.access-Eigenschaft auf TRUE gesetzt werden, sodassdie Spaltenzugriffsmethode die Ordinalzahl für die Spalte verwendet. Wenn Sie diese Eigenschaftauf FALSE setzen, ändert sich die Spaltenzugriffsmethode auf die Verwendung des Spaltennamens.Analog dazu verwenden Sie für ORC die orc.column.index.access -Eigenschaft, um dieSpaltenzugriffsmethode festzulegen. Weitere Informationen finden Sie unter Index-Zugriff in ORC undParquet (p. 138).

Mit CSV und TSV können Sie alle Schema-Manipulationen durchführen, mit Ausnahme der Neuanordnungvon Spalten oder des Hinzufügens von Spalten am Anfang der Tabelle. Wenn Ihre Schemaentwicklungz. B. nur das Umbenennen von Spalten, nicht aber deren Entfernung erfordert, können Sie Ihre Tabellen

136

Amazon Athena BenutzerhandbuchZusammenfassung: Updates und Datenformate in Athena

in CSV oder TSV erstellen. Wenn Sie Spalten entfernen möchten, verwenden Sie nicht CSV oder TSV,sondern eines der anderen unterstützten Formate, vorzugsweise ein Spaltenformat wie Parquet oder ORC.

Schema-Updates und Datenformate in Athena

ErwarteterTyp desSchema-Updates

Zusammenfassung CSV(mit undohneHeader)undTSV

JSONAVROPARQUET:LesennachNamen(Standard)

PARQUET:LesennachIndex

ORC:LesennachIndex(Standard)

ORC:LesennachNamen

Spaltenumbenennen (p. 142)

Speichern Sie IhreDaten in CSV undTSV oder in ORCund Parquet, wennsie nach dem Indexgelesen werden.

Y N N N Y Y N

Hinzufügenvon Spaltenam Anfangoder in derMitte derTabelle (p. 140)

Speichern Sie IhreDaten in JSON,AVRO oder inParquet und ORC,wenn sie nach demNamen gelesenwerden. VerwendenSie nicht CSV undTSV.

N Y Y Y N N Y

Hinzufügenvon Spaltenam Ende derTabelle (p. 141)

Speichern Sie IhreDaten im CSV-,TSV-, JSON-,AVRO-, ORC- oderParquet-Format.

Y Y Y Y Y Y Y

Spaltenentfernen (p. 141)

Speichern Sie IhreDaten in JSON,AVRO oder inParquet und ORC,wenn sie nach demNamen gelesenwerden. VerwendenSie nicht CSV undTSV.

N Y Y Y N N Y

NeuanordnenvonSpalten (p. 143)

Speichern Sie IhreDaten in AVRO,JSON oder ORCund Parquet, wennsie nach demNamen gelesenwerden.

N Y Y Y N N Y

Ändern desDatentypseinerSpalte (p. 143)

Speichern Sie IhreDaten in einembeliebigen Format,testen Sie IhreAbfrage jedochin Athena, um

Y Y Y Y Y Y Y

137

Amazon Athena BenutzerhandbuchIndex-Zugriff in ORC und Parquet

ErwarteterTyp desSchema-Updates

Zusammenfassung CSV(mit undohneHeader)undTSV

JSONAVROPARQUET:LesennachNamen(Standard)

PARQUET:LesennachIndex

ORC:LesennachIndex(Standard)

ORC:LesennachNamen

sicherzustellen,dass die Datentypenkompatibel sind. FürParquet und ORCist eine Änderungdes Datentyps nurfür partitionierteTabellen möglich.

Index-Zugriff in ORC und ParquetPARQUET und ORC sind spaltenbasierte Dateiformaten, die nach Index gelesen werden können, odernach Namen. Wenn Sie Ihre Daten in einem dieser Formate speichern, können Sie alle Operationen anSchemata durchführen und Athena-Abfragen ohne Schema-Fehler ausführen.

• Athena liest ORC standardmäßig nach dem Index, wie in SERDEPROPERTIES( 'orc.column.index.access'='true') definiert. Weitere Informationen finden Sie unter ORC:Nach dem Index lesen (p. 138).

• Athena liest Parquet standardmäßig nach dem Namen, wie in SERDEPROPERTIES( 'parquet.column.index.access'='false') definiert. Weitere Informationen finden Sie unterPARQUET: Dem Namen nach lesen (p. 139).

Da dies die Standardoptionen sind, ist die Angabe dieser SerDe-Eigenschaften in Ihren CREATE TABLE-Abfragen optional, weil sie implizit verwendet werden. Wenn sie verwendet werden, gestatten sie Ihnen dieAusführung einiger Schema-Update-Operationen, während sie andere solcher Operationen verhindern.Um diese Operationen zu aktivieren, führen Sie eine weitere CREATE TABLE-Anfrage aus und ändern dieSerDe-Einstellungen.

Note

Die SerDe-Eigenschaften werden nicht automatisch für jede Partition weitergegeben. VerwendenSie ALTER TABLE ADD PARTITION-Anweisungen zum Festlegen der SerDe-Eigenschaften fürjede Partition. Um diesen Prozess zu automatisieren, schreiben Sie ein Skript, das ALTER TABLEADD PARTITION-Anweisungen ausführt.

In den folgenden Abschnitten werden diese Fälle ausführlich beschrieben.

ORC: Lesen nach IndexEine Tabelle wird in ORC standardmäßig nach dem Index gelesen. Dies wird durch die folgende Syntaxdefiniert:

WITH SERDEPROPERTIES ( 'orc.column.index.access'='true')

Lesen nach Index erlaubt, die Spalten umzubenennen. Sie verlieren damit jedoch die Möglichkeit, Spaltenzu entfernen oder in der Mitte der Tabelle hinzuzufügen.

138

Amazon Athena BenutzerhandbuchArten von Updates

Damit ORC nach dem Namen liest, sodass Sie Spalten in der Mitte der Tabelle hinzufügen oder entfernenkönnen, setzhen Sie die SerDe-Eigenschaft orc.column.index.access in der CREATE TABLE-Anweisung auf FALSE. In dieser Konfiguration verlieren Sie die Möglichkeit, Spalten umzubenennen.

Das folgende Beispiel zeigt, wie Sie die ORC abändern, um nach Namen zu lesen:

CREATE EXTERNAL TABLE orders_orc_read_by_name ( ò_comment` string, ò_orderkey` int, ò_custkey` int, ò_orderpriority` string, ò_orderstatus` string, ò_clerk` string, ò_shippriority` int, ò_orderdate` string) ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.orc.OrcSerde' WITH SERDEPROPERTIES ( 'orc.column.index.access'='false') STORED AS INPUTFORMAT 'org.apache.hadoop.hive.ql.io.orc.OrcInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat'LOCATION 's3://schema_updates/orders_orc/';

Parquet: Lesen nach NamenEine Tabelle wird in Parquet standardmäßig nach dem Namen gelesen. Dies wird durch die folgendeSyntax definiert:

WITH SERDEPROPERTIES ( 'parquet.column.index.access'='false')

Lesen nach Namen ermöglicht Ihnen das Hinzufügen von Spalten in der Mitte der Tabelle und dasEntfernen von Spalten. Aber dann verlieren Sie die Möglichkeit, Spalten umzubenennen.

Um Parquet umzustellen, sodass es nach dem Index liest und Sie Spalten umbenennen können, müssenSie eine Tabelle erstellen, deren SerDe-Eigenschaft parquet.column.index.access auf TRUE gesetztist.

Arten von UpdatesNachfolgend finden Sie eine Liste der Updates, die ein Tabellenschema haben kann. Wir überprüfen jedeArt Schema-Update und geben an, welche Datenformate sie in Athena unterstützen.

Important


• Hinzufügen von Spalten am Anfang oder in der Mitte der Tabelle (p. 140)• Hinzufügen von Spalten am Ende der Tabelle (p. 141)• Spalten entfernen (p. 141)• Spalten umbenennen (p. 142)• Reihenfolge von Spalten ändern (p. 143)• Ändern des Datentyps einer Spalte (p. 143)

139


Je nachdem, wie sich Ihre Schemata voraussichtlich weiterentwickeln, verwenden Sie ein kompatiblesDatenformat, um weiterhin Athena-Abfragen verwenden zu können.

Untersuchen wir als Erstes eine Anwendung, in der Bestellinformationen aus einer orders-Tabellegelesen werden. Diese existiert in zwei Formaten: CSV und Parquet.

Mit dem folgenden Beispiel wird eine Tabelle in Parquet erstellt:

CREATE EXTERNAL TABLE orders_parquet ( òrderkey` int, òrderstatus` string, `totalprice` double, òrderdate` string, òrderpriority` string, `clerk` string, `shippriority` int) STORED AS PARQUETLOCATION 's3://schema_updates/orders_ parquet/';

Mit dem folgenden Beispiel wird die gleiche Tabelle in CSV erstellt:

CREATE EXTERNAL TABLE orders_csv ( òrderkey` int, òrderstatus` string, `totalprice` double, òrderdate` string, òrderpriority` string, `clerk` string, `shippriority` int) ROW FORMAT DELIMITED FIELDS TERMINATED BY ','LOCATION 's3://schema_updates/orders_csv/';

In den folgenden Abschnitten sehen wir uns an, wie sich Aktualisierungen für diese Tabellen auf Athena-Abfragen auswirken.

Hinzufügen von Spalten am Anfang oder in der Mitte der TabelleDas Hinzufügen von Spalten ist eine der am häufigsten vorkommenden Schemaänderungen.Beispielsweise können Sie eine neue Spalte hinzufügen, um die Tabelle um neue Daten zu erweitern.Alternativ können Sie eine neue Spalte hinzufügen, wenn sich die Quelle für eine vorhandene Spaltegeändert hat, und die vorherige Version dieser Spalte beibehalten. So haben Sie Zeit, Anwendungenanzupassen, die von dieser Spalte abhängig sind.

Um Spalten am Anfang oder in der Mitte der Tabelle hinzuzufügen und Abfragen für bestehende Tabellendurchzuführen, verwenden Sie AVRO, JSON und Parquet und ORC, wenn deren SerDe Eigenschaft sogesetzt ist, dass sie dem Namen nach lesen. Weitere Informationen finden Sie unter Index-Zugriff in ORCund Parquet (p. 138).

Fügen Sie keine Spalten am Anfang oder in der Mitte der Tabelle in CSV und TSV hinzu, da diese Formatevon der Reihenfolge abhängen. Das Hinzufügen einer Spalte führt in diesen Fällen zu Schemakonflikten,falls sich das Schema der Partitionen ändert.

Das folgende Beispiel zeigt das Hinzufügen einer Spalte zu einer JSON-Tabelle in der Mitte der Tabelle:

CREATE EXTERNAL TABLE orders_json_column_addition ( ò_orderkey` int, ò_custkey` int, ò_orderstatus` string, ò_comment` string, ò_totalprice` double,

140


ò_orderdate` string, ò_orderpriority` string, ò_clerk` string, ò_shippriority` int, ò_comment` string) ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'LOCATION 's3://schema_updates/orders_json/';

Hinzufügen von Spalten am Ende der TabelleWenn Sie Tabellen in einem der Formate erstellen, die Athena unterstützt, z. B. Parquet, ORC, Avro,JSON, CSV und TSV, können Sie neue Spalten am Ende der Tabelle hinzufügen. Für Tabellen in Parquetoder ORC können Sie am Ende der Tabelle Spalten hinzufügen, unabhängig von der verwendeten Art desIndex-Zugriffs (p. 138).

Im folgenden Beispiel wird eine vorhandene Tabelle in Parquet gelöscht und eine neue Parquet-Tabelle miteiner neuen `comment`-Spalte am Ende der Tabelle hinzugefügt:

DROP TABLE orders_parquet;CREATE EXTERNAL TABLE orders_parquet ( òrderkey` int, òrderstatus` string, `totalprice` double, òrderdate` string, òrderpriority` string, `clerk` string, `shippriority` int `comment` string) STORED AS PARQUETLOCATION 's3://schema_updates/orders_parquet/';

Im folgenden Beispiel wird eine vorhandene Tabelle in CSV gelöscht und eine neue CSV-Tabelle mit einerneuen `comment`-Spalte am Ende der Tabelle hinzugefügt:

DROP TABLE orders_csv;CREATE EXTERNAL TABLE orders_csv ( òrderkey` int, òrderstatus` string, `totalprice` double, òrderdate` string, òrderpriority` string, `clerk` string, `shippriority` int `comment` string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ','LOCATION 's3://schema_updates/orders_csv/';

Spalten entfernenMöglicherweise müssen Sie Spalten aus Tabellen entfernen, wenn sie keine Daten mehr enthalten, oderzum Einschränken des Zugriffs auf die darin enthaltenen Daten.

• Sie können Spalten aus Tabellen in JSON, Avro und Parquet und ORC entfernen, wenn diese demNamen nach lesen. Weitere Informationen finden Sie unter Index-Zugriff in ORC und Parquet (p. 138).

• Wir raten davon ab, Spalten aus Tabellen in CSV und TSV zu entfernen, wenn Sie die Tabellen, die Siebereits in Athena angelegt haben, beibehalten möchten. Das Entfernen einer Spalte stört das Schemaund erfordert, dass Sie die Tabelle ohne die entfernte Spalte neu anlegen.

141


In diesem Beispiel entfernen Sie eine Spalte `totalprice` aus einer Tabelle in Parquet und führen eineAbfrage aus. In Athena wird Parquet standardmäßig dem Namen nach gelesen. Deshalb lassen wir dieKonfiguration SERDEPROPERTIES weg, die das Lesen dem Namen nach angibt. Beachten Sie, dass diefolgende Abfrage erfolgreich ist, obwohl Sie das Schema geändert haben:

CREATE EXTERNAL TABLE orders_parquet_column_removed ( ò_orderkey` int, ò_custkey` int, ò_orderstatus` string, ò_orderdate` string, ò_orderpriority` string, ò_clerk` string, ò_shippriority` int, ò_comment` string) STORED AS PARQUETLOCATION 's3://schema_updates/orders_parquet/';

Spalten umbenennenMöglicherweise möchten Sie in Ihren Tabellen Spalten umbenennen, um die Schreibweise zu korrigieren,Spalten mit besser verständlichen Namen zu versehen oder eine vorhandene Spalte erneut nutzen, umeine Änderung der Reihenfolge für die Spalten zu vermeiden.

Sie können Spalten umbenennen, wenn Sie Ihre Daten in CSV und TSV speichern, oder in Parquet undORC, wenn diese so konfiguriert sind, dass sie dem Index nach lesen. Weitere Informationen finden Sieunter Index-Zugriff in ORC und Parquet (p. 138).

Athena liest Daten in CSV und TSV in der Reihenfolge der Spalten in das Schema und gibt sie in dergleichen Reihenfolge aus. Hierbei werden keine Spaltennamen für die Zuweisung von Daten in einer Spalteverwendet. Aus diesem Grund können Sie keine Spalten in CSV oder TSV umbenennen, ohne Athena-Abfragen zu beschädigen.

In diesem Beispiel benennen Sie die Spalte ò_totalprice` in der Parquet-Tabelle inò_total_price` um und führen dann eine Abfrage in Athena aus:

CREATE EXTERNAL TABLE orders_parquet_column_renamed ( ò_orderkey` int, ò_custkey` int, ò_orderstatus` string, ò_total_price` double, ò_orderdate` string, ò_orderpriority` string, ò_clerk` string, ò_shippriority` int, ò_comment` string) STORED AS PARQUETLOCATION 's3://TBD/schema_updates/orders_parquet/';

Im Fall der Parquet-Tabelle wird die folgende Abfrage erfolgreich ausgeführt, aber die umbenannte Spaltezeigt keine Daten an, da auf die Spalte nicht über den Index, sondern über den Namen zugegriffen wurde(ein Standard in Parquet):

SELECT * FROM orders_parquet_column_renamed;

Eine Abfrage mit einer Tabelle in CSV sieht ähnlich aus:

142


CREATE EXTERNAL TABLE orders_csv_column_renamed ( ò_orderkey` int, ò_custkey` int, ò_orderstatus` string, ò_total_price` double, ò_orderdate` string, ò_orderpriority` string, ò_clerk` string, ò_shippriority` int, ò_comment` string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ','LOCATION 's3://schema_updates/orders_csv/';

Bei der CSV-Tabelle wird die folgende Abfrage ausgeführt und für alle Spalten erscheinen Daten, auch fürdie umbenannte Spalte:

SELECT * FROM orders_csv_column_renamed;

Reihenfolge von Spalten ändernSie können Spalten nur für Tabellen mit Daten in Formaten neu anordnen, die dem Namen nach lesen,wie JSON oder ORC, die standardmäßig dem Namen nach lesen. Falls nötig, können Sie auch Parquet soeinstellen, dass es dem Namen nach liest. Weitere Informationen finden Sie unter Index-Zugriff in ORC undParquet (p. 138).

Das folgende Beispiel veranschaulicht das Ändern der Reihenfolge von Spalten:

CREATE EXTERNAL TABLE orders_parquet_columns_reordered ( ò_comment` string, ò_orderkey` int, ò_custkey` int, ò_orderpriority` string, ò_orderstatus` string, ò_clerk` string, ò_shippriority` int, ò_orderdate` string) STORED AS PARQUETLOCATION 's3://schema_updates/orders_parquet/';

Ändern des Datentyps einer SpalteSie ändern Spaltentypen, wenn der Datentyp einer Spalte die Menge an Informationen nicht mehraufnehmen kann. Das ist z. B. der Fall, wenn eine ID-Spalte die Große eines INT-Datentyps übersteigt undauf einen BIGINT-Datentyp geändert werden muss.

Für die Änderung des Datentyps einer Spalte gelten die folgenden Einschränkungen:

• Nur bestimmte Datentypen können in andere Datentypen konvertiert werden. Die Datentypen, diegeändert werden können, können Sie der Tabelle in diesem Abschnitt entnehmen.

• Für Daten in Parquet und ORC können Sie den Datentyp einer Spalte nicht ändern, wenn die Tabellenicht partitioniert ist.

In partitionierten Tabellen in Parquet und ORC kann sich der Spaltentyp einer Partition vom Spaltentypeiner anderen Partition unterscheiden und Athena wendet CAST auf den gewünschten Typ an, wenn diesmöglich ist. Weitere Informationen finden Sie unter Vermeiden von Schemakonflikt-Fehlern für Tabellenmit Partitionen (p. 145).

143

Amazon Athena BenutzerhandbuchUpdates in Tabellen mit Partitionen

Important

Wir raten Ihnen dringend, Ihre Abfragen zu testen und zu überprüfen, bevor Sie Datentyp-Änderungen vornehmen. Wenn Athena den Datentyp nicht vom Original-Datentyp auf den Ziel-Datentyp ändern kann, schlägt die CREATE TABLE-Abfrage möglicherweise fehl.

In der folgenden Tabelle sind die Datentypen aufgelistet, die Sie ändern können:

Kompatible Datentypen

Original-Datentyp Verfügbare Ziel-Datentypen

STRING BYTE, TINYINT, SMALLINT, INT, BIGINT

BYTE TINYINT, SMALLINT, INT, BIGINT

TINYINT SMALLINT, INT, BIGINT

SMALLINT INT, BIGINT

INT BIGINT

FLOAT DOUBLE

Im folgenden Beispiel der orders_json-Tabelle ändern Sie den Datentyp der Spalteò_shippriority` auf BIGINT:

CREATE EXTERNAL TABLE orders_json ( ò_orderkey` int, ò_custkey` int, ò_orderstatus` string, ò_totalprice` double, ò_orderdate` string, ò_orderpriority` string, ò_clerk` string, ò_shippriority` BIGINT) ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'LOCATION 's3://schema_updates/orders_json';

Die folgende Abfrage wird erfolgreich ausgeführt, ähnlich wie die SELECT-Originalabfrage vor dem Änderndes Datentyps:

Select * from orders_json LIMIT 10;

Updates in Tabellen mit PartitionenIn Athena müssen eine Tabelle und ihre Partitionen die gleichen Datenformate verwenden, ihre Schematakönnen aber unterschiedlich sein. Wenn Sie eine neue Partition erstellen, erbt die Partition in der Regel dasSchema der Tabelle. Im Laufe der Zeit können sich die Schemas ggf. unterscheiden. Gründe sind u. a.:

• Wenn sich das Schema der Tabelle ändert, werden die Schemas für Partitionen nicht aktualisiert, umweiterhin dem Schema der Tabelle zu entsprechen.

• Mit dem AWS Glue Crawler können Sie Daten in Partitionen mit abweichenden Schemata finden. Dasbedeutet: Wenn Sie eine Tabelle in Athena mit AWS Glue erstellen, können sich die Schemata für dieTabelle und ihre Partitionen unterscheiden, nachdem der Crawler mit der Verarbeitung fertig ist.

144

Amazon Athena BenutzerhandbuchAbfragen von Arrays

• Wenn Sie Partitionen direkt mit einer AWS-API hinzufügen.

Athena verarbeitet Tabellen mit Partitionen erfolgreich, wenn sie die folgendenBeschränkungen erfüllen. Wenn diese Beschränkungen nicht erfüllt sind, gibt Athena einenHIVE_PARTITION_SCHEMA_MISMATCH-Fehler aus.

• Das Schema jeder Partition ist kompatibel mit dem Tabellenschema.• Das Datenformat der Tabelle ermöglicht die Art der Aktualisierung, die Sie ausführen möchten: Spalten

hinzufügen, löschen, ihre Reihenfolge ändern oder den Datentyp einer Spalte ändern.

Beispiel: In den Formaten CSV und TSV können Sie Spalten umbenennen, neue Spalten am Ende derTabelle hinzufügen und den Datentyp einer Spalte ändern, falls die Typen kompatibel sind. Sie könnenaber keine Spalten entfernen. Bei anderen Formaten können Sie Spalten hinzufügen oder entfernen oderden Datentyp in einen anderen ändern, wenn die Typen kompatibel sind. Weitere Informationen findenSie unter Zusammenfassung: Updates und Datenformate in Athena (p. 136).

Important


Vermeiden von Schemakonflikt-Fehlern für Tabellen mitPartitionenZu Beginn der Abfrageausführung überprüft Athena das Schema einer Tabelle, indem überprüft wird, dassder Datentyp jeder Spalte in der Tabelle und der Partition kompatibel ist.

• Für Parquet- und ORC-Datenspeichertypen stützt sich Athena auf die Spaltennamen undverwendet sie für die auf Spaltennamen basierte Überprüfung des Schemas. Dadurch werdenHIVE_PARTITION_SCHEMA_MISMATCH-Fehler für Tabellen mit Partitionen in Parquet und ORCverhindert. (Dies gilt für ORC, wenn die SerDe-Eigenschaft für den Zugriff auf den Index nach Namefestgelegt ist: orc.column.index.access=FALSE. Parquet liest den Index standardmäßig demNamen nach).

• Für CSV, JSON und Avro verwendet Athena eine Index-basierte Schemaverifizierung. Das bedeutet:Wenn bei Ihnen ein Schemakonflikt-Fehler auftritt, sollten Sie die Partition löschen, die einenSchemakonflikt auslöst, und sie erneut erstellen. So kann Athena sie ohne Fehler abfragen.

Athena vergleicht das Schema der Tabelle mit den Partitionsschemata. Wenn Sie eine Tabelle in CSV,JSON und AVRO in Athena mit AWS Glue Crawler erstellen, können sich die Schemata für die Tabelleund ihre Partitionen unterscheiden, nachdem der Crawler mit der Verarbeitung fertig ist. Tritt ein Konfliktzwischen dem Tabellen- und dem Partitionsschema auf, scheitern Ihre Abfragen in Athena wegen einesFehlers beim Überprüfen des Schemas, ähnlich dem Folgenden: „‚crawler_test.click_avro‘ ist als Typ‚string‘ deklariert, in der Partition ‚partition_0=2017-01-17‘ ist die Spalte ‚col68‘ aber mit dem Typ ‚double‘deklariert.“

Eine typische Behelfslösung für diesen Fehler besteht darin, dass die Partition entfernt wird, die den Fehlerauslöst, und Sie sie dann erneut erstellen.

Abfragen von ArraysSie können mit Amazon Athena Arrays erstellen, sie verketten, in andere Datentypen umwandeln undanschließend filtern, reduzieren und sortieren.

145

Amazon Athena BenutzerhandbuchErstellen von Arrays

Themen• Erstellen von Arrays (p. 146)• Verketten von Arrays (p. 147)• Konvertieren von Array-Datentypen (p. 148)• Suchen nach Längen (p. 149)• Zugreifen auf Array-Elemente (p. 149)• Reduzieren von verschachtelten Arrays (p. 150)• Erstellen von Arrays aus Unterabfragen (p. 152)• Filtern von Arrays (p. 153)• Sortieren von Arrays (p. 154)• Verwenden von Aggregationsfunktionen mit Arrays (p. 154)• Konvertieren von Arrays in Zeichenfolgen (p. 155)• Verwenden von Arrays zum Erstellen von Karten (p. 155)• Abfragen von Arrays mit komplexen Typen und verschachtelten Strukturen (p. 156)

Erstellen von ArraysZum Erstellen eines Arrayliterals in Athena verwenden Sie das Schlüsselwort ARRAY, gefolgt vonKlammern [ ], und schließen die durch Kommata getrennten Array-Elemente ein.

BeispieleDiese Abfrage erstellt ein Array mit vier Elementen.

SELECT ARRAY [1,2,3,4] AS items

Folgendes wird zurückgegeben:

+-----------+| items |+-----------+| [1,2,3,4] |+-----------+

Diese Abfrage erstellt zwei Arrays.

SELECT ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items


+--------------------+| items |+--------------------+| [[1, 2], [3, 4]] |+--------------------+

Zum Erstellen eines Arrays aus ausgewählten Spalten kompatibler Typen nutzen Sie eine Abfrage, wie imfolgenden Beispiel gezeigt:

WITHdataset AS (

146

Amazon Athena BenutzerhandbuchVerketten von Arrays

SELECT 1 AS x, 2 AS y, 3 AS z)SELECT ARRAY [x,y,z] AS items FROM dataset

Diese Abfrage gibt Folgendes zurück:

+-----------+| items |+-----------+| [1,2,3] |+-----------+

Im folgenden Beispiel werden zwei Arrays ausgewählt und in Form einer Willkommensnachrichtzurückgegeben.

WITHdataset AS ( SELECT ARRAY ['hello', 'amazon', 'athena'] AS words, ARRAY ['hi', 'alexa'] AS alexa)SELECT ARRAY[words, alexa] AS welcome_msgFROM dataset


+----------------------------------------+| welcome_msg |+----------------------------------------+| [[hello, amazon, athena], [hi, alexa]] |+----------------------------------------+

Zum Erstellen eines Arrays aus Schlüssel/Wert-Paaren nutzen Sie den MAP-Operator. Dieser verwendetein Schlüssel-Array gefolgt von einem Werte-Array, wie im folgenden Beispiel gezeigt:

SELECT ARRAY[ MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']), MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']), MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8'])] AS people


+-----------------------------------------------------------------------------------------------------+| people |+-----------------------------------------------------------------------------------------------------+| [{last=Smith, first=Bob, age=40}, {last=Doe, first=Jane, age=30}, {last=Smith, first=Billy, age=8}] |+-----------------------------------------------------------------------------------------------------+

Verketten von ArraysVerwenden Sie zum Verketten von mehreren Arrays den doppelten Pipe-Operator || zwischen den Arrays.

147

Amazon Athena BenutzerhandbuchKonvertieren von Array-Datentypen

SELECT ARRAY [4,5] || ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items


+--------------------------+| items |+--------------------------+| [[4, 5], [1, 2], [3, 4]] |+--------------------------+

Um mehrere Arrays in einem einzelnen Array zu kombinieren, verwenden Sie die Funktion concat.

WITHdataset AS ( SELECT ARRAY ['hello', 'amazon', 'athena'] AS words, ARRAY ['hi', 'alexa'] AS alexa)SELECT concat(words, alexa) AS welcome_msgFROM dataset


+------------------------------------+| welcome_msg |+------------------------------------+| [hello, amazon, athena, hi, alexa] |+------------------------------------+

Konvertieren von Array-DatentypenUm Daten in einem Array in einen unterstützten Datentyp zu konvertieren, verwenden Sie den CAST-Operator als CAST(value AS type). Athena unterstützt alle nativen Presto-Datentypen.

SELECT ARRAY [CAST(4 AS VARCHAR), CAST(5 AS VARCHAR)]AS items


+-------+| items |+-------+| [4,5] |+-------+

Erstellen Sie zwei Arrays mit Schlüssel-Wert-Paar-Elementen, konvertieren Sie sie zu JSON und verkettenSie sie wie in diesem Beispiel:

SELECT ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] || ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]AS items


148

Amazon Athena BenutzerhandbuchSuchen nach Längen

+--------------------------------------------------+| items |+--------------------------------------------------+| [{"a1":1,"a2":2,"a3":3}, {"b1":4,"b2":5,"b3":6}] |+--------------------------------------------------+

Suchen nach LängenDie Funktion cardinality gibt die Länge eines Arrays wie in diesem Beispiel zurück:

SELECT cardinality(ARRAY[1,2,3,4]) AS item_count


+------------+| item_count |+------------+| 4 |+------------+

Zugreifen auf Array-ElementeVerwenden Sie für den Zugriff auf Array-Elemente den []-Operator, wobei 1 das erste Elementebezeichnet, 2 das zweite Elemente usw., wie im folgenden Beispiel:

WITH dataset AS (SELECT ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] || ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]AS items )SELECT items[1] AS item FROM dataset


+------------------------+| item |+------------------------+| {"a1":1,"a2":2,"a3":3} |+------------------------+

Verwenden Sie für den Zugriff auf die Array-Elemente an einer bestimmten Position (die Indexposition) dieFunktion element_at() und geben Sie den Namen des Array und die Indexposition an:

• Wenn der Index größer als 0 ist, gibt element_at() das angegebene Element zurück und zählt dasArray dabei von Anfang bis Ende durch. Die Funktion verhält sich dabei wie der []-Operator.

• Wenn der Index kleiner als 0 ist, gibt element_at() das angegebene Element zurück und zählt dasArray dabei von Ende bis Anfang durch.

In der folgenden Abfrage wird ein Array words erstellt und das erste Element hello als first_word,das zweite Element amazon (vom Ende des Arrays aus gezählt) als middle_word und das dritte Elementathena als last_word ausgewählt.

WITH dataset AS (

149

Amazon Athena BenutzerhandbuchReduzieren von verschachtelten Arrays

SELECT ARRAY ['hello', 'amazon', 'athena'] AS words)SELECT element_at(words, 1) AS first_word, element_at(words, -2) AS middle_word, element_at(words, cardinality(words)) AS last_wordFROM dataset


+----------------------------------------+| first_word | middle_word | last_word |+----------------------------------------+| hello | amazon | athena |+----------------------------------------+

Reduzieren von verschachtelten ArraysBeim Arbeiten mit verschachtelten Arrays müssen Sie verschachtelte Array-Elemente oft zu einemeinzelnen Array erweitern oder das Array in mehrere Zeilen erweitern.

BeispieleVerwenden Sie die Funktion flatten, um die Elemente eines verschachtelten Arrays zu einem einzelnenArray mit Werten zu reduzieren. Diese Abfrage gibt eine Zeile für jedes Element im Array zurück.

SELECT flatten(ARRAY[ ARRAY[1,2], ARRAY[3,4] ]) AS items


+-----------+| items |+-----------+| [1,2,3,4] |+-----------+

Um ein Array in mehrere Zeilen zu reduzieren, verwenden Sie CROSS JOIN in Verbindung mit demUNNEST-Operator wie in diesem Beispiel:

WITH dataset AS ( SELECT 'engineering' as department, ARRAY['Sharon', 'John', 'Bob', 'Sally'] as users)SELECT department, names FROM datasetCROSS JOIN UNNEST(users) as t(names)


+----------------------+| department | names |+----------------------+| engineering | Sharon |+----------------------|| engineering | John |

150

Amazon Athena BenutzerhandbuchReduzieren von verschachtelten Arrays

+----------------------|| engineering | Bob |+----------------------|| engineering | Sally |+----------------------+

Um ein Array mit Schlüssel-Wert-Paaren zu reduzieren, verteilen Sie die ausgewählten Schlüssel wie indiesem Beispiel in Spalten:

WITHdataset AS ( SELECT 'engineering' as department, ARRAY[ MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']), MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']), MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8']) ] AS people )SELECT names['first'] AS first_name, names['last'] AS last_name, department FROM datasetCROSS JOIN UNNEST(people) AS t(names)


+--------------------------------------+| first_name | last_name | department |+--------------------------------------+| Bob | Smith | engineering || Jane | Doe | engineering || Billy | Smith | engineering |+--------------------------------------+

Wählen Sie aus einer Liste mit Mitarbeitern den Mitarbeiter mit den höchsten kombinierten Werten aus.UNNEST kann in der Klausel FROM ohne vorangestelltes CROSS JOIN, da es der Standard-JOIN-Operatorist und somit vorausgesetzt wird.

WITHdataset AS ( SELECT ARRAY[ CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))), CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))), CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))) ] AS users),users AS ( SELECT person, score FROM dataset, UNNEST(dataset.users) AS t(person), UNNEST(person.scores) AS t(score))SELECT person.name, person.department, SUM(score) AS total_score FROM usersGROUP BY (person.name, person.department)ORDER BY (total_score) DESCLIMIT 1

151

Amazon Athena BenutzerhandbuchErstellen von Arrays aus Unterabfragen


+---------------------------------+| name | department | total_score |+---------------------------------+| Amy | devops | 54 |+---------------------------------+

Wählen Sie aus einer Liste mit Mitarbeitern den Mitarbeiter mit den höchsten einzelnen Werten aus.

WITHdataset AS ( SELECT ARRAY[ CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))), CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))), CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))) ] AS users),users AS ( SELECT person, score FROM dataset, UNNEST(dataset.users) AS t(person), UNNEST(person.scores) AS t(score))SELECT person.name, score FROM usersORDER BY (score) DESCLIMIT 1


+--------------+| name | score |+--------------+| Amy | 15 |+--------------+

Erstellen von Arrays aus UnterabfragenErstellen Sie ein Array aus einer Sammlung von Zeilen.

WITHdataset AS ( SELECT ARRAY[1,2,3,4,5] AS items)SELECT array_agg(i) AS array_itemsFROM datasetCROSS JOIN UNNEST(items) AS t(i)


+-----------------+| array_items |+-----------------+| [1, 2, 3, 4, 5] |

152

Amazon Athena BenutzerhandbuchFiltern von Arrays

+-----------------+

Nutzen Sie das Schlüsselwort distinct, um ein Array, bestehend aus eindeutigen Werten, aus einerReihe von Zeilen zu erstellen.

WITHdataset AS ( SELECT ARRAY [1,2,2,3,3,4,5] AS items)SELECT array_agg(distinct i) AS array_itemsFROM datasetCROSS JOIN UNNEST(items) AS t(i)

Diese Abfrage gibt das folgende Ergebnis zurück. Beachten Sie, dass die Reihenfolge nicht garantiert ist.

+-----------------+| array_items |+-----------------+| [1, 2, 3, 4, 5] |+-----------------+

Filtern von ArraysErstellen Sie ein Array aus einer Reihe von Zeilen, die den Filterkriterien entsprechen.

WITHdataset AS ( SELECT ARRAY[1,2,3,4,5] AS items)SELECT array_agg(i) AS array_itemsFROM datasetCROSS JOIN UNNEST(items) AS t(i)WHERE i > 3


+-------------+| array_items |+-------------+| [4, 5] |+-------------+

Filtern Sie ein Array basierend darauf, ob Elemente einen bestimmten Wert (z. B. 2) enthalten, wie indiesem Beispiel:

WITHdataset AS ( SELECT ARRAY [ ARRAY[1,2,3,4], ARRAY[5,6,7,8], ARRAY[9,0] ] AS items)SELECT i AS array_items FROM datasetCROSS JOIN UNNEST(items) AS t(i)WHERE contains(i, 2)

153

Amazon Athena BenutzerhandbuchSortieren von Arrays


+--------------+| array_items |+--------------+| [1, 2, 3, 4] |+--------------+

Sortieren von ArraysErstellen Sie ein sortiertes Array mit eindeutigen Werten aus einer Reihe von Zeilen.

WITHdataset AS ( SELECT ARRAY[3,1,2,5,2,3,6,3,4,5] AS items)SELECT array_sort(array_agg(distinct i)) AS array_itemsFROM datasetCROSS JOIN UNNEST(items) AS t(i)


+--------------------+| array_items |+--------------------+| [1, 2, 3, 4, 5, 6] |+--------------------+

Verwenden von Aggregationsfunktionen mit Arrays• Fügen Sie mit SUM Werte zu einem Array hinzu, wie im folgenden Beispiel dargestellt.• Aggregieren Sie mit array_agg mehrere Zeilen in einem Array. Weitere Informationen finden Sie unter

Creating Arrays from Subqueries (p. 152).

Note

ORDER BY wird für Aggregationsfunktionen nicht unterstützt und kann z. B. innerhalb vonarray_agg(x) nicht verwendet werden.

WITHdataset AS ( SELECT ARRAY [ ARRAY[1,2,3,4], ARRAY[5,6,7,8], ARRAY[9,0] ] AS items),item AS ( SELECT i AS array_items FROM dataset, UNNEST(items) AS t(i))SELECT array_items, sum(val) AS totalFROM item, UNNEST(array_items) AS t(val)GROUP BY array_items;

154

Amazon Athena BenutzerhandbuchKonvertieren von Arrays in Zeichenfolgen

Diese Abfrage gibt folgende Ergebnisse zurück. Die Reihenfolge der zurückgegebenen Ergebnisse ist nichtgewährleistet.

+----------------------+| array_items | total |+----------------------+| [1, 2, 3, 4] | 10 || [5, 6, 7, 8] | 26 || [9, 0] | 9 |+----------------------+

Konvertieren von Arrays in ZeichenfolgenZum Konvertieren eines Arrays in eine einzelne Zeichenfolge verwenden Sie die array_join-Funktion.

WITHdataset AS ( SELECT ARRAY ['hello', 'amazon', 'athena'] AS words)SELECT array_join(words, ' ') AS welcome_msgFROM dataset


+---------------------+| welcome_msg |+---------------------+| hello amazon athena |+---------------------+

Verwenden von Arrays zum Erstellen von KartenZuordnungen sind Schlüssel-Wert-Paare, die aus einem in Athena verfügbaren Datentyp bestehen.Verwenden Sie zum Erstellen von Zuordnungen den MAP-Operator und übergeben Sie zwei Arrays: Daserste Array enthält die Spaltennamen (Schlüssel) und das zweite Array enthält die Werte. Alle Werte inden Arrays müssen denselben Typ haben. Wenn bestimmte Zuordnungswerte im Array einen anderen Typbenötigen, können Sie sie später umwandeln.

BeispieleIn diesem Beispiel wird ein Benutzer aus einem Dataset ausgewählt. Dem verwendeten MAP-Operatorwerden zwei Arrays übergeben. Das erste Array enthält Werte für die Spaltennamen wie "first", "last" und"age". Das zweite Array enthält die Werte für die einzelnen Spalten, z. B. "Bob", "Smith", "35".

WITH dataset AS ( SELECT MAP( ARRAY['first', 'last', 'age'], ARRAY['Bob', 'Smith', '35'] ) AS user)SELECT user FROM dataset


+---------------------------------+

155

Amazon Athena BenutzerhandbuchAbfragen von Arrays mit komplexen

Typen und verschachtelten Strukturen

| user |+---------------------------------+| {last=Smith, first=Bob, age=35} |+---------------------------------+

Sie können Map-Werte abrufen, indem Sie den Feldnamen gefolgt von [key_name] wie in diesem Beispielauswählen:

WITH dataset AS ( SELECT MAP( ARRAY['first', 'last', 'age'], ARRAY['Bob', 'Smith', '35'] ) AS user)SELECT user['first'] AS first_name FROM dataset


+------------+| first_name |+------------+| Bob |+------------+

Abfragen von Arrays mit komplexen Typen undverschachtelten StrukturenQuelldaten enthalten oft Arrays mit komplexen Datentypen und verschachtelten Strukturen. In denBeispielen in diesem Abschnitt wird gezeigt, wie Sie mit Athena-Abfragen den Datentyp eines Elementsändern, Elemente in einem Array finden und Schlüsselwörter finden können.

• Erstellen einer ROW (p. 156)• Ändern von Feldnamen in Arrays mit CAST (p. 157)• Filtern von Arrays mit der . Notation (p. 157)• Filtern von Arrays mit verschachtelten Werten (p. 158)• Filtern von Arrays mit UNNEST (p. 159)• Suchen nach Schlüsselwörtern in Arrays mithilfe von regexp_like (p. 159)

Erstellen einer ROWNote

In den Beispielen in diesem Abschnitt wird ROW verwendet, um Beispieldaten zu erstellen. WennSie Tabellen mit Athena abfragen, müssen Sie keine ROW-Datentypen erstellen, da sie bereits ausIhrer Datenquelle erstellt wurden. Wenn Sie CREATE_TABLE verwenden, definiert Athena eineSTRUCT darin, füllt sie mit Daten und erstellt für jede Zeile in einem Dataset den ROW-Datentyp fürSie. Der zugrunde liegende ROW-Datentyp besteht aus benannten Feldern beliebiger unterstützterSQL-Datentypen.

WITH dataset AS ( SELECT ROW('Bob', 38) AS users

156



)SELECT * FROM dataset


+-------------------------+| users |+-------------------------+| {field0=Bob, field1=38} |+-------------------------+

Ändern von Feldnamen in Arrays mit CASTVerwenden Sie zum Ändern des Feldnamens in einem Array, das ROW-Werte enthält, eine CAST-Anweisung für die ROW-Deklaration:

WITH dataset AS ( SELECT CAST( ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER) ) AS users)SELECT * FROM dataset


+--------------------+| users |+--------------------+| {NAME=Bob, AGE=38} |+--------------------+

Note

Im obigen Beispiel deklarieren Sie name als VARCHAR, da dies der Datentyp in Presto ist. WennSie dieses STRUCT innerhalb einer CREATE TABLE-Anweisung deklarieren, verwenden Sie denDatentyp String, da Hive diesen Datentyp als String definiert.

Filtern von Arrays mit der . NotationWählen Sie im folgenden Beispiel das Feld accountId aus der Spalte userIdentity einer AWSCloudTrail-Protokolltabelle mit der Punktnotation . aus. Weitere Informationen finden Sie unter QueryingAWS CloudTrail Logs (p. 190).

SELECT CAST(useridentity.accountid AS bigint) as newidFROM cloudtrail_logsLIMIT 2;


+--------------+| newid |+--------------+| 112233445566 |

157



+--------------+| 998877665544 |+--------------+

Um ein Array mit Werten abzufragen, senden Sie diese Abfrage:

WITH dataset AS ( SELECT ARRAY[ CAST(ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)), CAST(ROW('Alice', 35) AS ROW(name VARCHAR, age INTEGER)), CAST(ROW('Jane', 27) AS ROW(name VARCHAR, age INTEGER)) ] AS users)SELECT * FROM dataset

Sie erhalten das folgende Ergebnis:

+-----------------------------------------------------------------+| users |+-----------------------------------------------------------------+| [{NAME=Bob, AGE=38}, {NAME=Alice, AGE=35}, {NAME=Jane, AGE=27}] |+-----------------------------------------------------------------+

Filtern von Arrays mit verschachtelten WertenGroße Arrays enthalten oft verschachtelte Strukturen und Sie müssen die darin enthaltenen Werte filternoder suchen können.

Um ein Dataset für ein Array mit Werten zu definieren, das einen verschachtelten BOOLEAN-Wert enthält,senden Sie die folgende Abfrage:

WITH dataset AS ( SELECT CAST( ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN)) ) AS sites)SELECT * FROM dataset


+----------------------------------------------------------+| sites |+----------------------------------------------------------+| {HOSTNAME=aws.amazon.com, FLAGGEDACTIVITY={ISNEW=true}} |+----------------------------------------------------------+

Verwenden Sie nun zum Filtern von und Zugreifen auf den BOOLEAN-Wert dieses Elements die Dot .-Notation.

WITH dataset AS ( SELECT CAST( ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN)) ) AS sites

158



)SELECT sites.hostname, sites.flaggedactivity.isnewFROM dataset

Mit dieser Abfrage werden die verschachtelten Felder ausgewählt und folgendes Ergebnis zurückgegeben:

+------------------------+| hostname | isnew |+------------------------+| aws.amazon.com | true |+------------------------+

Filtern von Arrays mit UNNESTUm ein Array mit einer verschachtelten Struktur nach einem untergeordneten Element zu filtern, verwendenSie eine Abfrage mit einem UNNEST-Operator. Weitere Informationen zu UNNEST finden Sie unterReduzieren von verschachtelten Arrays (p. 150).

Diese Abfrage sucht beispielsweise Hostnamen von Websites im Dataset.

WITH dataset AS ( SELECT ARRAY[ CAST( ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN)) ), CAST( ROW('news.cnn.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN)) ), CAST( ROW('netflix.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN)) ) ] as items)SELECT sites.hostname, sites.flaggedActivity.isNewFROM dataset, UNNEST(items) t(sites)WHERE sites.flaggedActivity.isNew = true


+------------------------+| hostname | isnew |+------------------------+| aws.amazon.com | true |+------------------------+

Suchen nach Schlüsselwörtern in Arrays mithilfe vonregexp_like

Die folgenden Beispiele veranschaulichen, wie Sie mit der Funktion regexp_like ein Dataset nach einemSchlüsselwort innerhalb eines Elements in einem Array durchsuchen. Sie übernimmt als Eingabe einauszuwertendes reguläres Ausdrucksmuster oder eine Liste von Begriffen, die durch einen senkrechtenStrich (|) voneinander getrennt sind, und bestimmt, ob diese Eingabe in der angegebenen Zeichenfolgeenthalten ist.

159

https://prestodb.io/docs/0.172/functions/regexp.html



Das reguläre Ausdrucksmuster muss innerhalb der Zeichenfolge enthalten sein, braucht aber nicht genaumit ihr übereinzustimmen. Wenn es mit der gesamten Zeichenfolge übereinstimmen soll, setzen Sie dasMuster zwischen ein ^ am Anfang und ein $ am Ende, z. B. '^pattern$'.

Stellen Sie sich ein Array von Websites mit deren Hostname und einem Element flaggedActivity vor.Dieses Element enthält ein ARRAY mit mehreren MAP-Elementen, die jeweils beliebte Schlüsselwörter undderen Beliebtheitswert enthalten. Angenommen, Sie möchten ein bestimmtes Schlüsselwort innerhalb einerMAP in diesem Array finden.

Um dieses Dataset nach Websites mit einem bestimmten Schlüsselwort zu durchsuchen, verwenden Sieregexp_like anstelle des ähnlichen SQL-LIKE-Operators, da die Suche nach einer großen Anzahl vonSchlüsselwörtern mit regexp_like effizienter ist.

Example Beispiel 1: Verwenden von regexp_like

Die Abfrage in diesem Beispiel sucht mit der Funktion regexp_like nach den Begriffen 'politics|bigdata' in den Werten innerhalb des Arrays:

WITH dataset AS ( SELECT ARRAY[ CAST( ROW('aws.amazon.com', ROW(ARRAY[ MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']), MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']), MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']), MAP(ARRAY['term', 'count'], ARRAY['iot', '74']) ]) ) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) )) ), CAST( ROW('news.cnn.com', ROW(ARRAY[ MAP(ARRAY['term', 'count'], ARRAY['politics', '241']), MAP(ARRAY['term', 'count'], ARRAY['technology', '211']), MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']), MAP(ARRAY['term', 'count'], ARRAY['iot', '170']) ]) ) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) )) ), CAST( ROW('netflix.com', ROW(ARRAY[ MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']), MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']), MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']), MAP(ARRAY['term', 'count'], ARRAY['iot', '4']) ]) ) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) )) ) ] AS items),sites AS ( SELECT sites.hostname, sites.flaggedactivity FROM dataset, UNNEST(items) t(sites))SELECT hostnameFROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)WHERE regexp_like(flags['term'], 'politics|bigdata')GROUP BY (hostname)

Diese Abfrage gibt zwei Websites zurück:

+----------------+| hostname |+----------------+

160



| aws.amazon.com |+----------------+| news.cnn.com |+----------------+

Example Beispiel 2: Verwenden von regexp_like

Bei der Abfrage im folgenden Beispiel werden die Gesamtbeliebtheitswerte für die Websites, die mit IhrenSuchbegriffen übereinstimmen, mit der Funktion regexp_like addiert und dann von hoch nach niedrigsortiert.

WITH dataset AS ( SELECT ARRAY[ CAST( ROW('aws.amazon.com', ROW(ARRAY[ MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']), MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']), MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']), MAP(ARRAY['term', 'count'], ARRAY['iot', '74']) ]) ) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) )) ), CAST( ROW('news.cnn.com', ROW(ARRAY[ MAP(ARRAY['term', 'count'], ARRAY['politics', '241']), MAP(ARRAY['term', 'count'], ARRAY['technology', '211']), MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']), MAP(ARRAY['term', 'count'], ARRAY['iot', '170']) ]) ) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) )) ), CAST( ROW('netflix.com', ROW(ARRAY[ MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']), MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']), MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']), MAP(ARRAY['term', 'count'], ARRAY['iot', '4']) ]) ) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) )) ) ] AS items),sites AS ( SELECT sites.hostname, sites.flaggedactivity FROM dataset, UNNEST(items) t(sites))SELECT hostname, array_agg(flags['term']) AS terms, SUM(CAST(flags['count'] AS INTEGER)) AS totalFROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)WHERE regexp_like(flags['term'], 'politics|bigdata')GROUP BY (hostname)ORDER BY total DESC

Diese Abfrage gibt zwei Websites zurück:

+------------------------------------+| hostname | terms | total |+----------------+-------------------+| news.cnn.com | politics | 241 |+----------------+-------------------+| aws.amazon.com | big data | 10 |+----------------+-------------------+

161

Amazon Athena BenutzerhandbuchAbfragen von &JSON

Abfragen von &JSONMit Amazon Athena können Sie JSON-kodierte Werte analysieren, Daten aus JSON extrahieren, nachWerten suchen und die Länge und Größe von JSON-Arrays bestimmen.

Themen• Bewährte Methoden zum Lesen von JSON-Daten (p. 162)• Extrahieren von Daten aus JSON (p. 163)• Suchen nach Werten in JSON-Arrays (p. 166)• Abrufen der Länge und Größe von JSON-Arrays (p. 167)

Bewährte Methoden zum Lesen von JSON-DatenJavaScript Object Notation (JSON) ist eine gängige Methode zur Kodierung von Datenstrukturen als Text.Viele Anwendungen und Tools geben Daten im JSON-Format aus.

In Amazon Athena können Sie Tabellen aus externen Daten erstellen und die JSON-kodierten Datendarin einschließen. Verwenden Sie für solche Quelldaten Athena zusammen mit JSON SerDe-Bibliotheken (p. 301).

Nutzen Sie die folgenden Tipps, um JSON-kodierte Daten zu lesen:

• Wählen Sie den richtigen SerDe aus: einen nativen JSON SerDe,org.apache.hive.hcatalog.data.JsonSerDe oder einen OpenX SerDe,org.openx.data.jsonserde.JsonSerDe. Weitere Informationen finden Sie unter JSON SerDe-Bibliotheken (p. 301).

• Stellen Sie sicher, dass jeder JSON-kodierte Datensatz in einer eigenen Zeile abgebildet wird.• Generieren Sie die JSON-kodierten Daten in Spalten (ohne Berücksichtigung von Groß-/

Kleinschreibung).• Binden Sie eine Option zum Ignorieren fehlerhafter Datensätze (wie in diesem Beispiel) ein.

CREATE EXTERNAL TABLE json_table ( column_a string column_b int ) ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe' WITH SERDEPROPERTIES ('ignore.malformed.json' = 'true') LOCATION 's3://bucket/path/';

• Konvertieren Sie Felder der Quelldaten, die ein unbestimmtes Schema haben, in JSON-Zeichenfolgen inAthena.

Wenn Athena Tabellen basierend auf JSON-Daten erstellt, werden die Daten basierend auf vorhandenenund vordefinierten Schemata analysiert. Es verfügen jedoch möglicherweise nicht alle Ihre Daten überein vordefiniertes Schema. Um die Schemaverwaltung in solchen Fällen zu vereinfachen, ist es ofthilfreich, Felder in Quelldaten, die ein unbestimmtes Schema haben, in Athena in JSON-Zeichenfolgen zukonvertieren und dann JSON SerDe-Bibliotheken (p. 301) zu verwenden.

Nehmen wir als Beispiel eine IoT-Anwendung, die Ereignisse mit gängigen Feldern von verschiedenenSensoren veröffentlicht. In einem dieser Felder muss eine benutzerdefinierte Nutzlast gespeichert werden,die für den Sensor, der das Ereignis sendet, eindeutig ist. Da Sie in diesem Fall das Schema nicht kennen,empfehlen wir, die Information als JSON-kodierte Zeichenfolge zu speichern. Konvertieren Sie hierfürdie Daten in Ihrer Athena-Tabelle in das JSON-Format, wie im folgenden Beispiel dargestellt. Sie könnenJSON-kodierte Daten auch in Athena-Datentypen konvertieren.

162

Amazon Athena BenutzerhandbuchExtrahieren von Daten aus JSON

• Konvertieren von Athena-Datentypen nach JSON (p. 163)• Konvertieren von JSON-Datentypen nach Athena (p. 163)

Konvertieren von Athena-Datentypen in JSONVerwenden Sie CAST, um Athena-Datentypen in JSON zu konvertieren.

WITH dataset AS ( SELECT CAST('HELLO ATHENA' AS JSON) AS hello_msg, CAST(12345 AS JSON) AS some_int, CAST(MAP(ARRAY['a', 'b'], ARRAY[1,2]) AS JSON) AS some_map)SELECT * FROM dataset


+-------------------------------------------+| hello_msg | some_int | some_map |+-------------------------------------------+| "HELLO ATHENA" | 12345 | {"a":1,"b":2} |+-------------------------------------------+

Konvertieren von JSON in Athena-DatentypenVerwenden Sie CAST, um JSON-Daten in Athena-Datentypen zu konvertieren.

Note

Um in diesem Beispiel Zeichenfolgen als JSON-kodiert zu kennzeichnen, beginnen Sie mit demJSON-Schlüsselwort und verwenden Sie einfache Anführungszeichen wie JSON '12345'.

WITH dataset AS ( SELECT CAST(JSON '"HELLO ATHENA"' AS VARCHAR) AS hello_msg, CAST(JSON '12345' AS INTEGER) AS some_int, CAST(JSON '{"a":1,"b":2}' AS MAP(VARCHAR, INTEGER)) AS some_map)SELECT * FROM dataset


+-------------------------------------+| hello_msg | some_int | some_map |+-------------------------------------+| HELLO ATHENA | 12345 | {a:1,b:2} |+-------------------------------------+

Extrahieren von Daten aus JSONMöglicherweise verfügen Sie über Quelldaten mit JSON-kodierten Zeichenfolgen, die Sie nicht in eineTabelle in Athena deserialisieren möchten. In diesem Fall können Sie mit den JSON-Funktionen in Prestodennoch SQL-Operationen für diese Daten ausführen.

163


Betrachten Sie diese JSON-Zeichenfolge als Beispiel-Dataset.

{"name": "Susan Smith","org": "engineering","projects": [ {"name":"project1", "completed":false}, {"name":"project2", "completed":true} ]}

Beispiele: Extrahieren von EigenschaftenUm die Eigenschaften name und projects aus der JSON-Zeichenfolge zu extrahieren, verwenden Siedie Funktion json_extract wie im folgenden Beispiel. Die Funktion json_extract übernimmt dieSpalte mit der JSON-Zeichenfolge und durchsucht sie mit einem JSONPath-artigen Ausdruck in der Dot .-Notation.

Note

JSONPath führt einen einfachen Strukturdurchlauf aus. Dabei wird das Stammverzeichnis desJSON-Dokuments mit $ bezeichnet, gefolgt von einem Punkt und einem direkt unterhalb desStammverzeichnisses verschachtelten Elements wie $.name.

WITH dataset AS ( SELECT '{"name": "Susan Smith", "org": "engineering", "projects": [{"name":"project1", "completed":false}, {"name":"project2", "completed":true}]}' AS blob)SELECT json_extract(blob, '$.name') AS name, json_extract(blob, '$.projects') AS projectsFROM dataset

Der zurückgegebene Wert ist eine JSON-kodierte Zeichenfolge und kein nativer Athena-Datentyp.

+-----------------------------------------------------------------------------------------------+| name | projects |+-----------------------------------------------------------------------------------------------+| "Susan Smith" | [{"name":"project1","completed":false},{"name":"project2","completed":true}] |+-----------------------------------------------------------------------------------------------+

Verwenden Sie zum Extrahieren von skalaren Werten aus der JSON-Zeichenfolge die Funktionjson_extract_scalar. Sie ist json_extract ähnlich, gibt jedoch nur skalare Werte (boolesche Werte,Zahlen oder Zeichenfolgen) zurück.

Note

Verwenden Sie die Funktion json_extract_scalar nicht für Arrays, Zuordnungen oderStrukturen.

WITH dataset AS (

164


SELECT '{"name": "Susan Smith", "org": "engineering", "projects": [{"name":"project1", "completed":false},{"name":"project2", "completed":true}]}' AS blob)SELECT json_extract_scalar(blob, '$.name') AS name, json_extract_scalar(blob, '$.projects') AS projectsFROM dataset


+---------------------------+| name | projects |+---------------------------+| Susan Smith | |+---------------------------+

Um das erste Element der Eigenschaft projects in dem Beispiel-Array abzurufen, verwenden Sie dieFunktion json_array_get und geben Sie die Indexposition an.

WITH dataset AS ( SELECT '{"name": "Bob Smith", "org": "engineering", "projects": [{"name":"project1", "completed":false},{"name":"project2", "completed":true}]}' AS blob)SELECT json_array_get(json_extract(blob, '$.projects'), 0) AS itemFROM dataset

Es wird der Wert an der angegebenen Indexposition in dem JSON-kodierten Array zurückgegeben.

+---------------------------------------+| item |+---------------------------------------+| {"name":"project1","completed":false} |+---------------------------------------+

Um einen Athena-Zeichenfolgetyp zurückzugeben, verwenden Sie den []-Operator in einem JSONPath-Ausdruck und verwenden Sie anschließend die Funktion json_extract_scalar. Weitere Informationenzu [] finden Sie unter Zugreifen auf Array-Elemente (p. 149).

WITH dataset AS ( SELECT '{"name": "Bob Smith", "org": "engineering", "projects": [{"name":"project1", "completed":false},{"name":"project2", "completed":true}]}' AS blob)SELECT json_extract_scalar(blob, '$.projects[0].name') AS project_nameFROM dataset


+--------------+| project_name |+--------------+

165

Amazon Athena BenutzerhandbuchSuchen nach Werten in JSON-Arrays

| project1 |+--------------+

Suchen nach Werten in JSON-ArraysUm zu ermitteln, ob ein bestimmter Wert in einem JSON-kodierten Array vorhanden ist, nutzen Sie diejson_array_contains-Funktion.

Die folgende Abfrage führt die Namen der Benutzer auf, die an "project2" teilnehmen.

WITH dataset AS ( SELECT * FROM (VALUES (JSON '{"name": "Bob Smith", "org": "legal", "projects": ["project1"]}'), (JSON '{"name": "Susan Smith", "org": "engineering", "projects": ["project1", "project2", "project3"]}'), (JSON '{"name": "Jane Smith", "org": "finance", "projects": ["project1", "project2"]}') ) AS t (users))SELECT json_extract_scalar(users, '$.name') AS userFROM datasetWHERE json_array_contains(json_extract(users, '$.projects'), 'project2')

Diese Abfrage gibt eine Liste von Benutzern zurück.

+-------------+| user |+-------------+| Susan Smith |+-------------+| Jane Smith |+-------------+

Die folgende Beispielabfragespiel listet die Namen von Benutzern auf, die Projekte abgeschlossen haben,einschließlich der Anzahl abgeschlossener Projekte. Folgende Aktionen werden durchgeführt:

• Verwendet zum Zwecke der Übersicht SELECT-Anweisungen.• Extrahiert das Projekt-Array.• Wandelt das Array mittels CAST in einen nativen Array von Schlüssel/Wert-Paaren um.• Extrahiert jedes einzelne Array-Element mit dem UNNEST-Operator.• Filtert abgerufene Werte nach abgeschlossenen Projekten und zählt diese.

Note

Wenn Sie CAST zum MAP verwenden, können Sie das Schlüsselelement als VARCHAR (nativeZeichenfolge in Presto) angeben, behalten aber den Wert als JSON bei, da die Werte in MAPunterschiedliche Typen aufweisen: Das erste Schlüssel/Wert-Paar ist ein Zeichenfolgenwert unddas zweite ein boolescher.

WITH dataset AS ( SELECT * FROM (VALUES (JSON '{"name": "Bob Smith", "org": "legal", "projects": [{"name":"project1", "completed":false}]}'), (JSON '{"name": "Susan Smith", "org": "engineering", "projects": [{"name":"project2", "completed":true}, {"name":"project3", "completed":true}]}'),

166

Amazon Athena BenutzerhandbuchAbrufen der Länge und Größe von JSON-Arrays

(JSON '{"name": "Jane Smith", "org": "finance", "projects": [{"name":"project2", "completed":true}]}') ) AS t (users)),employees AS ( SELECT users, CAST(json_extract(users, '$.projects') AS ARRAY(MAP(VARCHAR, JSON))) AS projects_array FROM dataset),names AS ( SELECT json_extract_scalar(users, '$.name') AS name, projects FROM employees, UNNEST (projects_array) AS t(projects))SELECT name, count(projects) AS completed_projects FROM namesWHERE cast(element_at(projects, 'completed') AS BOOLEAN) = trueGROUP BY name

Diese Abfrage gibt das folgende Ergebnis zurück:

+----------------------------------+| name | completed_projects |+----------------------------------+| Susan Smith | 2 |+----------------------------------+| Jane Smith | 1 |+----------------------------------+

Abrufen der Länge und Größe von JSON-ArraysBeispiel: json_array_lengthUm die Länge eines JSON-kodierten Arrays abzurufen, verwenden Sie die Funktionjson_array_length.

WITH dataset AS ( SELECT * FROM (VALUES (JSON '{"name": "Bob Smith", "org": "legal", "projects": [{"name":"project1", "completed":false}]}'), (JSON '{"name": "Susan Smith", "org": "engineering", "projects": [{"name":"project2", "completed":true}, {"name":"project3", "completed":true}]}'), (JSON '{"name": "Jane Smith", "org": "finance", "projects": [{"name":"project2", "completed":true}]}') ) AS t (users))SELECT json_extract_scalar(users, '$.name') as name, json_array_length(json_extract(users, '$.projects')) as countFROM datasetORDER BY count DESC


+---------------------+

167

Amazon Athena BenutzerhandbuchAbfragen von koordinatenbasierten Daten

| name | count |+---------------------+| Susan Smith | 2 |+---------------------+| Bob Smith | 1 |+---------------------+| Jane Smith | 1 |+---------------------+

Beispiel: json_sizeUm die Größe eines JSON-kodierten Arrays oder Objekts abzurufen, verwenden Sie die Funktionjson_size und geben die Spalte an, die die JSON-Zeichenfolge und den JSONPath-Ausdruck zu demArray oder Objekt enthält.

WITH dataset AS ( SELECT * FROM (VALUES (JSON '{"name": "Bob Smith", "org": "legal", "projects": [{"name":"project1", "completed":false}]}'), (JSON '{"name": "Susan Smith", "org": "engineering", "projects": [{"name":"project2", "completed":true},{"name":"project3", "completed":true}]}'), (JSON '{"name": "Jane Smith", "org": "finance", "projects": [{"name":"project2", "completed":true}]}') ) AS t (users))SELECT json_extract_scalar(users, '$.name') as name, json_size(users, '$.projects') as countFROM datasetORDER BY count DESC


+---------------------+| name | count |+---------------------+| Susan Smith | 2 |+---------------------+| Bob Smith | 1 |+---------------------+| Jane Smith | 1 |+---------------------+

Abfragen von koordinatenbasierten DatenKoordinatenbasierte Daten enthalten Kennungen, die eine geografische Position für ein Objekt angeben.Zu den Beispielen für diese Art von Daten zählen Wetterberichte, Wegbeschreibungen, Tweets mitgeografischen Positionen, Filialstandorte und Flugrouten. Koordinatenbasierte Daten spielen eine wichtigeRolle bei Geschäftsanalysen, der Berichterstattung und bei Vorhersagen.

Geografische Kennungen, wie z. B. Längen- und Breitengrade, ermöglichen das Umwandeln vonPostanschriften in geografische Koordinaten.

Themen• Was ist eine koordinatenbasierte Abfrage? (p. 169)• Eingabedatenformate und Geometrie-Datentypen (p. 169)

168

Amazon Athena BenutzerhandbuchWas ist eine koordinatenbasierte Abfrage?

• Liste der unterstützten koordinatenbasierten Funktionen (p. 170)• Beispiele: Koordinatenbasierte Abfragen (p. 178)

Was ist eine koordinatenbasierte Abfrage?Koordinatenbasierte Abfragen sind spezielle SQL-Abfragen, die in Athena unterstützt werden. Sieunterscheiden sich von nicht koordinatenbezogenen SQL-Abfragen wie folgt:

• Verwendung der folgenden spezialisierten Geometrie-Datentypen: pointline, multiline, polygonund multipolygon.

• Angeben von Beziehungen zwischen Geometrie-Datentypen wie distance, equals, crosses,touches, overlaps, disjoint und anderen.

Mit koordinatenbasierten Abfragen in Athena können Sie diese und ähnliche Operationen ausführen:

• Bestimmen des Abstands zwischen zwei Punkten.• Feststellen, ob ein Bereich (Polygon) einen anderen enthält.• Feststellen, ob eine Linie eine andere oder ein Polygon berührt oder schneidet.

Um beispielsweise den Geometriedatentyp point aus einem Paar von double-Werten fürdie geografischen Koordinaten des Mount Rainier in Athena abzurufen, verwenden Sie diekoordinatenbezogene Funktion ST_POINT (double, double) (longitude, latitude) und gebenzuerst den Längengrad und dann den Breitengrad an.

ST_POINT(-121.7602, 46.8527) (longitude, latitude)

Eingabedatenformate und Geometrie-DatentypenZum Verwenden von koordinatenbasierten Funktionen in Athena geben Sie die Daten im WKT-Formatein oder nutzen Sie den Hive JSON SerDe. Sie können auch die in Athena unterstützten Geometrie-Datentypen nutzen.

EingabedatenformateZur Verarbeitung von koordinatenbasierten Abfragen unterstützt Athena Eingabedaten in diesenDatenformaten:

• WKT (Well-known Text). In Athena wird WKT als varchar-Datentyp dargestellt.• JSON-kodierte koordinatenbasierte Daten. Zum Analysieren von JSON-Dateien mit koordinatenbasierten

Daten und zum Erstellen von Tabellen für diese verwendet Athena den Hive JSON SerDe. WeitereInformationen zur Verwendung des SerDe in Athena finden Sie auf der Seite zu JSON SerDe-Bibliotheken (p. 301).

Geometrie-DatentypenZur Verarbeitung von koordinatenbasierten Abfragen unterstützt Athena diese speziellen Geometrie-Datentypen:

• point

• line

169

https://github.com/Esri/spatial-framework-for-hadoop/wiki/Hive-JSON-SerDe

Amazon Athena BenutzerhandbuchListe der unterstützten koordinatenbasierten Funktionen

• polygon

• multiline

• multipolygon

Liste der unterstützten koordinatenbasiertenFunktionenKoordinatenbasierte Funktionen in Athena haben folgende Eigenschaften:

• Die Funktionen folgen den Grundprinzipien von koordinatenbasierten Abfragen.• Die Funktionen werden als Presto-Plug-in basierend auf der ESRI Java Geometry-Bibliothek

implementiert. Diese Bibliothek verfügt über eine Apache 2-Lizenz.• Die Funktionen benötigen die ESRI Geometry API.• Nicht alle ESRI-unterstützten Funktionen sind in Athena verfügbar. In diesem Thema werden nur die

koordinatenbasierten ESRI-Funktionen vorgestellt, die von Athena unterstützt werden.• Sie können keine Ansichten mit raumbezogenen Funktionen verwenden.

Athena unterstützt vier Arten von koordinatenbasierten Funktionen:

• Konstruktorfunktionen (p. 171)• Koordinatenbasierte Verhältnisfunktionen (p. 172)• Operationsfunktionen (p. 174)• Zugriffsfunktionen (p. 176)

Bevor Sie beginnenErstellen Sie zwei Tabellen, earthquakes und counties wie folgt:

CREATE external TABLE earthquakes( earthquake_date STRING, latitude DOUBLE, longitude DOUBLE, depth DOUBLE, magnitude DOUBLE, magtype string, mbstations string, gap string, distance string, rms string, source string, eventid string)ROW FORMAT DELIMITED FIELDS TERMINATED BY ','STORED AS TEXTFILE LOCATION 's3://my-query-log/csv'

CREATE external TABLE IF NOT EXISTS counties ( Name string, BoundaryShape binary )ROW FORMAT SERDE 'com.esri.hadoop.hive.serde.JsonSerde'

170

https://en.wikipedia.org/wiki/Spatial_query

https://esri.github.io/geometry-api-java/javadoc/index.html?overview-summary.html


STORED AS INPUTFORMAT 'com.esri.json.hadoop.EnclosedJsonInputFormat'OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://my-query-log/json'

Einige der folgenden Beispiele basieren auf diesen Tabellen und benötigen zwei Beispieldateien, die indem Amazon S3-Speicherort gespeichert sind. Diese Dateien sind nicht in Athena enthalten und werdenausschließlich zu Zwecken der Illustration verwendet:

• Die Datei earthquakes.csv, die Erdbeben in Kalifornien auflistet. Diese Datei enthält Felder, die denFeldern in der Tabelle earthquakes entsprechen.

• Die Datei california-counties.json, die JSON-kodierte Bezirksdaten im ESRI-kompatiblenFormat auflistet und zahlreiche Felder enthält, darunter AREA, PERIMETER, STATE, COUNTY und NAME.Die Tabelle counties basiert auf dieser Datei und enthält nur zwei Felder: Name (Zeichenfolge) undBoundaryShape (binärer Wert).

KonstruktorfunktionenMithilfe von Konstruktorfunktionen erhalten Sie binäre Werte der Geometriedatentypen point, line oderpolygon. Sie können diese Funktionen auch verwenden, um binäre Daten in Text umzuwandeln undbinäre Werte für Geometriedaten zu erhalten, die als Well-Known Text (WKT) ausgedrückt werden.

ST_POINT(double, double)

Gibt den binären Wert des Geometriedatentyps point zurück.

Um den Geometriedatentyp point zu erhalten, verwenden Sie die Funktion ST_POINT in Athena. AlsEingabedatenwerte für diese Funktion verwenden Sie geometrische Werte, z. B. Werte im kartesischenUniversal Transverse Mercator (UTM)-Koordinatensystem oder geografische Karteneinheiten (Längen- undBreitengrad) in Dezimalgraden. Die Längen- und Breitengradwerte verwenden das World Geodetic System,auch als WGS 1984 oder EPSG:4326 bezeichnet. WGS 1984 ist das vom Global Positioning System (GPS)verwendete Koordinatensystem.

In der folgenden Notation werden die Kartenkoordinaten beispielsweise in Längen- und Breitengradenangegeben. Der Wert .072284, bei dem es sich um die Pufferdistanz handelt, wird in Winkeleinheiten alsDezimalgrad angegeben:

ST_BUFFER(ST_POINT(-74.006801, 40.705220), .072284)

Syntax:

SELECT ST_POINT(longitude, latitude) FROM earthquakes LIMIT 1;

In der alternativen Syntax können Sie die Koordinaten auch als Datentyp point mit zwei Werten angeben:

SELECT ST_POINT('point (-74.006801 40.705220)');

Beispiel. In diesem Beispiel werden bestimmte Längen- und Breitenkoordinaten aus earthquakes.csvverwendet:

SELECT ST_POINT(61.56, -158.54)FROM earthquakesLIMIT 1;

Es wird die folgende binäre Darstellung eines Geometrie-Datentyps point zurückgegeben:

171


00 00 00 00 01 01 00 00 00 48 e1 7a 14 ae c7 4e 40 e1 7a 14 ae 47 d1 63 c0

Im nächsten Beispiel werden bestimmte Längen- und Breitenkoordinaten verwendet:

SELECT ST_POINT(-74.006801, 40.705220);

Es wird die folgende binäre Darstellung eines Geometrie-Datentyps point zurückgegeben:

00 00 00 00 01 01 00 00 00 20 25 76 6d 6f 80 52 c0 18 3e 22 a6 44 5a 44 40

Im folgenden Beispiel wird die Funktion ST_GEOMETRY_TO_TEXT zum Abrufen der binären Werte ausWKT verwendet:

SELECT ST_GEOMETRY_TO_TEXT(ST_POINT(-74.006801, 40.705220)) AS WKT;

Diese Abfrage gibt den WKT-Wert des Geometrietyps point zurück: 1 POINT (-74.00680140.70522).

ST_LINE(varchar)

Gibt einen Wert mit dem Datentyp line zurück, der eine binäre Darstellung des Geometrie-Datentyps (p. 169) line ist. Beispiel:

SELECT ST_Line('linestring(1 1, 2 2, 3 3)')

ST_POLYGON(varchar)

Gibt einen Wert mit dem Datentyp polygon zurück, der eine binäre Darstellung des Geometrie-Datentyps (p. 169) polygon ist. Beispiel:

SELECT ST_POLYGON('polygon ((1 1, 1 4, 4 4, 4 1))')

ST_GEOMETRY_TO_TEXT (varbinary)

Konvertiert die einzelnen angegebenen Geometrie-Datentypen (p. 169) in Text. Gibt einen Wert mit demGeometrie-Datentyp zurück, der eine WKT-Darstellung des Geometrie-Datentyps ist. Beispiel:

SELECT ST_GEOMETRY_TO_TEXT(ST_POINT(61.56, -158.54))

ST_GEOMETRY_FROM_TEXT (varchar)

Konvertiert Text in einen Geometrie-Datentyp. Gibt einen Wert mit dem Geometrie-Datentyp zurück, dereine binäre Darstellung des Geometrie-Datentyps ist. Beispiel:

SELECT ST_GEOMETRY_FROM_TEXT(ST_GEOMETRY_TO_TEXT(ST_Point(1, 2)))

Koordinatenbasierte VerhältnisfunktionenDie folgenden Funktionen drücken Verhältnisse zwischen zwei verschiedenen Geometrien aus, die Sie alsEingabe festlegen. Sie geben Ergebnisse mit dem Datentyp boolean zurück. Es ist wichtig, in welcher

172


Reihenfolge Sie die Geometrien angeben: Der erste Geometriewert wird als linke Geometrie bezeichnetund der zweite Geometriewert als rechte Geometrie.

Diese Funktionen geben Folgendes zurück:

• TRUE, wenn und nur wenn das von der Funktion beschriebene Verhältnis erfüllt ist.• FALSE, wenn und nur wenn das von der Funktion beschriebene Verhältnis nicht erfüllt ist.

ST_CONTAINS (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie die rechte Geometrie enthält. Beispiele:

SELECT ST_CONTAINS('POLYGON((0 2,1 1,0 -1,0 2))', 'POLYGON((-1 3,2 1,0 -3,-1 3))')

SELECT ST_CONTAINS('POLYGON((0 2,1 1,0 -1,0 2))', ST_Point(0, 0));

SELECT ST_CONTAINS(ST_GEOMETRY_FROM_TEXT('POLYGON((0 2,1 1,0 -1,0 2))'), ST_GEOMETRY_FROM_TEXT('POLYGON((-1 3,2 1,0 -3,-1 3))'))

ST_CROSSES (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie die rechte Geometrie überschreitet. Beispiel:

SELECT ST_CROSSES(ST_LINE('linestring(1 1, 2 2 )'), ST_LINE('linestring(0 1, 2 2)'))

ST_DISJOINT (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die Schnittmenge der linken und rechten Geometrie leer ist.Beispiel:

SELECT ST_DISJOINT(ST_LINE('linestring(0 0, 0 1)'), ST_LINE('linestring(1 1, 1 0)'))

ST_EQUALS (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie die rechte Geometrie übereinstimmen. Beispiel:

SELECT ST_EQUALS(ST_LINE('linestring( 0 0, 1 1)'), ST_LINE('linestring(1 3, 2 2)'))

ST_INTERSECTS (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie die rechte Geometrie schneidet. Beispiel:

SELECT ST_INTERSECTS(ST_LINE('linestring(8 7, 7 8)'), ST_POLYGON('polygon((1 1, 4 1, 4 4, 1 4))'))

ST_OVERLAPS (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie sich mit der rechten Geometrie überschneidet.Beispiel:

SELECT ST_OVERLAPS(ST_POLYGON('polygon((2 0, 2 1, 3 1))'), ST_POLYGON('polygon((1 1, 1 4, 4 4, 4 1))'))

173


ST_RELATE (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie das angegebene DE-9IM (DimensionallyExtended nine-Intersection Model)-Verhältnis zu der rechten Geometrie hat. Weitere Informationen findenSie im Wikipedia-Artikel zu DE-9IM. Beispiel:

SELECT ST_RELATE(ST_LINE('linestring(0 0, 3 3)'), ST_LINE('linestring(1 1, 4 4)'), 'T********')

ST_TOUCHES (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie die rechte Geometrie berührt.

Beispiel:

SELECT ST_TOUCHES(ST_POINT(8, 8), ST_POLYGON('polygon((1 1, 1 4, 4 4, 4 1))'))

ST_WITHIN (geometry, geometry)

Gibt TRUE zurück, wenn und nur wenn die linke Geometrie sich innerhalb der rechten Geometrie befindet.

Beispiel:

SELECT ST_WITHIN(ST_POINT(8, 8), ST_POLYGON('polygon((1 1, 1 4, 4 4, 4 1))'))

OperationsfunktionenVerwenden Sie Operationsfunktionen, um Operationen auf den Werten des Geometrie-Datentypsauszuführen. Sie können beispielsweise die Grenzen eines einzelnen Geometrie-Datentyps, Schnittpunktezwischen zwei Geometrie-Datentypen, Unterschiede zwischen linker und rechter Geometrie (sofern beideGeometrien denselben Datentyp aufweisen) oder einen externen Puffer oder Ring um einen bestimmtenGeometrie-Datentyp abrufen.

Alle Operationsfunktionen übernehmen als Eingabe einen der Geometrie-Datentypen und geben derenbinäre Darstellung zurück.

ST_BOUNDARY (geometry)

Übernimmt als Eingabe einen der Geometrie-Datentypen und gibt eine binäre Darstellung des boundary-Geometrie-Datentyps zurück.

Beispiele:

SELECT ST_BOUNDARY(ST_LINE('linestring(0 1, 1 0)')))

SELECT ST_BOUNDARY(ST_POLYGON('polygon((1 1, 1 4, 4 4, 4 1))'))

ST_BUFFER (geometry, double)

Nimmt als Eingabe einen der geometrischen Datentypen, wie z. B. Punkt, Linie, Polygon, Mehrfachzeileoder Mehrfachpolygon, und als Typ double einen Abstand an. Gibt eine binäre Darstellung desgeometrischen Datentyps, gepuffert durch den angegebenen Abstand (oder Radius), an. Beispiel:

174

https://en.wikipedia.org/wiki/DE-9IM


SELECT ST_BUFFER(ST_Point(1, 2), 2.0)

Im folgenden Beispiel werden die Kartenkoordinaten in Längen- und Breitengraden angegeben. DerWert .072284, bei dem es sich um die Pufferdistanz handelt, wird in Winkeleinheiten als Dezimalgradangegeben:

ST_BUFFER(ST_POINT(-74.006801, 40.705220), .072284)

ST_DIFFERENCE (geometry, geometry)

Gibt eine binäre Darstellung des Unterschieds zwischen linker und rechter Geometrie zurück. Beispiel:

SELECT ST_GEOMETRY_TO_TEXT(ST_DIFFERENCE(ST_POLYGON('polygon((0 0, 0 10, 10 10, 10 0))'), ST_POLYGON('polygon((0 0, 0 5, 5 5, 5 0))')))

ST_ENVELOPE (geometry)

Nimmt als Eingabe die Geometriedatentypen line, polygon, multiline und multipolygon.Unterstützt den Geometriedatentyp point nicht. Gibt den binären Wert einer Hülle zurück, wobei eineHülle ein Rechteck um den angegebenen Geometriedatentyp ist. Beispiele:

SELECT ST_ENVELOPE(ST_LINE('linestring(0 1, 1 0)'))

SELECT ST_ENVELOPE(ST_POLYGON('polygon((1 1, 1 4, 4 4, 4 1))'))

ST_EXTERIOR_RING (geometry)

Gibt eine binäre Darstellung des externen Rings des Eingabetyps polygon zurück. Beispiele:

SELECT ST_EXTERIOR_RING(ST_POLYGON(1,1, 1,4, 4,1))

SELECT ST_EXTERIOR_RING(ST_POLYGON('polygon ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))'))

ST_INTERSECTION (geometry, geometry)

Gibt eine binäre Darstellung des Schnittpunkts zwischen linker und rechter Geometrie zurück. Beispiele:

SELECT ST_INTERSECTION(ST_POINT(1,1), ST_POINT(1,1))

SELECT ST_INTERSECTION(ST_LINE('linestring(0 1, 1 0)'), ST_POLYGON('polygon((1 1, 1 4, 4 4, 4 1))'))

SELECT ST_GEOMETRY_TO_TEXT(ST_INTERSECTION(ST_POLYGON('polygon((2 0, 2 3, 3 0))'), ST_POLYGON('polygon((1 1, 4 1, 4 4, 1 4))')))

ST_SYMMETRIC_DIFFERENCE (geometry, geometry)

Gibt eine binäre Darstellung des geometrisch symmetrischen Unterschieds zwischen linker und rechterGeometrie zurück. Beispiel:

175


SELECT ST_GEOMETRY_TO_TEXT(ST_SYMMETRIC_DIFFERENCE(ST_LINE('linestring(0 2, 2 2)'), ST_LINE('linestring(1 2, 3 2)')))

ZugriffsfunktionenMithilfe von Zugriffsfunktionen können Sie Werte der Typen varchar, bigint und double vonunterschiedlichen geometry-Datentypen abrufen, wobei geometry einer der von Athena, point,line, polygon, multiline und multipolygon unterstützten Geometrie-Datentypen ist. Sie könnenbeispielsweise einen Bereich eines polygon-Geometrie-Datentyps, die maximalen und minimalen X- undY-Werte für einen angegebenen Geometrie-Datentyp, die Länge einer line oder die Anzahl der Punkte ineinem angegebenen Geometrie-Datentyp abrufen.

ST_AREA (geometry)

Übernimmt als Eingabe einen polygon-Geometrie-Datentyp und gibt einen Bereich vom Typ doublezurück. Beispiel:

SELECT ST_AREA(ST_POLYGON('polygon((1 1, 4 1, 4 4, 1 4))'))

ST_CENTROID (geometry)

Übernimmt als Eingabe einen -Geometrie-Datentyp (p. 169) polygon und gibt einen point, der imZentrum der Hülle des Polygons liegt, mit dem Typ varchar zurück. Beispiele:

SELECT ST_CENTROID(ST_GEOMETRY_FROM_TEXT('polygon ((0 0, 3 6, 6 0, 0 0))'))

SELECT ST_GEOMETRY_TO_TEXT(ST_CENTROID(ST_ENVELOPE(ST_GEOMETRY_FROM_TEXT('POINT (53 27)'))))

ST_COORDINATE_DIMENSION (geometry)

Übernimmt als Eingabe einen der unterstützten Geometrie-Datentypen (p. 169) und gibt die Anzahl derKoordinatenkomponenten mit dem Typ bigint zurück. Beispiel:

SELECT ST_COORDINATE_DIMENSION(ST_POINT(1.5,2.5))

ST_DIMENSION (geometry)

Übernimmt als Eingabe einen der unterstützten Geometrie-Datentypen (p. 169) und gibt die räumlicheDimension einer Geometrie mit dem Typ bigint zurück. Beispiel:

SELECT ST_DIMENSION(ST_POLYGON('polygon((1 1, 4 1, 4 4, 1 4))'))

ST_DISTANCE (geometry, geometry)

Gibt die Entfernung zwischen der linken und rechten Geometrie mit dem Typ double zurück. Beispiel:

SELECT ST_DISTANCE(ST_POINT(0.0,0.0), ST_POINT(3.0,4.0))

ST_IS_CLOSED (geometry)

Gibt TRUE (Typ boolean) zurück, wenn und nur wenn die Linie geschlossen ist. Beispiel:

176


SELECT ST_IS_CLOSED(ST_LINE('linestring(0 2, 2 2)'))

ST_IS_EMPTY (geometry)

Nimmt als Eingabe nur die Geometriedatentypen (p. 169) line und multiline an.. Gibt TRUE (Typboolean) zurück, wenn und nur wenn die angegebene Geometrie leer ist, d. h., wenn die line- Anfangs-und Endwerte übereinstimmen. Beispiel:

SELECT ST_IS_EMPTY(ST_POINT(1.5, 2.5))

ST_IS_RING (geometry)

Gibt TRUE (Typ boolean) zurück, wenn und nur wenn der line-Typ geschlossen und einfach ist. Beispiel:

SELECT ST_IS_RING(ST_LINE('linestring(0 2, 2 2)'))

ST_LENGTH (geometry)

Gibt die Länge von line mit dem Typ double zurück. Beispiel:

SELECT ST_LENGTH(ST_LINE('linestring(0 2, 2 2)'))

ST_MAX_X (geometry)

Gibt die maximale X-Koordinate einer Geometrie mit dem Typ double zurück. Beispiel:

SELECT ST_MAX_X(ST_LINE('linestring(0 2, 2 2)'))

ST_MAX_Y (geometry)

Gibt die maximale Y-Koordinate einer Geometrie mit dem Typ double zurück. Beispiel:

SELECT ST_MAX_Y(ST_LINE('linestring(0 2, 2 2)'))

ST_MIN_X (geometry)

Gibt die minimale X-Koordinate einer Geometrie mit dem Typ double zurück. Beispiel:

SELECT ST_MIN_X(ST_LINE('linestring(0 2, 2 2)'))

ST_MIN_Y (geometry)

Gibt die minimale Y-Koordinate einer Geometrie mit dem Typ double zurück. Beispiel:

SELECT ST_MAX_Y(ST_LINE('linestring(0 2, 2 2)'))

ST_START_POINT (geometry)

Gibt den ersten Punkt eines line-Geometrie-Datentyps mit dem Typ point zurück. Beispiel:

177

Amazon Athena BenutzerhandbuchBeispiele: Koordinatenbasierte Abfragen

SELECT ST_START_POINT(ST_LINE('linestring(0 2, 2 2)'))

ST_END_POINT (geometry)

Gibt den letzten Punkt eines line-Geometrie-Datentyps mit dem Typ point zurück. Beispiel:

SELECT ST_END_POINT(ST_LINE('linestring(0 2, 2 2)'))

ST_X (point)

Gibt die X-Koordinate eines Punkts mit dem Typ double zurück. Beispiel:

SELECT ST_X(ST_POINT(1.5, 2.5))

ST_Y (point)

Gibt die Y-Koordinate eines Punkts mit dem Typ double zurück. Beispiel:

SELECT ST_Y(ST_POINT(1.5, 2.5))

ST_POINT_NUMBER (geometry)

Gibt die Anzahl an Punkten in der Geometrie mit dem Typ bigint zurück. Beispiel:

SELECT ST_POINT_NUMBER(ST_POINT(1.5, 2.5))

ST_INTERIOR_RING_NUMBER (geometry)

Gibt die Anzahl an inneren Ringen in der polygon-Geometrie mit dem Typ bigint zurück. Beispiel:

SELECT ST_INTERIOR_RING_NUMBER(ST_POLYGON('polygon ((0 0, 8 0, 0 8, 0 0), (1 1, 1 5, 5 1, 1 1))'))

Beispiele: Koordinatenbasierte AbfragenIn den folgenden Beispielen werden zwei Tabellen erstellt und eine Abfrage darin ausgeführt.

Note

Diese Dateien sind nicht im Produkt enthalten und werden in der Dokumentation ausschließlichzu Zwecken der Illustration verwendet. Sie enthalten Beispieldaten, deren Genauigkeit nichtgarantiert wird.

Diese Beispiele basieren auf zwei Dateien:

• Die Beispieldatei earthquakes.csv, die Erdbeben in Kalifornien auflistet. Diese Datei enthält Felder,die den Feldern in der Tabelle earthquakes im folgenden Beispiel entsprechen.

• Die Datei california-counties.json, die JSON-kodierte Bezirksdaten im ESRI-kompatiblenFormat auflistet und zahlreiche Felder enthält, darunter AREA, PERIMETER, STATE, COUNTY undNAME. Das folgende Beispiel zeigt die counties-Tabelle aus dieser Datei mit nur zwei Feldern: Name(Zeichenfolge) und BoundaryShape (binärer Wert).

178

Amazon Athena BenutzerhandbuchBeispiele: Koordinatenbasierte Abfragen

Weitere Beispiele für koordinatenbasierte Abfragen finden Sie in folgenden Blogbeiträgen:

• Abfragen von OpenStreetMap mit Amazon Athena• Visualisieren von mehr als 200 Jahren globaler Klimadaten mit Amazon Athena und Amazon QuickSight.

Mit dem folgenden Code-Beispiel wird eine Tabelle namens earthquakes erstellt:

CREATE external TABLE earthquakes( earthquake_date string, latitude double, longitude double, depth double, magnitude double, magtype string, mbstations string, gap string, distance string, rms string, source string, eventid string)ROW FORMAT DELIMITED FIELDS TERMINATED BY ','STORED AS TEXTFILE LOCATION 's3://my-query-log/csv/';

Mit dem folgenden Code-Beispiel wird eine Tabelle namens counties erstellt:

CREATE external TABLE IF NOT EXISTS counties ( Name string, BoundaryShape binary )ROW FORMAT SERDE 'com.esri.hadoop.hive.serde.JsonSerde'STORED AS INPUTFORMAT 'com.esri.json.hadoop.EnclosedJsonInputFormat'OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://my-query-log/json/';

Im folgenden Code-Beispiel wird die Funktion CROSS JOIN für die beiden zuvor erstellten Tabellenverwendet. Zusätzlich wird für beide Tabellen ST_CONTAINS verwendet und Bezirke abgefragt, derenGrenzen einen geografischen Standort mit Erdbeben enthalten, angegeben durch ST_POINT. Dannwerden diese Bezirke nach Name gruppiert, nach Anzahl sortiert und in absteigender Reihenfolgezurückgegeben.

SELECT counties.name, COUNT(*) cntFROM countiesCROSS JOIN earthquakesWHERE ST_CONTAINS (counties.boundaryshape, ST_POINT(earthquakes.longitude, earthquakes.latitude))GROUP BY counties.nameORDER BY cnt DESC


+------------------------+| name | cnt |+------------------------+| Kern | 36 |+------------------------+

179

https://aws.amazon.com/blogs/big-data/querying-openstreetmap-with-amazon-athena/

https://aws.amazon.com/blogs/big-data/visualize-over-200-years-of-global-climate-data-using-amazon-athena-and-amazon-quicksight/


| San Bernardino | 35 |+------------------------+| Imperial | 28 |+------------------------+| Inyo | 20 |+------------------------+| Los Angeles | 18 |+------------------------+| Riverside | 14 |+------------------------+| Monterey | 14 |+------------------------+| Santa Clara | 12 |+------------------------+| San Benito | 11 |+------------------------+| Fresno | 11 |+------------------------+| San Diego | 7 |+------------------------+| Santa Cruz | 5 |+------------------------+| Ventura | 3 |+------------------------+| San Luis Obispo | 3 |+------------------------+| Orange | 2 |+------------------------+| San Mateo | 1 |+------------------------+

Die Verwendung vonSie können Athena in verwenden, um SQL-Anweisungen zu schreiben, die Machine Learning (ML)-Inferenzen mittels Amazon SageMaker ausführen. Diese Funktion vereinfacht den Zugriff auf ML-Modellezum Zweck von Datenanalysen. Daher müssen keine komplexen Programmiermethoden verwendetwerden, um Inferenzen auszuführen.

Um zu verwenden, definieren Sie eine -Funktion mittels der Klausel USING FUNCTION. Die Funktion zeigtauf den Amazon SageMaker-Modellendpunkt, den Sie verwenden sollten, und gibt die Variablennamenund Datentypen an, die an das Modell übergeben werden sollen. Die folgenden Klauseln in der Abfrageverweisen auf die Funktion, um Werte an das Modell zu übergeben. Das Modell führt Inferenzen basierendauf den von der Abfrage übergebenen Werten aus und gibt anschließend Inferenzergebnisse zurück.Weitere Informationen zu Amazon SageMaker und zur Funktionsweise von Amazon SageMaker-Endpunkten finden Sie unter Bereitstellen eines Modells auf Amazon SageMaker Hosting Services imAmazon SageMaker-Entwicklerhandbuch.

Überlegungen und Einschränkungen• AmazonAthenaPreviewFunctionality-Arbeitsgruppe –• Amazon SageMaker-Modellendpunkt muss text/csv akzeptieren und zurückgeben – Weitere

Informationen zu Datenformaten finden Sie unter Häufig verwendete Datenformate für Inferenzen imAmazon SageMaker-Entwicklerhandbuch.

• Amazon SageMaker-Endpunktskalierung – Der Amazon SageMaker-Modellendpunkt, auf den verwiesenwird, muss ausreichend skaliert sein, um Athena-Aufrufe an den Endpunkt verarbeiten zu können.Weitere Informationen finden Sie unter Automatisches Skalieren von Amazon SageMaker-Modellenim Amazon SageMaker-Entwicklerhandbuch und CreateEndpointConfig im Amazon SageMaker-API-Referenz.

180

https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-hosting.html

https://docs.aws.amazon.com/sagemaker/latest/dg/

https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html

https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html

https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpointConfig.html

Amazon Athena Benutzerhandbuch-Syntax

• IAM-Berechtigungen – Um Abfragen auszuführen, die eine -Funktion angeben, muss der IAM-Prinzipal,der die Abfrage ausführt, die Aktion sagemaker:InvokeEndpoint für den Amazon SageMaker-Modellendpunkt ausführen können, auf den verwiesen wird. Weitere Informationen finden Sie unterErlauben des Zugriffs für (p. 236).

• -Funktionen dürfen in GROUP BY-Klauseln nicht direkt verwendet werden

-SyntaxDie Klausel USING FUNCTION gibt eine -Funktion oder mehrere Funktionen an, auf die durcheine nachfolgende SELECT-Anweisung in der Abfrage verwiesen werden kann. Sie definieren denFunktionsnamen, die Variablennamen und die Datentypen für die Variablen und Rückgabewerte.

SyntaxDas folgende Beispiel zeigt eine USING FUNCTION-Klausel, die eine -Funktion angibt.

USING FUNCTION ML_function_name(variable1 data_type[, variable2 data_type][,...]) RETURNS data_type TYPE SAGEMAKER_INVOKE_ENDPOINT WITH (sagemaker_endpoint= 'my_sagemaker_endpoint')[, FUNCTION...][, ...] SELECT [...] ML_function_name(expression) [...]

ParameterUSING FUNCTION ML_function_name(variable1 data_type[, variable2 data_type][,...])

ML_function_name definiert den Namen der Funktion. Dieser kann in nachfolgendenAbfrageklauseln verwendet werden. variable data_type gibt eine benannte Variable mitihrem Datentyp an, die das Amazon SageMaker-Modell als Eingabe akzeptieren kann. Legen Siedata_type auf einen der unterstützten Athena-Datentypen an, die das Amazon SageMaker-Modellals Eingabe akzeptieren kann.

RETURNS data_type TYPE

data_type gibt den SQL-Datentyp an, den ML_function_name als Ausgabe aus dem AmazonSageMaker-Modell an die Abfrage zurückgibt.

SAGEMAKER_INVOKE_ENDPOINT WITH (sagemaker_endpoint= 'my_sagemaker_endpoint')

my_sagemaker_endpoint gibt den Endpunkt des Amazon SageMaker-Modells an.SELECT [...] ML_function_name(expression) [...]

Die SELECT-Abfrage, die Werte an Funktionsvariablen und das Amazon SageMaker-Modell übergibt,um ein Ergebnis zurückzugeben. ML_function_name gibt die zuvor in der Abfrage definierteFunktion an, gefolgt von einem expression, der ausgewertet wird, um Werte zu übergeben. Dieübergebenen und zurückgegebenen Werte müssen mit den Datentypen übereinstimmen, die in derKlausel USING FUNCTION für die Funktion angegeben sind.

BeispieleDas folgende Beispiel zeigt eine Abfrage mittels .

Example

USING FUNCTION predict_customer_registration(age INTEGER)

181

Amazon Athena BenutzerhandbuchAbfragen mit UDFs (Vorversion)

RETURNS DOUBLE TYPE SAGEMAKER_INVOKE_ENDPOINT WITH (sagemaker_endpoint = 'xgboost-2019-09-20-04-49-29-303') SELECT predict_customer_registration(age) AS probability_of_enrolling, customer_id FROM "sampledb"."ml_test_dataset" WHERE predict_customer_registration(age) < 0.5;

Abfragen mit benutzerdefinierten Funktionen (UserDefined Functions, UDFs) (Vorversion)

Mit benutzerdefinierten Funktionen (UDF) in Amazon Athena können Sie eigene Funktionen zumVerarbeiten von Datensätzen oder Datensatzgruppen erstellen. Eine UDF akzeptiert Parameter, führt Arbeitaus und gibt dann ein Ergebnis zurück.

Um eine UDF in Athena zu verwenden, schreiben Sie eine USING FUNCTION-Klausel vor eine SELECT-Anweisung in einer SQL-Abfrage. Die SELECT-Anweisung verweist auf die UDF und definiert die Variablen,die beim Ausführen der Abfrage an die UDF übergeben werden. Die SQL-Abfrage ruft eine Lambda-Funktion mit der Java-Laufzeitumgebung auf, wenn sie die UDF aufruft. UDFs werden innerhalb derLambda-Funktion als Methoden in einem Java-Bereitstellungspaket definiert. Mehrere UDFs können imgleichen Java-Bereitstellungspaket für eine Lambda-Funktion definiert werden. Sie geben auch den Namender Lambda-Funktion in der USING FUNCTION-Klausel an.

Sie haben zwei Optionen zum Bereitstellen einer Lambda-Funktion für Athena-UDFs. Sie können dieFunktion direkt mit Lambda bereitstellen, oder Sie können die AWS Serverless Application Repositoryverwenden. Um vorhandene Lambda-Funktionen für UDFs zu finden, können Sie das öffentliche AWSServerless Application Repository oder das private Repository durchsuchen und dann auf Lambdabereitstellen. Sie können auch Java-Quellcode erstellen oder ändern, ihn in eine JAR-Datei verpackenund mit Lambda oder dem AWS Serverless Application Repository bereitstellen. Wir bieten Beispiel-Java-Quellcode und -Pakete, um Ihnen den Einstieg zu ermöglichen. Mehr über Lambda erfahren Sie unter AWSLambda Developer Guide. Weitere Informationen über AWS Serverless Application Repository finden Sieunter Entwicklerhandbuch für AWS Serverless Application Repository.

Überlegungen und Einschränkungen• AmazonAthenaPreviewFunctionality-Arbeitsgruppe –• Integrierte Athena-Funktionen– Integrierte Presto-Funktionen in Athena sind so konzipiert, dass sie

sehr leistungsfähig sind. Wir empfehlen, wenn möglich integrierte Funktionen anstelle von UDFs zuverwenden. Weitere Hinweise zu integrierten Funktionen finden Sie unter Presto-Funktionen in AmazonAthena (p. 323).

• Nur skalare UDFs – Athena unterstützt nur skalare UDFs, die jeweils eine Zeile verarbeiten und eineneinzelnen Spaltenwert zurückgeben. Athena übergibt einen Stapel von Zeilen, möglicherweise parallel,an die UDF, wenn Lambda aufgerufen wird. Achten Sie beim Entwerfen von UDFs und Abfragen darauf,welche Auswirkungen dieser Verarbeitungsentwurf auf den Netzwerkdatenverkehr haben kann.

• Nur Java-Laufzeitumgebung– Derzeit unterstützen Athena-UDFs nur die Java 8-Laufzeit für Lambda.• IAM-Berechtigungen – Zum Ausführen einer Abfrage in Athena, die eine UDF-Abfrageanweisung enthält,

und zum Erstellen von UDF-Anweisungen muss der IAM-Prinzipal, der die Abfrage ausführt, zusätzlichzu Athena-Funktionen Aktionen ausführen dürfen. Weitere Informationen finden Sie unter Beispiele fürIAM-Berechtigungsrichtlinien, die zulassen (p. 234).

• Lambda-Limits – Lambda-Limits gelten für UDFs. Weitere Informationen finden Sie unter AWS Lambda-Limits im AWS Lambda Developer Guide.

• Bekannte Probleme – Die aktuelle Liste bekannter Probleme finden Sie unter Einschränkungen undProbleme im .

182

https://docs.aws.amazon.com/lambda/latest/dg/

https://docs.aws.amazon.com/lambda/latest/dg/

https://docs.aws.amazon.com/serverlessrepo/latest/devguide/

https://docs.aws.amazon.com/lambda/latest/dg/limits.html

https://docs.aws.amazon.com/lambda/latest/dg/limits.html



Amazon Athena BenutzerhandbuchUDF-Abfragesyntax

UDF-AbfragesyntaxDie USING FUNCTION-Klausel gibt eine UDF oder mehrere UDFs an, auf die durch eine nachfolgendeSELECT-Anweisung in der Abfrage verwiesen werden kann. Sie benötigen den Methodennamen für dieUDF und den Namen der Lambda-Funktion, die die UDF hostet.

SyntaxUSING FUNCTION UDF_name(variable1 data_type[, variable2 data_type][,...]) RETURNS data_type TYPE LAMBDA_INVOKE WITH (lambda_name = 'my_lambda_function')[, FUNCTION][, ...] SELECT [...] UDF_name(expression) [...]

ParameterUSING FUNCTION UDF_name(variable1 data_type[, variable2 data_type][,...])

UDF_name gibt den Namen der UDF an, der einer Java-Methode innerhalb der referenzierten Lambda-Funktion entsprechen muss. Jeder variable data_type gibt eine benannte Variable mit ihrementsprechenden Datentyp an, die die UDF als Eingabe akzeptieren kann. Geben Sie data_typeals einen der unterstützten Athena-Datentypen an, die in der folgenden Tabelle aufgeführt sind. DerDatentyp muss dem entsprechenden Java-Datentyp zugeordnet werden.

Athena-Datentyp Java-Datentyp

TIMESTAMP java.time.LocalDateTime (UTC)

DATUM java.time.LocalDate (UTC)

TINYINT java.lang.Byte

SMALLINT java.lang.Short

REAL java.lang.Float

DOUBLE java.lang.Double

DECIMAL java.math.BigDecimal

BIGINT java.lang.Long

INTEGER java.lang.Int

VARCHAR java.lang.String

VARBINARY byte[]

BOOLEAN java.lang.Boolean

ARRAY java.util.List

ROW java.util.Map<String, Object>

RETURNS data_type TYPE

data_type gibt den SQL-Datentyp an, den die UDF als Ausgabe zurückgibt. Die in der obigenTabelle aufgeführten Athena-Datentypen werden unterstützt.

183

Amazon Athena BenutzerhandbuchErstellen und Bereitstellen einer UDF mit Lambda

LAMBDA_INVOKE WITH (lambda_name = 'my_lambda_function')

my_lambda_function gibt den Namen der Lambda-Funktion an, die bei Ausführung der UDFaufgerufen werden soll.

SELECT [...] UDF_name(expression) [...]

Die SELECT-Abfrage, die Werte an die UDF übergibt und ein Ergebnis zurückgibt. UDF_name gibtdie zu verwendende UDF an, gefolgt von einer expression die ausgewertet wird, um Werte zuübergeben. Werte, die übergeben und zurückgegeben werden, müssen mit den entsprechendenDatentypen übereinstimmen, die für die UDF in der USING FUNCTION-Klausel angegeben sind.

BeispieleDie folgenden Beispiele veranschaulichen Abfragen mit UDFs. Die Athena-Abfragebeispiele basieren aufdem AthenaUDFHandler.java-Code in GitHub.

Example – Komprimieren und Dekomprimieren einer Zeichenfolge

Athena SQL

Das folgende Beispiel veranschaulicht die Verwendung der in einer Lambda-Funktion namensMyAthenaUDFLambda definierten compress UDF.

USING FUNCTION compress(col1 VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'MyAthenaUDFLambda') SELECT compress('StringToBeCompressed');

Das Abfrageergebnis gibt ewLLinKzEsPyXdKdc7PLShKLS5OTQEAUrEH9w== zurück.

Das folgende Beispiel veranschaulicht die Verwendung der in derselben Lambda-Funktion definiertendecompress-UDF.

USING FUNCTION decompress(col1 VARCHAR) RETURNS VARCHAR TYPE LAMBDA_INVOKE WITH (lambda_name = 'MyAthenaUDFLambda') SELECT decompress('ewLLinKzEsPyXdKdc7PLShKLS5OTQEAUrEH9w==');

Das Abfrageergebnis gibt StringToBeCompressed zurück.

Erstellen und Bereitstellen einer UDF mit LambdaUm eine eigene UDF zu erstellen, erstellen Sie eine neue Java-Klasse, indem Siedie UserDefinedFunctionHandler-Klasse erweitern. Der Quellcode für dasUserDefinedFunctionHandler.java im SDK ist auf GitHub im Repository awslabs/aws-athena-query-federation/athena-federation-sdk verfügbar, zusammen mit Beispiel-UDF-Implementierungen die Sieuntersuchen und ändern können, um eine eigene UDF zu erstellen.

Die Schritte in diesem Abschnitt veranschaulichen das Schreiben und Erstellen einer benutzerdefiniertenUDF-JAR-Datei mit Apache Maven über die Befehlszeile und eine Bereitstellung.

Schritte zum Erstellen einer eigenen UDF für die Athena Verwendung von Maven• Klonen des SDK und Vorbereitung der Entwicklungsumgebung (p. 185)

184

https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/src/main/java/com/amazonaws/athena/connectors/udfs/AthenaUDFHandler.java

https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-federation-sdk/src/main/java/com/amazonaws/athena/connector/lambda/handlers/UserDefinedFunctionHandler.java

https://github.com/awslabs/aws-athena-query-federation/athena-federation-sdk

https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-udfs

https://maven.apache.org/index.html


• Erstellen Ihres Maven-Projekts (p. 185)• Hinzufügen von Abhängigkeiten und Plugins zu Ihrem Maven-Projekt (p. 186)• Schreiben von Java-Code für die UDFs (p. 186)• Erstellen der JAR-Datei (p. 188)• Bereitstellen des JAR zu AWS Lambda (p. 188)

Klonen des SDK und Vorbereitung der EntwicklungsumgebungBevor Sie beginnen, stellen Sie mithilfe von sudo yum install git -y sicher, dass git auf IhremSystem installiert ist.

So installieren Sie das AWS-Query Federation SDK

• Geben Sie Folgendes in der Befehlszeile ein, um das SDK-Repository zu klonen. Dieses Repositoryenthält den SDK, Beispiele und eine Suite von Datenquellenkonnektoren. Weitere Hinweise zuDatenquellenkonnektoren finden Sie unter Die Verwendung von (p. 66).

git clone https://github.com/awslabs/aws-athena-query-federation.git

So installieren Sie die Voraussetzungen für dieses Verfahren:

Wenn Sie an einer Entwicklungsmaschine arbeiten, auf der bereits Apache Maven, die AWS CLI unddas Serverloses Anwendungsmodell von AWS-Build-Tool installiert sind, können Sie diesen Schrittüberspringen.

1. Führen Sie im aws-athena-query-federation-Stammverzeichnis des Verzeichnisses, das Siebeim Klonen erstellt haben, das Skript prepare_dev_env.sh aus, das die Entwicklungsumgebungvorbereitet.

2. Aktualisieren Sie die Shell, um neue Variablen zu erzeugen, die durch den Installationsprozess erstelltwurden, oder starten Sie die Terminalsitzung neu.

source ~/.profile

Important

Wenn Sie diesen Schritt überspringen, erhalten Sie später Fehler dazu, dass das AWS CLI-oder AWS SAM-Build-Tool Ihre Lambda-Funktion nicht veröffentlichen kann.

Erstellen Ihres Maven-ProjektsFühren Sie den folgenden Befehl aus, um Ihr Maven-Projekt zu erstellen. Ersetzen Sie groupId durchdie eindeutige ID Ihrer Organisation und my-athena-udf durch den Namen Ihrer Anwendung. WeitereInformationen finden Sie unter Wie erstelle ich mein erstes Maven-Projekt? in der Apache MavenDokumentation.

mvn -B archetype:generate \-DarchetypeGroupId=org.apache.maven.archetypes \-DgroupId=groupId \-DartifactId=my-athena-udfs

185

https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/prepare_dev_env.sh

https://maven.apache.org/guides/getting-started/index.html#How_do_I_make_my_first_Maven_project


Hinzufügen von Abhängigkeiten und Plugins zu Ihrem Maven-ProjektFügen Sie die folgenden Konfigurationen zu Ihrer Maven-pom.xml-Projektdatei hinzu. Ein Beispiel findenSie in der Datei pom.xml in GitHub.

<properties> <aws-athena-federation-sdk.version>2019.48.1</aws-athena-federation-sdk.version></properties>

<dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-athena-federation-sdk</artifactId> <version>${aws-athena-federation-sdk.version}</version> </dependency></dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.2.1</version> <configuration> <createDependencyReducedPom>false</createDependencyReducedPom> <filters> <filter> <artifact>*:*</artifact> <excludes> <exclude>META-INF/*.SF</exclude> <exclude>META-INF/*.DSA</exclude> <exclude>META-INF/*.RSA</exclude> </excludes> </filter> </filters> </configuration> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> </execution> </executions> </plugin> </plugins></build>

Schreiben von Java-Code für die UDFsErstellen Sie eine neue Klasse, indem Sie UserDefinedFunctionHandler.java erweitern. Schreiben Sie IhreUDFs in der Klasse.

Im folgenden Beispiel werden zwei Java-Methoden für UDFs, compress() und decompress(), innerhalbder Klasse MyUserDefinedFunctions erstellt.

*package *com.mycompany.athena.udfs;

public class MyUserDefinedFunctions extends UserDefinedFunctionHandler

186

https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/pom.xml

https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-federation-sdk/src/main/java/com/amazonaws/athena/connector/lambda/handlers/UserDefinedFunctionHandler.java


{ private static final String SOURCE_TYPE = "MyCompany";

public MyUserDefinedFunctions() { super(SOURCE_TYPE); }

/** * Compresses a valid UTF-8 String using the zlib compression library. * Encodes bytes with Base64 encoding scheme. * * @param input the String to be compressed * @return the compressed String */ public String compress(String input) { byte[] inputBytes = input.getBytes(StandardCharsets.UTF_8);

// create compressor Deflater compressor = new Deflater(); compressor.setInput(inputBytes); compressor.finish();

// compress bytes to output stream byte[] buffer = new byte[4096]; ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(inputBytes.length); while (!compressor.finished()) { int bytes = compressor.deflate(buffer); byteArrayOutputStream.write(buffer, 0, bytes); }

try { byteArrayOutputStream.close(); } catch (IOException e) { throw new RuntimeException("Failed to close ByteArrayOutputStream", e); }

// return encoded string byte[] compressedBytes = byteArrayOutputStream.toByteArray(); return Base64.getEncoder().encodeToString(compressedBytes); }

/** * Decompresses a valid String that has been compressed using the zlib compression library. * Decodes bytes with Base64 decoding scheme. * * @param input the String to be decompressed * @return the decompressed String */ public String decompress(String input) { byte[] inputBytes = Base64.getDecoder().decode((input));

// create decompressor Inflater decompressor = new Inflater(); decompressor.setInput(inputBytes, 0, inputBytes.length);

// decompress bytes to output stream byte[] buffer = new byte[4096]; ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(inputBytes.length); try {

187


while (!decompressor.finished()) { int bytes = decompressor.inflate(buffer); if (bytes == 0 && decompressor.needsInput()) { throw new DataFormatException("Input is truncated"); } byteArrayOutputStream.write(buffer, 0, bytes); } } catch (DataFormatException e) { throw new RuntimeException("Failed to decompress string", e); }

try { byteArrayOutputStream.close(); } catch (IOException e) { throw new RuntimeException("Failed to close ByteArrayOutputStream", e); }

// return decoded string byte[] decompressedBytes = byteArrayOutputStream.toByteArray(); return new String(decompressedBytes, StandardCharsets.UTF_8); }}

Erstellen der JAR-DateiFühren Sie mvn clean install aus um Ihr Projekt zu erstellen. Nachdem es erfolgreich erstellt wurde,wird eine JAR-Datei im target-Ordner Ihres Projekts mit dem Namen artifactId-version.jarerstellt, wobei artifactId der Name ist, den Sie im Maven-Projekt angegeben haben, z. B. my-athena-udfs.

Bereitstellen des JAR zu AWS LambdaSie haben zwei Möglichkeiten, Ihren Code in Lambda bereitzustellen:

• Bereitstellen mit AWS Serverless Application Repository (empfohlen)• Erstellen einer Lambda-Funktion aus der JAR-Datei

Option 1: Bereitstellen zu AWS Serverless Application RepositoryWenn Sie Ihre JAR-Datei zu AWS Serverless Application Repository bereitstellen, erstellen Sie eine AWSSAM-YAML-Vorlagendatei, die die Architektur Ihrer Anwendung darstellt. Anschließend geben Sie dieseYAML-Datei und einen Amazon S3-Bucket an, in dem Artefakte für Ihre Anwendung hochgeladen undverfügbar gemacht werden AWS Serverless Application Repository. Im folgenden Verfahren wird das Skriptpublish.sh verwendet, das sich im athena-query-federation/tools-Verzeichnis des Athena QueryFederation-SDKs befindet, das Sie zuvor geklont haben.

Weitere Informationen und Anforderungen finden Sie unter Veröffentlichen von Anwendungen imEntwicklerhandbuch für AWS Serverless Application Repository, AWS SAMVorlagenkonzepte imServerloses Anwendungsmodell von AWS-Entwicklerhandbuch und in Veröffentlichen serverloserAnwendungen mit der AWS SAM-CLI.

Das folgende Beispiel veranschaulicht Parameter in einer YAML-Datei. Fügen Sie Ihrer YAML-Dateiähnliche Parameter hinzu und speichern Sie diese in Ihrem Projektverzeichnis. Ein vollständiges Beispielfinden Sie unter athena-udf.yaml in GitHub.

Transform: 'AWS::Serverless-2016-10-31'Metadata:

188

https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/publish.sh

https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-publishing-applications.html

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html

https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/athena-udfs.yaml


'AWS::ServerlessRepo::Application': Name: MyApplicationName Description: 'The description I write for my application' Author: 'Author Name' Labels: - athena-federation SemanticVersion: 1.0.0Parameters: LambdaFunctionName: Description: 'The name of the Lambda function that will contain your UDFs.' Type: String LambdaTimeout: Description: 'Maximum Lambda invocation runtime in seconds. (min 1 - 900 max)' Default: 900 Type: Number LambdaMemory: Description: 'Lambda memory in MB (min 128 - 3008 max).' Default: 3008 Type: NumberResources: ConnectorConfig: Type: 'AWS::Serverless::Function' Properties: FunctionName: !Ref LambdaFunctionName Handler: "full.path.to.your.handler. For example, com.amazonaws.athena.connectors.udfs.MyUDFHandler" CodeUri: "Relative path to your JAR file. For example, ./target/athena-udfs-1.0.jar" Description: "My description of the UDFs that this Lambda function enables." Runtime: java8 Timeout: !Ref LambdaTimeout MemorySize: !Ref LambdaMemory

Kopieren Sie das publish.sh-Skript in das Projektverzeichnis, in dem Sie Ihre YAML-Datei gespeicherthaben, und führen Sie den folgenden Befehl aus:

./publish.sh MyS3Location MyYamlFile

Zum Beispiel, wenn Ihr Bucket-Speicherort s3://mybucket/mysarapps/athenaudf ist und Ihre YAML-Datei unter my-athena-udfs.yaml gespeichert wurde:

./publish.sh mybucket/mysarapps/athenaudf my-athena-udfs

So erstellen Sie eine Lambda-Funktion:

1. Öffnen Sie die Lambda-Konsole bei https://console.aws.amazon.com/Lambda/, wählen Sie Createfunction (Funktion erstellen) und dann Browse serverless app repository (Serverloses App-Repositorydurchsuchen)

2. Wählen Sie Private applications (Private Anwendungen) aus, suchen Sie Ihre Anwendung in der Listeoder mit Schlüsselwörtern und wählen Sie sie aus.

3. Überprüfen und geben Sie Anwendungsdetails an, und wählen Sie dann Deploy (Bereitstellen).

Sie können nun die Methodennamen verwenden, die in Ihrer Lambda-Funktion-JAR-Datei als UDFs inAthena definiert sind.

Option 2: Direktes Erstellen einer Lambda-FunktionSie können eine Lambda-Funktion auch direkt über die Konsole oder AWS CLI erstellen. Das folgendeBeispiel veranschaulicht die Verwendung des CLI-Befehls Lambda create-function. Ersetzen

189

https://console.aws.amazon.com/lambda/

Amazon Athena BenutzerhandbuchAbfragen von AWS-Serviceprotokollen

aws lambda create-function \ --function-name MyLambdaFunctionName \ --runtime java8 \ --role arn:aws:iam::1234567890123:role/my_lambda_role \ --handler com.mycompany.athena.udfs.MyUserDefinedFunctions \ --timeout 900 \ --zip-file fileb://./target/my-athena-udfs-1.0-SNAPSHOT.jar

Abfragen von AWS-ServiceprotokollenDieser Abschnitt enthält mehrere Verfahren zum Verwenden von Amazon Athena für die Abfrage beliebterDatasets wie AWS CloudTrail-Protokolle, CAmazon CloudFront-Protokolle, Classic Load Balancer-Protokolle, Application Load Balancer-Protokolle, Amazon VPC-Flow-Protokolle und Netzwerk-Load-Balancer-Protokolle.

Für die Aufgaben in diesem Abschnitt wird die Athena-Konsole eingesetzt. Sie können jedoch auch andereTools verwenden, die über JDBC verbunden werden. Weitere Informationen finden Sie unter Verwendungvon Athena mit dem JDBC-Treiber (p. 76), der AWS-CLI oder im Amazon Athena-API-Referenz.

Bei den Themen in diesem Abschnitt wird davon ausgegangen, dass Sie wohl einen IAM-Benutzer mitentsprechenden Berechtigungen für den Zugriff auf Athena, als auch einen Amazon S3-Bucket eingerichtethaben, auf dem die abzufragenden Daten gespeichert sind. Weitere Informationen finden Sie auf der Seitezur Einrichtung (p. 23) und der Seite über Erste Schritte (p. 25).

Themen• Abfragen von AWS CloudTrail-Protokollen (p. 190)• Abfragen von Amazon CloudFront-Protokollen (p. 194)• Abfragen von Amazon EMR-Protokollen (p. 196)• Abfragen von Classic Load Balancer-Protokollen (p. 199)• Abfragen von Netzwerk-Load-Balancer-Protokollen (p. 200)• Abfragen von Application Load Balancer-Protokollen (p. 202)• Abfragen von Amazon VPC-Flow-Protokollen (p. 204)• Abfragen von AWS WAF-Protokollen (p. 206)

Abfragen von AWS CloudTrail-ProtokollenAWS CloudTrail ist ein Service zur Erfassung von AWS-API-Aufrufen und Ereignissen für AWS-Konten.

CloudTrail-Protokolle enthalten Angaben zu den API-Aufrufen an Ihre AWS-Services, einschließlich derKonsole. CloudTrail generiert verschlüsselte Protokolldateien und speichert diese in Amazon S3. WeitereInformationen finden Sie im AWS CloudTrail-Benutzerhandbuch.

Die Verwendung von Athena in Verbindung mit CloudTrail-Protokollen bietet eine ausgezeichneteMöglichkeit, die Analyse Ihrer AWS-Services zu optimieren. Beispielsweise können Sie mithilfe vonAbfragen Trends ermitteln und Vorgänge nach Attributen (z. B. Quell-IP-Adresse oder Benutzer) trennen.

In der Regel werden CloudTrail-Protokolle zur Analyse der betriebsbezogenen Vorgänge für Sicherheitund Compliance herangezogen. Informationen zu einem detaillierten Beispiel finden Sie im AWS Big Data-Blogbeitrag unter http://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/Analyze Security, Compliance, and OperationalActivity Using AWS CloudTrail and Amazon Athena.

Mithilfe von Athena können Sie diese Protokolldateien direkt aus Amazon S3 abrufen, wenn Sie dieLOCATION der Protokolldateien angeben. Dafür stehen Ihnen zwei Optionen zur Verfügung:

190



https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html



Amazon Athena BenutzerhandbuchAbfragen von AWS CloudTrail-Protokollen

• Sie können Tabellen für CloudTrail-Protokolldateien direkt von der CloudTrail-Konsole aus erstellen.• Sie können Tabellen für CloudTrail-Protokolldateien manuell in der Athena-Konsole erstellen.

Themen• Grundlegendes zu CloudTrail-Protokollen und Athena-Tabellen (p. 191)• Erstellen einer Tabelle für CloudTrail-Protokolle in der CloudTrail-Konsole (p. 191)• Manuelles Erstellen der Tabelle für CloudTrail-Protokolle in Athena (p. 192)• Beispielabfrage für CloudTrail-Protokolle (p. 193)• Tipps für Abfragen von CloudTrail-Protokollen (p. 193)

Grundlegendes zu CloudTrail-Protokollen und Athena-TabellenBevor Sie Tabellen erstellen, sollten Sie sich ein wenig mit CloudTrail und der zugehörigenDatenspeicherung vertraut machen. Das hilft Ihnen, die benötigten Tabellen in der CloudTrail-Konsole oderüber Athena zu erstellen.

CloudTrail speichert Protokolle als JSON-Textdateien im komprimierten GZIP-Format (*.json.gzip). DerSpeicherort der Protokolldateien hängt von Ihrer Einrichtung der Trails und der zu protokollierenden AWS-Region (oder Regionen) und weiteren Faktoren ab.

Weitere Informationen zum Speicherort der Protokolldateien, der JSON-Struktur und den Datensatzinhaltenfinden Sie unter folgenden Themen im AWS CloudTrail-Benutzerhandbuch:

• Suchen nach CloudTrail-Protokolldateien• Beispiele für CloudTrail-Protokolldateien• CloudTrail-Datensatzinhalte• CloudTrail-Protokollereignisreferenz

Aktivieren Sie CloudTrail für die Konsole, um Protokolle zu erfassen und in Amazon S3 zu speichern.Weitere Informationen finden Sie unter Erstellen eines Trails im AWS CloudTrail-Benutzerhandbuch.

Notieren Sie den Amazon S3-Ziel-Bucket, in dem die Protokolle gespeichert werden. Ersetzen Sie dieKlausel LOCATION durch den Pfad zum CloudTrail-Protokollspeicherort und den zu verwendendenObjektsatz. Im Beispiel wird der Wert LOCATION für Protokolle eines bestimmten Kontos verwendet, aberSie können den Grad an Spezifität angeben, der für Ihre Anwendung erforderlich ist.

Beispiel:

• Für die Datenanalyse von mehreren Konten können Sie den Bezeichner LOCATION zurücksetzen unddann mit LOCATION 's3://MyLogFiles/AWSLogs/ alle AWSLogs angeben.

• Zur Analyse der Daten von einem bestimmten Datum, Konto und Region verwenden Sie LOCATION`s3://MyLogFiles/123456789012/CloudTrail/us-east-1/2016/03/14/'.

Die oberste Ebene der Objekthierarchie bietet bei Abfragen mit Athena die größte Flexibilität.

Erstellen einer Tabelle für CloudTrail-Protokolle in der CloudTrail-KonsoleSie können automatisch Tabellen zum Abfragen der CloudTrail-Protokolle direkt aus der CloudTrail-Konsole erstellen. Das ist eine recht einfache Methode zur Tabellenerstellung, die Sie allerdings nur nutzenkönnen, sofern sich der Amazon S3-Bucket, in dem die Protokolldateien für den Trail enthalten sind, ineiner von Amazon Athena unterstützten Region befindet und Sie als IAM-Benutzer oder -Rolle angemeldet

191

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-find-log-files.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-log-file-examples.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html


sind, der/die über ausreichende Berechtigungen zum Erstellen von Tabellen in Athena verfügt. WeitereInformationen finden Sie unter Einrichten (p. 23).

So erstellen Sie eine Tabelle für einen CloudTrail-Trail in der CloudTrail-Konsole

1. Öffnen Sie die CloudTrail-Konsole unter https://console.aws.amazon.com/cloudtrail/.2. Wählen Sie im Navigationsbereich Event history aus.3. Wählen Sie im Bereich Event history die Option Run advanced queries in Amazon Athena aus.4. Wählen Sie unter Storage location den Amazon S3-Bucket aus, in dem die Protokolldateien für den

abzufragenden Trail gespeichert sind.

Note

Um den mit einem Bucket verknüpften Trail zu ermitteln, wählen Sie unter Trails denentsprechenden Pfad aus. Der Bucket-Name wird im Feld Storage location (Speicherort)angezeigt.

5. Wählen Sie Create table aus. Die Tabelle wird mit einem Standardnamen erstellt, in dem der Namedes Amazon S3-Buckets enthalten ist.

Manuelles Erstellen der Tabelle für CloudTrail-Protokolle inAthenaSie können Tabellen für CloudTrail-Protokolldateien manuell in der Athena-Konsole erstellen undanschließend Abfragen in Athena ausführen.

So erstellen Sie eine Tabelle für einen CloudTrail-Trail in der CloudTrail-Konsole

1. Kopieren Sie die folgende DDL-Anweisung in die Athena-Konsole.2. Ändern Sie s3://CloudTrail_bucket_name/AWSLogs/Account_ID/ so, dass auf den Amazon

S3-Bucket gezeigt wird, der Ihre Protokolldaten enthält.3. Überprüfen Sie, ob die Felder korrekt aufgeführt werden. Weitere Informationen zur vollständigen Liste

der Felder in einem CloudTrail-Datensatz finden Sie unter CloudTrail-Datensatzinhalte.

In diesem Beispiel werden die Felder additionaleventdata, requestparameters undresponseelements als Typ STRING in der Abfrage aufgelistet, stellen jedoch den Datentyp STRUCTdar, der in JSON verwendet wird. Um aus diesen Feldern Daten zu extrahieren, müssen Sie daherJSON_EXTRACT-Funktionen verwenden. Weitere Informationen finden Sie unter the section called“Extrahieren von Daten aus JSON” (p. 163).

CREATE EXTERNAL TABLE cloudtrail_logs (eventversion STRING,useridentity STRUCT< type:STRING, principalid:STRING, arn:STRING, accountid:STRING, invokedby:STRING, accesskeyid:STRING, userName:STRING,sessioncontext:STRUCT<attributes:STRUCT< mfaauthenticated:STRING, creationdate:STRING>,sessionissuer:STRUCT< type:STRING, principalId:STRING, arn:STRING,

192

https://console.aws.amazon.com/cloudtrail/



accountId:STRING, userName:STRING>>>,eventtime STRING,eventsource STRING,eventname STRING,awsregion STRING,sourceipaddress STRING,useragent STRING,errorcode STRING,errormessage STRING,requestparameters STRING,responseelements STRING,additionaleventdata STRING,requestid STRING,eventid STRING,resources ARRAY<STRUCT< ARN:STRING, accountId:STRING, type:STRING>>,eventtype STRING,apiversion STRING,readonly STRING,recipientaccountid STRING,serviceeventdetails STRING,sharedeventid STRING,vpcendpointid STRING)ROW FORMAT SERDE 'com.amazon.emr.hive.serde.CloudTrailSerde'STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://CloudTrail_bucket_name/AWSLogs/Account_ID/';

4. Führen Sie die Abfrage in der Athena-Konsole aus. Nach Beendigung der Abfrage wirdcloudtrail_logs von Athena registriert, sodass Sie die darin enthaltenen Daten für Abfragennutzen können.

Beispielabfrage für CloudTrail-ProtokolleDas folgende Beispiel zeigt einen Teil einer Abfrage, die alle anonymen (nicht signierten) Anfragen aus derTabelle zurückgibt, die auf der Basis von CloudTrail-Ereignisprotokollen erstellt wurde. Diese Abfrage wähltdie Anforderungen aus, in denen useridentity.accountid anonym ist und useridentity.arn nichtangegeben wird:

SELECT *FROM cloudtrail_logsWHERE eventsource = 's3.amazonaws.com' AND eventname in ('GetObject') AND useridentity.accountid LIKE '%ANONYMOUS%' AND useridentity.arn IS NULL AND requestparameters LIKE '%[your bucket name ]%';

Weitere Informationen finden Sie im AWS Big Data-Blogbeitrag unter Analyze Security, Compliance, andOperational Activity Using AWS CloudTrail and Amazon Athena.

Tipps für Abfragen von CloudTrail-ProtokollenNutzen Sie die folgenden Tipps zum Analysieren der CloudTrail-Protokolldaten:

• Bevor Sie Abfragen für Protokolle ausführen, sollten Sie sicherstellen, dass Ihre Protokolltabelle ebensoaussieht wie die unter the section called “Manuelles Erstellen der Tabelle für CloudTrail-Protokolle

193



Amazon Athena BenutzerhandbuchAbfragen von Amazon CloudFront-Protokollen

in Athena” (p. 192). Falls dies nicht die erste Tabelle ist, löschen Sie die vorhandene Tabelle mitfolgendem Befehl: DROP TABLE cloudtrail_logs;.

• Nachdem Sie die vorhandene Tabelle gelöscht haben, erstellen Sie diese neu. Weitere Informationenfinden Sie unter Erstellen der Tabelle für CloudTrail-Protokolle (p. 192).

Überprüfen Sie, ob die Felder in der Athena-Abfrage korrekt aufgeführt werden. Informationenzur vollständigen Liste der Felder in einem CloudTrail-Datensatz finden Sie unter CloudTrail-Datensatzinhalte.

Falls die Abfrage Felder in JSON-Formaten enthält (z. B. STRUCT), extrahieren Sie die Daten aus JSON.Weitere Informationen finden Sie unter Extracting Data From JSON (p. 163).

Nun können Sie Abfragen für die CloudTrail-Tabelle ausführen.• Sehen Sie sich zunächst an, welche IAM-Benutzer welche API-Operationen über welche Quell-IP-

Adressen aufgerufen haben.• Verwenden Sie die folgende SQL-Basisabfrage als Vorlage. Fügen Sie die Abfrage in die Athena-

Konsole ein und führen Sie sie aus.

SELECT useridentity.arn, eventname, sourceipaddress, eventtimeFROM cloudtrail_logsLIMIT 100;

• Ändern Sie die vorherige Abfrage ab, um die Daten weiter zu analysieren.• Um die Leistung zu verbessern, binden Sie die Klausel LIMIT ein, damit ein bestimmtes Subset von

Zeilen zurückgegeben wird.

Abfragen von Amazon CloudFront-ProtokollenSie können Amazon CloudFront CDN so konfigurieren, dass Zugriffsprotokolle für Web-Verteilungen nachAmazon Simple Storage Service exportiert werden. Anhand dieser Protokolle lassen sich die Surfing-Muster der Benutzer für die von CloudFront bereitgestellten Web-Eigenschaften analysieren.

Bevor Sie mit der Abfrage der Protokolle beginnen, aktivieren Sie das Zugriffsprotokoll für Web-Verteilungen für die gewünschte CloudFront-Verteilung. Weitere Informationen finden Sie unterZugriffsprotokolle im Amazon CloudFront-Entwicklerhandbuch.

Notieren Sie den Amazon S3-Bucket, in dem die Protokolle gespeichert werden sollen.Note

Dieses Verfahren gilt für die Zugriffsprotokolle für Web-Verteilungen in CloudFront. Es kann nichtfür Streaming-Protokolle von RTMP-Verteilungen eingesetzt werden.

• Erstellen der Tabelle für CloudFront-Protokolle (p. 194)• Beispielabfrage für CloudFront-Protokolle (p. 195)

Erstellen der Tabelle für CloudFront-ProtokolleSo erstellen Sie die CloudFront-Tabelle

1. Kopieren Sie die folgende DDL-Anweisung in die Athena-Konsole. Ändern Sie den LOCATION für denAmazon S3-Bucket, in dem Ihre Protokolle gespeichert werden.

194



https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html

Amazon Athena BenutzerhandbuchAbfragen von Amazon CloudFront-Protokollen

In dieser Abfrage wird standardmäßig LazySimpleSerDe (p. 304) verwendet, sodass dieser Schrittübersprungen werden kann.

Die Spalte date ist mit Escape-Zeichen – einfachen umgekehrten Anführungszeichen (`) – versehen, daes sich um ein reserviertes Wort in Athena handelt. Weitere Informationen finden Sie unter ReservierteSchlüsselwörter (p. 36).

CREATE EXTERNAL TABLE IF NOT EXISTS default.cloudfront_logs ( `date` DATE, time STRING, location STRING, bytes BIGINT, request_ip STRING, method STRING, host STRING, uri STRING, status INT, referrer STRING, user_agent STRING, query_string STRING, cookie STRING, result_type STRING, request_id STRING, host_header STRING, request_protocol STRING, request_bytes BIGINT, time_taken FLOAT, xforwarded_for STRING, ssl_protocol STRING, ssl_cipher STRING, response_result_type STRING, http_version STRING, fle_status STRING, fle_encrypted_fields INT)ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'LOCATION 's3://CloudFront_bucket_name/AWSLogs/ACCOUNT_ID/'TBLPROPERTIES ( 'skip.header.line.count'='2' )

2. Führen Sie die Abfrage in der Athena-Konsole aus. Nach Beendigung der Abfrage registriert Athena diecloudfront_logs-Tabelle, sodass Sie die Daten zum Ausgeben von Abfragen nutzen können.

Beispielabfrage für CloudFront-ProtokolleDie folgende Abfrage summiert die von CloudFront zwischen dem 09. Juni und dem 11. Juni 2018bereitgestellten Bytes. Setzen Sie den Spaltennamen "date" in doppelte Anführungszeichen, da es sich umein reserviertes Wort handelt.

SELECT SUM(bytes) AS total_bytesFROM cloudfront_logsWHERE "date" BETWEEN DATE '2018-06-09' AND DATE '2018-06-11'LIMIT 100;

In einigen Fällen müssen leere Werte aus den Ergebnissen der Abfrage CREATE TABLE für CloudFrontentfernt werden. Führen Sie dazu Folgendes aus:

SELECT DISTINCT * FROM cloudfront_logs

195

Amazon Athena BenutzerhandbuchAbfragen von Amazon EMR-Protokollen

LIMIT 10;

Weitere Informationen finden Sie im AWS Big Data-Blogbeitrag Build a Serverless Architecture to AnalyzeAmazon CloudFront Access Logs Using AWS Lambda, Amazon Athena, and Amazon Kinesis Analytics.

Abfragen von Amazon EMR-ProtokollenAmazon EMR und Big Data-Anwendungen, die auf von Amazon EMR erzeugten Protokolldateienausgeführt werden. Protokolldateien werden auf den Master-Knoten geschrieben, und Sie können AmazonEMR zudem so konfigurieren, dass Protokolldateien automatisch in Amazon S3 archiviert werden. Siekönnen mit Amazon Athena diese Protokolle abfragen, um Ereignisse und Trends für Anwendungenund Cluster zu identifizieren. Weitere Informationen zu den Typen von Protokolldateien in Amazon EMRund zum Speichern dieser Dateien in Amazon S3 finden Sie unter Anzeigen von Protokolldateien imManagement Guide für Amazon EMR.

Erstellen und Abfragen einer Basistabelle basierend auf AmazonEMR-ProtokolldateienIm folgenden Beispiel wird die Basistabelle myemrlogs erstellt, die auf Protokolldateien basiert, diein s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/elasticmapreduce/ gespeichert sind. Der in den folgenden Beispielen verwendete Amazon S3-Speicherort spiegelt das Muster des Standardprotokollspeicherorts für einen EMR-Cluster wider, derdurch das AWS-Konto 123456789012 in der Region us-west-2 erstellt wurde. Wenn Sie einenbenutzerdefinierten Speicherort verwenden, lautet das Muster s3://PathToEMRLogs/ClusterID.

Hinweise zum Erstellen einer partitionierten Tabelle zur potenziellen Verbesserung der Abfrageleistung undzur Verringerung der Datenübertragung finden Sie unter Erstellen und Abfragen einer partitionierten Tabellebasierend auf Amazon EMR-Protokollen (p. 197).

CREATE EXTERNAL TABLE `myemrlogs`( `data` string COMMENT 'from deserializer')ROW FORMAT DELIMITED FIELDS TERMINATED BY '|'LINES TERMINATED BY '\n'STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6'

Die folgenden Beispielabfragen können für die im vorherigen Beispiel erstellte myemrlogs-Tabelleausgeführt werden.

Example – Abfrage von Step-Protokollen nach Vorkommen von ERROR, WARN, INFO,EXCEPTION, FATAL oder DEBUG

SELECT data, "$PATH"FROM "default"."myemrlogs"WHERE regexp_like("$PATH",'s-86URH188Z6B1') AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;

Example – Abfrage eines bestimmten Instance-Protokolls, i-00b3c0a839ece0a9c, nach ERROR,WARN, INFO, EXCEPTION, FATAL oder DEBUG

SELECT "data",

196

http://aws.amazon.com/blogs/big-data/build-a-serverless-architecture-to-analyze-amazon-cloudfront-access-logs-using-aws-lambda-amazon-athena-and-amazon-kinesis-analytics/

http://aws.amazon.com/blogs/big-data/build-a-serverless-architecture-to-analyze-amazon-cloudfront-access-logs-using-aws-lambda-amazon-athena-and-amazon-kinesis-analytics/

https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-manage-view-web-log-files.html


"$PATH" AS filepathFROM "default"."myemrlogs"WHERE regexp_like("$PATH",'i-00b3c0a839ece0a9c') AND regexp_like("$PATH",'state') AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;

Example – Abfrage von Presto-Anwendungsprotokollen nach ERROR, WARN, INFO,EXCEPTION, FATAL oder DEBUG

SELECT "data", "$PATH" AS filepathFROM "default"."myemrlogs"WHERE regexp_like("$PATH",'presto') AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;

Example – Abfrage von Namenode-Anwendungsprotokollen nach ERROR, WARN, INFO,EXCEPTION, FATAL oder DEBUG

SELECT "data", "$PATH" AS filepathFROM "default"."myemrlogs"WHERE regexp_like("$PATH",'namenode') AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;

Example – Abfrage aller Protokolle nach Datum und Stunde für ERROR, WARN, INFO,EXCEPTION, FATAL oder DEBUG

SELECT distinct("$PATH") AS filepathFROM "default"."myemrlogs"WHERE regexp_like("$PATH",'2019-07-23-10') AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;

Erstellen und Abfragen einer partitionierten Tabelle basierend aufAmazon EMR-ProtokollenDiese Beispiele verwenden denselben Protokollspeicherort zum Erstellen einer Athena-Tabelle, dieTabelle wird aber partitioniert, und dann wird für jeden Protokollspeicherort eine Partition erstellt. WeitereInformationen finden Sie unter Partitionieren von Daten (p. 39).

Die folgende Abfrage erstellt die partitionierte Tabelle mit dem Namen mypartitionedemrlogs:

CREATE EXTERNAL TABLE `mypartitionedemrlogs`( `data` string COMMENT 'from deserializer') partitioned by (logtype string)ROW FORMAT DELIMITED FIELDS TERMINATED BY '|'LINES TERMINATED BY '\n'STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat' OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6'

Die folgenden Abfrageanweisungen erstellen dann Tabellenpartitionen basierend auf Unterverzeichnissenfür verschiedene Protokolltypen, die Amazon EMR in Amazon S3 erstellt:

197


ALTER TABLE mypartitionedemrlogs ADD PARTITION (logtype='containers') LOCATION s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/containers/

ALTER TABLE mypartitionedemrlogs ADD PARTITION (logtype='hadoop-mapreduce') LOCATION s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/hadoop-mapreduce/

ALTER TABLE mypartitionedemrlogs ADD PARTITION (logtype='hadoop-state-pusher') LOCATION s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/hadoop-state-pusher/

ALTER TABLE mypartitionedemrlogs ADD PARTITION (logtype='node') LOCATION s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/node/

ALTER TABLE mypartitionedemrlogs ADD PARTITION (logtype='steps') LOCATION s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/steps/

Nachdem Sie die Partitionen erstellt haben, können Sie eine SHOW PARTITIONS-Abfrage in der Tabelleausführen, um Folgendes zu bestätigen:

SHOW PARTITIONS mypartitionedemrlogs;

In den folgenden Beispielen werden Abfragen für bestimmte Protokolleinträge veranschaulicht, die dieanhand der obigen Beispiele erstellten Tabelle und Partitionen verwenden.

Example – Abfrage der Protokolle von Anwendung application_1561661818238_0002 in derContainer-Partition nach ERROR oder WARN

SELECT data, "$PATH"FROM "default"."mypartitionedemrlogs"WHERE logtype='containers' AND regexp_like("$PATH",'application_1561661818238_0002') AND regexp_like(data, 'ERROR|WARN') limit 100;

Example – Abfrage der Hadoop-Mapreduce-Partition nach Auftrag job_1561661818238_0004 undfehlgeschlagene Reduzierungen

SELECT data, "$PATH"FROM "default"."mypartitionedemrlogs"WHERE logtype='hadoop-mapreduce' AND regexp_like(data,'job_1561661818238_0004|Failed Reduces') limit 100;

198

Amazon Athena BenutzerhandbuchAbfragen von Classic Load Balancer-Protokollen

Example – Abfrage von Hive-Protokollen in der Knotenpartition nach Abfrage-ID056e0609-33e1-4611-956c-7a31b42d2663

SELECT data, "$PATH"FROM "default"."mypartitionedemrlogs"WHERE logtype='node' AND regexp_like("$PATH",'hive') AND regexp_like(data,'056e0609-33e1-4611-956c-7a31b42d2663') limit 100;

Example – Abfrage von Ressourcenmanager-Protokollen in der Knotenpartition für die Anwendung1567660019320_0001_01_000001

SELECT data, "$PATH"FROM "default"."mypartitionedemrlogs"WHERE logtype='node' AND regexp_like(data,'resourcemanager') AND regexp_like(data,'1567660019320_0001_01_000001') limit 100

Abfragen von Classic Load Balancer-ProtokollenMithilfe von Classic Load Balancer-Protokollen können Sie Datenverkehrsmuster von und zu Elastic LoadBalancing-Instances und Backend-Anwendungen analysieren und nachvollziehen. Dabei werden Ihnen dieDatenverkehrsquelle, die Latenz und die übertragenen Bytes angezeigt.

Bevor Sie die Elastic Load Balancing-Protokolle analysieren, konfigurieren Sie sie für die Speicherung imAmazon S3-Ziel-Bucket. Weitere Informationen finden Sie unter Aktivieren der Zugriffsprotokolle für IhrenClassic Load Balancer.

• Erstellen der Tabelle für Elastic Load Balancing-Protokolle (p. 199)• Elastic Load Balancing-Beispielabfragen (p. 200)

So erstellen Sie die Tabelle für Elastic Load Balancing-Protokolle1. Kopieren Sie die folgende DDL-Anweisung in die Athena-Konsole. Überprüfen Sie die Syntax der

Elastic Load Balancing Protokolldatensätze. Möglicherweise müssen Sie die folgende Abfrageaktualisieren, so dass sie die Spalten und die Regex-Syntax für die neueste Version des Datensatzesenthält.

CREATE EXTERNAL TABLE IF NOT EXISTS elb_logs ( timestamp string, elb_name string, request_ip string, request_port int, backend_ip string, backend_port int, request_processing_time double, backend_processing_time double, client_response_time double, elb_response_code string, backend_response_code string, received_bytes bigint, sent_bytes bigint, request_verb string, url string,

199

https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html

https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html

https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html#access-log-entry-format

Amazon Athena BenutzerhandbuchAbfragen von Netzwerk-Load-Balancer-Protokollen

protocol string, user_agent string, ssl_cipher string, ssl_protocol string)ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'WITH SERDEPROPERTIES ( 'serialization.format' = '1', 'input.regex' = '([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \\\"([^ ]*) ([^ ]*) (- |[^ ]*)\\\" (\"[^\"]*\") ([A-Z0-9-]+) ([A-Za-z0-9.-]*)$' )LOCATION 's3://your_log_bucket/prefix/AWSLogs/AWS_account_ID/elasticloadbalancing/';

2. Ändern Sie LOCATION für den Amazon S3-Bucket und geben Sie den Zielspeicherort der Elastic LoadBalancing-Protokolle an.

3. Führen Sie die Abfrage in der Athena-Konsole aus. Nach Beendigung der Abfrage wird die Tabelleelb_logs von Athena registriert, sodass Sie die darin enthaltenen Daten für Abfragen nutzen können.Weitere Informationen finden Sie unter Elastic Load Balancing-Beispielabfragen (p. 200).

Elastic Load Balancing-BeispielabfragenVerwenden Sie eine ähnliche Abfrage wie im folgenden Beispiel. Die Abfrage listet die Backend-Anwendungsserver auf, die den Fehlercode 4XX oder 5XX zurückgegeben haben. Mit dem Operator LIMITlässt sich die Anzahl der im gleichen Schritt abzufragenden Protokolle einschränken.

SELECT request_timestamp, elb_name, backend_ip, backend_response_codeFROM elb_logsWHERE backend_response_code LIKE '4%' OR backend_response_code LIKE '5%'LIMIT 100;

Mit einer weiteren Abfrage fassen Sie die Reaktionszeit aller Transaktionen gruppiert nach Backend-IP-Adresse und Elastic Load Balancing-Instance-Namen zusammen.

SELECT sum(backend_processing_time) AS total_ms, elb_name, backend_ipFROM elb_logs WHERE backend_ip <> ''GROUP BY backend_ip, elb_nameLIMIT 100;

Weitere Informationen finden Sie unter Analyzing Data in S3 using Athena.

Abfragen von Netzwerk-Load-Balancer-ProtokollenVerwenden Sie Athena zum Analysieren und Verarbeiten von Protokollen aus Netzwerk-Load-Balancer.Diese Protokolle erhalten detaillierte Informationen über die Transport Layer Security(TLS)-Anfragen, diean Netzwerk-Load-Balancer gesendet werden. Sie können diese Zugriffsprotokolle für die Analyse vonDatenverkehrsmustern und zur Problembehebung verwenden.

Bevor Sie die Netzwerk-Load-Balancer-Zugriffsprotokolle analysieren, aktivieren und konfigurieren Sie siefür die Speicherung im Amazon S3-Ziel-Bucket. Weitere Informationen finden Sie unter Zugriffsprotokollefür Ihren Netzwerk-Load-Balancer.

200

http://aws.amazon.com/blogs/big-data/analyzing-data-in-s3-using-amazon-athena/

https://docs.aws.amazon.com/elasticloadbalancing/latest//network/load-balancer-access-logs.html

https://docs.aws.amazon.com/elasticloadbalancing/latest//network/load-balancer-access-logs.html

Amazon Athena BenutzerhandbuchAbfragen von Netzwerk-Load-Balancer-Protokollen

• Erstellen der Tabelle für Netzwerk-Load-Balancer-Protokolle (p. 201)• Netzwerk-Load-Balancer-Beispielabfragen (p. 201)

So erstellen Sie die Tabelle für Netzwerk-Load-Balancer-Protokolle1. Kopieren Sie die folgende DDL-Anweisung in die Athena-Konsole. Überprüfen Sie die Syntax der

Netzwerk-Load-Balancer Protokolldatensätze. Möglicherweise müssen Sie die folgende Abfrageaktualisieren, so dass sie die Spalten und die Regex-Syntax für die neueste Version des Datensatzesenthält.

CREATE EXTERNAL TABLE IF NOT EXISTS nlb_tls_logs ( type string, version string, time string, elb string, listener_id string, client_ip string, client_port int, target_ip string, target_port int, tcp_connection_time_ms double, tls_handshake_time_ms double, received_bytes bigint, sent_bytes bigint, incoming_tls_alert int, cert_arn string, certificate_serial string, tls_cipher_suite string, tls_protocol_version string, tls_named_group string, domain_name string, new_field string ) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ( 'serialization.format' = '1', 'input.regex' = '([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*):([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-0-9]*) ([-0-9]*) ([-0-9]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*)($| [^ ]*)') LOCATION 's3://your_log_bucket/prefix/AWSLogs/AWS_account_ID/elasticloadbalancing/region';

2. Ändern Sie LOCATION für den Amazon S3-Bucket und geben Sie den Zielspeicherort der Netzwerk-Load-Balancer-Protokolle an.

3. Führen Sie die Abfrage in der Athena-Konsole aus. Nach Beendigung der Abfrage wird die Tabellenlb_tls_logs von Athena registriert, sodass Sie die darin enthaltenen Daten für Abfragen nutzenkönnen.

Netzwerk-Load-Balancer-BeispielabfragenWenn Sie wissen möchten, wie oft ein Zertifikat verwendet wird, verwenden Sie eine Abfrage ähnlich wie indiesem Beispiel:

SELECT count(*) AS ct, cert_arn

201

https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html#access-log-file-format

Amazon Athena BenutzerhandbuchAbfragen von Application Load Balancer-Protokollen

FROM "nlb_tls_logs"GROUP BY cert_arn;

Die folgende Abfrage zeigt, wie viele Benutzer die ältere TLS-Version verwenden:

SELECT tls_protocol_version, COUNT(tls_protocol_version) AS num_connections, client_ipFROM "nlb_tls_logs"WHERE tls_protocol_version < 'tlsv12'GROUP BY tls_protocol_version, client_ip;

Verwenden Sie die folgende Abfrage, um Verbindungen zu identifizieren, die eine lange TLS-Handshake-Zeit benötigen:

SELECT *FROM "nlb_tls_logs"ORDER BY tls_handshake_time_ms DESC LIMIT 10;

Abfragen von Application Load Balancer-ProtokollenEin Application Load Balancer ist eine Lastverteilungsoption für Elastic Load Balancing, die eine Verteilungdes Datenverkehrs in einer Microservices-Bereitstellung mit Containern ermöglicht. Durch das Abfragenvon Application Load Balancer-Protokollen können Sie die Datenverkehrsquelle, die Latenz und die Bytesanzeigen, die zwischen Elastic Load Balancing-Instances und Backend-Anwendungen übermittelt werden.

Bevor Sie beginnen, aktivieren Sie die Zugriffsprotokollierung für Application Load Balancer-Protokolle, diein Ihrem Amazon S3-Bucket gespeichert werden sollen.

• Erstellen der Tabelle für ALB-Protokolle (p. 202)• Beispielabfragen für ALB-Protokolle (p. 203)

Erstellen der Tabelle für ALB-Protokolle1. Kopieren Sie die folgende DDL-Anweisung und fügen Sie sie in die Athena-Konsole ein. Modifizieren

Sie die Werte in LOCATION 's3://your-alb-logs-directory/AWSLogs/<ACCOUNT-ID>/elasticloadbalancing/<REGION>/'.

Erstellen Sie die alb_logs-Tabelle wie folgt.

Note

Diese Abfrage enthält alle Felder, die in der Liste der aktuellen Application LoadBalancer-Zugriffsprotokolleinträge vorhanden sind. Sie enthält am Ende auch die Tabellenspaltenew_field, falls Sie Ergänzungen zu den ALB-Protokollen benötigen. Dieses Feld ist fürdie Durchführung der Abfrage nicht ausschlaggebend. Der reguläre Ausdruck in den SerDe-Eigenschaften ignoriert dieses Feld, wenn es nicht in Ihren Protokollen enthalten ist.

CREATE EXTERNAL TABLE IF NOT EXISTS alb_logs ( type string, time string, elb string, client_ip string, client_port int,

202

https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#enable-access-logging

https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format

Amazon Athena BenutzerhandbuchAbfragen von Application Load Balancer-Protokollen

target_ip string, target_port int, request_processing_time double, target_processing_time double, response_processing_time double, elb_status_code string, target_status_code string, received_bytes bigint, sent_bytes bigint, request_verb string, request_url string, request_proto string, user_agent string, ssl_cipher string, ssl_protocol string, target_group_arn string, trace_id string, domain_name string, chosen_cert_arn string, matched_rule_priority string, request_creation_time string, actions_executed string, redirect_url string, lambda_error_reason string, new_field string ) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ( 'serialization.format' = '1', 'input.regex' = '([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \"([^ ]*) ([^ ]*) (- |[^ ]*)\" \"([^\"]*)\" ([A-Z0-9-]+) ([A-Za-z0-9.-]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^\"]*)\" ([-.0-9]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\"($| \"[^ ]*\")(.*)') LOCATION 's3://your-alb-logs-directory/AWSLogs/<ACCOUNT-ID>/elasticloadbalancing/<REGION>/';

2. Führen Sie die Abfrage in der Athena-Konsole aus. Nach Beendigung der Abfrage registriert Athena diealb_logs-Tabelle, sodass Sie die Daten zum Ausgeben von Abfragen nutzen können.

Beispielabfragen für ALB-ProtokolleBei der folgenden Abfrage wird die Anzahl der HTTP GET-Anfragen gezählt und nach Client-IP-Adressengruppiert, die vom Load Balancer empfangen wurden:

SELECT COUNT(request_verb) AS count, request_verb, client_ipFROM alb_logsGROUP BY request_verb, client_ipLIMIT 100;

Eine weitere Abfrage zeigt die URLs, die von Safari-Browser-Benutzern besucht wurden:

SELECT request_urlFROM alb_logsWHERE user_agent LIKE '%Safari%'LIMIT 10;

Im folgenden Beispiel wird gezeigt, wie Sie die Protokolle nach datetime durchsuchen:

203

Amazon Athena BenutzerhandbuchAbfragen von Amazon VPC-Flow-Protokollen

SELECT client_ip, sum(received_bytes) FROM alb_logs_config_us WHERE parse_datetime(time,'yyyy-MM-dd''T''HH:mm:ss.SSSSSS''Z') BETWEEN parse_datetime('2018-05-30-12:00:00','yyyy-MM-dd-HH:mm:ss') AND parse_datetime('2018-05-31-00:00:00','yyyy-MM-dd-HH:mm:ss') GROUP BY client_ip;

Abfragen von Amazon VPC-Flow-ProtokollenAmazon Virtual Private Cloud-Flow-Protokolle erfassen Informationen zum IP-Datenverkehr zuund von Netzwerkschnittstellen in einer VPC. Verwenden Sie die Protokolle zur Untersuchung vonNetzwerkdatenverkehrsmustern und zur Identifizierung von Bedrohungen und Risiken in Ihrem VPC-Netzwerk.

Bevor Sie die Protokolle in Athena abfragen, aktivieren Sie VPC-Flow-Protokolle und konfigurieren Siediese so, dass sie in Ihrem Amazon S3-Bucket gespeichert werden. Nach dem Erstellen der Protokolleführen Sie diese einige Minuten lang aus, um Daten zu erfassen. Die Protokolle werden in einem GZIP-Komprimierungsformat erstellt, das Sie über Athena direkt abfragen können.

Wenn Sie ein VPC-Flow-Protokoll erstellen, können Sie das Standardformat verwenden oder einbenutzerdefiniertes Format angeben. In einem benutzerdefinierten Format geben Sie an, welche Felderim Flow-Protokoll zurückgegeben werden sollen, und in welcher Reihenfolge sie angezeigt werden sollen.Weitere Informationen finden Sie unter Flow-Protokolldatensätze im Amazon VPC Benutzerhandbuch.

• Erstellen der Tabelle für VPC-Flow-Protokolle (p. 204)• Beispiel-Abfragen für Amazon VPC-Flow-Protokolle (p. 205)

Erstellen der Tabelle für VPC-Flow-ProtokolleDer folgende Abschnitt erstellt eine Amazon VPC-Tabelle für VPC-Flow-Protokolle, die das Standardformatverwenden. Wenn Sie ein Flow-Protokoll mit einem benutzerdefinierten Format erstellen, müssen Sieeine Tabelle mit Feldern erstellen, die mit den Feldern übereinstimmen, die Sie beim Erstellen des Flow-Protokolls angegeben haben, in der gleichen Reihenfolge, in der Sie sie angegeben haben.

So erstellen Sie die Amazon VPC-Tabelle

1. Kopieren Sie die folgende DDL-Anweisung in die Athena-Konsole. Diese Abfrage gibt ROW FORMATDELIMITED an, jedoch keinen SerDe. Dies bedeutet, dass die Abfrage für CSV-, TSV- undbenutzerdefinierte, durch Trennzeichen getrennte Dateien den LazySimpleSerDe verwendet (p. 304).Zudem werden Felder bei dieser Abfrage durch ein Leerzeichen beendet. Ändern Sie bei einem VPC-Flow-Protokoll mit einem benutzerdefinierten Format die Felder, die Sie beim Erstellen des Flow-Protokolls angegeben haben.

2. Ändern Sie LOCATION 's3://your_log_bucket/prefix/AWSLogs/{subscribe_account_id}/vpcflowlogs/{region_code}/' so, dass auf den Amazon S3-Bucketgezeigt wird, der Ihre Protokolldaten enthält.

CREATE EXTERNAL TABLE IF NOT EXISTS vpc_flow_logs ( version int, account string, interfaceid string, sourceaddress string, destinationaddress string, sourceport int, destinationport int, protocol int, numpackets int, numbytes bigint,

204

https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/flow-logs.html

https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records

Amazon Athena BenutzerhandbuchAbfragen von Amazon VPC-Flow-Protokollen

starttime int, endtime int, action string, logstatus string) PARTITIONED BY (dt string)ROW FORMAT DELIMITEDFIELDS TERMINATED BY ' 'LOCATION 's3://your_log_bucket/prefix/AWSLogs/{subscribe_account_id}/vpcflowlogs/{region_code}/'TBLPROPERTIES ("skip.header.line.count"="1");

3. Führen Sie die Abfrage in der Athena-Konsole aus. Nach Beendigung der Abfrage registriert Athena dievpc_flow_logs-Tabelle, sodass Sie die Daten zum Ausgeben von Abfragen nutzen können.

4. Erstellen Sie Partitionen, um die Daten lesen zu können, wie in der folgenden Beispielabfrage. DieseAbfrage erstellt eine einfache Partition für ein angegebenes Datum. Ersetzen Sie die Platzhalter fürDatum und Standort nach Bedarf.

Note

Diese Abfrage erstellt für einen von Ihnen angegebenen Zeitraum lediglich eine einzigePartition. Um den Prozess zu automatisieren, verwenden Sie ein Skript, das diese Abfragein dieser Weise für den year/month/day ausführt, oder einen AWS Glue-Crawler, umPartitionen für einen vorhandenen Amazon S3-Bucket zu erstellen. Informationen hierzu findenSie unter Planen eines Crawlers zur Synchronisierung des AWS Glue-Datenkatalogs mitAmazon S3 (p. 52).

ALTER TABLE vpc_flow_logsADD PARTITION (dt='YYYY-MM-dd')location 's3://your_log_bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/YYYY/MM/dd';

Beispiel-Abfragen für Amazon VPC-Flow-ProtokolleDie folgende Abfrage listet alle abgelehnten TCP-Verbindungen auf und verwendet die neu erstellteDatumspartitionsspalte dt, um daraus den Wochentag zu extrahieren, an dem diese Ereignisseaufgetreten sind.

Diese Abfrage verwendet Datums- und Zeitfunktionen und -Operatoren. Sie konvertiert Werte in der Spalte„dt-Zeichenfolge“ anhand der Datumsfunktion from_iso8601_timestamp(string) in Zeitstempel undextrahiert aus diesen mit day_of_week den Wochentag.

SELECT day_of_week(from_iso8601_timestamp(dt)) AS day, dt, interfaceid, sourceaddress, action, protocolFROM vpc_flow_logsWHERE action = 'REJECT' AND protocol = 6LIMIT 100;

Nutzen Sie diese Abfrage, um herauszufinden, welcher Ihrer Server die meisten HTTPS-Anforderungenempfängt. Bei der Abfrage werden die Pakete gezählt, die vom HTTPS-Port 443 empfangen werden. Siewerden nach IP-Adressen gruppiert und die führenden 10 ausgegeben.

SELECT SUM(numpackets) AS

205

https://prestodb.io/docs/0.172/functions/datetime.html

Amazon Athena BenutzerhandbuchAbfragen von AWS WAF-Protokollen

packetcount, destinationaddressFROM vpc_flow_logsWHERE destinationport = 443GROUP BY destinationaddressORDER BY packetcount DESCLIMIT 10;

Weitere Informationen finden Sie im AWS Big Data-Blog-Beitrag Analyzing VPC Flow Logs with AmazonKinesis Firehose, Athena, and Amazon QuickSight.

Abfragen von AWS WAF-ProtokollenAWS WAF-Protokolle enthalten Informationen über den Datenverkehr, der von Ihrem Web-ACL analysiertwird, z. B. die Zeit, zu der AWS WAF die Anfrage von Ihrer AWS-Ressource empfangen hat, detaillierteInformationen über die Anforderung und die Aktion für die Regel, der jede Anforderung entsprach.

Sie können die Zugriffsprotokollierung für AWS WAF-Protokolle aktivieren;, speichern Sie sie in AmazonS3, und fragen Sie die Protokolle in Athena ab. Weitere Informationen zum Aktivieren von AWS WAF-Protokollen und über die Protokolldatensatz-Struktur finden Sie unter Protokollieren von Web ACL-Datenverkehr-Informationen im AWS WAF-Entwicklerhandbuch.

Notieren Sie den Amazon S3-Bucket, in dem die Protokolle gespeichert werden sollen.

• Erstellen der Tabelle für AWS WAF-Protokolle (p. 206)• Beispielabfragen für AWS WAF-Protokolle (p. 207)

Erstellen der Tabelle für AWS WAF-ProtokolleSo erstellen Sie die AWS WAF-Tabelle:

1. Kopieren Sie die folgende DDL-Anweisung in die Athena-Konsole. Ändern Sie den LOCATION für denAmazon S3-Bucket, in dem Ihre Protokolle gespeichert werden.

Diese Abfrage verwendet den Hive JSON SerDe (p. 301). Das Tabellenformat und der SerDe werdenvom AWS Glue-Crawler vorgeschlagen, wenn dieser AWS WAF-Protokolle analysiert.

CREATE EXTERNAL TABLE `waf_logs`( `timestamp` bigint, `formatversion` int, `webaclid` string, `terminatingruleid` string, `terminatingruletype` string, `action` string, `httpsourcename` string, `httpsourceid` string, `rulegrouplist` array<string>, `ratebasedrulelist` array< struct< ratebasedruleid:string, limitkey:string, maxrateallowed:int > >, `nonterminatingmatchingrules` array< struct< ruleid:string, action:string >

206

http://aws.amazon.com/blogs/big-data/analyzing-vpc-flow-logs-with-amazon-kinesis-firehose-amazon-athena-and-amazon-quicksight/

http://aws.amazon.com/blogs/big-data/analyzing-vpc-flow-logs-with-amazon-kinesis-firehose-amazon-athena-and-amazon-quicksight/

https://docs.aws.amazon.com/waf/latest/developerguide/logging.html

https://docs.aws.amazon.com/waf/latest/developerguide/logging.html


>, `httprequest` struct< clientip:string, country:string, headers:array< struct< name:string, value:string > >, uri:string, args:string, httpversion:string, httpmethod:string, requestid:string > )ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'WITH SERDEPROPERTIES ( 'paths'='action,formatVersion,httpRequest,httpSourceId,httpSourceName,nonTerminatingMatchingRules,rateBasedRuleList,ruleGroupList,terminatingRuleId,terminatingRuleType,timestamp,webaclId')STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://athenawaflogs/WebACL/'

2. Führen Sie die Abfrage in der Athena-Konsole aus. Nach Beendigung der Abfrage wird die Tabellewaf_logs von Athena registriert, so dass Sie die darin enthaltenen Daten für Abfragen nutzen können.

Beispielabfragen für AWS WAF-ProtokolleIn der folgenden Abfrage wird die Anzahl der Male, die eine IP-Adresse von der RATE_BASED-Beendigungsregel gesperrt wurde, gezählt.

SELECT COUNT(httpRequest.clientIp) as count,httpRequest.clientIpFROM waf_logsWHERE terminatingruletype='RATE_BASED' AND action='BLOCK'GROUP BY httpRequest.clientIpORDER BY count LIMIT 100;

Die folgende Abfrage zählt, wie oft die Anforderung von einer IP-Adresse angekommen ist, die zu Irland(IE) gehört und von der RATE_BASED-Beendigungsregel gesperrt wurde.

SELECT COUNT(httpRequest.country) as count,httpRequest.countryFROM waf_logsWHERE terminatingruletype='RATE_BASED' AND httpRequest.country='IE'GROUP BY httpRequest.countryORDER BY countLIMIT 100;

Die folgende Abfrage zählt, wie oft die Anfrage mit Ergebnisse gesperrt wurde, gruppiert nach WebACL,RuleId, ClientIP und HTTP-Anforderungs-URI.

SELECT COUNT(*) AScount,webaclid,terminatingruleid,

207


httprequest.clientip,httprequest.uriFROM waf_logsWHERE action='BLOCK'GROUP BY webaclid, terminatingruleid, httprequest.clientip, httprequest.uriORDER BY count DESCLIMIT 100;

Die folgende Abfrage zählt, wie oft eine bestimmte Beendigungsregel-ID vorkam (WHEREterminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'). Die Abfrage gruppiert danndie Ergebnisse nach WebACL, Action, ClientIP und HTTP-Anforderungs-URI.

SELECT COUNT(*) AScount,webaclid,action,httprequest.clientip,httprequest.uriFROM waf_logsWHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'GROUP BY webaclid, action, httprequest.clientip, httprequest.uriORDER BY count DESCLIMIT 100;

208

Amazon Athena BenutzerhandbuchDatenschutz

Amazon AthenaSicherheitCloud-Sicherheit bei AWS ist unsere oberste Priorität. Als AWS-Kunde profitieren Sie von einerRechenzentrums- und Netzwerkarchitektur, die zur Erfüllung der Anforderungen von Organisationenentwickelt wurden, für die Sichherheit eine kritische Bedeutung hat.

Sicherheit ist eine übergreifende Verantwortlichkeit zwischen AWS und Ihnen. Im Modell derübergreifenden Verantwortlichkeit wird Folgendes mit „Sicherheit der Cloud“ bzw. „Sicherheit in der Cloud“umschrieben:

• Sicherheit der Cloud – AWS ist für den Schutz der Infrastruktur verantwortlich, in der AWS-Services inder AWS Cloud ausgeführt werden. AWS bietet Ihnen außerdem Services, die Sie auf sichere Weiseverwenden können. Die Wirksamkeit unserer Sicherheitsfunktionen wird regelmäßig von externenPrüfern im Rahmen des AWS-Compliance-Programms getestet und überprüft. Informationen zuden Compliance-Programmen, die für Athena gelten, finden Sie unter Vom Compliance-Programmabgedeckte AWS-Services.

• Sicherheit in der Cloud in – Ihr Verantwortungsumfang wird durch den AWS-Service bestimmt, den Sieverwenden. In Ihre Verantwortung fallen außerdem weitere Faktoren, wie z. B. die Vertraulichkeit derDaten, die Anforderungen Ihrer Organisation sowie geltende Gesetze und Vorschriften.

Diese Dokumentation beschreibt, wie Sie das Modell der übergreifenden Verantwortlichkeit bei derVerwendung von Amazon Athena anwenden können. Die folgenden Themen veranschaulichen, wieSie Athena zur Erfüllung Ihrer Sicherheits- und Compliance-Ziele konfigurieren können. Sie erfahrenaußerdem, wie Sie Ihre Athena-Ressourcen mithilfe weiterer AWS-Services überwachen und sichernkönnen.

Themen• Datenschutz in Athena (p. 209)• Identitäts- und Zugriffsverwaltung in Athena (p. 217)• Protokollieren und überwachen in Athena (p. 239)• Compliance-Validierung für Amazon Athena (p. 240)• Resilienz in Athena (p. 240)• Sicherheit der Infrastruktur in Athena (p. 241)• Konfigurations- und Schwachstellenanalyse in Athena (p. 243)• Verwenden von Athena zum Abfragen von Daten, die in AWS Lake Formation registriert sind (p. 243)

Datenschutz in AthenaEs sind mehrere Datentypen involviert, wenn Sie Datenbanken und Tabellen mit Athena erstellen. DieseDatentypen umfassen in Amazon S3 gespeicherte Quelldaten, Metadaten für Datenbanken und Tabellen,die Sie erstellen, wenn Sie Abfragen ausführen oder die AWS Glue-Crawle zum Ermitteln und Abfragenvon Ergebnisdaten und des Abfrageverlaufs. In diesem Abschnitt werden alle diese Arten von Datenbesprochen und ihre Verarbeitung erläutert.

• Quelldaten – Sie speichern die Daten für Datenbanken und Tabellen in Amazon S3, und Athenaverändert diese nicht. Weitere Informationen finden Sie unter Schützen von Daten in Amazon S3 im

209

https://aws.amazon.com/compliance/shared-responsibility-model/


https://aws.amazon.com//compliance/programs/

https://aws.amazon.com//compliance/services-in-scope/

https://aws.amazon.com//compliance/services-in-scope/

https://docs.aws.amazon.com/AmazonS3/latest/dev/DataDurability.html

Amazon Athena BenutzerhandbuchVerschlüsselung im Ruhezustand

Entwicklerhandbuch für Amazon Simple Storage Service. Sie steuern den Zugriff auf Ihre Quelldatenund ihre Verschlüsselung in Amazon S3. Sie können Athena zum Erstellen von Tabellen basierend aufverschlüsselten Datasets in Amazon S3 (p. 213) verwenden.

• Datenbank- und Tabellenmetadaten (Schema) – Athena verwendet die Schema-on-Read-Technologie.Dies bedeutet, dass Ihre Tabellendefinitionen auf Ihre Daten in Amazon S3 angewendet werden, wennAthena Abfragen ausführt. Alle von Ihnen definierten Schemata werden automatisch gespeichert, essei denn, Sie löschen sie ausdrücklich. In Athena können Sie die Data Catalog-Metadaten mit DDL-Anweisungen änern. Sie können auch Tabellendefinitionen und Schemata löschen, ohne dass diesAuswirkungen auf die zugrunde liegenden Daten hat, die in Amazon S3 gespeichert sind.

Note

Die Metadaten für Datenbanken und Tabellen, die Sie in Athena verwenden, werden imAWS Glue-Datenkatalog gespeichert. Wir empfehlen nachdrücklich ein Upgrade (p. 60) zurVerwendung des AWS Glue-Datenkatalog mit Athena. Weitere Informationen zu den Vorteilendes AWS Glue-Datenkatalog finden Sie unter Häufig gestellte Fragen: Upgrade auf den AWSGlue-Datenkatalog (p. 62).

Sie können differenzierte Zugriffsrichtlinien für Datenbanken und Tabellen (p. 222) definieren, die imAWS Glue-Datenkatalog registriert sind (mit AWS Identity and Access Management (IAM)). Sie könnenMetadaten im AWS Glue-Datenkatalog verschlüsseln. Sie können auch Metadaten im AWS Glue-Datenkatalog verschlüsseln. Wenn Sie die Metadaten verschlüsseln, verwenden Sie Berechtigungen fürden Zugriff auf verschlüsselte Metadaten (p. 215).

• Abfrageergebnisse und Abfrageverläufe, einschließlich gespeicherter Abfragen – Abfrageergebnissewerden an einem Speicherort in Amazon S3 gespeichert, den Sie global oder für jede Arbeitsgruppewählen können. Wenn Sie dies nicht angeben, verwendet Athena in jedem Fall den Standard-Speicherort. Sie kontrollieren den Zugriff auf Amazon S3-Buckets zum Speichern von Abfrageergebnisseund gespeicherten Abfragen. Darüber hinaus können Sie die Abfrageergebnisse verschlüsseln, dieSie in Amazon S3 speichern. Benutzer müssen über die entsprechenden Berechtigungen zum Zugriffauf Amazon S3-Speicherorte und zum Entschlüsseln von Dateien verfügen. Weitere Informationenfinden Sie unter Verschlüsseln der in Amazon S3 gespeicherten Abfrageergebnisse (p. 212) in diesemDokument..

Athena hält den Abfrageverlauf 45 Tage vor. Sie können den Abfrageverlauf (p. 120) mit Athena-APIsin der Konsole, und mit AWS CLI anzeigen. Um die Abfragen für länger als 45 Tage lang vorzuhalten,müssen Sie sie speichern. Verwenden Sie zum Schutz des Zugriffs auf gespeicherte AbfragenArbeitsgruppen (p. 251) in Athena, die den Zugriff auf gespeicherte Abfragen nur auf dazu berechtigteBenutzer einschränken.

Themen• Verschlüsselung im Ruhezustand (p. 210)• Verschlüsselung während der Übertragung (p. 216)• Schlüsselverwaltung (p. 216)• Richtlinie für den Datenverkehr zwischen Netzwerken (p. 216)

Verschlüsselung im RuhezustandSie können Abfragen in Amazon Athena auf verschlüsselte Daten in Amazon S3 in derselben Regiondurchführen. Sie können auch die Abfrageergebnisse in Amazon S3 und die Daten im AWS Glue DataCatalog verschlüsseln.

Sie können die folgenden Ressourcen in Athena verschlüsseln:

• Die Ergebnisse aller Abfragen in Amazon S3, die von Athena in einem als Amazon S3-Ergebnisortbezeichneten Ort gespeichert werden. Die in Amazon S3 gespeicherten Abfrageergebnisse lassen

210

https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html


sich verschlüsseln, und zwar unabhängig davon, ob das zugrunde liegende Dataset in Amazon S3verschlüsselt oder unverschlüsselt ist. Weitere Informationen finden Sie unter Berechtigungen für imAmazon S3 gespeicherte verschlüsselte Abfrageergebnisse (p. 212).

• Die Daten im AWS Glue-Data Catalog. Weitere Informationen finden Sie unter Berechtigungen fürverschlüsselte Metadaten im AWS Glue-Datenkatalog (p. 215).

Unterstützte Amazon S3-VerschlüsselungsoptionenAthena unterstützt die folgenden Amazon S3-Verschlüsselungsoptionen sowohl für verschlüsselte Datasetsin Amazon S3, als auch für verschlüsselte Abfrageergebnisse:

• Serverseitige Verschlüsselung (SSE) mit einem von Amazon S3 verwalteten Schlüssel (SSE-S3)• Serverseitige Verschlüsselung (SSE) mit einem vom Kunden verwalteten AWS Key Management

Service-Schlüssel (SSE-KMS)• Clientseitige Verschlüsselung (CSE) mit einem vom Kunden verwalteten AWS KMS-Schlüssel (CSE-

KMS)

Note

Im Falle von SSE-KMS müssen Sie beim Erstellen einer Tabelle in Athena keineDatenverschlüsselung mehr angeben.

Weitere Informationen zur AWS KMS-Verschlüsselung mit Amazon S3 finden Sie unter Was ist der AWSKey Management Service? und Wie Amazon Simple Storage Service (Amazon S3) AWS KMS verwendetim AWS Key Management Service Developer Guide.

Athena unterstützt weder die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln(SSE-C) noch die clientseitige Verschlüsselung mit einem clientseitigen Masterschlüssel. Informationenzum Vergleichen von Amazon S3-Verschlüsselungsoptionen finden Sie unter Daten durch Verschlüsselungschützen im Entwicklerhandbuch für Amazon Simple Storage Service.

Athena unterstützt keine Abfragen aus einer Region auf verschlüsselte Daten, die in Amazon S3 in eineranderen Region gespeichert sind.

Important

Sie müssen die Abfrage von verschlüsselten Datasets in Amazon S3 sowie die Optionen zumVerschlüsseln der Abfrageergebnisse in Athena unterschiedlich einrichten. Jede Option wirdseparat konfiguriert und aktiviert. Sie können jeweils verschiedene Verschlüsselungsmethodenoder Schlüssel verwenden. Das heißt, das Lesen von verschlüsselten Daten in Amazon S3 führtnicht automatisch zur Verschlüsselung der Athena-Abfrageergebnisse in Amazon S3. Umgekehrtgilt dies auch. Mit der Verschlüsselung der Athena-Abfrageergebnisse in Amazon S3 wird nichtautomatisch auch das zugrunde liegende Dataset in Amazon S3 verschlüsselt.

Unabhängig davon, ob Sie diese Optionen für die Verschlüsselung von Daten in Ruhe in Amazon S3verwenden, verschlüsselt die Transport Layer Security (TLS) Objekte während des Übergangs zwischenAthena-Ressourcen sowie zwischen Athena und Amazon S3. Abfrageergebnisse, die an JDBC- oderODBC-Clients gestreamt werden, werden mit TLS verschlüsselt.

Berechtigungen für verschlüsselte Daten in Amazon S3Abhängig von der Art der in Amazon S3 verwendeten Verschlüsselung müssen Sie möglicherweiseBerechtigungen, auch „Allow“-Aktionen (Zulassen) genannt, zu Ihren in Athena verwendeten Richtlinienhinzufügen:

211

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingClientSideEncryption.html#client-side-encryption-kms-managed-master-key-intro

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingClientSideEncryption.html#client-side-encryption-kms-managed-master-key-intro

https://docs.aws.amazon.com/kms/latest/developerguide/overview.html


https://docs.aws.amazon.com/kms/latest/developerguide/services-s3.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingEncryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingEncryption.html


• SSE-S3 – Wenn Sie für die Verschlüsselung SSE-S3 verwenden, benötigen Athena-Benutzer keinezusätzlichen Berechtigungen in ihren Richtlinien. Es reicht, wenn die entsprechenden Amazon S3-Berechtigungen für den jeweiligen Amazon S3-Speicherort und für Athena-Aktionen vorhandensind. Weitere Informationen zu Richtlinien, mit denen die erforderlichen Athena- und Amazon S3-Berechtigungen erteilt werden, finden Sie unter IAM-Richtlinien für den Benutzerzugriff (p. 217) undAmazon S3-Berechtigungen (p. 221).

• AWS KMS –Wenn Sie AWS KMS für die Verschlüsselung verwenden, müssen Athena-Benutzerbestimmte AWS KMS-Aktionen zusätzlich zu Athena- und Amazon S3-Berechtigungen ausführenkönnen. Sie können die Berechtigungen für diese Aktionen durch Bearbeiten der Schlüsselrichtlinie fürdie vom Kunden verwalteten AWS KMS-Schlüssel (CMKs) erteilen, die zur Datenverschlüsselung inAmazon S3 genutzt werden. Die einfachste Möglichkeit ist, über die IAM-Konsole Schlüsselbenutzerzu den entsprechenden AWS KMS-Schlüsselrichtlinien hinzuzufügen. Weitere Informationen darüber,wie Sie einen Benutzer zu einer AWS KMS-Schlüsselrichtlinie hinzufügen, finden Sie unter Ändern einerSchlüsselrichtlinie im AWS Key Management Service Developer Guide.

Note

Erfahrene Schlüsselrichtlinien-Administratoren können die Schlüsselrichtlinien anpassen.kms:Decrypt ist die minimal erlaubte Aktion für einen Athena-Benutzer, um miteinem verschlüsselten Dataset arbeiten zu können. Zur Nutzung von verschlüsseltenAbfrageergebnissen sind Berechtigungen für die Aktionen kms:GenerateDataKey undkms:Decrypt notwendig.

Wenn Sie in Amazon S3 Abfragen für Datasets mit einer großen Anzahl von Objekten in Athenaausführen, die mit AWS KMS verschlüsselt sind, werden die Abfrageergebnisse möglicherweise vonAWS KMS gedrosselt. Bei einer hohen Zahl kleiner Objekte ist dies noch wahrscheinlicher. WiederholteAnfragen werden von Athena unterbunden, dennoch kann ein Ablehnungsfehler auftreten. Rufen Sie indiesem Fall das AWS Support-Center auf und erstellen Sie einen Fall, um Ihr Limit zu erhöhen. WeitereInformationen zu Limits und der AWS KMS-Drosselung finden Sie unter Limits im AWS Key ManagementService Developer Guide.

Verschlüsseln der in Amazon S3 gespeichertenAbfrageergebnisseSie richten die Verschlüsselung der Abfrageergebnisse mithilfe der Athena-Konsole ein. Arbeitsgruppenermöglichen Ihnen die Durchsetzung der Verschlüsselung der Abfrageergebnisse.

Wenn Sie Verbindungen mithilfe der JDBC- oder ODBC-Treiber herstellen, konfigurieren SieTreiberoptionen zur Angabe der zu verwendenden Verschlüsselungsart und des Speicherorts des AmazonS3 Staging-Verzeichnisses. Informationen zum Konfigurieren des JDBC- oder ODBC-Treibers zumVerschlüsseln der Abfrageergebnisse mit einem der von Athena unterstützten Verschlüsselungsprotokollefinden Sie unter Herstellen einer Verbindung zu Amazon Athena mit ODBC- und JDBC-Treibern (p. 76).

Sie können die Einstellung für die Verschlüsselung von Abfrageergebnisse auf zwei Arten konfigurieren:

• Clientseitige Einstellungen – Wenn Sie Settings (Einstellungen) in der Konsole oder den API-Operationenverwenden, um anzugeben, dass Sie Abfrageergebnisse verschlüsseln möchten, wird dies alsVerwendung clientseitiger Einstellungen bezeichnet. Zu den clientseitigen Einstellungen gehören derSpeicherort der Abfrageergebnisse und die Verschlüsselung. Wenn Sie diese angeben, werden sieverwendet, solange sie nicht von den Arbeitsgruppeneinstellungen überschrieben werden.

• Arbeitsgruppeneinstellungen – Wenn Sie eine Arbeitsgruppe erstellen oder bearbeiten und dasFeld Override client-side settings (Clientseitige Einstellungen überschreiben) (p. 262) auswählen,verwenden alle in dieser Arbeitsgruppe ausgeführten Abfragen die Arbeitsgruppeneinstellungen.Weitere Informationen finden Sie unter Arbeitsgruppeneinstellungen überschreiben clientseitigeEinstellungen (p. 261). Zu den Arbeitsgruppeneinstellungen gehören der Speicherort derAbfrageergebnisse und die Verschlüsselung.

212

https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to-console-default-view

https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to-console-default-view

https://console.aws.amazon.com/support/home

https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second


So verschlüsseln Sie die in Amazon S3 gespeicherten Abfrageergebnisse mit der Konsole:

Important

Wenn für Ihre Arbeitsgruppe das Feld Override client-side settings (Clientseitige Einstellungenüberschreiben) ausgewählt ist, verwenden die Abfragen die Arbeitsgruppeneinstellungen. DieVerschlüsselungskonfiguration und der Speicherort der Abfrageergebnisse, die in den Settings(Einstellungen) aufgelistet werden; die API-Operationen und der Treiber werden nicht verwendet.Weitere Informationen finden Sie unter Arbeitsgruppeneinstellungen überschreiben clientseitigeEinstellungen (p. 261).

1. Wählen Sie in der Athena-Konsole Settings (Einstellungen).

2. Geben Sie im Feld Query result location einen eigenen Wert ein oder übernehmen Sie dieStandardeinstellung. Dies ist das Amazon S3-Staging-Verzeichnis, in dem die Abfrageergebnissegespeichert werden.

3. Wählen Sie Encrypt query results aus.

4. Wählen Sie im Feld Encryption type den Eintrag CSE-KMS, SSE-KMS oder SSE-S3 aus.5. Wenn Sie SSE-KMS oder CSE-KMS ausgewählt haben, geben Sie den Verschlüsselungsschlüssel an.

• Sofern Ihr Konto Zugriff auf einen vorhandenen vom Kunden verwalteten AWS KMS-Schlüssel(CMK) hat, wählen Sie den Alias aus. Wählen Sie andernfalls KMS-Schüssel-ARN eingeben aus undgeben Sie einen ARN ein.

• Falls Ihr Konto nicht über Zugriff auf einen vorhandenen vom Kunden verwalteten AWS KMS-Schlüssel (CMK) verfügt, klicken Sie auf KMS-Schlüssel erstellen und öffnen Sie die AWS-KMS-Konsole. Klicken Sie im Navigationsbereich auf AWS managed keys (Von AWS verwalteteSchlüssel).Weitere Informationen finden Sie unter Erstellen von Schlüsseln im AWS KeyManagement Service Developer Guide.

6. Kehren Sie zur Athena-Konsole zurück, um den Schlüssel nach Alias oder ARN anzugeben, wie imvorherigen Schritt beschrieben.

7. Wählen Sie Save (Speichern) aus.

Erstellen von Tabellen basierend auf verschlüsselten Datasets inAmazon S3Wenn Sie eine Tabelle erstellen, zeigen Sie Athena an, dass ein Dataset in Amazon S3 verschlüsseltist. Bei Verwendung von SSE-KMS ist dies nicht erforderlich. Bei der SSE-S3- und der AWS KMS-

213

https://console.aws.amazon.com/kms


https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html


Verschlüsselung ermittelt Athena die erforderlichen Materialien zum Verschlüsseln des Datasets und zumErstellen der Tabelle. Daher müssen Sie keine Schlüsselinformationen angeben.

Benutzer, die Abfragen ausführen möchten – einschließlich des Benutzers, der die Tabelle erstellt – ,müssen die zuvor in diesem Thema beschriebenen Berechtigungen haben.

Important

Wenn Sie Amazon EMR zusammen mit EMRFS zum Hochladen verschlüsselter Parquet-Dateien verwenden, müssen Sie mehrteilige Uploads deaktivieren, indem Sie fürfs.s3n.multipart.uploads.enabled false festlegen. Wenn Sie dies nicht tun, kannAthena die Länge der Parquet-Datei nicht ermitteln und der Fehler HIVE_CANNOT_OPEN_SPLITtritt auf. Weitere Informationen finden Sie unter Konfigurieren von mehrteiligen Uploads fürAmazon S3 im Management Guide für Amazon EMR.

Geben Sie mithilfe einer der folgenden Möglichkeiten an, dass ein Dataset in Amazon S3 verschlüsselt ist.Bei Verwendung von SSE-KMS ist dieser Schritt nicht erforderlich.

• Verwenden Sie die Anweisung CREATE TABLE (p. 330) mit der Klausel TBLPROPERTIES, die'has_encrypted_data'='true' angibt.

• Verwenden Sie den JDBC-Treiber (p. 76) und legen Sie den Wert von TBLPROPERTIES wie im obigenBeispiel gezeigt fest, wenn Sie CREATE TABLE (p. 330) mit statement.executeQuery()ausführen.

• Verwenden Sie den Assistenten Add table (Tabelle hinzufügen) in der Athena-Konsole und wählenSie Encrypted Data set (Verschlüsseltes Dataset), wenn Sie einen Wert für Location of input data set(Speicherort des Eingabedatasets) festlegen.

214

https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart

https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart


Tabellen, die auf verschlüsselten Daten in Amazon S3 basieren, werden in der Liste Database (Datenbank)mit einem Verschlüsselungssymbol dargestellt.

Berechtigungen für verschlüsselte Metadaten im AWS Glue-Datenkatalog.Wenn Sie Metadaten im AWS Glue-Datenkatalog verschlüsseln, müssen Sie "kms:GenerateDataKey"-,"kms:Decrypt"- und "kms:Encrypt"-Aktionen zu den Richtlinien hinzufügen, die Sie für den Zugriff aufAthena verwenden. Weitere Informationen finden Sie unter Zugriff auf verschlüsselte Metadaten im AWSGlue-Datenkatalog (p. 228).

215


Amazon Athena BenutzerhandbuchVerschlüsselung während der Übertragung

Verschlüsselung während der ÜbertragungZusätzlich zum Verschlüsseln von Daten in Ruhe in Amazon S3 verwendet Amazon Athena die TransportLayer Security (TLS) -Verschlüsselung für Daten während der Übertragung zwischen Athena und AmazonS3 und zwischen Athena und Kundenanwendungen, die darauf zugreifen.

Erlauben Sie nur verschlüsselte Verbindungen über HTTPS (TLS) unter Verwendung dersaws:SecureTransport condition auf Amazon S3-Bucket-IAM-Richtlinien.

Abfrageergebnisse, die zu JDBC- oder ODBC-Clients gestreamt werden, werden mit TLS verschlüsselt.Weitere Informationen über die neuesten Versionen der JDBC- und ODBC-Treibern und ihreDokumentation finden Sie unter Herstellen einer Verbindung mit dem JDBC-Treiber (p. 76) und Herstelleneiner Verbindung mit dem ODBC-Treiber (p. 78).

SchlüsselverwaltungAmazon Athena unterstützt AWS Key Management Service (AWS KMS) zum Verschlüsseln von Datasetsin Amazon S3- und Athena-Abfrageergebnissen. AWS KMS verwendet Kundenmasterschlüssel (CMKs) fürdie Verschlüsselung Ihrer Amazon S3-Objekte und stützt sich auf die Envelope-Verschlüsselung.

Sie können in AWS KMS folgende Aktionen ausführen:

• Erstellen von Schlüsseln• Import Ihres eigenen Schlüsselmaterials für neue CMKs

Weitere Informationen finden Sie unter Was ist der AWS Key Management Service? im AWS KeyManagement Service Developer Guide und unter Wie Amazon Simple Storage Service AWS KMSverwendet. Zum Anzeigen der Schlüssel in Ihrem Konto, die AWS für Sie erstellt und verwaltet, wählen Sieim Navigationsbereich AWS managed keys (Von AWS verwaltete Schlüssel) aus.

Wenn Sie mit SSE-KMS verschlüsselte Objekte hochladen oder darauf zugreifen, benötigen Sie AWSSignature Version 4 für zusätzliche Sicherheit. Weitere Informationen finden Sie unter Angabe derSignature-Version in der Anforderungsauthentifizierung im Entwicklerhandbuch für Amazon Simple StorageService.

Richtlinie für den Datenverkehr zwischen NetzwerkenDer Datenverkehr wird sowohl zwischen Athena und lokalen Anwendungen sowie zwischen Athena undAmazon S3 geschützt. Der Datenverkehr zwischen Athena und anderen Diensten, wie z. B. AWS Glue undAWS Key Management Service, verwendet standardmäßig HTTPS.

• Für Datenverkehr zwischen Athena und lokalen Clients und Anwendungen werden Abfrageergebnisse,die zu JDBC- oder ODBC-Clients gestreamt werden, mit Transport Layer Security (TLS) verschlüsselt.

Sie können eine der Konnektivitätsoptionen zwischen Ihrem privaten Netzwerk und AWS verwenden:• Eine Site-to-Site-VPN AWS VPN-Verbindung. Weitere Informationen finden Sie unter Was ist Site-to-

Site-VPN AWS VPN? im AWS Site-to-Site-VPN-Benutzerhandbuch.• Eine AWS Direct Connect-Verbindung. Weitere Informationen finden Sie unter Was ist AWS Direct

Connect? im AWS Direct Connect-Benutzerhandbuch.• Für Datenverkehr zwischen Athena- und Amazon S3-Buckets verschlüsselt Transport Layer Security

(TLS) die Objekte bei der Übertragung zwischen Athena und Amazon S3 sowie zwischen Athena undKundenanwendungen, die darauf zugreifen; Sie sollten nur verschlüsselte Verbindungen über HTTPS(TLS) unter Verwendung von aws:SecureTransport condition auf Amazon S3-Bucket-IAM-Richtlinien zulassen.

216

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html#Conditions_Boolean

https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#enveloping


https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html


https://docs.aws.amazon.com/AmazonS3/latest/dev/services-s3.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/services-s3.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingAWSSDK.html#specify-signature-version

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingAWSSDK.html#specify-signature-version

https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html

https://docs.aws.amazon.com/vpn/latest/s2svpn/VPC_VPN.html

https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html

https://docs.aws.amazon.com/directconnect/latest/UserGuide/Welcome.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html#Conditions_Boolean

Amazon Athena BenutzerhandbuchIdentitäts- und Zugriffsverwaltung

Identitäts- und Zugriffsverwaltung in AthenaAmazon Athena verwendet AWS Identity and Access Management (IAM)-Richtlinien, um den Zugriff aufAthena-Operationen zu beschränken.

Zum Ausführen von Abfragen in Athena benötigen Sie entsprechende Berechtigungen für:

• Athena API-Aktionen einschließlich zusätzlicher Aktionen für Athena-Arbeitsgruppen (p. 251).• Amazon S3-Standorte, an denen die zugrunde liegenden Daten für die Abfrage gespeichert sind.• Metadaten und Ressourcen, die Sie im AWS Glue-Datenkatalog speichern, wie z. B. Datenbanken und

Tabellen, einschließlich zusätzlicher Aktionen für verschlüsselte Metadaten.

Wenn Sie der Administrator anderer Benutzer sind, müssen Sie sicherstellen, dass deren Benutzerprofilendie entsprechenden Berechtigungen zugewiesen sind.

Themen• Verwaltete Richtlinien für den Benutzerzugriff (p. 217)• Zugriff über JDBC- und ODBC-Verbindungen (p. 221)• Zugriff auf Amazon S3 (p. 221)• Differenzierter Zugriff auf Datenbanken und Tabellen in AWS Glue-Datenkatalog (p. 222)• Zugriff auf verschlüsselte Metadaten im AWS Glue-Datenkatalog (p. 228)• Kontoübergreifender Zugriff (p. 229)• Zugriff auf Arbeitsgruppen und Tags (p. 229)• So gewähren Sie den Zugriff auf eine : (p. 230)• Beispiel für IAM-Berechtigungsrichtlinien, die zulassen (p. 232)• Beispiele für IAM-Berechtigungsrichtlinien, die zulassen (p. 234)• Erlauben des Zugriffs für (p. 236)• Aktivieren des föderierten Zugriffs auf die Athena-API (p. 236)

Verwaltete Richtlinien für den BenutzerzugriffUm Amazon Athena-Service-Aktionen für sich oder andere Benutzer von AWS Identity and AccessManagement (IAM) zuzulassen oder zu verweigern, hängen Sie Prinzipalen wie Benutzern oder Gruppenidentitätsbasierte Richtlinien an.

Jede identitätsbasierte Richtlinie besteht aus Anweisungen, die die zugelassenen oder nicht zugelassenenAktionen definieren. Weitere Informationen und Schritt-für-Schritt-Anweisungen für das Zuweisen einerRichtlinie zu einem Benutzer finden Sie auf der Seite zum Anfügen verwalteter Richtlinien im AWS Identityand Access Management Benutzerhandbuch. Eine Liste von Aktionen finden Sie in der Amazon Athena-API-Referenz.

Verwaltete Richtlinien sind einfach zu nutzen und werden automatisch mit den erforderlichen Aktionenaktualisiert, wenn sich der Service weiterentwickelt.

Athena weist die folgenden verwalteten Richtlinien auf:

• Die verwaltete Richtlinie AmazonAthenaFullAccess gewährt vollständigen Zugriff auf Athena.Fügen Sie sie Benutzern und anderen Prinzipalen an, die Vollzugriff auf Athena benötigen. WeitereInformationen finden Sie unter Verwaltete Richtlinie AmazonAthenaFullAccess (p. 218).

217

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html#attach-managed-policy-console



Amazon Athena BenutzerhandbuchVerwaltete Richtlinien für den Benutzerzugriff

• Die verwaltete Richtlinie AWSQuicksightAthenaAccess gewährt Zugriff auf Aktionen, die AmazonQuickSight für die Integration in Athena benötigt. Fügen Sie diese Richtlinie Prinzipalen an, die AmazonQuickSight in Verbindung mit Athena verwenden. Weitere Informationen finden Sie unter VerwalteteRichtlinie AWSQuicksightAthenaAccess (p. 220).

Vom Kunden verwaltete und eingebundene identitätsbasierte Richtlinien ermöglichen Ihnen, detailliertereAthena-Aktionen innerhalb einer Richtlinie zur Optimierung der Zugriffsregelung anzugeben. Wirempfehlen, dass Sie die AmazonAthenaFullAccess-Richtlinie als Ausgangspunkt verwenden und dannbestimmte, in der Amazon Athena-API-Referenz definierte Aktionen zulassen oder verweigern. WeitereInformationen zu eingebundenen Richtlinien finden Sie unter Verwaltete Richtlinien und eingebundeneRichtlinien im AWS Identity and Access Management Benutzerhandbuch.

Wenn Sie außerdem Prinzipale verwalten, die Verbindungen per JDBC herstellen, müssen Sie die JDBC-Treiber-Anmeldeinformationen für Ihre Anwendung bereitstellen. Weitere Informationen finden Sie in denAngaben zu Service-Aktionen für JDBC-Verbindungen (p. 221).

Wenn Sie AWS Glue mit Athena verwenden, und den AWS Glue-Datenkatalog verschlüsselt haben,müssen Sie zusätzliche Aktionen in den identitätsbasierten IAM-Richtlinien für Athena angeben. WeitereInformationen finden Sie unter Zugriff auf verschlüsselte Metadaten im AWS Glue-Datenkatalog (p. 228).

Important

Wenn Sie Arbeitsgruppen erstellen und verwenden, müssen Sie sicherstellen, dass IhreRichtlinien einen entsprechenden Zugriff auf Arbeitsgruppenaktionen enthalten. DetaillierteInformationen hierzu finden Sie unter the section called “ IAM-Richtlinien für den Zugriff aufArbeitsgruppen” (p. 255) und the section called “Beispiel-Arbeitsgruppenrichtlinien” (p. 256).

Verwaltete Richtlinie AmazonAthenaFullAccessDie verwaltete Richtlinie AmazonAthenaFullAccess gewährt vollständigen Zugriff auf Athena.

Der Inhalt verwalteter Richtlinien kann sich ändern, sodass die hier gezeigte Richtlinie möglicherweise nichtmehr aktuell ist. Suchen Sie in der IAM-Konsole nach der aktuellen Richtlinie.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "athena:*" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "glue:CreateDatabase", "glue:DeleteDatabase", "glue:GetDatabase", "glue:GetDatabases", "glue:UpdateDatabase", "glue:CreateTable", "glue:DeleteTable", "glue:BatchDeleteTable", "glue:UpdateTable", "glue:GetTable",

218


https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html


"glue:GetTables", "glue:BatchCreatePartition", "glue:CreatePartition", "glue:DeletePartition", "glue:BatchDeletePartition", "glue:UpdatePartition", "glue:GetPartition", "glue:GetPartitions", "glue:BatchGetPartition" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket", "s3:ListBucketMultipartUploads", "s3:ListMultipartUploadParts", "s3:AbortMultipartUpload", "s3:CreateBucket", "s3:PutObject" ], "Resource": [ "arn:aws:s3:::aws-athena-query-results-*" ] }, { "Effect": "Allow", "Action": [ "s3:GetObject", "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::athena-examples*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket", "s3:GetBucketLocation", "s3:ListAllMyBuckets" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "sns:ListTopics", "sns:GetTopicAttributes" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "cloudwatch:PutMetricAlarm", "cloudwatch:DescribeAlarms",

219


"cloudwatch:DeleteAlarms" ], "Resource": [ "*" ] } ]}

Verwaltete Richtlinie AWSQuicksightAthenaAccessEine zusätzliche verwaltete Richtlinie, AWSQuicksightAthenaAccess, gewährt Zugriff auf Aktionen,die Amazon QuickSight für die Integration in Athena benötigt. Diese Richtlinie enthält einige Aktionenfür Athena, die entweder veraltet und nicht in der aktuellen öffentlichen API eingebunden sind oder dieausschließlich mit dem JDBC- und ODBC-Treiber verwendet werden. Fügen Sie diese Richtlinie nur zuPrinzipalen hinzu, die Amazon QuickSight mit Athena verwenden.

Der Inhalt verwalteter Richtlinien kann sich ändern, so dass die hier gezeigte Richtlinie möglicherweisenicht mehr aktuell ist. Suchen Sie in der IAM-Konsole nach der aktuellen Richtlinie.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "athena:BatchGetQueryExecution", "athena:CancelQueryExecution", "athena:GetCatalogs", "athena:GetExecutionEngine", "athena:GetExecutionEngines", "athena:GetNamespace", "athena:GetNamespaces", "athena:GetQueryExecution", "athena:GetQueryExecutions", "athena:GetQueryResults", "athena:GetQueryResultsStream", "athena:GetTable", "athena:GetTables", "athena:ListQueryExecutions", "athena:RunQuery", "athena:StartQueryExecution", "athena:StopQueryExecution" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "glue:CreateDatabase", "glue:DeleteDatabase", "glue:GetDatabase", "glue:GetDatabases", "glue:UpdateDatabase", "glue:CreateTable", "glue:DeleteTable", "glue:BatchDeleteTable", "glue:UpdateTable", "glue:GetTable", "glue:GetTables", "glue:BatchCreatePartition",

220

Amazon Athena BenutzerhandbuchZugriff über JDBC- und ODBC-Verbindungen

"glue:CreatePartition", "glue:DeletePartition", "glue:BatchDeletePartition", "glue:UpdatePartition", "glue:GetPartition", "glue:GetPartitions", "glue:BatchGetPartition" ], "Resource": [ "*" ] }, { "Effect": "Allow", "Action": [ "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket", "s3:ListBucketMultipartUploads", "s3:ListMultipartUploadParts", "s3:AbortMultipartUpload", "s3:CreateBucket", "s3:PutObject" ], "Resource": [ "arn:aws:s3:::aws-athena-query-results-*" ] } ]}

Zugriff über JDBC- und ODBC-VerbindungenStellen Sie die JDBC- oder ODBC-Treiber-Anmeldeinformationen für Ihre Anwendung bereit, um Zugriff aufAWS-Services und -Ressourcen wie Athena und Amazon S3-Buckets zu erhalten. Wenn Sie den JDBC-oder ODBC-Treiber verwenden, stellen Sie sicher, dass die IAM-Zugriffsrichtlinie alle der unter VerwalteteRichtlinie AWSQuicksightAthenaAccess (p. 220) genannten Aktionen enthält.

Weitere Informationen über die neuesten Versionen der JDBC- und ODBC-Treibern und ihreDokumentation finden Sie unter Herstellen einer Verbindung mit dem JDBC-Treiber (p. 76) und Herstelleneiner Verbindung mit dem ODBC-Treiber (p. 78).

Zugriff auf Amazon S3Wenn Sie oder Ihre Benutzer Tabellen erstellen und mit zugrunde liegenden Daten arbeiten, müssen sieZugriff auf den Amazon S3-Speicherort der Daten haben. Dieser Zugriff gilt zusätzlich zu den zulässigenAktionen für Athena, die in identitätsbasierten IAM-Richtlinien definiert sind.

Sie können den Zugriff auf Amazon S3-Orte mit identitätsbasierten Richtlinien, Bucket-Ressourcenrichtlinien oder beidem gewähren. Detaillierte Informationen sowie Szenarien zumGewähren des Amazon S3-Zugriffs finden Sie unter Beispiel-Anleitungen: Verwalten des Zugriffs imEntwicklerhandbuch für Amazon Simple Storage Service. Weitere Informationen sowie ein Beispiel fürAmazon S3-Aktionen, die zugelassen werden können, finden Sie in der Beispiel-Bucket-Richtlinie weiterunten unter Kontoübergreifender Zugriff (p. 229).

Note

Athena unterstützt weder das Einschränken noch das Erlauben des Zugriffs auf Amazon S3-Ressourcen auf Grundlage des aws:SourceIp-Bedingungsschlüssels.

221

https://docs.aws.amazon.com/AmazonS3/latest/dev/example-walkthroughs-managing-access.html

Amazon Athena BenutzerhandbuchDifferenzierter Zugriff auf Datenbanken und Tabellen

Differenzierter Zugriff auf Datenbanken und Tabellenin AWS Glue-DatenkatalogWenn Sie AWS Glue-Datenkatalog mit Amazon Athena verwenden, können Sie Richtlinien aufRessourcenebene für die folgenden Data Catalog-Objekte definieren, die in Athena verwendet werden:Datenbanken und Tabellen.

Berechtigungen auf Ressourcenebene werden in identitätsbasierten IAM-Richtlinien definiert.Important

In diesem Abschnitt werden Berechtigungen auf Ressourcenebene in identitätsbasiertenIAM-Richtlinien besprochen. Diese unterscheiden sich von ressourcenbasierten Richtlinien.Weitere Informationen zu den Unterschieden finden Sie unter Identitätsbasierte Richtlinien undressourcenbasierte Richtlinien im AWS Identity and Access Management Benutzerhandbuch.

Beachten Sie für diese Aufgaben folgende Themen:

Zur Ausführung dieserAufgabe

Beachten Sie folgendes Thema

Erstellen einerIAM-Richtlinie, diedifferenzierten Zugriff aufRessourcen definiert

Erstellen von IAM-Richtlinien im AWS Identity and Access ManagementBenutzerhandbuch.

Informationen zu den inAWS Glue verwendetenidentitätsbasierten IAM-Richtlinien

Identitätsbasierte Richtlinien (IAM-Richtlinien) im AWS Glue-Entwicklerhandbuch.

In diesem Abschnitt

• Einschränkungen (p. 222)• Obligatorisch: Zugriffsrichtlinie für die Standarddatenbank und -katalog pro AWS-Region (p. 223)• Tabellenpartitionen und -versionen in AWS Glue (p. 224)• Beispiele für differenzierte Richtlinien (p. 224)

EinschränkungenBerücksichtigen Sie die folgenden Einschränkungen bei Verwendung der differenzierten Zugriffskontrollemit AWS Glue-Datenkatalog und Athena:

• Sie können den Zugriff nur auf Datenbanken und Tabellen beschränken. Differenzierte Zugriffskontrollenwerden auf Tabellenebene angewendet und Sie können den Zugriff auf einzelne Partitionen in einerTabelle nicht einschränken. Weitere Informationen finden Sie unter Tabellenpartitionen und -versionen inAWS Glue (p. 224).

• Athena unterstützt keinen kontoübergreifenden Zugriff auf AWS Glue-Datenkatalog.• AWS Glue-Datenkatalog enthält folgende Ressourcen: CATALOG, DATABASE, TABLE und FUNCTION.

Note

Ressourcen in dieser Liste, die zwischen Athena und AWS Glue-Datenkatalog gleich sind,sind für jedes Konto TABLE, DATABASE und CATALOG. Function ist spezifisch für AWSGlue. Zum Löschen von Aktionen in Athena müssen Sie Berechtigungen für AWS Glue-

222

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html

https://docs.aws.amazon.com/glue/latest/dg/using-identity-based-policies.html


Aktionen einschließen. Weitere Informationen finden Sie unter Beispiele für differenzierteRichtlinien (p. 224).

Die Hierarchie lautet wie folgt: CATALOG ist ein Vorgänger von allen DATABASES in jedem Konto undjede DATABASE ist ein Vorgänger für alle ihre TABLES und FUNCTIONS. Beispiel: Für eine Tabellemit dem Namen table_test einer Datenbank db im Katalog in Ihrem Konto sind ihre Vorgänger dbund der Katalog in Ihrem Konto. Für die db-Datenbank ist ihr Vorgänger der Katalog in Ihrem Kontound ihre untergeordneten Elemente sind Tabellen und Funktionen. Weitere Informationen über diehierarchische Struktur von Ressourcen finden Sie unter Liste der ARNs im Datenkatalog im AWS GlueEntwicklerhandbuch.

• Für jede Nicht-Löschaktion in Athena auf einer Ressource, z. B. CREATE DATABASE, CREATE TABLE,SHOW DATABASE, SHOW TABLE oder ALTER TABLE, benötigen Sie Berechtigungen zum Aufrufendieser Aktion auf dieser Ressource (Tabelle oder Datenbank) und alle Vorrgänger dieser Ressource inData Catalog. Beispielsweise sind die Vorgänger einer Tabelle die Datenbank, zu der sie gehört, undder Katalog für das Konto. Für eine Datenbank ist ihr Vorgänger der Katalog für das Konto. WeitereInformationen finden Sie unter Beispiele für differenzierte Richtlinien (p. 224).

• Für eine Löschaktion in Athena, wie z. B. DROP DATABASE oder DROP TABLE, müssen Sie auchBerechtigungen zum Aufrufen der Aktion auf allen Vorgängern und abhängigen Elemente derRessource in der Data Catalog besitzen. Wenn Sie beispielsweise eine Datenbank löschen, benötigenSie Berechtigungen für die Datenbank, den Katalog, der ihr Vorgänger ist, sowie alle Tabellen undbenutzerdefinierten Funktionen, die ihre Nachfolger sind. Eine Tabelle hat keine Nachfolger. ZurAusführung von DROP TABLE müssen Sie Berechtigungen für diese Aktion auf der Tabelle derDatenbank, zu dem sie gehört, und den Katalog haben. Weitere Informationen finden Sie unter Beispielefür differenzierte Richtlinien (p. 224).

• Wenn Sie den Zugriff auf eine bestimmte Datenbank in Data Catalog beschränken, müssen Sie auchdie Zugriffsrichtlinie für die default-Datenbank und -Katalog für jede AWS-Region für GetDatabase-und CreateDatabase-Aktionen angeben. Wenn Sie Athena in mehreren Regionen verwenden, fügenSie der Richtlinie für den Ressourcen-ARN für jede default-Datenbank und -Katalog in jeder einzelnenRegion eine separate Zeile hinzu.

Wenn Sie beispielsweise GetDatabase Zugriff auf example_db in der Region us-east-1 (N.Virginia)gewähren möchten, nehmen Sie auch die default-Datenbank und -Katalog in die Richtlinie für dieseRegion für zwei Aktionen auf: GetDatabase und CreateDatabase:

{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default", "arn:aws:glue:us-east-1:123456789012:database/example_db" ]}

Obligatorisch: Zugriffsrichtlinie für die Default-Datenbank undden Katalog pro AWS-RegionDamir Athena mit AWS Glue-Datenkatalog funktionieren kann, muss die folgende Zugriffsrichtlinie fürdie default-Datenbank und für AWS Glue-Datenkatalog pro AWS-Region für GetDatabase undCreateDatabase vorhanden sein:

{ "Effect": "Allow",

223

https://docs.aws.amazon.com/glue/latest/dg/glue-specifying-resource-arns.html#data-catalog-resource-arns


"Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default" ]}

Tabellenpartitionen und -versionen in AWS GlueTabellen können in AWS Glue Partitionen und Versionen haben. Tabellenversionen und -partitionen geltennicht als unabhängige Ressourcen in AWS Glue. Zugriff auf die Tabellenversionen und -partitionen wirddurch Erteilen des Zugriffs auf die Tabelle und Vorgängerressourcen für die Tabelle gewährt.

Für die Zwecke der differenzierten Zugriffskontrolle gelten die folgenden Zugriffsberechtigungen:

• Differenzierte Zugriffskontrollen gelten auf Tabellenebene. Sie können den Zugriff nur auf Datenbankenund Tabellen beschränken. Wenn Sie zum Beispiel den Zugriff auf eine partitionierte Tabelle gewähren,gilt dies für alle Partitionen in der Tabelle. Sie können den Zugriff nicht auf einzelne Partitionen innerhalbeiner Tabelle beschränken.

Important

Zugriff auf alle Partitionen in einer Tabelle reicht nicht aus, wenn Sie Aktionen auf Partitionenin AWS Glue ausführen müssen. Um Aktionen für Partitionen auszuführen, benötigen SieBerechtigungen für diese Aktionen. Wenn Sie beispielsweise GetPartitions auf derTabelle myTable in der Datenbank myDB ausführen, benötigen Sie Berechtigungen für die glue:GetPartitions-Aktion in Data Catalog, der myDB-Datenbank und myTable.

• Differenzierte Zugriffskontrollen gelten nicht für Tabellenversionen. Wie bei Partitionen wird der Zugriffauf frühere Versionen einer Tabelle durch den Zugriff auf die Tabellenversions-APIs in AWS Glue in derTabelle und für die Tabellenvorfahren gewährt.

Weitere Informationen zu Berechtigungen für AWS Glue-Aktionen finden Sie unter AWS Glue-API-Berechtigungen: Referenz für Aktionen und Ressourcen im AWS Glue Entwicklerhandbuch.

Beispiele für differenzierte Berechtigungen für Tabellen undDatenbankenIn der folgenden Tabelle sind Beispiele für identitätsbasierte IAM-Richtlinien aufgeführt, die einendifferenzierten Zugriff auf Datenbanken und Tabellen in Athena ermöglichen. Wir empfehlen Ihnen, mitdiesen Beispielen zu beginnen und diese Ihren Anforderungen entsprechend anzupassen, um bestimmteAktionen für einzelne Datenbanken und Tabellen zuzulassen oder zu verweigern.

Diese Beispiele umfassen die Zugriffsrichtlinie für die default-Datenbank und -Katalog fürGetDatabase- und CreateDatabase-Aktionen. Diese Richtlinie wird von Athena und AWS Glue-Datenkatalog für die Zusammenarbeit benötigt. Nehmen Sie bei mehreren AWS-Regionen diese Richtliniefür jede default-Datenbank und ihre Kataloge in einer Zeile für jede Region auf.

Ersetzen Sie außerdem die Namen der example_db-Datenbank und test-Tabelle durch die Namen IhrerDatenbanken und Tabellen.

DDL-Anweisung Beispiel für eine IAM-Zugriffsrichtlinie, die Zugriff auf die Ressource erteilt

CREATE DATABASE Hiermit können Sie die Datenbank mit dem Namen example_db erstellen.

224

https://docs.aws.amazon.com/glue/latest/dg/api-permissions-reference.html

https://docs.aws.amazon.com/glue/latest/dg/api-permissions-reference.html



{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default", "arn:aws:glue:us-east-1:123456789012:database/example_db" ] }

ALTER DATABASE Hiermit können Sie die Eigenschaften für die example_db-Datenbankändern.

{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default" ]},{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:UpdateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/example_db" ] }

225



DROP DATABASE Hiermit können Sie die example_db-Datenbank mit allen darin enthaltenenTabellen löschen.

{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default" ]},{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:DeleteDatabase", "glue:GetTables", "glue:GetTable", "glue:DeleteTable" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/example_db", "arn:aws:glue:us-east-1:123456789012:table/example_db/*", "arn:aws:glue:us-east-1:123456789012:userDefinedFunction/example_db/*" ] }

SHOW DATABASES Hiermit können Sie alle Datenbanken in AWS Glue-Datenkatalog auflisten.

{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase"

], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default" ]}, { "Effect": "Allow", "Action": [ "glue:GetDatabases" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/*" ] }

226



CREATE TABLE Hiermit können Sie eine Tabelle mit dem Namen test in der example_db-Datenbank erstellen.

{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default" ]}, { "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:GetTable", "glue:CreateTable" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/example_db", "arn:aws:glue:us-east-1:123456789012:table/example_db/test" ] }

SHOW TABLES Hiermit können Sie alle Tabellen in der example_db-Datenbank auflisten.

{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default" ]}, { "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:GetTables" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/example_db", "arn:aws:glue:us-east-1:123456789012:table/example_db/*" ] }

227

Amazon Athena BenutzerhandbuchZugriff auf verschlüsselte Metadaten im Data Catalog


DROP TABLE Hiermit können Sie eine partitionierte Tabelle mit dem Namen test in derexample_db-Datenbank löschen. Falls Ihre Tabelle keine Partitionen hat,nehmen Sie keine Aktionen für Partitionen auf.

{ "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:CreateDatabase" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/default" ]}, { "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:GetTable", "glue:DeleteTable", "glue:GetPartitions", "glue:GetPartition", "glue:DeletePartition" ], "Resource": [ "arn:aws:glue:us-east-1:123456789012:catalog", "arn:aws:glue:us-east-1:123456789012:database/example_db", "arn:aws:glue:us-east-1:123456789012:table/example_db/test" ] }

Zugriff auf verschlüsselte Metadaten im AWS Glue-DatenkatalogWenn Sie AWS Glue-Datenkatalog mit Amazon Athena verwenden, können Sie die Verschlüsselung inAWS Glue-Datenkatalog mithilfe der AWS Glue-Konsole oder der API aktivieren. Informationen hierzufinden Sie unter Verschlüsseln Ihres Datenkatalogs im AWS Glue-Entwicklerhandbuch.

Wenn das AWS Glue-Datenkatalog verschlüsselt ist, müssen Sie die folgenden Aktionen allen Richtlinienhinzufügen, die für den Zugriff auf Athena verwendet werden:

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": [ "kms:GenerateDataKey", "kms:Decrypt", "kms:Encrypt" ], "Resource": "(arn of key being used to encrypt the catalog)" }}

228


Amazon Athena BenutzerhandbuchKontoübergreifender Zugriff

Kontoübergreifender ZugriffEin gängiges Amazon Athena-Szenario ist das Gewähren des Zugriffs für Benutzer in einem Konto, dassich von dem des Bucket-Eigentümers unterscheidet, damit diese Abfragen ausführen können. VerwendenSie in diesem Fall eine Bucket-Richtlinie zum Gewähren des Zugriffs.

Die folgende Beispiel-Bucket-Richtlinie, die vom Bucket-Eigentümer erstellt und auf den Bucket s3://my-athena-data-bucket angewendet wurde, gewährt allen Benutzern im Konto 123456789123 Zugriff.Hierbei handelt es sich um ein anderes Konto.

{ "Version": "2012-10-17", "Id": "MyPolicyID", "Statement": [ { "Sid": "MyStatementSid", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789123:root" }, "Action": [ "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket", "s3:ListBucketMultipartUploads", "s3:ListMultipartUploadParts", "s3:AbortMultipartUpload", "s3:PutObject" ], "Resource": [ "arn:aws:s3:::my-athena-data-bucket", "arn:aws:s3:::my-athena-data-bucket/*" ] } ] }

Um einem bestimmten Benutzer in einem Konto Zugriff zu gewähren, ersetzen Sie den SchlüsselPrincipal durch einen Schlüssel, der anstelle von root den Benutzer angibt. Verwenden Sie für dasBenutzerprofil Dave beispielsweise arn:aws:iam::123456789123:user/Dave.

Zugriff auf Arbeitsgruppen und TagsEine Arbeitsgruppe ist eine von Athena verwaltete Ressource. Wenn Ihre Arbeitsgruppenrichtlinie daherAktionen verwaltet, die workgroup als Eingabe verwenden, müssen Sie den ARN der Arbeitsgruppe wiefolgt angeben, wobei workgroup-name der Name Ihrer Arbeitsgruppe ist:

"Resource": [arn:aws:athena:region:AWSAcctID:workgroup/workgroup-name]

Geben Sie zum Beispiel für eine Arbeitsgruppe mit dem Namen test_workgroup in der Region us-west-2 für AWS-Konto 123456789012 die Arbeitsgruppe als Ressource mit dem folgenden ARN an:

"Resource":["arn:aws:athena:us-east-1:123456789012:workgroup/test_workgroup"]

• Eine Liste mit Arbeitsgruppenrichtlinien finden Sie unter the section called “Beispiel-Arbeitsgruppenrichtlinien” (p. 256).

• Eine Liste mit Tag-basierten Richtlinien für Arbeitsgruppen finden Sie unter Tagbasierte IAM-Zugriffssteuerungsrichtlinien (p. 281).

229

Amazon Athena BenutzerhandbuchSo gewähren Sie den Zugriff auf eine :

• Weitere Informationen zum Erstellen von IAM-Richtlinien für Arbeitsgruppen finden Sie unter IAM-Richtlinien für Arbeitsgruppen (p. 255).

• Eine vollständige Liste der Amazon Athena-Aktionen finden Sie unter den API-Aktionsnamen in derAmazon Athena-API-Referenz.

• Weitere Informationen zu IAM-Richtlinien finden Sie unter Erstellen von Richtlinien mit dem Visual Editorim IAM-Benutzerhandbuch.

So gewähren Sie den Zugriff auf eine :Die Beispiele für Berechtigungsrichtlinien in diesem Thema veranschaulichen die erforderlichenzulässigen Aktionen und die Ressourcen, für die sie zulässig sind. Untersuchen Sie diese Richtliniensorgfältig und ändern Sie sie entsprechend Ihren Anforderungen, bevor Sie IAM-Identitäten ähnlicheBerechtigungsrichtlinien anfügen.

• Beispielrichtlinie, die einem IAM-Prinzipal erlaubt, mit Daten abzufragen (p. 230)• Beispielrichtlinie, die einem IAM-Prinzipal das Erstellen eines erlaubt (p. 231)

Example – IAM-Prinzipale können mit Daten abfragen

Die folgende Richtlinie ist den IAM-Prinzipalen zusätzlich zur Richtlinie Verwaltete RichtlinieAmazonAthenaFullAccess (p. 218) angefügt, die vollen Zugriff auf Athena-Aktionen gewährt.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor1", "Effect": "Allow", "Action": [ "lambda:GetFunction", "lambda:GetLayerVersion", "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunction", "arn:aws:lambda:*:MyAWSAcctId:function:AnotherAthenaLambdaFunction", "arn:aws:lambda:*:MyAWSAcctId:layer:MyAthenaLambdaLayer:*" ] }, { "Sid": "VisualEditor2", "Effect": "Allow", "Action": [ "s3:GetBucketLocation", "s3:GetObject", "s3:ListBucket", "s3:PutObject", "s3:ListMultipartUploadParts", "s3:AbortMultipartUpload" ], "Resource": "arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillLocation" } ]}

230


https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-visual-editor

Amazon Athena BenutzerhandbuchSo gewähren Sie den Zugriff auf eine :

Erläuterung der Berechtigungen

Zulässige Aktionen Erklärung

"s3:GetBucketLocation","s3:GetObject","s3:ListBucket","s3:PutObject","s3:ListMultipartUploadParts","s3:AbortMultipartUpload"

s3-Aktionen ermöglichen das Lesenund Schreiben in die Ressource, die als"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillLocation" angegeben ist,wobei MyLambdaSpillLocation den Spill-Bucket identifiziert, der in der Konfiguration deraufgerufenen Lambda-Funktion oder -Funktionenangegeben ist. Die Ressourcenkennungarn:aws:lambda:*:MyAWSAcctId:layer:MyAthenaLambdaLayer:*ist nur erforderlich, wenn Sie eine Lambda-Ebene zur Erstellung benutzerdefinierterLaufzeitabhängigkeiten verwenden, um dieFunktionsartefaktgröße zur Bereitstellungszeit zureduzieren. Der * in der letzten Position ist einPlatzhalter für die Ebenenversion.

"lambda:GetFunction","lambda:GetLayerVersion","lambda:InvokeFunction"

Ermöglicht Abfragen zum Aufruf der imResource-Block angegebenen AWSLambda-Funktionen. Beispielsweisearn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunction,wobei MyAthenaLambdaFunction den Nameneiner Lambda-Funktion angibt, die aufgerufenwerden soll. Es können mehrere Funktionenangegeben werden, wie im Beispiel gezeigt.

Example – IAM-Prinzipale können einen erstellen

Die folgende Richtlinie ist den IAM-Prinzipalen zusätzlich zur Richtlinie Verwaltete RichtlinieAmazonAthenaFullAccess (p. 218) angefügt, die vollen Zugriff auf Athena-Aktionen gewährt.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "lambda:GetFunction", "lambda:ListFunctions", "lambda:GetLayerVersion", "lambda:InvokeFunction", "lambda:CreateFunction", "lambda:DeleteFunction", "lambda:PublishLayerVersion", "lambda:DeleteLayerVersion", "lambda:UpdateFunctionConfiguration", "lambda:PutFunctionConcurrency", "lambda:DeleteFunctionConcurrency" ], "Resource": "arn:aws:lambda:*:MyAWSAcctId: function: MyAthenaLambdaFunctionsPrefix*" } ]}

231

Amazon Athena BenutzerhandbuchZulassen des Zugriffs auf


Erlaubt Abfragen zum Aufruf der AWS Lambda-Funktionen für die AWSLambda-Funktionen, die im Resource-Block angegeben sind- Beispielsweisearn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunction, wobeiMyAthenaLambdaFunction den Namen einer Lambda-Funktion angibt, die aufgerufen werden soll. Eskönnen mehrere Funktionen angegeben werden, wie im Beispiel gezeigt.

Beispiel für IAM-Berechtigungsrichtlinien, die zulassenDie Beispiele für Berechtigungsrichtlinien in diesem Thema veranschaulichen die erforderlichen zulässigenAktionen und die Ressourcen, für die sie zulässig sind. Untersuchen Sie diese Richtlinien sorgfältig undändern Sie sie entsprechend Ihren Anforderungen, bevor Sie diese an IAM-Identitäten anfügen.

• Beispielrichtlinie, die erlaubt, dass ein IAM-Prinzipal ausführt und damit Ergebnisse zurückgibt (p. 232)• Beispielrichtlinie, die erlaubt, dass ein IAM-Prinzipal einen Datenquellenkonnektor erstellt (p. 233)

Example – Zulassen, dass ein IAM-Prinzipal mit Ergebnisse zurückgibt

Die folgende identitätsbasierte Berechtigungsrichtlinie ermöglicht Aktionen, die ein Benutzer oder einanderer IAM-Prinzipal erfordert, um zu verwenden. Prinzipale, die diese Aktionen ausführen dürfen, könnenAbfragen ausführen, die Athena-Kataloge angeben, die einer Verbunddatenquelle zugeordnet sind.



"athena:StartQueryExecution", "athena:GetQueryResults", "athena:GetWorkGroup", "athena:CancelQueryExecution", "athena:StopQueryExecution", "athena:GetQueryExecution",

Athena-Berechtigungen, die zumAusführen von Abfragen in derAmazonAthenaPreviewFunctionality-Arbeitsgruppe erforderlich sind.

"s3:PutObject","s3:GetObject","s3:AbortMultipartUpload"

s3:PutObject unds3:AbortMultipartUploaderlauben das Schreiben vonAbfrageergebnissen in alle Unterordner desAbfrageergebnis-Buckets, wie durch denarn:aws:s3:::MyQueryResultsBucket/*-Ressourcenbezeichner angegeben, wobeiMyQueryResultsBucket der Athena-Abfrageergebnis-Bucket ist. Weitere Informationenfinden Sie unter Arbeiten mit Abfrageergebnissen,Ausgabedateien und dem Abfrageverlauf (p. 115).

s3:GetObject erlaubt das Lesen derAbfrageergebnisse und des Abfrageverlaufs für dieals arn:aws:s3:::MyQueryResultsBucketangegebene Ressource, wobeiMyQueryResultsBucket der Athena-Abfrageergebnis-Bucket ist.

s3:GetObject erlaubtauch das Lesen von der als"arn:aws:s3:::MyLambdaSpillBucket/

232


Zulässige Aktionen ErklärungMyLambdaSpillPrefix*" angegebenenRessource, wobei MyLambdaSpillPrefix in derKonfiguration der aufgerufenen Lambda-Funktionoder -Funktionen angegeben wird.

"lambda:InvokeFunction"Erlaubt Abfragen zum Aufruf der AWSLambda-Funktionen für die AWSLambda-Funktionen, die im Resource-Block angegeben sind- Beispielsweisearn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunction,wobei MyAthenaLambdaFunction den Nameneiner Lambda-Funktion angibt, die aufgerufenwerden soll. Es können mehrere Funktionenangegeben werden, wie im Beispiel gezeigt.

Example – IAM-Prinzipale können Datenquellenkonnektoren erstellen



"lambda:CreateFunction","lambda:ListVersionsByFunction","lambda:GetFunctionConfiguration","lambda:PutFunctionConcurrency","lambda:ListTags","lambda:DeleteFunction","lambda:GetAlias","lambda:InvokeFunction","lambda:GetFunction","lambda:ListAliases","lambda:UpdateFunctionConfiguration","lambda:UpdateFunctionCode","lambda:AddPermission","lambda:DeleteFunctionConcurrency","lambda:RemovePermission","lambda:GetPolicy""lambda:GetAccountSettings","lambda:ListFunctions","lambda:ListEventSourceMappings",

Erlauben der Erstellung und Verwaltung vonLambda-Funktionen, die als Ressourcenaufgeführt sind. In diesem Beispiel wird einNamenspräfix in der Ressourcenkennungarn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunctionsPrefix*verwendet, wobeiMyAthenaLambdaFunctionsPrefix eingemeinsames Präfix ist, das im Namen einerGruppe von Lambda-Funktionen verwendetwird, sodass diese nicht einzeln als Ressourcenangegeben werden müssen. Sie können eine odermehrere Lambda-Funktionsressourcen angeben.

"s3:GetObject"Erlaubt das Lesen eines Buckets, dergemäß der Ressourcenbezeichnungarn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/* für AWSServerless Application Repository erforderlich ist.Dieser Bucket kann spezifisch für Ihr Konto sein.

"cloudformation:*"Erlaubt die Erstellung und Verwaltung von AWSCloudFormation-Stacks, die von der RessourceMyCFStackPrefixangegeben werden. DieseStacks und Stacksets stellen die Art und Weisedar, wie AWS Serverless Application Repository-Konnektoren und UDFs bereitstellt.

"serverlessrepo:*"Erlaubt das Suchen, Anzeigen, Veröffentlichenund Aktualisieren von Anwendungen in

233


Zulässige Aktionen ErklärungAWS Serverless Application Repository,die durch den Ressourcenbezeichnerarn:aws:serverlessrepo:*:*:applications/* angegeben sind.

Beispiele für IAM-Berechtigungsrichtlinien, diezulassenDie Beispiele für Berechtigungsrichtlinien in diesem Thema veranschaulichen die erforderlichenzulässigen Aktionen und die Ressourcen, für die sie zulässig sind. Untersuchen Sie diese Richtliniensorgfältig und ändern Sie sie entsprechend Ihren Anforderungen, bevor Sie IAM-Identitäten ähnlicheBerechtigungsrichtlinien anfügen.

• Beispielrichtlinie, die erlaubt, dass ein IAM-Prinzipal Abfragen ausführt und zurückgibt, die eine -Anweisung enthalten (p. 234)

• Beispielrichtlinie, die einem IAM-Prinzipal erlaubt, ein zu erstellen (p. 235)

Example – IAM-Prinzipale können Abfragen ausführen und zurückgeben, die eine -Anweisungenthalten.

Die folgende identitätsbasierte Berechtigungsrichtlinie erlaubt Aktionen, die ein Benutzer oder ein andererIAM-Prinzipal benötigt, um Abfragen auszuführen, die -Anweisungen verwenden.



"athena:StartQueryExecution", "athena:GetQueryResults", "athena:GetWorkGroup", "athena:CancelQueryExecution", "athena:StopQueryExecution", "athena:GetQueryExecution",

Athena-Berechtigungen, die zumAusführen von Abfragen in derAmazonAthenaPreviewFunctionality-Arbeitsgruppe erforderlich sind.

"s3:PutObject","s3:GetObject","s3:AbortMultipartUpload"

s3:PutObject unds3:AbortMultipartUploaderlauben das Schreiben vonAbfrageergebnissen in alle Unterordner desAbfrageergebnis-Buckets, wie durch denarn:aws:s3:::MyQueryResultsBucket/*-Ressourcenbezeichner angegeben, wobeiMyQueryResultsBucket der Athena-Abfrageergebnis-Bucket ist. Weitere Informationenfinden Sie unter Arbeiten mit Abfrageergebnissen,Ausgabedateien und dem Abfrageverlauf (p. 115).

s3:GetObject erlaubt das Lesen derAbfrageergebnisse und des Abfrageverlaufs für dieals arn:aws:s3:::MyQueryResultsBucketangegebene Ressource, wobeiMyQueryResultsBucket der Athena-Abfrageergebnis-Bucket ist. Weitere Informationen

234


Zulässige Aktionen Erklärungfinden Sie unter Arbeiten mit Abfrageergebnissen,Ausgabedateien und dem Abfrageverlauf (p. 115).

s3:GetObject erlaubtauch das Lesen von der als"arn:aws:s3:::MyLambdaSpillBucket/MyLambdaSpillPrefix*" angegebenenRessource, wobei MyLambdaSpillPrefix in derKonfiguration der aufgerufenen Lambda-Funktionoder -Funktionen angegeben wird.

"lambda:InvokeFunction"Ermöglicht Abfragen zum Aufruf der imResource-Block angegebenen AWSLambda-Funktionen. Beispielsweisearn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunction,wobei MyAthenaLambdaFunction den Nameneiner Lambda-Funktion angibt, die aufgerufenwerden soll. Es können mehrere Funktionenangegeben werden, wie im Beispiel gezeigt.

Example – IAM-Prinzipale können ein erstellen



"lambda:CreateFunction","lambda:ListVersionsByFunction","lambda:GetFunctionConfiguration","lambda:PutFunctionConcurrency","lambda:ListTags","lambda:DeleteFunction","lambda:GetAlias","lambda:InvokeFunction","lambda:GetFunction","lambda:ListAliases","lambda:UpdateFunctionConfiguration","lambda:UpdateFunctionCode","lambda:AddPermission","lambda:DeleteFunctionConcurrency","lambda:RemovePermission","lambda:GetPolicy""lambda:GetAccountSettings","lambda:ListFunctions","lambda:ListEventSourceMappings",

Erlauben der Erstellung und Verwaltung vonLambda-Funktionen, die als Ressourcenaufgeführt sind. In diesem Beispiel wird einNamenspräfix in der Ressourcenkennungarn:aws:lambda:*:MyAWSAcctId:function:MyAthenaLambdaFunctionsPrefix*verwendet, wobeiMyAthenaLambdaFunctionsPrefix eingemeinsames Präfix ist, das im Namen einerGruppe von Lambda-Funktionen verwendetwird, sodass diese nicht einzeln als Ressourcenangegeben werden müssen. Sie können eine odermehrere Lambda-Funktionsressourcen angeben.

"s3:GetObject"Erlaubt das Lesen eines Buckets, dergemäß der Ressourcenbezeichnungarn:aws:s3:::awsserverlessrepo-changesets-1iiv3xa62ln3m/* für AWSServerless Application Repository erforderlich ist.

"cloudformation:*"Erlaubt die Erstellung und Verwaltung von AWSCloudFormation-Stacks, die von der RessourceMyCFStackPrefixangegeben werden. DieseStacks und Stacksets stellen die Art und Weise

235

Amazon Athena BenutzerhandbuchErlauben des Zugriffs für

Zulässige Aktionen Erklärungdar, wie AWS Serverless Application Repository-Konnektoren und UDFs bereitstellt.

"serverlessrepo:*"Erlaubt das Suchen, Anzeigen, Veröffentlichenund Aktualisieren von Anwendungen inAWS Serverless Application Repository,die durch den Ressourcenbezeichnerarn:aws:serverlessrepo:*:*:applications/* angegeben sind.

Erlauben des Zugriffs fürIAM-Prinzipale, die Athena ML-Abfragen ausführen, müssen berechtigt sein, diesagemaker:invokeEndpoint Aktion für Sagemaker-Endpunkte auszuführen, die sie verwenden.Fügen Sie eine Richtlinienanweisung ähnlich der folgenden in identitätsbasierte Berechtigungsrichtlinienein, die an Benutzeridentitäten angefügt sind. Fügen Sie außerdem die Verwaltete RichtlinieAmazonAthenaFullAccess (p. 218) an, die vollen Zugriff auf Athena-Aktionen gewährt, oder einemodifizierte Inline-Richtlinie, die eine Teilmenge von Aktionen ermöglicht.

Ersetzen Sie arn:aws:sagemaker:region:AWSAcctID:ModelEndpoint im Beispiel durch den ARNoder die ARNs von Modellendpunkten, die in Abfragen verwendet werden sollen. Weitere Informationenfinden Sie im Abschnitt Aktionen, Ressourcen und Bedingungsschlüssel für Amazon SageMaker im IAM-Benutzerhandbuch.

{ "Effect": "Allow", "Action": [ "sagemaker:invokeEndpoint" ], "Resource": "arn:aws:sagemaker:us-west-2:123456789012:workteam/public-crowd/default"}

Aktivieren des föderierten Zugriffs auf die Athena-APIIn diesem Abschnitt wird der föderierte Zugriff beschrieben, der Benutzern oder Client-Anwendungenin Ihrer Organisation den Aufruf von Amazon Athena-API-Operationen ermöglicht. In diesem Fallverfügen die Benutzer Ihrer Organisation nicht über direkten Zugriff auf Athena. Stattdessen verwaltenSie Benutzeranmeldeinformationen außerhalb von AWS in Microsoft Active Directory. Active Directoryunterstützt SAML 2.0 (Security Assertion Markup Language 2.0).

In diesem Fall verwenden Sie zur Authentifizierung von Benutzern den JDBC- oder ODBC-Treiber mitSAML 2.0-Unterstützung, der auf die Active Directory Federation Services (AD FS) 3.0 zugreift und Client-Anwendungen den Zugriff auf Athena-API-Operationen ermöglicht.

Weitere Informationen zur SAML 2.0-Unterstützung auf AWS finden Sie unter Informationen zur SAML 2.0-Föderierung im IAM-Benutzerhandbuch.

Note

Der föderierte Zugriff auf die Athena-API wird für eine bestimmte Art von Identitätsanbieter(IdP) unterstützt, nämlich den Active Directory Federation Service (AD FS 3.0), der Teil vonWindows Server ist. Der Zugriff wird durch die Versionen von JDBC- bzw. ODBC-Treibernhergestellt, die SAML 2.0 unterstützen. Weitere Informationen finden Sie unter Verwenden vonAthena mit dem JDBC-Treiber (p. 76) und Verbindung zu Amazon Athena mit ODBC (p. 78).

236

https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html

https://wiki.oasis-open.org/security



Amazon Athena BenutzerhandbuchAktivieren des föderierten Zugriffs auf die Athena-API

Themen• Bevor Sie beginnen (p. 237)• Architekturdiagramm (p. 237)• Verfahren: SAML-basierter föderierter Zugriff auf die Athena-API (p. 238)

Bevor Sie beginnenStellen Sie vor Beginn sicher, dass die folgenden Voraussetzungen erfüllt sind:

• Installieren und konfigurieren Sie AD FS 3.0 innerhalb Ihrer Organisation als IdP.• Installieren und konfigurieren Sie die neuesten verfügbaren Versionen der JDBC- oder ODBC-Treiber auf

Clients, die für den Zugriff auf Athena verwendet werden. Der Treiber muss mit dem föderierten Zugriffmit SAML 2.0 kompatible Unterstützung bieten. Weitere Informationen finden Sie unter Verwenden vonAthena mit dem JDBC-Treiber (p. 76) und Verbindung zu Amazon Athena mit ODBC (p. 78).

ArchitekturdiagrammDas folgende Diagramm veranschaulicht diesen Prozess.

1. Ein Benutzer in Ihrer Organisation verwendet eine Client-Anwendung mit dem JDBC- oder ODBC-Treiber, um eine Authentifizierung vom Identitätsanbieter Ihrer Organisation anzufordern. DerIdentitätsanbieter ist AD FS 3.0.

2. Der Identitätsanbieter authentifiziert den Benutzer anhand von Active Directory, dem IdentitätsspeicherIhrer Organisation.

3. Der Identitätsanbieter konstruiert eine SAML-Zusicherung mit Informationen über den Benutzer undsendet die Zusicherung über den JDBC- oder ODBC-Treiber an die Client-Anwendung.

4. Der JDBC- oder ODBC-Treiber ruft die AWS Security Token Service-API-OperationAssumeRoleWithSAML auf und übergibt ihr dabei die folgenden Parameter:• Den ARN des SAML-Anbieters• Den ARN der zu übernehmenden Rolle

237

https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRoleWithSAML.html

Amazon Athena BenutzerhandbuchAktivieren des föderierten Zugriffs auf die Athena-API

• Die SAML-Zusicherung des Identitätsanbieters

Weitere Informationen finden Sie unter AssumeRoleWithSAML im AWS Security Token Service APIReference.

5. Die API-Antwort an die Client-Anwendung über den JDBC- oder ODBC-Treiber umfasst temporäreSicherheitsanmeldeinformationen.

6. Die Client-Anwendung verwendet die temporären Sicherheitsanmeldeinformationen zum Aufrufen vonAthena-API-Operationen, so dass Ihre Benutzer auf Athena-API-Operationen zugreifen können.

Verfahren: SAML-basierter föderierter Zugriff auf die Athena-APIDas Verfahren umfasst Schritte, die eine Vertrauensbeziehung zwischen dem Identitätsanbieter IhrerOrganisation und Ihrem AWS-Konto schaffen, um den SAML-basierten föderierten Zugriff auf die AmazonAthena-API-Operation zu gewährleisten.

Den föderierten Zugriff auf die Athena-API aktivieren Sie wie folgt:

1. Registrieren Sie AWS in Ihrer Organisation als Dienstanbieter in Ihrem Identitätsanbieter. DieserProzess wird als Vertrauensstellung der vertrauenden Seite bezeichnet. Weitere Informationen findenSie unter Konfigurieren des SAML 2.0-Identitätsanbieters mit der Vertrauensstellung der vertrauendenSeite im IAM-Benutzerhandbuch. Führen Sie als Teil dieser Aufgabe die folgenden Schritte aus:

a. Rufen Sie das Beispiel-SAML-Metadatendokument von dieser URL ab: https://signin.aws.amazon.com/static/saml-metadata.xml.

b. Erstellen Sie im Identitätsanbieter Ihrer Organisation (AD FS) eine entsprechende Metadaten-XML-Datei, die Ihren Identitätsanbieter als Identitätsanbieter für AWS beschreibt. DieMetadatendatei muss den Namen des Ausstellers, ein Erstellungsdatum, ein Ablaufdatum undSchlüssel enthalten, die AWS verwendet, um Authentifizierungsantworten (Zusicherungen) vonIhrer Organisation zu überprüfen.

2. In der IAM-Konsole erstellen Sie eine SAML-Identitätsanbietereinheit. Weitere Informationen finden Sieunter Erstellen von SAML-Identitätsanbietern im IAM-Benutzerhandbuch. Tun Sie im Rahmen diesesSchritts Folgendes:

a. Öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.b. Laden Sie das SAML-Metadatendokument hoch, das der Identitätsanbieter (AD FS) im Rahmen

von Schritt 1 dieses Verfahrens erstellt hat.3. Erstellen Sie in der IAM-Konsole mindestens eine IAM-Rolle für Ihren Identitätsanbieter. Weitere

Informationen finden Sie unter Erstellen von Rollen für externe Identitätsanbieter (Verbund) im IAM-Benutzerhandbuch. Tun Sie im Rahmen dieses Schritts Folgendes:

• Führen Sie in der Berechtigungsrichtlinie der Rolle Aktionen auf, die Benutzer Ihrer Organisation inAWS ausführen dürfen.

• Legen Sie in der Vertrauensrichtlinie der Rolle die SAML-Anbieter-Entity als Prinzipal fest, die Sie inSchritt 2 dieses Verfahrens erstellt haben.

Dies baut eine Vertrauensstellung zwischen Ihrer Organisation und AWS auf.4. Definieren Sie im Identitätsanbieter Ihrer Organisation (AD FS) Zusicherungen, in denen Benutzer

oder Gruppen in Ihrer Organisation den IAM-Rollen zugeordnet werden. Die Zuweisung von Benutzernund Gruppen zu den IAM-Rollen wird auch als Anspruchsregel bezeichnet. Beachten Sie, dassunterschiedliche Benutzer und Gruppen in Ihrer Organisation unterschiedlichen IAM-Rollen zugeordnetwerden können.

Weitere Informationen zum Konfigurieren der Zuweisung in ADFS finden Sie im Blog-Beitrag EnablingFederation to AWS Using Windows Active Directory, ADFS, and SAML 2.0.

238


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html

https://signin.aws.amazon.com/static/saml-metadata.xml

https://signin.aws.amazon.com/static/saml-metadata.xml

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html

aws.amazon.com/blogssecurity/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/

aws.amazon.com/blogssecurity/enabling-federation-to-aws-using-windows-active-directory-adfs-and-saml-2-0/

Amazon Athena BenutzerhandbuchProtokollieren und überwachen

5. Installieren und konfigurieren Sie den JDBC- oder ODBC-Treiber mit SAML 2.0-Unterstützung. WeitereInformationen finden Sie unter Verwenden von Athena mit dem JDBC-Treiber (p. 76) und Verbindungzu Amazon Athena mit ODBC (p. 78).

6. Geben Sie die Verbindungszeichenfolge aus Ihrer Anwendung im JDBC- bzw. ODBC-Treiber an.Weitere Informationen zu der Verbindungszeichenfolge, die Ihre Anwendung verwenden muss, findenSie unter dem Thema "Verwendung des Anmeldeinformationsanbieters Active Directory FederationServices (ADFS)" im JDBC-Treiberinstallations- and konfigurationshandbuch bzw. einem ähnlichenThema im ODBC-Treiberinstallations- and konfigurationshandbuch.

Die allgemeine Zusammenfassung der Konfiguration der Verbindungszeichenfolge für die Treiber istwie folgt:

1. Stellen Sie in AwsCredentialsProviderClass configuration dencom.simba.athena.iamsupport.plugin.AdfsCredentialsProvider ein, um anzugeben,dass Sie die SAML 2.0-basierte Authentifizierung über den Identitätsanbieter AD FS nutzenmöchten.

2. Geben Sie für idp_host den Hostnamen des AD FS-Identitätsanbieterservers an.3. Geben Sie für idp_port die Nummer des Ports an, auf dem der AD FS-Identitätsanbieter auf die

SAML-Zusicherungsanfrage hört.4. Geben Sie für UID und PWD die AD-Domänenbenutzer-Anmeldeinformationen an. Wenn Sie den

Treiber auf Windows verwenden und UID und PWD nicht angegeben sind, versucht der Treiber, dieAnmeldeinformationen des Benutzers abzurufen, der an dem Windows-Computer angemeldet ist.

5. Optional können Sie für ssl_insecure den Wert true festlegen. In diesem Fall überprüft derTreiber nicht die Authentizität des SSL-Zertifikats für den ADFS-Identitätsanbieterserver. DieEinstellung auf true ist erforderlich, wenn das SSL-Zertifikat des Identitätsanbieters ADFS nichtvom Treiber als vertrauenswürdig konfiguriert wurde.

6. Zum Aktivieren der Zuweisung eines Active Directory-Domänenbenutzers bzw. einer Gruppezu mindestens einer IAM-Rolle (wie in Schritt 4 dieses Verfahrens erwähnt) geben Sie in derpreferred_role für die JDBC- bzw. ODBC-Verbindung die IAM-Rolle (ARN) an, die für dieTreiberverbindung übernommen werden soll. Die Angabe der preferred_role ist optional, abernützlich, wenn die Rolle nicht die erste in der Anspruchsregel aufgeführte Rolle ist.

Aufgrund dieses Verfahrens werden die folgenden Aktionen ausgeführt:

1. Der JDBC- bzw. ODBC-Treiber ruft die AWS STS-API AssumeRoleWithSAML auf und übergibt ihrdie Zusicherungen, wie in Schritt 4 des Architekturdiagramms (p. 237) abgebildet.

2. AWS stellt sicher, dass die Anforderung zum Übernehmen der Rolle vom Identitätsanbieter stammt,auf den in der SAML-Anbieter-Entity verwiesen wird.

3. Wenn die Anfrage erfolgreich ist, gibt die AWS STS-API-Operation AssumeRoleWithSAMLeineReihe temporärer Sicherheitsanmeldeinformationen zurück, die Ihre Client-Anwendung verwendet,um signierte Anforderungen an Athena zu stellen.

Ihre Anwendung verfügt nun über Informationen zum aktuellen Benutzer und kannprogrammgesteuert auf Athena zugreifen.

Protokollieren und überwachen in AthenaUm Vorfälle zu erkennen, Benachrichtigungen zu Vorfällen zu erhalten und um darauf zu reagieren,verwenden Sie diese Optionen mit Amazon Athena:

• Monitor (Überwachen)Athena mit AWS CloudTrail – AWS CloudTrail bietet eine Aufzeichnung vonAktionen eines Benutzers, einer Rolle oder eines AWS-Services in Athena. Es erfasst Aufrufe überdie Athena-Konsole und Code-Aufrufe der Athena-API-Operationen als Ereignisse. Damit können Siedie an Athena ergangene Anfrage erkennen, die IP-Adresse, von der die Anfrage ausgegangen ist,

239





https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

Amazon Athena BenutzerhandbuchCompliance-Validierung

wer die Anfrage getätigt hat, wann sie erfolgte, sowie weitere Einzelheiten. Sie können mit Athenaauch CloudTrail-Protokolldateien abfragen. Weitere Informationen finden Sie unter Abfragen von AWSCloudTrail-Protokollen (p. 190) und CloudTrail SerDe (p. 294).

• Verwenden Sie CloudWatch-Ereignisse mit Athena – CloudWatch-Ereignisse bietet einen Stream vonSystemereignissen nahezu in Echtzeit, der Änderungen in AWS-Ressourcen beschreibt. CloudWatch-Ereignisse bemerkt operationale Veränderungen, sobald diese auftreten, reagiert auf diese, und führtbei Bedarf Korrekturmaßnahmen durch, indem es an die Umgebung Nachrichten versendet, Funktionenaktiviert, Änderungen vornimmt und Statusinformationen erfasst. Um CloudWatch-Ereignisse mit Athenazu verwenden, erstellen Sie eine Regel, die bei einem Athena-API-Aufruf über CloudTrail ausgelöst wird:Weitere Informationen finden Sie unter Erstellen einer CloudWatch-Ereignisse-Regel, die bei einemAWS-API-Aufruf mit CloudTrail ausgelöst wird im Benutzerhandbuch für Amazon CloudWatch Events.

• Verwenden Sie Arbeitsgruppen zum Trennen von Benutzern, Teams, Anwendungen oder Arbeitslastensowie zum Einrichten von Abfragegrenzwerten und zur Begrenzung von Abfragekosten – Sie könnenabfragebezogene Metriken in Amazon CloudWatch anzeigen, Abfragekosten durch die Konfigurationvon Grenzwerten für die Menge der gescannten Daten steuern, Schwellwerte einrichten sowie Aktionenwie etwa Amazon SNS-Alarme auslösen, wenn diese Grenzwerte überschritten werden. Das allgemeineVerfahren finden Sie unter Einrichten von Arbeitsgruppen (p. 253). Verwenden Sie IAM-Berechtigungenauf Ressourcenebene für die Steuerung des Zugriffs auf eine bestimmte Arbeitsgruppe. WeitereInformationen finden Sie unter Verwenden von Arbeitsgruppen zum Ausführen von Abfragen (p. 251)und Kontrollieren von Kosten und Überwachung von Abfragen mit CloudWatch-Metriken (p. 270).

Compliance-Validierung für Amazon AthenaDie Auditoren Dritter bewerten die Sicherheit und die Compliance von Amazon Athena im Rahmenmehrerer AWS-Compliance-Programme. Hierzu zählen unter anderem SOC, PCI, FedRAMP und andere.

Eine Liste der AWS-Services, die von bestimmten Compliance-Programmen abgedeckt werden, finden Sieunter Von Compliance-Programmen abgedeckte AWS-Services. Allgemeine Informationen finden Sie unterAWS-Compliance-Programme.

Die Auditberichte von Drittanbietern lassen sich mit AWS Artifact herunterladen. Weitere Informationenfinden Sie unter Herunterladen von Berichten in AWS Artifact.

Ihre Compliance-Verantwortung bei der Verwendung Athena wird durch die Sensibilität Ihrer Daten, dieCompliance-Ziele Ihres Unternehmens und die geltenden Gesetze und Vorschriften bestimmt. AWS bietetdie folgenden Ressourcen zur Unterstützung bei der Compliance:

• Kurzanleitungen für Sicherheit und Compliance – In diesen Bereitstellungsleitfäden finden Sie wichtigeÜberlegungen zur Architektur sowie die einzelnen Schritte zur Bereitstellung von sicherheits- undCompliance-orientierten Basisumgebungen in AWS.

• Whitepaper zur Erstellung einer Architektur mit HIPAA-konformer Sicherheit und Compliance – DiesesWhitepaper beschreibt, wie Unternehmen mithilfe von AWS HIPAA-konforme Anwendungen erstellen.

• AWS-Compliance-Ressourcen: Diese Arbeitsbücher und Leitfäden könnten für Ihre Branche und IhrenStandort interessant sein.

• AWS Config: Dieser AWS-Service bewertet, zu welchem Grad die Konfiguration Ihrer Ressourcen deninternen Vorgehensweisen, Branchenrichtlinien und Vorschriften entspricht.

• AWS Security Hub: Dieser AWS-Service liefert einen umfassenden Überblick über den Sicherheitsstatusin AWS. So können Sie die Compliance mit den Sicherheitsstandards in der Branche und den bewährtenMethoden abgleichen.

Resilienz in AthenaIm Zentrum der globalen AWS-Infrastruktur stehen AWS-Regionen und Availability Zones. AWS-Regionenstellen mehrere physisch getrennte und isolierte Availability Zones bereit, die über hoch redundante

240

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-CloudTrail-Rule.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/Create-CloudWatch-Events-CloudTrail-Rule.html

http://aws.amazon.com/compliance/services-in-scope/

http://aws.amazon.com/compliance/programs/

https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html

http://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance

https://d0.awsstatic.com/whitepapers/compliance/AWS_HIPAA_Compliance_Whitepaper.pdf

http://aws.amazon.com/compliance/resources/

https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html

https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html

Amazon Athena BenutzerhandbuchSicherheit der Infrastruktur

Netzwerke mit niedriger Latenz und hohen Durchsätzen verbunden sind. Mithilfe von Availability Zoneskönnen Sie Anwendungen und Datenbanken erstellen und ausführen, die automatisch Failover zwischenAvailability Zones ausführen, ohne dass es zu Unterbrechungen kommt. Availability Zones sind besserhoch verfügbar, fehlertoleranter und skalierbarer als herkömmliche Infrastrukturen mit einem oder mehrerenRechenzentren.

Weitere Informationen zu AWS-Regionen und Availability Zones finden Sie unter Globale AWS-Infrastruktur.

Neben der globalen AWS-Infrastruktur stellt Athena verschiedene Funktionen bereit, um IhrenAnforderungen an Ausfallsicherheit und Datensicherung gerecht zu werden.

Athena verwendet keine Server, daher muss keine Infrastruktur eingerichtet oder verwaltet werden. Athenaist hoch verfügbar und führt Abfragen mithilfe von Computerressourcen in mehreren Availability Zonesdurch, wobei Abfragen automatisch entsprechend umgeleitet werden, wenn eine bestimmte AvailabilityZone nicht erreichbar ist. Athena verwendet Amazon S3 als zugrunde liegenden Datenspeicher, wodurchIhre Daten hoch verfügbar und beständig sind. Amazon S3 bietet eine beständige Infrastruktur zumSpeichern wichtiger Daten und ist für eine Beständigkeit von 99,999999999 % der Objekte konzipiert.Ihre Daten werden redundant an mehreren Standorten und auf mehreren Geräten an jedem Standortgespeichert.

Sicherheit der Infrastruktur in AthenaAls verwalteter Service ist Amazon Athena durch die globalen Verfahren zur Gewährleistung derNetzwerksicherheit von AWS geschützt, die im Whitepaper Amazon Web Services: Übersicht über dieSicherheitsprozesse beschrieben sind.

Sie verwenden von AWS veröffentlichte API-Aufrufe, um über das Netzwerk auf Athena zuzugreifen.Clients müssen TLS (Transport Layer Security) 1.0 unterstützen. Wir empfehlen TLS 1.2 oder höher.Clients müssen außerdem Cipher Suites mit PFS (Perfect Forward Secrecy) wie DHE (EphemeralDiffie-Hellman) oder ECDHE (Elliptic Curve Ephemeral Diffie-Hellman) unterstützen. Die meistenmodernen Systemen wie Java 7 und höher unterstützen diese Modi. Außerdem müssen Anforderungenmit einer Zugriffsschlüssel-ID und einem geheimen Zugriffsschlüssel signiert sein, der mit einem IAM-Prinzipal verknüpft ist. Alternativ können Sie mit AWS Security Token Service (AWS STS) temporäreSicherheitsanmeldeinformationen erstellen, um die Anforderungen zu signieren.

Verwenden Sie IAM-Richtlinien zum Einschränken des Zugriffs auf Athena-Operationen. Von Athenaverwaltete Richtlinien (p. 217) sind einfach zu nutzen und werden automatisch mit den erforderlichenAktionen aktualisiert, wenn sich der Service weiterentwickelt. Vom Kunden verwaltete und eingebundeneRichtlinien ermöglichen Ihnen die Optimierung von Richtlinien, indem Sie detailliertere Athena-Aktionenin der Richtlinie angeben. Gewähren Sie geeigneten Zugriff auf den Amazon S3-Speicherort der Daten.Ausführliche Informationen sowie Szenarien zum Gewähren von Amazon S3-Zugriff finden Sie unterBeispiel-Anleitungen: Verwalten des Zugriffs im Amazon Simple Storage Service Entwicklerhandbuch.Weitere Informationen sowie ein Beispiel für Amazon S3-Aktionen, die zuzulassen sind, finden Sie in derBeispiel-Bucket-Richtlinie unter Kontoübergreifender Zugriff (p. 229).

Themen• Herstellen einer Verbindung mit Amazon Athena über einen Schnittstellen-VPC-Endpunkt (p. 241)

Herstellen einer Verbindung mit Amazon Athena übereinen Schnittstellen-VPC-EndpunktSie können sich direkt mit Athena über einen Schnittstellen-VPC-Endpunkt (AWS PrivateLink) in IhrerVirtual Private Cloud (VPC) verbinden, anstatt eine Verbindung über das Internet herzustellen. Wenn

241

http://aws.amazon.com/about-aws/global-infrastructure/

http://aws.amazon.com/about-aws/global-infrastructure/

https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf


https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/example-walkthroughs-managing-access.html

https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html

Amazon Athena BenutzerhandbuchHerstellen einer Verbindung mit Amazon

Athena über einen Schnittstellen-VPC-Endpunkt

Sie einen Schnittstellen-VPC-Endpunkt verwenden, findet die Kommunikation zwischen Ihrer VPC undAthena vollständig innerhalb des AWS-Netzwerks statt. Jeder VPC-Endpunkt wird durch eine oder mehrereelastische Netzwerkschnittstellen (ENIs) mit privaten IP-Adressen in Ihren VPC-Subnetzen repräsentiert.

Der Schnittstellen-VPC-Endpunkt verbindet Ihre VPC direkt mit Athena, ohne ein Internet-Gateway, einNAT-Gerät, eine VPN-Verbindung oder eine AWS Direct Connect-Verbindung. Die Instances in Ihrer VPCbenötigen für die Kommunikation mit der Athena-API keine öffentlichen IP-Adressen.

Um Athena über Ihre VPC zu verwenden, müssen Sie für die Verbindung eine Instance innerhalb Ihrer VPCverwenden oder Ihr privates Netzwerk mit Ihrer VPC verbinden. Dies erreichen Sie mithilfe eines AmazonVirtual Private Network (VPN) oder mit AWS Direct Connect. Informationen zu Amazon VPN finden Sieunter VPN-Verbindungen im Amazon Virtual Private Cloud Benutzerhandbuch. Informationen zu AWSDirect Connect finden Sie unter Erstellen einer Verbindung im AWS Direct Connect Benutzerhandbuch.

Note

AWS PrivateLink für Athena wird in der Region Europa (Stockholm) nicht unterstützt. Athenaunterstützt VPC-Endpunkte in allen anderen AWS-Regionen, in denen sowohl Amazon VPC alsauch Athena verfügbar sind.

Sie können über die AWS-Konsole oder AWS Command Line Interface (AWS CLI)-Befehle einenSchnittstellen-VPC-Endpunkt erstellen, um eine Verbindung zu Athena herzustellen. Weitere Informationenfinden Sie unter Erstellen eines Schnittstellenendpunkts.

Wenn Sie nach dem Erstellen eines Schnittstellen-VPC-Endpunkts private DNS-Hostnamen für denEndpunkt aktivieren, wird der Athena-Standardendpunkt (https://athena.Region.amazonaws.com) in IhrenVPC-Endpunkt aufgelöst.

Wenn Sie keine privaten DNS-Hostnamen aktivieren, stellt Amazon VPC einen DNS-Endpunktnamenbereit, den Sie im folgenden Format verwenden können:

VPC_Endpoint_ID.athena.Region.vpce.amazonaws.com

Weitere Informationen finden Sie unter Schnittstellen-VPC-Endpunkte (AWS PrivateLink) im Amazon VPCBenutzerhandbuch.

Athena unterstützt Aufrufe aller API-Aktionen innerhalb Ihrer VPC.

Erstellen einer VPC-Endpunktrichtlinie für AthenaSie können eine Richtlinie für Amazon VPC-Endpunkte für Athena erstellen, in der Sie Folgendes angeben:

• Den Prinzipal, der die Aktionen ausführen kann.• Die Aktionen, die ausgeführt werden können.• Die Ressourcen, für die Aktionen ausgeführt werden können.

Weitere Informationen finden Sie unter Steuerung des Zugriffs auf Services mit VPC-Endpunkten imAmazon VPC Benutzerhandbuch.

Example – VPC-Endpunktrichtlinie für Athena-Aktionen

Der Endpunkt, an den diese Richtlinie angefügt ist, gewährt allen Prinzipalen in workgroupA Zugriff auf dieaufgeführten athena-Aktionen.

{ "Statement": [{ "Principal": "*",

242

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html

https://docs.aws.amazon.com/vpc/latest/userguide/vpn-connections.html

https://docs.aws.amazon.com/directconnect/latest/UserGuide/create-connection.html

https://docs.aws.amazon.com/general/latest/gr/rande.html#vpc_region


https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint

https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_Operations.html

https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html

Amazon Athena BenutzerhandbuchKonfigurations- und Schwachstellenanalyse

"Effect": "Allow", "Action": [ "athena:StartQueryExecution", "athena:RunQuery", "athena:GetQueryExecution", "athena:GetQueryResults", "athena:CancelQueryExecution", "athena:ListWorkGroups", "athena:GetWorkGroup", "athena:TagResource" ], "Resource": [ "arn:aws:athena:us-west-1:AWSAccountId:workgroup/workgroupA" ] }]}

Konfigurations- und Schwachstellenanalyse inAthena

Athena verwendet keine Server, daher muss keine Infrastruktur eingerichtet oder verwaltet werden. AWSwickelt grundlegende Sicherheitsaufgaben wie das Patching von Gastbetriebssystemen und Datenbanken,die Firewall-Konfiguration sowie die Notfallwiederherstellung ab. Diese Verfahren wurden von qualifiziertenDritten überprüft und zertifiziert. Weitere Informationen finden Sie in den folgenden Ressourcen:

• Modell der übergreifenden Verantwortlichkeit• Amazon Web Services: Übersicht über Sicherheitsverfahren (Whitepaper)

Verwenden von Athena zum Abfragen von Daten,die in AWS Lake Formation registriert sind

Mit AWS Lake Formation können Sie Zugriffsrichtlinien auf Datenbank-, Tabellen- und Spaltenebenedefinieren und durchsetzen, wenn Sie Athena Abfragen verwenden, um in Amazon S3 gespeicherteDaten zu lesen. Lake Formation bietet eine Autorisierungs- und Governance-Ebene für in Amazon S3gespeicherte Daten. Sie können in Lake Formation eine Hierarchie von Berechtigungen verwenden, umBerechtigungen zum Lesen von Datenkatalogobjekten wie Datenbanken, Tabellen und Spalten zu erteilenoder zu widerrufen. Lake Formation vereinfacht die Verwaltung von Berechtigungen und ermöglicht Ihnendie Implementierung einer differenzierten Zugriffskontrolle (FGAC) für Ihre Daten.

Mit Athena können Sie sowohl Daten abfragen, die in Lake Formation registriert sind, als auch Daten, dienicht in Lake Formation registriert sind.

Lake Formation-Berechtigungen gelten, wenn Sie Athena verwenden, um Quelldaten aus Amazon S3-Standorten abzufragen, die in Lake Formation registriert sind. Lake Formation-Berechtigungen geltenauch, wenn Sie Datenbanken und Tabellen erstellen, die auf registrierte Amazon S3-Datenspeicherorteverweisen. Um Athena mit Daten zu verwenden, die in Lake Formation registriert wurden, muss Athena fürdie Verwendung der AWS Glue-Datenkatalog konfiguriert werden.

Lake Formation-Berechtigungen gelten weder beim Schreiben von Objekten in Amazon S3 noch beimAbfragen von Daten, die in Amazon S3 gespeichert sind, oder bei Metadaten, die nicht in Lake Formationregistriert sind. Für Quelldaten in Amazon S3 und Metadaten, die nicht in Lake Formation registriert sind,wird der Zugriff durch IAM-Berechtigungsrichtlinien für Amazon S3- und AWS Glue-Aktionen bestimmt.

243



https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html

Amazon Athena BenutzerhandbuchFunktionsweise des Lake Formation-Datenzugriffs

Speicherorte für Athena-Abfrageergebnisse in Amazon S3 können nicht in Lake Formation und IAM-Berechtigungsrichtlinien für den Amazon S3-Kontrollzugriff registriert werden. Darüber hinaus geltenLake Formation-Berechtigungen nicht für den Athena-Abfrageverlauf. Sie können Athena-Workgroupsverwenden, um den Zugriff auf den Abfrageverlauf zu steuern.

Weitere Informationen zu Lake Formation finden Sie in den Häufig gestellten Fragen zu Lake Formationsowie im AWS Lake Formation-Entwicklerhandbuch.

Themen• So greift Athena auf Daten zu, die in Lake Formation registriert sind (p. 244)• Überlegungen und Einschränkungen bei der Verwendung von Athena zur Abfrage von Daten, die in

Lake Formation registriert sind (p. 245)• Verwalten von Lake Formation- und Athena-Benutzerberechtigungen (p. 247)• Anwenden von Lake Formation-Berechtigungen auf vorhandene Datenbanken und Tabellen (p. 250)

So greift Athena auf Daten zu, die in Lake Formationregistriert sindDer in diesem Abschnitt beschriebene Zugriffs-Workflow gilt nur, wenn Athena-Abfragen für AmazonS3-Standorte und -Metadatenobjekte ausgeführt werden, die in Lake Formation registriert sind. WeitereInformationen finden Sie unter Registrieren eines Data Lake im AWS Lake Formation Developer Guide.Zusätzlich zur Registrierung von Daten wendet der Lake Formation-Administrator Lake Formation-Berechtigungen an, die den Zugriff auf Metadaten in der Data Catalog und dem Datenspeicherortin Amazon S3 gewähren oder widerrufen. Weitere Informationen finden Sie unter Sicherheit undZugriffskontrolle für Metadaten und Daten im AWS Lake Formation Developer Guide.

Jedes Mal, wenn ein Athena-Prinzipal (Benutzer, Gruppe oder Rolle) eine Abfrage für Daten ausführt, diein Lake Formation registriert wurden, überprüft Lake Formation, ob der Prinzipal über die entsprechendenLake Formation-Berechtigungen für die Datenbank, Tabelle und den Amazon S3-Speicherort verfügt,wie für die Abfrage geeignet. Wenn der Prinzipal Zugriff hat, bietet Lake Formation Athena temporäreAnmeldeinformationen und die Abfrage wird ausgeführt.

Das folgende Diagramm veranschaulicht den oben beschriebenen Ablauf.

Das folgende Diagramm zeigt, wie das Anbieten von Anmeldeinformationen in Athena je nach Abfrage füreine hypothetische SELECT-Abfrage in einer Tabelle mit einem in Lake Formation registrierten Amazon S3-Standort funktioniert:

244

https://aws.amazon.com/lake-formation/faqs/

https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html

https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html

https://docs.aws.amazon.com/lake-formation/latest/dg/security-data-access.html#security-data-access-permissions



1. Ein Prinzipal führt eine SELECT-Abfrage in Athena aus.2. Athena analysiert die Abfrage und prüft die Lake Formation-Berechtigungen, um festzustellen, ob dem

Prinzipal Zugriff auf die Tabelle, Tabellenpartitionen (falls zutreffend) und Tabellenspalten gewährtwurde.

3. Wenn der Prinzipal Zugriff hat, fordert Athena Anmeldeinformationen von Lake Formation an. Wenn derPrinzipal keinen Zugriff hat, gibt Athena einen Fehler für „Zugriff verweigert“ aus.

4. Lake Formation stellt Anmeldeinformationen für Athena bereit, die beim Lesen von Daten aus AmazonS3 und beim Zugriff auf Metadaten über die Data Catalog verwendet werden sollen.

5. Lake Formation gibt Abfrageergebnisse an Athena zurück. Nachdem die Abfrage abgeschlossen ist,verwirft Athena die Anmeldeinformationen.

Überlegungen und Einschränkungen bei derVerwendung von Athena zur Abfrage von Daten, die inLake Formation registriert sindBeachten Sie Folgendes, wenn Sie Athena verwenden, um Daten abzufragen, die in Lake Formationregistriert sind. Weitere Informationen finden Sie unter Bekannte Probleme für AWS Lake Formation imAWS Lake Formation Developer Guide.

Überlegungen und Einschränkungen• Spaltenmetadaten, die in einigen Fällen für nicht autorisierte Benutzer mit Avro und

benutzerdefiniertem SerDe sichtbar sind (p. 246)• Arbeiten mit Lake Formation-Berechtigungen für Ansichten (p. 246)• Nicht in Lake Formation registrierter Speicherort der Athena-Abfrageergebnisse in Amazon

S3 (p. 246)• Verwenden von Athena-Workgroups zum Einschränken des Zugriffs auf den Abfrageverlauf (p. 246)• Kontenübergreifende Data Catalogs werden nicht unterstützt (p. 247)• Mit SSE-KMS verschlüsselte Amazon S3-Standorte, die in Lake Formation registriert sind, können in

Athena nicht abgefragt werden (p. 247)

245

https://docs.aws.amazon.com/lake-formation/latest/dg/limitations.html


• Partitionierte Datenspeicherorte, die in Lake Formation registriert sind, müssen sich inTabellenunterverzeichnissen befinden. (p. 247)

• Erstellen von CTAS(Table As Select)-Abfragen erfordern Amazon S3-Schreibberechtigungen (p. 247)

Spaltenmetadaten, die in einigen Fällen für nicht autorisierteBenutzer mit Avro und benutzerdefiniertem SerDe sichtbar sindDie Autorisierung auf Lake Formation-Spaltenebene verhindert, dass ein Benutzer auf Daten in Spaltenzugreift, für die er keine Lake Formation-Berechtigungen besitzt. In bestimmten Situationen könnenBenutzer jedoch auf Metadaten zugreifen, die alle Spalten in der Tabelle beschreiben, einschließlich derSpalten, für deren Daten sie keine Berechtigungen besitzen.

Dies tritt auf, wenn Spaltenmetadaten in Tabelleneigenschaften für Tabellen gespeichert werden, dieentweder das Avro-Speicherformat oder einen benutzerdefinierten Serializer/Deserializer (SerDe)verwenden, in dem das Tabellenschema zusammen mit der SerDe-Definition in den Tabelleneigenschaftendefiniert ist. Wenn Sie Athena mit verwenden Lake Formation, empfehlen wir, den Inhalt derTabelleneigenschaften zu überprüfen, die Sie in Lake Formation registrieren, und nach Möglichkeitdie in den Tabelleneigenschaften gespeicherten Informationen zu begrenzen, um zu verhindern, dassvertrauliche Metadaten für Benutzer sichtbar sind.

Arbeiten mit Lake Formation-Berechtigungen für AnsichtenFür Daten, die in Lake Formation registriert sind, kann ein Athena-Benutzer nur dann einen VIEWerstellen, wenn er über Lake Formation-Berechtigungen für die Tabellen, Spalten und Amazon S3-Quelldatenspeicherorte verfügt, auf denen der VIEW basiert. Nachdem ein VIEW in Athena erstelltwurde, können Lake Formation-Berechtigungen auf den VIEW angewendet werden. Berechtigungen aufSpaltenebene sind für einen VIEW nicht verfügbar. Benutzer mit Lake Formation-Berechtigungen für einenVIEW aber ohne Berechtigungen für die Tabelle und Spalten, auf denen die Ansicht basiert, können denVIEW nicht zur Datenabfrage verwenden. Benutzer mit dieser Berechtigungskombination können jedochAnweisungen wie DESCRIBE VIEW, SHOW CREATE VIEW und SHOW COLUMNS verwenden, um VIEW-Metadaten anzuzeigen. Stellen Sie daher sicher, dass Sie die Lake Formation-Berechtigungen für jedenVIEW an den zugrunde liegenden Tabellenberechtigungen ausrichten.

Nicht in Lake Formation registrierter Speicherort der Athena-Abfrageergebnisse in Amazon S3The query results locations in Amazon S3 for Athena cannot be registered with Lake Formation. LakeFormation permissions do not limit access to these locations. Unless you limit access, Athena users canaccess query result files and metadata when they do not have Lake Formation permissions for the data.To avoid this, we recommend that you use workgroups to specify the location for query results and alignworkgroup membership with Lake Formation permissions. You can then use IAM permissions policiesto limit access to query results locations. For more information about query results, see Arbeiten mitAbfrageergebnissen, Ausgabedateien und dem Abfrageverlauf (p. 115).

Verwenden von Athena-Workgroups zum Einschränken desZugriffs auf den AbfrageverlaufAthena query history exposes a list of saved queries and complete query strings. Unless you useworkgroups to separate access to query histories, Athena users who are not authorized to query datain Lake Formation are able to view query strings run on that data, including column names, selectioncriteria, and so on. We recommend that you use workgroups to separate query histories, and align Athenaworkgroup membership with Lake Formation permissions to limit access. For more information, seeVerwendung von Arbeitsgruppen zur Kontrolle des Abfragenzugriffs und der Kosten (p. 251).

246

Amazon Athena BenutzerhandbuchVerwalten von Benutzerberechtigungen

Kontenübergreifende Data Catalogs werden nicht unterstütztAn Athena user from one account can not query databases and tables in the Data Catalog of a differentaccount, even when Lake Formation is used. To query an Amazon S3 data location in a different account,a resource-based IAM policy (bucket policy) must allow access to the location. For more information, seeKontoübergreifender Zugriff (p. 229). You can use Lake Formation to register an accessible bucketlocation in an external account with the Data Catalog in the local account.

Mit SSE-KMS verschlüsselte Amazon S3-Standorte, die in LakeFormation registriert sind, können in Athena nicht abgefragtwerdenAmazon S3-Datenspeicherorte, die in Lake Formation registriert und mit der serverseitigenVerschlüsselung mit AWS KMS-verwalteten Schlüsseln (SSE-KMS) verschlüsselt sind, können nicht mitAthena abgefragt werden. Sie können mit Athena weiterhin mit SSE-KMS verschlüsselte Amazon S3-Datenspeicherorte abfragen, die nicht in Lake Formation registriert sind, und mit IAM-Richtlinien den Zugrifferlauben oder verweigern.

Partitionierte Datenspeicherorte, die in Lake Formation registriertsind, müssen sich in Tabellenunterverzeichnissen befinden.Partitionierte Tabellen, die in Lake Formation registriert sind, müssen über partitionierte Daten inVerzeichnissen verfügen, die Unterverzeichnisse der Tabelle in Amazon S3 sind. Beispielsweise kann eineTabelle mit dem Speicherort s3://mydata/mytable und den Partitionen s3://mydata/mytable/dt=2019-07-11, s3://mydata/mytable/dt=2019-07-12, usw. in Lake Formation registriert und mitAthena abgefragt werden. Andererseits kann eine Tabelle mit dem Speicherort s3://mydata/mytableund Partitionen in s3://mydata/dt=2019-07-11, s3://mydata/dt=2019-07-12, usw. nicht in LakeFormation registriert werden. Sie können den Zugriff auf diese Tabellen mithilfe von IAM-Berechtigungenaußerhalb von Lake Formation einrichten, um sie in Athena abzufragen. Weitere Informationen finden Sieunter Partitionieren von Daten (p. 39).

Erstellen von CTAS(Table As Select)-Abfragen erfordern AmazonS3-SchreibberechtigungenCreate Table As Statements (CTAS) require write access to the Amazon S3 location of tables. To runCTAS queries on data registered with Lake Formation, Athena users must have IAM permissions to write tothe table Amazon S3 locations in addition to the appropriate Lake Formation permissions to read the datalocations. For more information, see Erstellen einer Tabelle aus Abfrageergebnissen (CTAS) (p. 126).

Verwalten von Lake Formation- und Athena-BenutzerberechtigungenLake Formation bietet Anmeldeinformationen für die Abfrage von Amazon S3-Datenspeichern, die in LakeFormation registriert sind. Wenn Sie zuvor IAM-Richtlinien verwendet haben, um Berechtigungen zumLesen von Datenspeicherorten in Amazon S3 zu gewähren oder zu verweigern, können Sie stattdessenLake Formation-Berechtigungen verwenden. Allerdings sind weiterhin andere IAM-Berechtigungenerforderlich.

In den folgenden Abschnitten werden die Berechtigungen zusammengefasst, die erforderlich sind, um diein Lake Formation registrierten Daten mithilfe von Athena abzufragen. Weitere Informationen finden Sieunter Sicherheit in AWS Lake Formation im AWS Lake Formation Developer Guide.

Berechtigungsübersicht

247

https://docs.aws.amazon.com/lake-formation/latest/dg/security.html


• Identitätsbasierte Berechtigungen für Lake Formation und Athena (p. 248)• Amazon S3-Berechtigungen für Athena-Abfrageergebnisspeicherorte (p. 248)• Athena-Workgoup-Mitgliedschaften zum Abfragen des Verlaufs (p. 248)• Lake Formation-Berechtigungen für Daten (p. 249)• IAM-Berechtigungen zum Schreiben in Amazon S3-Speicherorte (p. 249)• Berechtigungen für verschlüsselte Daten, Metadaten und Athena-Abfrageergebnisse (p. 249)• Ressourcenbasierte Berechtigungen für Amazon S3-Buckets in externen Konten (optional) (p. 249)

Identitätsbasierte Berechtigungen für Lake Formation und AthenaJeder, der die in Lake Formation registrierten Daten mithilfe von Athena abfragt, muss über eine IAM-Berechtigungsrichtlinie verfügen, mit der die lakeformation:GetDataAccess-Aktion zugelassen wird.Verwaltete Richtlinie AmazonAthenaFullAccess (p. 218) erlaubt diese Aktion. Wenn Sie eingebundenenRichtlinien verwenden, stellen Sie sicher, dass Sie die Berechtigungsrichtlinien aktualisieren, um dieseAktion zuzulassen.

In Lake Formation verfügt ein Data Lake-Administrator über Berechtigungen zum Erstellen vonMetadatenobjekten wie Datenbanken und Tabellen, zum Erteilen von Lake Formation-Berechtigungenfür andere Benutzer und zum Registrieren neuer Amazon S3-Speicherorte. Zur Registrierung neuerStandorte sind Berechtigungen für die serviceverknüpfte Rolle für Lake Formation erforderlich. WeitereInformationen finden Sie unter Create a Data Lake Administrator und Service-Linked Role Permissions forLake Formation im AWS Lake Formation-Entwicklerhandbuch.

Ein Lake Formation-Benutzer kann mit Athena Datenbanken, Tabellen, Tabellenspalten und zugrundeliegende Amazon S3-Datenspeicher basierend auf Lake Formation-Berechtigungen abfragen, die ihm vonData Lake-Administratoren erteilt wurden. Benutzer können weder Datenbanken oder Tabellen erstellennoch neue Amazon S3-Speicherorte in Lake Formation registrieren. Weitere Informationen finden Sie unterErstellen eines Data Lake-Benutzers im AWS Lake Formation-Entwicklerhandbuch.

In Athena steuern identitätsbasierte Berechtigungsrichtlinien, einschließlich derjenigen für Athena-Workgroups, weiterhin den Zugriff auf Athena-Aktionen für AWS-Kontobenutzer. Darüber hinaus kann derVerbundzugriff über die SAML-basierte Authentifizierung bereitgestellt werden, die mit Athena-Treibernverfügbar ist. Weitere Informationen finden Sie unter Verwendung von Arbeitsgruppen zur Kontrolle desAbfragenzugriffs und der Kosten (p. 251), IAM-Richtlinien für den Zugriff auf Arbeitsgruppen (p. 255)und Aktivieren des föderierten Zugriffs auf die Athena-API (p. 236).

Weitere Informationen finden Sie unter Erteilen von Lake Formation-Berechtigungen im AWS LakeFormation Developer Guide.

Amazon S3-Berechtigungen für Athena-AbfrageergebnisspeicherorteThe query results locations in Amazon S3 for Athena cannot be registered with Lake Formation. LakeFormation permissions do not limit access to these locations. Unless you limit access, Athena users canaccess query result files and metadata when they do not have Lake Formation permissions for the data.To avoid this, we recommend that you use workgroups to specify the location for query results and alignworkgroup membership with Lake Formation permissions. You can then use IAM permissions policiesto limit access to query results locations. For more information about query results, see Arbeiten mitAbfrageergebnissen, Ausgabedateien und dem Abfrageverlauf (p. 115).

Athena-Workgoup-Mitgliedschaften zum Abfragen des VerlaufsAthena query history exposes a list of saved queries and complete query strings. Unless you useworkgroups to separate access to query histories, Athena users who are not authorized to query data

248

https://docs.aws.amazon.com/lake-formation/latest/dg/getting-started-setup.html#create-data-lake-admin

https://docs.aws.amazon.com/lake-formation/latest/dg/service-linked-roles.html#service-linked-role-permissions

https://docs.aws.amazon.com/lake-formation/latest/dg/service-linked-roles.html#service-linked-role-permissions

https://docs.aws.amazon.com/lake-formation/latest/dg/cloudtrail-tut-create-lf-user.html

https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html


in Lake Formation are able to view query strings run on that data, including column names, selectioncriteria, and so on. We recommend that you use workgroups to separate query histories, and align Athenaworkgroup membership with Lake Formation permissions to limit access. For more information, seeVerwendung von Arbeitsgruppen zur Kontrolle des Abfragenzugriffs und der Kosten (p. 251).

Lake Formation-Berechtigungen für DatenZusätzlich zu der Basisberechtigung für die Verwendung von Lake Formation, müssen Athena-Benutzerüber Lake Formation-Berechtigungen für den Zugriff auf die von Ihnen abgefragten Ressourcen verfügen.Diese Berechtigungen werden von einem Lake Formation-Administrator erteilt und verwaltet. WeitereInformationen finden Sie unter Sicherheit und Zugriffskontrolle für Metadaten und Daten im AWS LakeFormation-Entwicklerhandbuch.

IAM-Berechtigungen zum Schreiben in Amazon S3-SpeicherorteLake Formation-Berechtigungen für Amazon S3 bieten nicht die Möglichkeit, in Amazon S3 zu schreiben.Create Table As Statements (CTAS) require write access to the Amazon S3 location of tables. To runCTAS queries on data registered with Lake Formation, Athena users must have IAM permissions to write tothe table Amazon S3 locations in addition to the appropriate Lake Formation permissions to read the datalocations. For more information, see Erstellen einer Tabelle aus Abfrageergebnissen (CTAS) (p. 126).

Berechtigungen für verschlüsselte Daten, Metadaten und Athena-AbfrageergebnisseZugrunde liegende Quelldaten in Amazon S3 und Metadaten in der Data Catalog, die in Lake Formationregistriert sind, können verschlüsselt werden. Es gibt keine Änderung an der Art und Weise, wie dieVerschlüsselung von Abfrageergebnissen von Athena verarbeitet wird, wenn Athena zum Abfragen vonDaten verwendet wird, die in Lake Formation registriert sind. Weitere Informationen finden Sie unterVerschlüsseln der in Amazon S3 gespeicherten Abfrageergebnisse (p. 212).

• Verschlüsselung von Quelldaten – SSE-S3- und CSE-KMS-Verschlüsselung der Quelldaten für AmazonS3-Datenspeicherorte wird unterstützt. SSE-KMS-Verschlüsselung wird nicht unterstützt. Athena-Benutzer, die verschlüsselte Amazon S3-Speicherorte abfragen, die in Lake Formation registriertsind, benötigen Berechtigungen zum Ver- und Entschlüsseln von Daten. Weitere Informationen zuAnforderungen finden Sie unter Berechtigungen für verschlüsselte Daten in Amazon S3 (p. 211).

• Verschlüsseln von Metadaten – das Verschlüsseln von Metadaten im Data Catalog wird unterstützt.Für Prinzipale, die Athena verwenden, müssen identitätsbasierte Richtlinien die Aktionen"kms:GenerateDataKey", "kms:Decrypt" und "kms:Encrypt" für den Schlüssel zulassen, mitdem Metadaten verschlüsselt werden. Weitere Informationen finden Sie unter Verschlüsseln von DataCatalog im AWS Glue-Entwicklerhandbuch und Zugriff auf verschlüsselte Metadaten im AWS Glue-Datenkatalog (p. 228).

Ressourcenbasierte Berechtigungen für Amazon S3-Buckets inexternen Konten (optional)An Athena user from one account can not query databases and tables in the Data Catalog of a differentaccount, even when Lake Formation is used. To query an Amazon S3 data location in a different account,a resource-based IAM policy (bucket policy) must allow access to the location. For more information, seeKontoübergreifender Zugriff (p. 229). You can use Lake Formation to register an accessible bucketlocation in an external account with the Data Catalog in the local account.

249




Amazon Athena BenutzerhandbuchAnwenden von Lake Formation-Berechtigungen

auf vorhandene Datenbanken und Tabellen

Anwenden von Lake Formation-Berechtigungen aufvorhandene Datenbanken und TabellenWenn Sie noch nicht mit Athena vertraut sind und den Zugriff auf Abfragedaten mit Lake Formationkonfigurieren, müssen Sie keine IAM-Richtlinien konfigurieren, damit Benutzer Amazon S3-Daten lesen undMetadaten erstellen können. Sie können Berechtigungen mit Lake Formation verwalten.

Das Registrieren von Daten in Lake Formation und das Aktualisieren von IAM-Berechtigungsrichtlinienist nicht erforderlich. Wenn keine Daten in Lake Formation registriert sind, können Athena-Benutzer mitden entsprechenden Berechtigungen in Amazon S3 (und falls zutreffend in AWS Glue) weiterhin Datenabfragen, die nicht in Lake Formation registriert sind.

Wenn Sie bereits über Athena-Benutzer verfügen, die Daten abfragen, die nicht bei registriert sind LakeFormation, können Sie die IAM-Berechtigungen für Amazon S3 (und sofern zutreffend für AWS Glue-Datenkatalog) aktualisieren, damit Sie Lake Formation-Berechtigungen verwenden für die zentraleVerwaltung des Benutzerzugriffs verwenden können.“ Wenn Sie die Berechtigung zum Lesen von AmazonS3-Datenverzeichnissen erhalten möchten, können Sie ressourcen- und identitätsbasierte Richtlinienaktualisieren, um Amazon S3-Berechtigungen zu entfernen. Wenn Sie für den Zugriff auf MetadatenRichtlinien auf Ressourcenebene für eine differenzierte Zugriffskontrolle mit AWS Glue konfigurierthaben, können Sie stattdessen Lake Formation-Berechtigungen für die Zugriffsverwaltung verwenden.Weitere Informationen finden Sie unter Differenzierter Zugriff auf Datenbanken und Tabellen in AWS Glue-Datenkatalog (p. 222) und Upgrading AWS Glue Data Permissions to the AWS Lake Formation Model imAWS Lake Formation--Entwicklerhandbuch.

250

https://docs.aws.amazon.com/lake-formation/latest/dg/upgrade-glue-lake-formation.html

Amazon Athena BenutzerhandbuchVerwenden von Arbeitsgruppenzum Ausführen von Abfragen

Verwendung von Arbeitsgruppen zurKontrolle des Abfragenzugriffs undder Kosten

Verwenden Sie Arbeitsgruppen zum Trennen von Benutzern, Teams, Anwendungen oder Workloads sowiezur Einrichtung von Grenzwerten für die Datenmenge, die jede Abfrage oder die gesamte Arbeitsgruppeverarbeiten kann, und zur Nachverfolgung von Kosten. Da Arbeitsgruppen als Ressourcen fungieren,können Sie identitätsbasierte Richtlinien auf Ressourcenebene verwenden, um den Zugriff auf einebestimmte Arbeitsgruppe zu steuern. Sie können auch abfragebezogene Metriken in Amazon CloudWatchanzeigen, durch die Konfiguration von Limits für die gescannten Daten Ihre Kosten kontrollieren,Schwellenwerte einrichten und Aktionen auslösen, wie etwa Amazon SNS, wenn diese Schwellenwerteüberschritten werden.

Arbeitsgruppen integrieren sich mit IAM, CloudWatch und Amazon Simple Notification Service wie folgt:

• Identitätsbasierte IAM-Richtlinien mit Berechtigungen auf Ressourcenebene steuern, wer in einerArbeitsgruppe Abfragen ausführen kann.

• Athena veröffentlicht die Arbeitsgruppen-Abfragemetriken auf CloudWatch, wenn Sie Abfragemetrikenaktivieren.

• In Amazon SNS, können Sie Amazon SNS-Themen erstellen, die Alarme für bestimmte Benutzer derArbeitsgruppe ausgeben, wenn die Datennutzungskontrollen für Abfragen in einer Arbeitsgruppe Ihrefestgelegten Schwellenwerte überschreiten.

Themen• Verwenden von Arbeitsgruppen zum Ausführen von Abfragen (p. 251)• Kontrollieren von Kosten und Überwachung von Abfragen mit CloudWatch-Metriken (p. 270)

Verwenden von Arbeitsgruppen zum Ausführen vonAbfragen

Wir empfehlen, Arbeitsgruppen zu verwenden, um Abfragen für Teams, Anwendungen oder verschiedeneArbeitslasten zu isolieren. Sie können beispielsweise separate Arbeitsgruppen für zwei verschiedeneTeams in Ihrer Organisation erstellen. Sie können auch Arbeitslasten trennen. So können Siebeispielsweise zwei unabhängige Arbeitsgruppen erstellen, eine für automatisierte geplante Anwendungenwie beispielsweise die Berichterstellung und eine andere zur Ad-hoc-Nutzung durch Analysten. Sie könnenzwischen Arbeitsgruppen umschalten.

Themen• Vorteile der Verwendung von Arbeitsgruppen (p. 252)• Funktionsweise von Arbeitsgruppen (p. 252)• Einrichten von Arbeitsgruppen (p. 253)

251

Amazon Athena BenutzerhandbuchVorteile der Verwendung von Arbeitsgruppen

• IAM-Richtlinien für den Zugriff auf Arbeitsgruppen (p. 255)• Beispiel-Arbeitsgruppenrichtlinien (p. 256)• Arbeitsgruppeneinstellungen (p. 260)• Verwalten von Arbeitsgruppen (p. 261)• Athena-Arbeitsgruppen-APIs (p. 268)• Fehlerbehebung bei Arbeitsgruppen (p. 268)

Vorteile der Verwendung von ArbeitsgruppenArbeitsgruppen bieten Ihnen folgende Möglichkeiten:

Isolieren von Benutzern,Teams, Anwendungen oderArbeitslasten in Gruppen

Jede Arbeitsgruppe verfügt über ihren eigenen Abfrageverlauf und eineListe gespeicherter Abfragen. Weitere Informationen finden Sie unterFunktionsweise von Arbeitsgruppen (p. 252).

Für alle Abfragen in der Arbeitsgruppe können SieArbeitsgruppeneinstellungen konfigurieren. Hierzu gehörenein Amazon S3-Speicherort für Abfrageergebnisse sowiedie Verschlüsselungskonfiguration. Sie können auchArbeitsgruppeneinstellungen durchsetzen. Weitere Informationen findenSie unter Arbeitsgruppeneinstellungen (p. 260).

Durchsetzen vonKosteneinschränkungen

Sie können zwei Arten von Kosteneinschränkungen für Abfragen in einerArbeitsgruppe festlegen:

• Das Per-query limit (Limit pro Abfrage) ist ein Schwellenwert für diebei jeder Abfrage gescannte Datenmenge. Athena bricht Abfragenab, wenn diese den angegebenen Schwellenwert überschreiten. DasLimit gilt für jede ausgeführte Abfrage innerhalb einer Arbeitsgruppe.Sie können nur ein Limit pro Abfrage festlegen und dieses bei Bedarfaktualisieren.

• Das Per-workgroup limit (Limit pro Arbeitsgruppe) ist ein Schwellenwert,den Sie für jede Arbeitsgruppe festlegen können und der die Mengeder bei Abfragen in der Arbeitsgruppe gescannten Daten betrifft. BeiÜberschreiten eines Schwellenwerts wird ein Amazon SNS-Alarmaktiviert, der eine Aktion Ihrer Wahl auslöst, beispielsweise das Sendeneiner E-Mail an einen bestimmten Benutzer. Sie können mehrere Limitspro Arbeitsgruppe für jede Arbeitsgruppe festlegen.

Die detaillierten Schritte finden Sie unter Festlegen von Limits für dieDatennutzungskontrolle (p. 273).

VerfolgungabfragebezogenerMetriken für alleArbeitsgruppenabfragen inCloudWatch

Für jede Abfrage, die in einer Arbeitsgruppe ausgeführt wird, gilt:Wenn Sie die Arbeitsgruppe für die Veröffentlichung von Metrikenkonfigurieren, veröffentlicht Athena sie auf CloudWatch. Sie könnenAbfragemetriken (p. 271) für Ihre Arbeitsgruppen in der Athena-Konsoleanzeigen. In CloudWatch, können Sie benutzerdefinierte Dashboardserstellen und Schwellenwerte sowie Alarme für diese Metriken festlegen.

Funktionsweise von ArbeitsgruppenArbeitsgruppen in Athena haben folgende Merkmale:

252

Amazon Athena BenutzerhandbuchEinrichten von Arbeitsgruppen

• Standardmäßig verfügt jedes Konto über eine primäre Arbeitsgruppe und alle authentifizierten Benutzerkönnen mit den Standardberechtigungen auf diese Arbeitsgruppe zugreifen. Die primäre Arbeitsgruppekann nicht gelöscht werden.

• In jeder von Ihnen erstellten Arbeitsgruppe werden gespeicherte Abfragen und der Abfrageverlauf nur fürdie in der Gruppe ausgeführten Abfragen, nicht für alle Abfragen in dem Konto angezeigt. So sind IhreAbfragen von anderen Abfragen in einem Konto getrennt und Sie können Ihre eigenen gespeichertenAbfragen und Abfragen im Verlauf effizienter lokalisieren.

• Wenn eine Arbeitsgruppe deaktiviert wird, können keine Abfragen darin ausgeführt werden, bis Sie dieGruppe aktivieren. Abfragen an eine deaktivierte Arbeitsgruppe schlagen fehl, bis Sie die Gruppe erneutaktivieren.

• Wenn Sie über Berechtigungen verfügen, können Sie eine leere Arbeitsgruppe und eine Arbeitsgruppemit gespeicherten Abfragen löschen. In diesem Fall werden Sie vor dem Löschen einer Arbeitsgruppevon Athena gewarnt, dass gespeicherte Abfragen gelöscht werden. Stellen Sie vor dem Löschen einerArbeitsgruppe, auf die andere Benutzer Zugriff haben, sicher, dass ihre Benutzer Zugriff auf andereArbeitsgruppen haben, in denen sie weiterhin Abfragen ausführen können.

• Sie können Einstellungen für eine gesamte Arbeitsgruppe festlegen und deren Nutzung bei allen in derArbeitsgruppe ausgeführten Abfragen durchsetzen. Zu den Einstellungen gehören der Speicherort derAbfrageergebnisse in Amazon S3 und die Verschlüsselungskonfiguration.

Important

Wenn Sie Einstellungen für eine gesamte Arbeitsgruppe durchsetzen, verwenden alle in dieserArbeitsgruppe ausgeführten Abfragen die Arbeitsgruppeneinstellungen. Das gilt auch, wenn ihreclientseitigen Einstellungen möglicherweise von den Arbeitsgruppeneinstellungen abweichen.Weitere Informationen finden Sie unter Arbeitsgruppeneinstellungen überschreiben clientseitigeEinstellungen (p. 261).

Einschränkungen für Arbeitsgruppen• Sie können bis zu 1000 Arbeitsgruppen pro Region in Ihrem Konto erstellen.• Die primäre Arbeitsgruppe kann nicht gelöscht werden.• Sie können innerhalb jeder Arbeitsgruppe bis zu zehn Abfrageregisterkarten öffnen. Wenn Sie zwischen

Arbeitsgruppen wechseln, bleiben Ihre Abfrageregisterkarten für bis zu drei Arbeitsgruppen geöffnet.

Einrichten von ArbeitsgruppenDie Einrichtung von Arbeitsgruppen umfasst das Erstellen der Gruppen und die Festlegung vonBerechtigungen für ihre Nutzung. Entscheiden Sie zunächst, welche Arbeitsgruppen Ihre Organisationbraucht, und erstellen Sie diese. Legen Sie dann IAM-Arbeitsgruppenrichtlinien fest, die denBenutzerzugriff und die Aktionen auf einer workgroup-Ressource steuern. Benutzer mit Zugriff auf dieseArbeitsgruppen können nun Abfragen darin ausführen.

Note

Verwenden Sie diese Tasks, um Arbeitsgruppen einzurichten, wenn Sie diese zum ersten Malverwenden. Wenn Ihr Athena-Konto bereits Arbeitsgruppen verwendet, benötigt jeder Benutzerdes Kontos Berechtigungen zur Ausführung von Abfragen in einer oder mehreren Arbeitsgruppenin dem Konto. Überprüfen Sie vor der Ausführung von Abfragen Ihre IAM-Richtlinien, umfestzustellen, auf welche Arbeitsgruppen Sie zugreifen können. Passen Sie Ihre Richtlinie beiBedarf an und wechseln Sie (p. 267) zu einer Arbeitsgruppe, die Sie verwenden möchten.

Wenn Sie keine Arbeitsgruppen erstellt haben, werden alle Abfragen in Ihrem Konto standardmäßig in derprimären Arbeitsgruppe ausgeführt:

253

Amazon Athena BenutzerhandbuchEinrichten von Arbeitsgruppen

Arbeitsgruppen werden in der Athena-Konsole auf der Registerkarte Workgroup:(Arbeitsgruppe)<workgroup_name> angezeigt. Auf der Konsole ist die Arbeitsgruppe aufgeführt,zu der Sie umgeschaltet haben. Wenn Sie Abfragen ausführen, werden sie in dieser Arbeitsgruppeausgeführt. Sie können Abfragen in der Arbeitsgruppe in der Konsole oder über die API-Operationen, dieBefehlszeilenschnittstelle oder eine Client-Anwendung über den JDBC- oder ODBC-Treiber ausführen.Wenn Sie Zugriff auf eine Arbeitsgruppe haben, können Sie die Einstellungen der Arbeitsgruppe,ihre Metriken und Limits für die Datennutzungskontrolle anzeigen. Darüber hinaus können Sie überBerechtigungen zur Bearbeitung der Einstellungen und der Limits für die Datennutzungskontrolle verfügen.

So richten Sie Arbeitsgruppen ein

1. Legen Sie fest, welche Arbeitsgruppen Sie erstellen möchten. Sie können beispielsweise Folgendesentscheiden:

• Wer Abfragen in den einzelnen Arbeitsgruppen ausführen kann und wer für dieArbeitsgruppenkonfiguration verantwortlich ist. Dies legt die von Ihnen erstellten IAM-Richtlinien fest.Weitere Informationen finden Sie unter IAM-Richtlinien für den Zugriff auf Arbeitsgruppen (p. 255).

• Welche Speicherorte Amazon S3 für die Ergebnisse der Abfragen verwendet werden sollen, die injeder Arbeitsgruppe ausgeführt werden. Sie können einen Speicherort nur für die Ergebnisse derArbeitsgruppeabfrage angeben, wenn er bereits in Amazon S3 vorhanden ist. Alle Benutzer, dieeine Arbeitsgruppe verwenden, müssen Zugriff auf diesen Speicherort haben. Weitere Informationenfinden Sie unter Arbeitsgruppeneinstellungen (p. 260).

• Welche Verschlüsselungseinstellungen erforderlich sind und welche Arbeitsgruppen Abfragenhaben, die verschlüsselt werden müssen. Wir empfehlen Ihnen, eine separate Arbeitsgruppenfür verschlüsselte und nicht-verschlüsselte Abfragen zu erstellen. Auf diese Weise können Sieeine Verschlüsselung für eine Arbeitsgruppe durchzusetzen, die dann für alle darin ausgeführtenAbfragen gilt. Weitere Informationen finden Sie unter Verschlüsseln der in Amazon S3 gespeichertenAbfrageergebnisse (p. 212).

2. Erstellen Sie nach Bedarf Arbeitsgruppen und fügen Sie diesen Tags hinzu. Öffnen Sie die Athena-Konsole und wählen Sie die Registerkarte Workgroup: (Arbeitsgruppe:) <workgroup_name> undanschließend Create workgroup (Arbeitsgruppe erstellen) aus. Die detaillierten Schritte finden Sieunter Erstellen einer Arbeitsgruppe (p. 262).

3. Erstellen Sie IAM-Richtlinien für Ihre Benutzer, Gruppen oder Rollen, um deren Zugriff aufArbeitsgruppen zu aktivieren. Die Richtlinien legen die Arbeitsgruppenzugehörigkeit und den Zugriffauf Aktionen auf einer workgroup-Ressource fest. Die detaillierten Schritte finden Sie unter IAM-Richtlinien für den Zugriff auf Arbeitsgruppen (p. 255). JSON-Richtlinien beispielsweise finden Sieunter Beispiel-Arbeitsgruppenrichtlinien (p. 229).

4. Richten Sie Arbeitsgruppeneinstellungen ein. Geben Sie gegebenenfalls einen Speicherortin Amazon S3 für Abfrageergebnisse und Verschlüsselungseinstellungen an. Sie könnenArbeitsgruppeneinstellungen durchsetzen. Weitere Informationen finden Sie unterArbeitsgruppeneinstellungen (p. 260).

Important

Wenn Sie clientseitige Einstellungen überschreiben (p. 261), wird Athena die Einstellungender Arbeitsgruppe verwenden. Dies betrifft Abfragen, die Sie in der Konsole über die Treiber,die Befehlszeilenschnittstelle oder die API-Operationen ausführen.Während Abfragen weiterhin ausgeführt werden, kann die Automatisierung, die aufder Verfügbarkeit von Ergebnissen in einem bestimmten Amazon S3-Bucket basiert,möglicherweise fehlschlagen. Wir empfehlen Ihnen, vor einer Überschreibung Ihre Benutzerzu informieren. Nachdem die Arbeitsgruppeneinstellungen für eine Überschreibung eingestelltwurden, können Sie die Angabe clientseitiger Einstellungen in den Treibern oder in der APIauslassen.

254

Amazon Athena BenutzerhandbuchIAM-Richtlinien für den Zugriff auf Arbeitsgruppen

5. Benachrichtigen Sie die Benutzer, welche Arbeitsgruppen sie für die Ausführung von Abfragenverwenden sollen. Senden Sie eine E-Mail, um die Benutzer Ihres Kontos über zu verwendendeArbeitsgruppennamen, die erforderlichen IAM-Richtlinien und die Arbeitsgruppeneinstellungen zuinformieren.

6. Konfigurieren Sie Limits für die Kostenkontrolle – auch als Limits für die Datennutzungskontrollebezeichnet – für Abfragen und Arbeitsgruppen. Erstellen Sie ein Amazon SNS-Thema undkonfigurieren Sie Abonnements, damit Sie bei Überschreitung eines Schwellenwerts benachrichtigtwerden. Die detaillierten Schritte finden Sie in den Abschnitten zum Festlegen von Limits für dieDatennutzungskontrolle (p. 273) und zum Erstellen eines Amazon SNS-Themas im Handbuch „ErsteSchritte” für Amazon Simple Notification Service.

7. Wechseln Sie zu der Arbeitsgruppe, damit Sie Abfragen ausführen können. Um Abfragen auszuführen,wechseln Sie zu der entsprechenden Arbeitsgruppe. Die detaillierten Schritte finden Sie unter thesection called “Angeben einer Arbeitsgruppe, in der Abfragen ausgeführt werden sollen” (p. 267).

IAM-Richtlinien für den Zugriff auf ArbeitsgruppenVerwenden Sie zur Steuerung des Zugriffs auf Arbeitsgruppen IAM-Berechtigungen auf Ressourcenebeneoder identitätsbasierte IAM-Richtlinien.

Das folgende Verfahren gilt speziell für Athena.

IAM-spezifische Informationen finden Sie unter den Links am Ende dieses Abschnitts.Informationen zu JSON-Beispiel-Arbeitsgruppenrichtlinien finden Sie im Abschnitt Beispiel-Arbeitsgruppenrichtlinien (p. 256).

Verwenden Sie den visuellen Editor in der IAM-Konsole, um eine Arbeitsgruppenrichtlinie zuerstellen

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Wählen Sie im Navigationsbereich auf der linken Seite Policies (Richtlinien) und dann Create Policy(Richtlinie erstellen) aus.

3. Wählen Sie auf der Registerkarte Visual editor (Visueller Editor) die Option Choose a service (WählenSie einen Service) aus. Wählen Sie dann Athena aus, um es der Richtlinie hinzuzufügen.

4. Wählen Sie Select actions (Aktionen auswählen) und dann die Aktionen aus, die Sie der Richtliniehinzufügen möchten. Im visuellen Editor werden die in Athena verfügbaren Aktionen angezeigt.Weitere Informationen finden Sie im Abschnitt über Aktionen, Ressourcen und Bedingungsschlüsselfür Amazon Athena im IAM-Benutzerhandbuch.

5. Wählen Sie Add actions (Aktionen hinzufügen) aus, um eine bestimmte Aktion einzugeben, oderverwenden Sie Platzhalter (*), um mehrere Aktionen anzugeben.

Standardmäßig lässt die Richtlinie, die Sie erstellen, die Aktionen zu, die Sie auswählen. WennSie eine oder mehrere Aktionen auswählen, die Berechtigungen auf Ressourcenebene für dieworkgroup-Ressource in Athena unterstützen, listet der Editor die workgroup-Ressource auf.

6. Wählen Sie Resources (Ressourcen) aus, um die Arbeitsgruppen für Ihre Richtlinie anzugeben. JSON-Arbeitsgruppenrichtlinien beispielsweise finden Sie unter Beispiel-Arbeitsgruppenrichtlinien (p. 256).

7. Geben Sie die workgroup-Ressource wie folgt an:

arn:aws:athena:<region>:<user-account>:workgroup/<workgroup-name>

8. Wählen Sie Review policy (Richtlinie prüfen) aus und geben Sie Name und Description (Beschreibung)(optional) für die zu erstellende Richtlinie ein. Prüfen Sie die Richtlinienübersicht, um sicherzustellen,dass Sie die beabsichtigten Berechtigungen erteilt haben.

9. Wählen Sie Create policy (Richtlinie erstellen) aus, um Ihre neue Richtlinie zu speichern.

255

https://docs.aws.amazon.com/sns/latest/gsg/creating-an-sns-topic.html





Amazon Athena BenutzerhandbuchBeispiel-Arbeitsgruppenrichtlinien

10. Fügen Sie diese identitätsbasierte Richtlinie einem Benutzer, einer Gruppe oder Rolle an und gebenSie die workgroup-Ressourcen an, auf die sie zugreifen dürfen.

Weitere Informationen finden Sie unter den folgenden Themen im IAM-Benutzerhandbuch:

• Aktionen, Ressourcen und Bedingungsschlüssel für Amazon Athena• Erstellen von Richtlinien mit dem visuellen Editor• Hinzufügen und Entfernen von IAM-Richtlinien• Steuern des Zugriffs auf Ressourcen

JSON-Arbeitsgruppenrichtlinien beispielsweise finden Sie unter Beispiel-Arbeitsgruppenrichtlinien (p. 256).

Eine vollständige Liste der Amazon Athena-Aktionen finden Sie in den API-Aktionsnamen in der AmazonAthena-API-Referenz.

Beispiel-ArbeitsgruppenrichtlinienIn diesem Abschnitt sind Beispielrichtlinien enthalten, die Sie verwenden können, um verschiedeneAktionen in Arbeitsgruppen zu aktivieren.

Eine Arbeitsgruppe ist eine IAM-Ressource, die von Athena verwaltet wird. Wenn IhreArbeitsgruppenrichtlinie daher Aktionen verwaltet, die workgroup als Eingabe verwenden, müssen Sieden ARN der Arbeitsgruppe wie folgt angeben:

"Resource": [arn:aws:athena:<region>:<user-account>:workgroup/<workgroup-name>]

Hierbei ist <workgroup-name> der Name Ihrer Arbeitsgruppe. Eine Arbeitsgruppe mit dem Namentest_workgroup geben Sie beispielsweise wie folgt als Ressource an:

"Resource": ["arn:aws:athena:us-east-1:123456789012:workgroup/test_workgroup"]

Eine vollständige Liste der Amazon Athena-Aktionen finden Sie in den API-Aktionsnamen in der AmazonAthena-API-Referenz. Weitere Informationen zu IAM-Richtlinien finden Sie unter Erstellen von Richtlinienmit dem Visual Editor im IAM-Benutzerhandbuch. Weitere Informationen zum Erstellen von IAM-Richtlinienfür Arbeitsgruppen finden Sie unter IAM-Richtlinien für Arbeitsgruppen (p. 255).

• Beispielrichtlinie für Vollzugriff auf alle Arbeitsgruppen (p. 256)• Beispielrichtlinie für Vollzugriff auf eine angegebene Arbeitsgruppe (p. 257)• Beispielrichtlinie für die Ausführung von Abfragen in einer angegebenen Arbeitsgruppe (p. 258)• Beispielrichtlinie für die Ausführung von Abfragen in der primären Arbeitsgruppe (p. 258)• Beispielrichtlinie für Verwaltungsoperationen in einer angegebenen Arbeitsgruppe (p. 259)• Beispielrichtlinie für die Auflistung von Arbeitsgruppen (p. 259)• Beispielrichtlinie für die Ausführung und das Stoppen von Abfragen in einer angegebenen

Arbeitsgruppe (p. 259)• Beispielrichtlinie für die Arbeit mit benannten Abfragen in einer angegebenen Arbeitsgruppe (p. 260)

Example Beispielrichtlinie für Vollzugriff auf alle Arbeitsgruppen

Die folgende Richtlinie erlaubt den vollständigen Zugriff auf alle möglicherweise in dem Konto vorhandenenArbeitsgruppenressourcen. Wir empfehlen Ihnen, diese Richtlinie für die Benutzer in Ihrem Konto zuverwenden, die Arbeitsgruppen für alle anderen Benutzer verwalten müssen.

256



https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html#access_controlling-resources








{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "athena:*" ], "Resource": [ "*" ] } ]}

Example Beispielrichtlinie für Vollzugriff auf eine angegebene Arbeitsgruppe

Die folgende Richtlinie gewährt vollständigen Zugriff auf eine einzelne Arbeitsgruppenressource namensworkgroupA. Sie können diese Richtlinie für Benutzer mit vollständiger Kontrolle über eine bestimmteArbeitsgruppe verwenden.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "athena:ListWorkGroups", "athena:GetExecutionEngine", "athena:GetExecutionEngines", "athena:GetNamespace", "athena:GetCatalogs", "athena:GetNamespaces", "athena:GetTables", "athena:GetTable" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "athena:StartQueryExecution", "athena:GetQueryResults", "athena:DeleteNamedQuery", "athena:GetNamedQuery", "athena:ListQueryExecutions", "athena:StopQueryExecution", "athena:GetQueryResultsStream", "athena:ListNamedQueries", "athena:CreateNamedQuery", "athena:GetQueryExecution", "athena:BatchGetNamedQuery", "athena:BatchGetQueryExecution" ], "Resource": [ "arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA" ] }, { "Effect": "Allow", "Action": [ "athena:DeleteWorkGroup", "athena:UpdateWorkGroup",

257


"athena:GetWorkGroup", "athena:CreateWorkGroup" ], "Resource": [ "arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA" ] } ]}

Example Beispielrichtlinie für die Ausführung von Abfragen in einer angegebenen Arbeitsgruppe

In der folgenden Richtlinie ist ein Benutzer berechtigt, Abfragen in der angegebenen workgroupAauszuführen und anzuzeigen. Der Benutzer darf keine Verwaltungsaufgaben für die Arbeitsgruppe selbstdurchführen, sie also beispielsweise nicht aktualisieren oder löschen.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "athena:ListWorkGroups", "athena:GetExecutionEngine", "athena:GetExecutionEngines", "athena:GetNamespace", "athena:GetCatalogs", "athena:GetNamespaces", "athena:GetTables", "athena:GetTable" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "athena:StartQueryExecution", "athena:GetQueryResults", "athena:DeleteNamedQuery", "athena:GetNamedQuery", "athena:ListQueryExecutions", "athena:StopQueryExecution", "athena:GetQueryResultsStream", "athena:ListNamedQueries", "athena:CreateNamedQuery", "athena:GetQueryExecution", "athena:BatchGetNamedQuery", "athena:BatchGetQueryExecution", "athena:GetWorkGroup" ], "Resource": [ "arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA" ] } ]}

Example Beispielrichtlinie für die Ausführung von Abfragen in der primären Arbeitsgruppe

Im folgenden Beispiel verwenden wir die Richtlinie, die es einem bestimmten Benutzer gestattet, Abfragenin der primären Arbeitsgruppe auszuführen.

258


Note

Wir empfehlen Ihnen, diese Richtlinie allen Benutzern hinzuzufügen, die ansonsten für dieAusführung von Abfragen in ihren bezeichneten Arbeitsgruppen konfiguriert sind. Es ist sinnvoll,diese Richtlinie ihren Arbeitsgruppen-Benutzerrichtlinien hinzuzufügen, falls ihre bezeichneteArbeitsgruppe gelöscht oder deaktiviert wird. Sie können dann weiterhin Abfragen in der primärenArbeitsgruppe ausführen.

Wenn Sie Benutzern in Ihrem Konto die Berechtigung zum Ausführen von Abfragen in der primärenArbeitsgruppe erteilen möchten, fügen Sie die folgende Richtlinie einem Ressourcenabschnitt derBeispielrichtlinie für die Ausführung von Abfragen in einer angegebenen Arbeitsgruppe (p. 258) hinzu.

"arn:aws:athena:us-east-1:123456789012:workgroup/primary"

Example Beispielrichtlinie für Verwaltungsoperationen in einer angegebenen Arbeitsgruppe

In der folgenden Richtlinie ist ein Benutzer berechtigt, eine Arbeitsgruppe test_workgroup zu erstellen,zu löschen, Details darüber abzurufen und die Arbeitsgruppe zu aktualisieren.

{ "Effect": "Allow", "Action": [ "athena:CreateWorkGroup", "athena:GetWorkGroup", "athena:DeleteWorkGroup", "athena:UpdateWorkGroup" ], "Resource": [ "arn:aws:athena:us-east-1:123456789012:workgroup/test_workgroup" ]}

Example Beispielrichtlinie für die Auflistung von Arbeitsgruppen

Mit der folgenden Richtlinie erhalten alle Benutzer die Berechtigung, alle Arbeitsgruppen aufzulisten:

{ "Effect": "Allow", "Action": [ "athena:ListWorkGroups" ], "Resource": "*"}

Example Beispielrichtlinie für die Ausführung und das Stoppen von Abfragen in einer angegebenenArbeitsgruppe

In dieser Richtlinie ist ein Benutzer berechtigt, Abfragen in der Arbeitsgruppe auszuführen:

{ "Effect": "Allow", "Action": [ "athena:StartQueryExecution", "athena:StopQueryExecution" ], "Resource": [ "arn:aws:athena:us-east-1:123456789012:workgroup/test_workgroup" ]}

259

Amazon Athena BenutzerhandbuchArbeitsgruppeneinstellungen

Example Beispielrichtlinie für die Arbeit mit benannten Abfragen in einer angegebenenArbeitsgruppe

In der folgenden Richtlinie verfügt ein Benutzer über Berechtigungen zum Erstellen, Löschen und Abrufenvon Informationen über benannte Abfragen in der angegebenen Arbeitsgruppe:

{ "Effect": "Allow", "Action": [ "athena:CreateNamedQuery", "athena:GetNamedQuery", "athena:DeleteNamedQuery" ], "Resource": [ "arn:aws:athena:us-east-1:123456789012:workgroup/test_workgroup" ]}

ArbeitsgruppeneinstellungenJede Arbeitsgruppe hat folgende Einstellungen:

• Einen eindeutigen Namen: Dieser kann zwischen 1 und 128 Zeichen umfassen, einschließlichalphanumerischer Zeichen, Bindestriche und Unterstriche. Der Name einer erstellten Arbeitsgruppekann nicht nachträglich geändert werden. Sie können jedoch eine neue Arbeitsgruppe mit denselbenEinstellungen und einem anderen Namen erstellen.

• Einstellungen, die für alle in der Arbeitsgruppe ausgeführten Abfragen gelten. Dazu gehören dieFolgenden:• Ein Speicherort in Amazon S3 für Abfrageergebnisse aller Abfragen, die in dieser Arbeitsgruppe

ausgeführt werden. Beim Erstellen der Arbeitsgruppe können Sie nur einen bereits vorhandenenSpeicherort angeben.

• Eine Verschlüsselungseinstellung, wenn Sie eine Verschlüsselung für alle Arbeitsgruppenabfragenverwenden. Sie haben nur die Möglichkeit, alle Abfragen in einer Arbeitsgruppe, nicht nur einigezu verschlüsseln. Am besten erstellen Sie separate Arbeitsgruppen für verschlüsselte und nichtverschlüsselte Abfragen.

Darüber hinaus können Sie clientseitige Einstellungen überschreiben (p. 261). Vor der Freigabevon Arbeitsgruppen können Sie den Speicherort für Ergebnisse sowie Verschlüsselungsoptionen alsParameter im JDBC- oder ODBC-Treiber oder auf der Registerkarte Properties (Eigenschaften) in derAthena-Konsole angeben. Diese Einstellungen könnten auch direkt über die API-Operationen angegebenwerden. Die Einstellungen werden auch als „clientseitige Einstellungen” bezeichnet. Mit Arbeitsgruppenkönnen Sie diese Einstellungen auf Arbeitsgruppenebene konfigurieren und die Kontrolle darüberdurchsetzen. So müssen Ihre Benutzer die Einstellungen nicht einzeln festlegen. Wenn Sie OverrideClient-Side Settings (Clientseitige Einstellungen überschreiben) auswählen, verwenden die Abfragen dieArbeitsgruppeneinstellungen und ignorieren die clientseitigen Einstellungen.

Bei Auswahl von Override Client-Side Settings (Clientseitige Einstellungen überschreiben) werdendie Benutzer auf der Konsole darüber informiert, dass ihre Einstellungen geändert wurden. Wenndie Arbeitsgruppeneinstellungen auf diese Weise durchgesetzt werden, können die Benutzer dieentsprechenden clientseitigen Einstellungen auslassen. So werden bei der Ausführung von Abfragenin der Konsole die Einstellungen der Arbeitsgruppe verwendet, auch wenn es für Abfragen clientseitigeEinstellungen gibt. Auch wenn Sie Abfragen in dieser Arbeitsgruppe über die Befehlszeilenschnittstelle,API-Operationen oder die Treiber ausführen, werden alle von Ihnen angegebenen Einstellungen mit denEinstellungen der Arbeitsgruppe überschrieben. Dies betrifft den Speicherort der Abfrageergebnisse unddie Verschlüsselung. Wenn Sie prüfen möchten, welche Einstellungen für die Arbeitsgruppe verwendetwerden, zeigen Sie die Details der Arbeitsgruppe an (p. 265).

260

Amazon Athena BenutzerhandbuchVerwalten von Arbeitsgruppen

Sie können auch Abfragelimits (p. 270) für Abfragen in Arbeitsgruppen festlegen.

Arbeitsgruppeneinstellungen überschreiben clientseitigeEinstellungenIn den Dialogfenstern Create workgroup (Arbeitsgruppe erstellen) und Edit workgroup (Arbeitsgruppebearbeiten) gibt es ein Feld mit der Bezeichnung Override client-side settings (Clientseitige Einstellungenüberschreiben). Diese Funktion ist standardmäßig nicht ausgewählt. Je nachdem, ob Sie das Feldauswählen, führt Athena die folgenden Schritte aus:

• Wenn Override client-side settings (Clientseitige Einstellungen überschreiben) nicht ausgewählt ist,werden die Arbeitsgruppeneinstellungen nicht durchgesetzt. In diesem Fall verwendet Athena füralle Abfragen, die in dieser Arbeitsgruppe ausgeführt werden, die clientseitigen Einstellungen fürden Speicherort der Abfrageergebnisse und die Verschlüsselung. Jeder Benutzer kann clientseitigeEinstellungen im Menü Settings (Einstellungen) auf der Konsole angeben. Wenn die clientseitigenEinstellungen nicht verwendet werden, gelten die arbeitsgruppenweiten Einstellungen, diese werdenjedoch nicht erzwungen. Auch wenn Sie Abfragen in dieser Arbeitsgruppe über die API-Operationen,die Befehlszeilenschnittstelle oder die JDBC- und ODBC-Treiber ausführen und dort den Speicherortder Abfrageergebnisse und die Verschlüsselung angeben, verwenden Ihre Abfragen weiterhin dieseEinstellungen.

• Bei Auswahl von Override client-side settings (Clientseitige Einstellungen überschreiben) verwendetAthena die arbeitsgruppenweiten Einstellungen für den Speicherort der Abfrageergebnisse und dieVerschlüsselung. Außerdem werden alle anderen Einstellungen überschrieben, die Sie für die Abfrage inder Konsole, über die API-Operationen oder die Treiber angegeben haben. Dies betrifft Sie nur bei derAusführung von Abfragen in dieser Arbeitsgruppe. In diesem Fall werden Arbeitsgruppeneinstellungenverwendet.

Wenn Sie clientseitige Einstellungen überschreiben, wird das im folgenden Beispiel dargestellteDialogfeld zur Benachrichtigung angezeigt, wenn Sie oder ein Benutzer der Arbeitsgruppe dasnächste Mal die Athena-Konsole öffnen. Sie werden darüber benachrichtigt, dass Abfragen in dieserArbeitsgruppe Arbeitsgruppeneinstellungen verwenden, und aufgefordert, diese Änderung zu bestätigen.

Important

Wenn Sie Abfragen über die API-Operationen, die Befehlszeilenschnittstelle oder die JDBC- undODBC-Treiber ausführen und Ihre Einstellungen nicht an die Einstellungen der Arbeitsgruppeangepasst haben, werden Ihre Abfragen zwar ausgeführt, verwenden jedoch die Einstellungender Arbeitsgruppe. Aus Gründen der Konsistenz wird empfohlen, dass Sie in diesem Fallkeine clientseitigen Einstellungen angeben oder die Einstellungen Ihrer Abfrage in Bezug aufErgebnisspeicherort und Verschlüsselung an die Einstellungen der Arbeitsgruppe anpassen.Wenn Sie prüfen möchten, welche Einstellungen für die Arbeitsgruppe verwendet werden,zeigen Sie die Details der Arbeitsgruppe an (p. 265).

Verwalten von ArbeitsgruppenSie können in der https://console.aws.amazon.com/athena/ folgende Aufgaben ausführen:

261



Statement Beschreibung

Erstellen vonArbeitsgruppen (p. 262)

Erstellen einer neuen Arbeitsgruppe.

Bearbeiten vonArbeitsgruppen (p. 264)

Bearbeiten einer Arbeitsgruppe und Ändern ihrer Einstellungen. Sie könnenden Namen einer Arbeitsgruppe nicht ändern, aber eine neue Arbeitsgruppemit denselben Einstellungen und einem anderen Namen erstellen.

Anzeigen derArbeitsgruppendetails (p. 265)

Anzeigen der Details der Arbeitsgruppe, z. B. Name, Beschreibung,Limits für die Datennutzung, Speicherort von Abfrageergebnissen undVerschlüsselung. Sie können auch überprüfen, ob diese Arbeitsgruppe ihreEinstellungen erzwingt, wenn Override client-side settings (ClientseitigeEinstellungen überschreiben) markiert ist.

Löschen vonArbeitsgruppen (p. 266)

Löschen von Arbeitsgruppen. Wenn Sie eine Arbeitsgruppe löschen,werden der Abfrageverlauf, die gespeicherten Abfragen, die Einstellungender Arbeitsgruppe und die Limits zur Kontrolle der Datennutzung ebenfallsgelöscht. Die arbeitsgruppenweiten Limits zur Kontrolle der Datennutzungbleiben in CloudWatch erhalten. Sie können diese einzeln löschen.

Die primäre Arbeitsgruppe kann nicht gelöscht werden.

Wechseln zwischenArbeitsgruppen (p. 267)

Wechseln zwischen Arbeitsgruppen, auf die Sie Zugriff haben.

Aktivieren undDeaktivieren vonArbeitsgruppen (p. 267)

Aktivieren oder Deaktivieren einer Arbeitsgruppe. Wenn eine Arbeitsgruppedeaktiviert wird, können ihre Benutzer keine Abfragen ausführen oderneue benannte Abfragen erstellen. Wenn Sie auf sie zugreifen können,können Sie weiter Metriken, Limits zur Kontrolle der Datennutzung,Arbeitsgruppeneinstellungen, den Abfrageverlauf und gespeicherteAbfragen anzeigen.

Angeben einerArbeitsgruppe, in derAbfragen ausgeführtwerden sollen (p. 267)

Bevor Sie Abfragen ausführen können, müssen Sie Athena angeben,welche Arbeitsgruppe verwendet werden soll. Sie müssen überBerechtigungen für die Arbeitsgruppe verfügen.

Erstellen von ArbeitsgruppenDas Erstellen einer Arbeitsgruppe erfordert Berechtigungen für CreateWorkgroup-API-Aktionen. WeitereInformationen finden Sie unter Zugriff auf Athena-Arbeitsgruppen (p. 229) und IAM-Richtlinien für denZugriff auf Arbeitsgruppen (p. 255). Wenn Sie Tags hinzufügen, müssen Sie auch Berechtigungen fürTagResource hinzufügen. Siehe the section called “Tag-Richtlinienbeispiele” (p. 281).

So erstellen Sie eine Arbeitsgruppe in der Konsole

1. Wählen Sie in der Athena-Konsole die Registerkarte Workgroup: (Arbeitsgruppe:)<workgroup_name>aus. Anschließend wird der Bereich Workgroups (Arbeitsgruppen) angezeigt.

2. Wählen Sie im Bereich Workgroups (Arbeitsgruppen) die Option Create workgroup (Arbeitsgruppeerstellen) aus.

262


3. Füllen Sie im Dialogfeld Create workgroup (Arbeitsgruppe erstellen) die Felder wie folgt aus:

Feld Beschreibung

Workgroup name (Nameder Arbeitsgruppe)

Erforderlich. Geben Sie einen eindeutigen Namen für Ihre Arbeitsgruppeein. Verwenden Sie zwischen 1 und 128 Zeichen. (A – Z, a – z, 0 – 9, _,-, .). Dieser Name kann nicht geändert werden.

Description(Beschreibung)

Optional. Geben Sie eine Beschreibung für Ihre Arbeitsgruppe ein. Siekann bis zu 1024 Zeichen enthalten.

Query result location(Speicherort vonAbfrageergebnissen)

Optional. Geben Sie einen Pfad zu einem Amazon S3-Bucket oder -Präfix ein. Dieser Bucket und dieses Präfix müssen bereits vorhandensein, bevor Sie sie angeben.

Note

Wenn Sie Abfragen in der Konsole ausführen, ist die Angabedes Speicherorts von Abfrageergebnissen optional. WennSie ihn für die Arbeitsgruppe oder in Settings (Einstellungen)nicht angeben, verwendet Athena den Standardspeicherortfür Abfrageergebnisse. Wenn Sie Abfragen mit der API oderden Treibern ausführen, müssen Sie den Speicherort fürAbfrageergebnisse auf mindestens eine der beiden folgendenArten angeben: für einzelne Abfragen mit OutputLocation oderfür die Arbeitsgruppe mit WorkGroupConfiguration.

Encrypt query results(Abfrageergebnisseverschlüsseln)

Optional. Verschlüsseln der in Amazon S3 gespeicherten Ergebnisse.Bei Auswahl werden alle Abfragen in der Arbeitsgruppe verschlüsselt.

Bei Auswahl dieser Option können Sie den Encryptiontype (Verschlüsselungstyp) und den Encryption key(Verschlüsselungsschlüssel) auswählen und den KMS Key ARN (KMS-Schlüssel-ARN) eingeben.

Wenn Sie keinen Schlüssel besitzen, öffnen Sie die AWS KMS-Konsole,um einen Schlüssel zu erstellen. Weitere Informationen finden Sie unterErstellen von Schlüsseln im AWS Key Management Service DeveloperGuide.

Publish toCloudWatch (Zu &CW;veröffentlichen)

Dieses Feld ist standardmäßig ausgewählt. Veröffentlichen vonAbfragemetriken zu Amazon CloudWatch. Weitere Informationen findenSie unter Anzeigen von Abfragemetriken (p. 271).

Override client-sidesettings (ClientseitigeEinstellungenüberschreiben)

Diese Funktion ist standardmäßig nicht ausgewählt. Bei Auswahl werdendie Arbeitsgruppeneinstellungen für alle Abfragen in der Arbeitsgruppeübernommen und die clientseitigen Einstellungen überschrieben.Weitere Informationen finden Sie unter Arbeitsgruppeneinstellungenüberschreiben clientseitige Einstellungen (p. 261).

263

https://docs.aws.amazon.com/athena/latest/APIReference/API_ResultConfiguration.html#athena-Type-ResultConfiguration-OutputLocation

https://docs.aws.amazon.com/athena/latest/APIReference/API_WorkGroupConfiguration.html




Feld Beschreibung

Tags Optional. Hinzufügen von einem oder mehreren Tags zu einerArbeitsgruppe. Ein Tag ist eine Markierung, die Sie einer Athena-Arbeitsgruppenressource zuordnen. Sie besteht aus einem Schlüsselund einem Wert. Verwenden Sie bewährte Methoden für AWS-Tagging-Strategien, um einen konsistenten Satz von Tags zu erstellen undArbeitsgruppen nach Zweck, Besitzer oder Umgebung zu kategorisieren.Sie können Tags auch in IAM-Richtlinien und zur Kontrolle vonAbrechnungskosten verwenden. Verwenden Sie keine doppelten Tag-Schlüssel in derselben Arbeitsgruppe. Weitere Informationen finden Sieunter Markieren von Arbeitsgruppen (p. 277).

S3-Buckets mit Zahlungdurch den Anforderer

Optional. Wählen Sie Enable queries on Requester Pays buckets inAmazon S3 (Abfragen für Buckets mit Zahlung durch den Anfordererin Amazon S3 aktivieren) aus, wenn Arbeitsgruppenbenutzer Abfragenfür Daten ausführen, die in Amazon S3-Buckets gespeichert sind,die als Zahlung durch den Anforderer konfiguriert sind. Dem Kontodes Benutzers, der die Abfrage ausführt, werden die entsprechendenDatenzugriffs- und Datenübertragungsgebühren in Rechnung gestellt,die mit der Abfrage verbunden sind. Weitere Informationen dazufinden Sie unter Buckets mit Zahlung durch den Anforderer imEntwicklerhandbuch für Amazon Simple Storage Service.

4. Wählen Sie Create workgroup (Arbeitsgruppe erstellen) aus. Die Arbeitsgruppe wird in der Liste imBereich Workgroups (Arbeitsgruppen) angezeigt.

Alternativ können Sie die API-Operationen zum Erstellen einer Arbeitsgruppe verwenden.

Important

Nach der Erstellung einer Arbeitsgruppe erstellen Sie IAM-Richtlinien für Arbeitsgruppen (p. 255)in IAM, um arbeitsgruppengezogene Aktionen ausführen zu können.

Bearbeiten von ArbeitsgruppenDas Bearbeiten einer Arbeitsgruppe erfordert Berechtigungen für UpdateWorkgroup-API-Operationen.Weitere Informationen finden Sie unter Zugriff auf Athena-Arbeitsgruppen (p. 229) und IAM-Richtlinien fürden Zugriff auf Arbeitsgruppen (p. 255). Wenn Sie Tags hinzufügen oder bearbeiten, müssen Sie auchBerechtigungen für TagResource besitzen. Siehe the section called “Tag-Richtlinienbeispiele” (p. 281).

So bearbeiten Sie eine Arbeitsgruppe in der Konsole

1. Wählen Sie in der Athena-Konsole die Registerkarte Workgroup: (Arbeitsgruppe:)<workgroup_name>aus. Anschließend wird ein Bereich mit dem Namen Workgroups (Arbeitsgruppen) angezeigt, in demalle Arbeitsgruppen im Konto aufgelistet werden.

264





2. Wählen Sie im Bereich Workgroups (Arbeitsgruppen) die Arbeitsgruppe aus, die Sie bearbeitenmöchten. Anschließend wird der Bereich View details (Details anzeigen) für die Arbeitsgruppe mitausgewählter Registerkarte Overview (Übersicht) angezeigt.

3. Wählen Sie Edit workgroup (Arbeitsgruppe bearbeiten) aus.

4. Ändern Sie die Felder wie gewünscht. Die Liste der Felder finden Sie unter Erstellen vonArbeitsgruppen (p. 262). Sie können alle Felder mit Ausnahme des Namens der Arbeitsgruppeändern. Wenn Sie den Namen ändern müssen, erstellen Sie eine andere Arbeitsgruppe mit dem neuenNamen und denselben Einstellungen.

5. Wählen Sie Save aus. Die aktualisierte Arbeitsgruppe wird in der Liste im Bereich Workgroups(Arbeitsgruppen) angezeigt.

Anzeigen der ArbeitsgruppendetailsSie können die Details jeder Arbeitsgruppe anzeigen. Die Details umfassen den Namen der Arbeitsgruppe,die Beschreibung der Arbeitsgruppe, die Angabe, ob sie aktiviert oder deaktiviert ist, sowie die für in derArbeitsgruppe ausgeführte Abfragen verwendeten Einstellungen. Zu diesen gehören der Speicherort derAbfrageergebnisse und die Verschlüsselungskonfiguration. Wenn es für eine Arbeitsgruppe Limits für dieDatennutzung gibt, werden diese ebenfalls angezeigt.

So zeigen Sie die Arbeitsgruppendetails an

• Wählen Sie im Bereich Workgroups (Arbeitsgruppen) die Arbeitsgruppe aus, die Sie bearbeitenmöchten. Anschließend wird der Bereich View details (Details anzeigen) für die Arbeitsgruppemit ausgewählter Registerkarte Overview (Übersicht) angezeigt. Anschließend werden dieArbeitsgruppendetails wie im folgenden Beispiel gezeigt angezeigt:

265


Löschen von ArbeitsgruppenSie können eine Arbeitsgruppe löschen, wenn Sie die entsprechende Berechtigung besitzen. Die primäreArbeitsgruppe kann nicht gelöscht werden.

Wenn Sie die Berechtigungen besitzen, können Sie eine leere Arbeitsgruppe jederzeit löschen. Sie könnenauch eine Arbeitsgruppe löschen, die gespeicherte Abfragen enthält. In diesem Fall werden Sie vor demLöschen der Arbeitsgruppe von Athena gewarnt, dass gespeicherte Abfragen gelöscht werden.

Wenn Sie eine Arbeitsgruppe löschen, während Sie sich in der Arbeitsgruppe befinden, wechselt dieKonsole zur primären Arbeitsgruppe. Wenn Sie auf diese zugreifen können, können Sie Abfragenausführen und ihre Einstellungen anzeigen.

Wenn Sie eine Arbeitsgruppe löschen, werden ihre Einstellungen und die Limits zur Kontrolle derDatennutzung pro Abfrage gelöscht. Die arbeitsgruppenweiten Limits zur Kontrolle der Datennutzungbleiben in CloudWatch erhalten. Sie können diese löschen, wenn nötig.

Important

Stellen Sie vor dem Löschen einer Arbeitsgruppe sicher, dass ihre Benutzer auch zu anderenArbeitsgruppen gehören, in denen sie weiter Abfragen ausführen können. Wenn die IAM-Richtlinien der Benutzer diese ausschließlich zur Ausführung von Abfragen in dieser Arbeitsgruppeberechtigt haben und Sie diese Arbeitsgruppe löschen, sind sie nicht mehr zum Ausführen vonAbfragen berechtigt. Weitere Informationen finden Sie unter Beispielrichtlinie für die Ausführungvon Abfragen in der primären Arbeitsgruppe (p. 258).

So löschen Sie eine Arbeitsgruppe in der Konsole


2. Wählen Sie im Bereich Workgroups (Arbeitsgruppen) die Arbeitsgruppe aus, die Sie löschen möchten.Anschließend wird der Bereich View details (Details anzeigen) für die Arbeitsgruppe mit ausgewählterRegisterkarte Overview (Übersicht) angezeigt.

3. Wählen Sie Delete workgroup (Arbeitsgruppe löschen) aus und bestätigen Sie die Löschung.

266


Um eine Arbeitsgruppe mit der API-Operation zu löschen, verwenden Sie die Aktion DeleteWorkGroup.

Wechseln zwischen ArbeitsgruppenSie können von einer Arbeitsgruppe zu einer anderen wechseln, wenn Sie für beide ArbeitsgruppenBerechtigungen besitzen.

Sie können innerhalb jeder Arbeitsgruppe bis zu zehn Abfrageregisterkarten öffnen. Wenn Sie zwischenArbeitsgruppen wechseln, bleiben Ihre Abfrageregisterkarten für bis zu drei Arbeitsgruppen geöffnet.

So wechseln Sie zwischen Arbeitsgruppen


2. Wählen Sie im Bereich Workgroups (Arbeitsgruppen) die Arbeitsgruppe aus, zu der Sie wechselnmöchten. Wählen Sie anschließend Switch workgroup (Arbeitsgruppe wechseln) aus.

3. Wählen Sie Switch (Wechseln) aus. In der Konsole wird die Registerkarte Workgroup:(Arbeitsgruppe:)<workgroup_name> mit dem Namen der Arbeitsgruppe angezeigt, zu der Siegewechselt sind. Sie können nun Abfragen in dieser Arbeitsgruppe ausführen.

Aktivieren und Deaktivieren von ArbeitsgruppenWenn Sie über die entsprechenden Berechtigungen verfügen, können Sie in der Konsole mittels der API-Operationen oder JDBC- oder ODBC-Treiber Arbeitsgruppen aktivieren oder deaktivieren.

So aktivieren oder deaktivieren Sie eine Arbeitsgruppe


2. Wählen Sie im Bereich Workgroups (Arbeitsgruppen) die Arbeitsgruppe und anschließend Enableworkgroup (Arbeitsgruppe aktivieren) oder Disable workgroup (Arbeitsgruppe deaktivieren) aus. WennSie eine Arbeitsgruppe deaktivieren, können ihre Benutzer keine Abfragen in ihr ausführen oder neuebenannte Abfragen erstellen. Wenn Sie eine Arbeitsgruppe aktivieren, können Benutzer sie zumAusführen von Abfragen verwenden.

Angeben einer Arbeitsgruppe, in der Abfragen ausgeführt werdensollenBevor Sie Abfragen ausführen können, müssen Sie Athena angeben, welche Arbeitsgruppe verwendetwerden soll. Sie müssen über Berechtigungen für die Arbeitsgruppe verfügen.

So geben Sie eine Arbeitsgruppe für Athena an

1. Stellen Sie sicher, dass Ihre Berechtigungen Ihnen das Ausführen von Abfragen in der Arbeitsgruppeermöglichen, die Sie verwenden möchten. Weitere Informationen finden Sie unter the section called “IAM-Richtlinien für den Zugriff auf Arbeitsgruppen” (p. 255).

267

Amazon Athena BenutzerhandbuchAthena-Arbeitsgruppen-APIs

2. Verwenden Sie eine der folgenden Optionen, um die Arbeitsgruppe für Athena anzugeben:

• Wenn Sie über die Konsole auf Athena zugreifen, legen Sie die Arbeitsgruppe über Wechselnzwischen Arbeitsgruppen (p. 267) fest.

• Wenn Sie die Athena-API-Operationen verwenden, geben Sie den Arbeitsgruppennamen in der API-Aktion an. Sie können beispielsweise den Arbeitsgruppennamen in StartQueryExecution wie folgtfestlegen:

StartQueryExecutionRequest startQueryExecutionRequest = new StartQueryExecutionRequest() .withQueryString(ExampleConstants.ATHENA_SAMPLE_QUERY) .withQueryExecutionContext(queryExecutionContext) .withWorkgroup(WorkgroupName)

• Wenn Sie den JDBC- oder ODBC-Treiber verwenden, legen Sie den Arbeitsgruppennamen mithilfedes Workgroup-Konfigurationsparameters in der Verbindungszeichenfolge fest. Der Treiberübergibt den Namen der Arbeitsgruppe an Athena. Sie geben die Arbeitsgruppenparameter in derVerbindungszeichenfolge wie im folgenden Beispiel gezeigt an:

jdbc:awsathena://AwsRegion=<AWSREGION>;UID=<ACCESSKEY>;PWD=<SECRETKEY>;S3OutputLocation=s3://<athena-output>-<AWSREGION>/;Workgroup=<WORKGROUPNAME>;

Weitere Informationen finden Sie im Abschnitt „Workgroup (Arbeitsgruppe)“ unter dem Link zurTreiberdokumentation, der in der JDBC-Treiberdokumentation (p. 77) enthalten ist.

Athena-Arbeitsgruppen-APIsIm Folgenden werden einige der REST API-Operationen aufgelistet, die für Athena-Arbeitsgruppenverwendet werden. Für alle folgenden Operationen (mit Ausnahme von ListWorkGroups) müssenSie eine Arbeitsgruppe angeben. In anderen Operationen, z. B. StartQueryExecution, ist derArbeitsgruppenparameter optional und die Operationen werden hier nicht aufgelistet. Die vollständige Listeder Operationen finden Sie im Amazon Athena-API-Referenz.

• CreateWorkGroup• DeleteWorkGroup• GetWorkGroup• ListWorkGroups• UpdateWorkGroup

Fehlerbehebung bei ArbeitsgruppenVerwenden Sie die folgenden Tipps, um Fehler für Arbeitsgruppen zu beheben.

• Überprüfen Sie die Berechtigungen für einzelne Benutzer in Ihrem Konto. Sie müssen Zugriff auf denSpeicherort für Abfrageergebnisse und auf die Arbeitsgruppe besitzen, in der sie Abfragen ausführenmöchten. Wenn sie zwischen zwei Arbeitsgruppen wechseln möchten, müssen sie über Berechtigungenfür beide Arbeitsgruppen verfügen. Weitere Informationen finden Sie unter IAM-Richtlinien für den Zugriffauf Arbeitsgruppen (p. 255).

• Achten Sie auf den Kontext in der Athena-Konsole, um zu sehen, in welcher Arbeitsgruppe Sie Abfragenausführen werden. Wenn Sie den Treiber verwenden, müssen Sie die Arbeitsgruppe auf die von Ihnenbenötigte Arbeitsgruppe festlegen. Weitere Informationen finden Sie unter the section called “Angebeneiner Arbeitsgruppe, in der Abfragen ausgeführt werden sollen” (p. 267).

268



https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateWorkGroup.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_DeleteWorkGroup.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_GetWorkGroup.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_ListWorkGroups.html

https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateWorkGroup.html

Amazon Athena BenutzerhandbuchFehlerbehebung bei Arbeitsgruppen

• Wenn Sie die API oder die Treiber für die Ausführung von Abfragen verwenden, müssen Sie denSpeicherort der Abfrageergebnisse mit einem von zwei Verfahren angeben: OutputLocation (clientseitig)oder in der Arbeitsgruppe mit WorkGroupConfiguration. Wenn der Speicherort nicht mit einem dieserVerfahren angegeben wird, gibt Athena bei der Abfrageausführung einen Fehler aus.

• Wenn Sie clientseitige Einstellungen mit Arbeitsgruppeneinstellungen überschreiben, tretenmöglicherweise Fehler für den Speicherort der Abfrageergebnisse auf. Beispielsweise könnte derBenutzer einer Arbeitsgruppe möglicherweise nicht über die nötigen Berechtigungen für den Speicherortder Arbeitsgruppe in Amazon S3 zum Speichern von Abfrageergebnissen verfügen. In diesem Fallmüssen Sie die notwendigen Berechtigungen hinzufügen.

• Arbeitsgruppen führen Änderungen in Bezug auf das Verhalten der API-Operationen ein. Aufrufeder folgenden vorhandenen API-Operationen erfordern, dass Benutzer in Ihrem Konto in IAMüber ressourcenbasierte Berechtigungen für die Arbeitsgruppen verfügen, in denen sie dieseAufrufe ausführen. Wenn keine Berechtigungen für die Arbeitsgruppe und Arbeitsgruppenaktionenvorhanden sind, lösen die folgenden API-Aktionen die Ausnahme AccessDeniedException aus:CreateNamedQuery, DeleteNamedQuery, GetNamedQuery, ListNamedQueries, StartQueryExecution,StopQueryExecution, ListQueryExecutions, GetQueryExecution, GetQueryResults undGetQueryResultsStream. (Die zuletzt genannte API-Aktion ist ausschließlich für die Verwendung mitdem Treiber verfügbar und wird nicht für die öffentlichen Verwendung verfügbar gemacht.) WeitereInformationen finden Sie im Abschnitt über Aktionen, Ressourcen und Bedingungsschlüssel für AmazonAthena im IAM-Benutzerhandbuch.

Aufrufe der API-Operationen BatchGetQueryExecution und BatchGetNamedQuery geben Informationenzur Abfrageausführung ausschließlich für Abfragen zurück, die in Arbeitsgruppen ausgeführt werden,auf die Benutzer zugreifen können. Wenn ein Benutzer keinen Zugriff auf eine Arbeitsgruppe hat,geben diese API-Operationen die ID der nicht autorisierten Abfrage als Teil der Liste nicht verarbeiteterIDs zurück. Weitere Informationen finden Sie unter the section called “ Athena-Arbeitsgruppen-APIs” (p. 268).

• Wenn die Arbeitsgruppe, in der eine Abfrage ausgeführt werden wird, mit einem erzwungenenSpeicherort für Abfrageergebnisse (p. 261) konfiguriert ist, dürfen Sie keinen external_location fürdie CTAS-Abfrage angeben. Wenn dies der Fall ist, gibt Athena eine Fehlermeldung aus und Abfragen,die einen external_location angibt, schlagen fehl. Die folgende Abfrage schlägt beispielsweisefehl, wenn Sie die clientseitigen Einstellungen für den Abfrageergebnisspeicherort überschreibenund die Verwendung eines eigenen Speicherorts für die Arbeitsgruppe erzwingen: CREATE TABLE<DB>.<TABLE1> WITH (format='Parquet', external_location='s3://my_test/test/')AS SELECT * FROM <DB>.<TABLE2> LIMIT 10;

Ihnen werden möglicherweise die folgenden Fehler angezeigt. Diese Tabelle enthält eine Liste miteinigen der Fehler, die im Zusammenhang mit Arbeitsgruppen auftreten können, und entsprechendeLösungsvorschläge.

Fehler für Arbeitsgruppen

Fehler Tritt auf, wenn ...

query state CANCELED. Bytes scannedlimit was exceeded.

Eine Abfrage das Limit für die Datennutzung proAbfrage erreicht und abgebrochen wird. Sie solltendie Abfrage neu schreiben, damit sie wenigerDaten liest, oder sich an den Kontoadministratorwenden.

User: arn:aws:iam::123456789012:user/abc is not authorized to perform:athena:StartQueryExecution onresource: arn:aws:athena:us-east-1:123456789012:workgroup/workgroupname

Ein Benutzer führt eine Abfrage in einerArbeitsgruppe aus, auf die er nicht zugreifenkann. Aktualisieren Sie Ihre Richtlinie, um auf dieArbeitsgruppe zugreifen zu können.

269





Amazon Athena BenutzerhandbuchKontrollieren von Kosten und Überwachung

von Abfragen mit CloudWatch-Metriken

Fehler Tritt auf, wenn ...

INVALID_INPUT. WorkGroup <name> isdisabled.

Ein Benutzer führt eine Abfrage in einerArbeitsgruppe aus, aber die Arbeitsgruppe istdeaktiviert. Ihre Arbeitsgruppe könnte von IhremAdministrator deaktiviert worden sein. Es istauch möglich, dass Sie keinen Zugriff auf dieArbeitsgruppe haben. In beiden Fällen solltenSie sich an einen Administrator wenden, derArbeitsgruppen ändern kann.

INVALID_INPUT. WorkGroup <name> is notfound.

Ein Benutzer führt eine Abfrage in einerArbeitsgruppe aus, aber die Arbeitsgruppe istnicht vorhanden. Dies kann der Fall sein, wenndie Arbeitsgruppe gelöscht wurde. Wechseln Siezu einer anderen Arbeitsgruppe, um Ihre Abfrageauszuführen.

InvalidRequestException: when callingthe StartQueryExecution operation: Nooutput location provided. An outputlocation is required either throughthe Workgroup result configurationsetting or as an API input.

Ein Benutzer führt eine Abfrage mit der API aus,ohne den Speicherort für Abfrageergebnisseanzugeben. Sie müssen den Ausgabespeicherortfür Abfrageergebnisse auf eine der beidenfolgenden Arten festlegen: für einzelne Abfragenunter OutputLocation (clientseitig) oder in derArbeitsgruppe unter WorkGroupConfiguration.

The Create Table As Select queryfailed because it was submitted withan 'external_location' property toan Athena Workgroup that enforcesa centralized output location forall queries. Please remove the'external_location' property andresubmit the query.

Wenn die Arbeitsgruppe, in der eine Abfrageausgeführt wird, mit einem erzwungenenSpeicherort für Abfrageergebnisse (p. 261)konfiguriert wurde und Sie einenexternal_location für die CTAS-Abfrageangeben. Entfernen Sie in diesem Fall denexternal_location und führen Sie die Abfrageerneut aus.

Kontrollieren von Kosten und Überwachung vonAbfragen mit CloudWatch-Metriken

Arbeitsgruppen ermöglichen Ihnen das Festlegen von Limits zur Kontrolle der Datennutzung pro Abfrageoder Arbeitsgruppe, das Einrichten von Alarmen bei Überschreitung dieser Limits und das Veröffentlichenvon Abfragemetriken zu CloudWatch.

In jeder Arbeitsgruppe können Sie folgende Aktionen ausführen:

• Konfigurieren von Data usage controls (Datennutzungskontrollen) pro Abfrage und Arbeitsgruppe undEinrichten von Aktionen, die ausgeführt werden sollen, wenn Abfragen die Schwellenwerte verletzen.

• Anzeigen und Analysieren von Abfragemetriken und ihre Veröffentlichung zu CloudWatch. Wenn Sieeine Arbeitsgruppe in der Konsole erstellen, wird die Einstellung für die Veröffentlichung der Metrikenzu CloudWatch für Sie ausgewählt. Wenn Sie die API-Operationen verwenden, müssen Sie dieVeröffentlichung der Metriken aktivieren (p. 271). Wenn Metriken veröffentlicht werden, werden sie aufder Registerkarte Metrics (Registerkarte) im Bereich Workgroups (Arbeitsgruppen) angezeigt. Metrikensind standardmäßig für die primäre Arbeitsgruppe deaktiviert.

Themen

270



Amazon Athena BenutzerhandbuchAktivieren von CloudWatch-Abfragemetriken

• Aktivieren von CloudWatch-Abfragemetriken (p. 271)• Überwachung von Athena-Abfragen mit CloudWatch-Metriken (p. 271)• Festlegen von Limits zur Kontrolle der Datennutzung (p. 273)

Aktivieren von CloudWatch-AbfragemetrikenWenn Sie eine Arbeitsgruppe in der Konsole erstellen, wird standardmäßig die Einstellung für dieVeröffentlichung von Abfragemetriken zu CloudWatch ausgewählt.

Wenn Sie API-Operationen, die Befehlszeilenschnittstelle oder die Client-Anwendung mit dem JDBC-Treiber zum Erstellen von Arbeitsgruppen verwenden, müssen Sie zum Aktivieren der Veröffentlichung vonAbfragemetriken PublishCloudWatchMetricsEnabled auf true in WorkGroupConfiguration festlegen.Das folgende Beispiel zeigt ausschließlich die Konfiguration von Metriken und lässt andere Konfigurationenaus:

"WorkGroupConfiguration": { "PublishCloudWatchMetricsEnabled": "true" .... }

Überwachung von Athena-Abfragen mit CloudWatch-MetrikenAthena veröffentlicht abfragebezogene Metriken zu Amazon CloudWatch, wenn Publish to CloudWatch (ZuCloudWatch veröffentlichen) ausgewählt ist. Sie können benutzerdefinierte Dashboards erstellen, Alarmeund Auslöser für Metriken in CloudWatch einrichten oder vorab ausgefüllte Dashboards direkt über dieAthena-Konsole verwenden.

Wenn Sie Abfragemetriken für Abfragen in Arbeitsgruppen aktivieren, werden die Metriken für jedeArbeitsgruppe in der Athena-Konsole auf der Registerkarte Metrics (Metriken) im Bereich Workgroups(Arbeitsgruppen) angezeigt.

Athena veröffentlicht die folgenden Metriken zur CloudWatch-Konsole:

• DataScannedInBytes – Gesamtzahl der pro Abfrage gescannten Daten• EngineExecutionTime – in Millisekunden• QueryPlanningTime – in Millisekunden• QueryQueueTime – in Millisekunden• QueryState – erfolgreich, fehlgeschlagen oder abgebrochen• QueryType – DDL oder DML• ServiceProcessingTime – in Millisekunden• TotalExecutionTime – in Millisekunden• WorkGroup – Name der Arbeitsgruppe

Weitere Informationen finden Sie unter Liste von CloudWatch-Metriken für Athena (p. 272) an spätererStelle in diesem Thema.

So zeigen Sie Abfragemetriken für eine Arbeitsgruppe in der Konsole an

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie die Registerkarte Workgroup: (Arbeitsgruppe:)<name> aus.

271



Amazon Athena BenutzerhandbuchÜberwachung von Athena-

Abfragen mit CloudWatch-Metriken

Um die Metriken einer Arbeitsgruppe anzuzeigen, müssen Sie nicht zu dieser wechseln. Sie können ineiner anderen Arbeitsgruppe bleiben. Sie müssen jedoch die Arbeitsgruppe aus der Liste auswählen.Sie müssen auch über die nötigen Berechtigungen für die Anzeige ihrer Metriken verfügen.

3. Wählen Sie die Arbeitsgruppe aus der Liste und anschließend View details (Details anzeigen) aus.Wenn Sie über die nötigen Berechtigungen verfügen, werden die Arbeitsgruppendetails auf derRegisterkarte Overview (Übersicht) angezeigt.

4. Wählen Sie die Registerkarte Metrics aus.

Anschließend werden die Metriken angezeigt.5. Wählen Sie das Intervall aus, in dem Athena die Abfragemetriken aus CloudWatch abrufen soll. Sie

können auch das Aktualisierungssymbol auswählen, um die angezeigten Metriken zu aktualisieren.

So zeigen Sie Metriken in der Amazon CloudWatch-Konsole an

1. Öffnen Sie die Amazon CloudWatch-Konsole unter https://console.aws.amazon.com/cloudwatch/.2. Wählen Sie im Navigationsbereich Metrics aus.3. Wählen Sie den AWS/Athena-Namespace.

So zeigen Sie Metriken im CLI-Dashboard an

• Öffnen Sie eine Eingabeaufforderung und verwenden Sie den folgenden Befehl:

aws cloudwatch list-metrics --namespace "AWS/Athena"

• Verwenden Sie den folgenden Befehl, um alle verfügbaren Metriken aufzulisten:

aws cloudwatch list-metrics --namespace "AWS/Athena"

Liste von CloudWatch-Metriken für AthenaWenn Sie CloudWatch-Metriken in Athena aktiviert haben, werden pro Arbeitsgruppe die folgendenMetriken an CloudWatch gesendet. Die Metriken verwenden den Namespace AWS/Athena.

Metrikname Beschreibung

DataScannedInBytes Die Menge der von Athena pro Abfrage gescannten Daten inMegabytes. Bei Abfragen, die storniert wurden (entweder durch

272

https://console.aws.amazon.com/cloudwatch

Amazon Athena BenutzerhandbuchFestlegen von Limits zur Kontrolle der Datennutzung

Metrikname Beschreibungdie Benutzer oder automatisch, wenn sie das Limit erreicht hatten),schließt dies die Menge der vor der Stornierung durchsuchten Datenein.

EngineExecutionTime Die Anzahl der Millisekunden, die für die Ausführung der Abfragebenötigt wurden.

QueryPlanningTime Die Anzahl der Millisekunden, die Athena zur Planung desAbfrageverarbeitungsflusses benötigt hat. Dies enthält die Zeit, diezum Abrufen von Tabellenpartitionen aus der Datenquelle benötigtwurde. Da die Abfrage-Engine die Abfrageplanung ausführt, ist dieAbfrageplanungszeit eine Teilmenge von EngineExecutionTime.

QueryQueueTime Die Anzahl der Millisekunden, während denen sich die Abfrage inder Abfragewarteschlange befunden und auf Ressourcen gewartethat. Wenn vorübergehende Fehler auftreten, kann die Abfrage derWarteschlange automatisch wieder hinzugefügt werden.

QueryState Der Abfragestatus.

Gültige Statistiken: Erfolgreich, Fehlgeschlagen, Abgebrochen

QueryType Der Abfragetyp.

Gültige Statistiken: DDL oder DML.

ServiceProcessingTime Anzahl der Millisekunden, die Athena für die Verarbeitung derAbfrageergebnisse benötigt hat, nachdem die Abfrage-Engine dieAbfrageausführung abgeschlossen hatte.

TotalExecutionTime Die Anzahl der Millisekunden, die Athena zum Ausführen der Abfragebenötigt hat.

WorkGroup Der Name der Arbeitsgruppe.

Festlegen von Limits zur Kontrolle der DatennutzungAthena ermöglicht Ihnen das Festlegen von zwei Arten von Kostenkontrollen: Limit pro Abfrage und Limitpro Arbeitsgruppe. Für jede Arbeitsgruppe können Sie nur ein Limit pro Abfrage festlegen. Sie könnenjedoch mehrere Limits pro Arbeitsgruppe festlegen.

• Das Limit zur Kontrolle pro Abfrage gibt die Gesamtmenge der pro Abfrage gescannten Daten an. Wenneine in der Arbeitsgruppe ausgeführte Abfrage das Limit überschreitet, wird sie abgebrochen. Sie könnenin einer Arbeitsgruppe nur ein Limit zur Kontrolle pro Abfrage erstellen. Dieses Limit gilt für jede in derArbeitsgruppe ausgeführte Abfrage. Bearbeiten Sie das Limit, wenn Sie es ändern müssen. DetaillierteAnweisungen finden Sie unter So erstellen Sie eine Kontrolle der Datennutzung pro Abfrage (p. 274).

• Das arbeitsgruppenweite Limit zur Kontrolle der Datennutzung gibt die Gesamtmenge der gescanntenDaten für alle Abfragen an, die in dieser Arbeitsgruppe während des angegebenen Zeitraums ausgeführtwerden. Sie können mehrere Limits pro Arbeitsgruppe erstellen. Das arbeitsgruppenweite Limit fürAbfragen ermöglicht Ihnen das Festlegen verschiedener Schwellenwerte für stündliche oder täglicheDatenaggregate, die von in der Arbeitsgruppe ausgeführten Abfragen gescannt werden.

Wenn die Gesamtmenge der gescannten Daten den Schwellenwert überschreitet, können Sie eine derfolgenden Aktionen wählen:

273


• Konfigurieren eines Amazon SNS-Alarms und einer -Aktion in der Athena-Konsole, um bei Verletzungdes Limits einen Administrator zu benachrichtigen. Detaillierte Anweisungen finden Sie unter Soerstellen Sie eine Kontrolle der Datennutzung pro Arbeitsgruppe (p. 275). Sie können darüber hinauseinen Alarm und eine Aktion für alle Metriken festlegen, die Athena aus der CloudWatch-Konsoleveröffentlicht. Beispielsweise können Sie eine Warnung für eine Reihe von fehlgeschlagenen Abfragenfestlegen. Diese Warnung kann eine E-Mail an einen Administrator auslösen, wenn die Zahl einenbestimmten Schwellenwert überschreitet. Wenn das Limit überschritten wird, sendet eine Aktion eineAmazon SNS-Alarmbenachrichtigung an die angegebenen Benutzer.

• eine Lambda-Funktion aufrufen Weitere Informationen finden Sie unter Aufrufen von Lambda-Funktionen mit Amazon SNS-Benachrichtigungen im Entwicklerhandbuch für Amazon SimpleNotification Service.

• Durch Deaktivieren der Arbeitsgruppe wird die Ausführung aller weiteren Abfragen gestoppt.

Die Limits pro Abfrage und pro Arbeitsgruppe sind voneinander unabhängig. Die angegebene Aktion wirdausgeführt, wenn eines der beiden Limits überschritten wird. Wenn zwei oder mehr Benutzer zur selbenZeit in derselben Arbeitsgruppe Abfragen ausführen, ist es möglich, dass die einzelnen Abfragen zwarkeines der angegebenen Limits überschreiten, die Gesamtmenge der gescannter Daten jedoch das Limitfür die Datennutzung pro Arbeitsgruppe überschreitet. In diesem Fall wird ein Amazon SNS-Alarm an dieBenutzer gesendet.

So erstellen Sie eine Kontrolle der Datennutzung pro Abfrage

Das Limit zur Kontrolle pro Abfrage gibt die Gesamtmenge der pro Abfrage gescannten Daten an.Wenn eine in der Arbeitsgruppe ausgeführte Abfrage das Limit überschreitet, wird sie abgebrochen.Abgebrochene Abfragen werden entsprechend den Amazon Athena-Preisen berechnet.

Note

Im Fall von abgebrochenen oder fehlgeschlagenen Abfragen hat Athena möglicherweise bereitspartielle Ergebnisse zu Amazon S3 geschrieben. In diesen Fällen löscht Athena die partiellenErgebnisse nicht aus dem Amazon S3-Präfix, in dem Ergebnisse gespeichert werden. Siemüssen das Amazon S3-Präfix mit den partiellen Ergebnissen entfernen. Athena verwendetmehrteilige Amazon S3-Uploads zum Schreiben von Daten zu Amazon S3. Wir empfehlen, dieBucket-Lebenszyklusrichtlinie so festzulegen, dass beim Fehlschlagen von Abfragen mehrteiligeUploads abgebrochen werden. Weitere Informationen finden Sie unter Abbrechen unvollständigermehrteiliger Uploads mit einer Bucket-Lebenszyklusrichtlinie im Entwicklerhandbuch für AmazonSimple Storage Service.

Sie können in einer Arbeitsgruppe nur ein Limit zur Kontrolle pro Abfrage erstellen. Dieses Limit gilt für jedein der Arbeitsgruppe ausgeführte Abfrage. Bearbeiten Sie das Limit, wenn Sie es ändern müssen.


Um eine Datennutzungskontrolle für eine Abfrage in einer bestimmten Arbeitsgruppe zu erstellen,müssen Sie nicht zu dieser Arbeitsgruppe wechseln. Sie können in einer anderen Arbeitsgruppebleiben. Sie müssen jedoch die Arbeitsgruppe aus der Liste auswählen und über die nötigenBerechtigungen für die Bearbeitung der Arbeitsgruppe verfügen.

3. Wählen Sie die Arbeitsgruppe aus der Liste und anschließend View details (Details anzeigen) aus.Wenn Sie über die nötigen Berechtigungen verfügen, werden die Arbeitsgruppendetails auf derRegisterkarte Overview (Übersicht) angezeigt.

4. Wählen Sie die Registerkarte Data usage controls (Datennutzungskontrollen) aus. Das Dialogfeld PerQuery Data Usage Control (Datennutzungskontrolle pro Abfrage) wird angezeigt.

274

https://docs.aws.amazon.com/sns/latest/dg/sns-lambda-as-subscriber.html

https://docs.aws.amazon.com/sns/latest/dg/sns-lambda-as-subscriber.html

https://aws.amazon.com/athena/pricing/

https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config

https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config



5. Geben Sie die Feldwerte wie folgt an (oder aktualisieren Sie die Feldwerte wie folgt):

• Geben Sie in Data limit (Datenlimit) einen Wert zwischen 10000 KB (Minimum) und 7 EB (Maximum)an.

Note

Dies sind von der Konsole für Datennutzungskontrollen innerhalb von Arbeitsgruppenvorgegebene Limits. Es handelt sich nicht um Abfragenlimits in Athena.

• Wähen Sie in „Units (Einheiten)“ den Einheitenwert aus der Dropdown-Liste aus.• Prüfen Sie den Standardwert für Action (Aktion). Der Standardwert für Action (Aktion) ist der

Abbruch der Abfrage bei Überschreiten des Limits. Diese Aktion kann nicht geändert werden.6. Wählen Sie Create (Erstellen) aus, wenn Sie ein neues Limit erstellen, oder Update (Aktualisieren),

wenn Sie ein vorhandenes Limit bearbeiten. Wenn Sie ein vorhandenes Limit bearbeiten, aktualisierenSie die Registerkarte Overview (Übersicht), um das aktualisierte Limit anzuzeigen.

So erstellen Sie eine Kontrolle der Datennutzung pro Arbeitsgruppe

Das arbeitsgruppenweite Limit zur Kontrolle der Datennutzung gibt die Gesamtmenge der gescanntenDaten für alle Abfragen an, die in dieser Arbeitsgruppe während des angegebenen Zeitraums ausgeführtwerden. Sie können mehrere Limits zur Kontrolle der Datennutzung pro Arbeitsgruppe erstellen. Wenn dasLimit überschritten wird, können Sie eine Aktion ausführen, z. B. eine Amazon SNS-Alarmbenachrichtigungan die angegebenen Benutzer senden.


Um eine Datennutzungskontrolle für eine bestimmte Arbeitsgruppe zu erstellen, müssen Sie nichtzu dieser Arbeitsgruppe wechseln. Sie können in einer anderen Arbeitsgruppe bleiben. Sie müssenjedoch die Arbeitsgruppe aus der Liste auswählen und über die nötigen Berechtigungen für dieBearbeitung der Arbeitsgruppe verfügen.

3. Wählen Sie die Arbeitsgruppe aus der Liste und anschließend View details (Details anzeigen) aus.Wenn Sie über die nötigen Bearbeitungsberechtigungen verfügen, werden die Arbeitsgruppendetailsauf der Registerkarte Overview (Übersicht) angezeigt.

4. Wählen Sie die Registerkarte Data usage controls (Datennutzungskontrollen) aus und scrollen Sienach unten. Wählen Sie anschließend Workgroup Data Usage Control (Datennutzungskontrolle fürArbeitsgruppe) aus, um ein neues Limit zu erstellen oder ein vorhandenes Limit zu bearbeiten. DasDialogfeld Create workgroup data usage control (Datennutzungskontrolle pro Arbeitsgruppe erstellen)wird angezeigt.

275



5. Geben Sie die Feldwerte wie folgt an:

• Geben Sie in Data limits (Datenlimits) einen Wert zwischen 10000 KB (Minimum) und 7 EB(Maximum) an.

Note

Dies sind von der Konsole für Datennutzungskontrollen innerhalb von Arbeitsgruppenvorgegebene Limits. Es handelt sich nicht um Abfragenlimits in Athena.

• Wähen Sie in „Units (Einheiten)“ den Einheitenwert aus der Dropdown-Liste aus.• Wählen Sie in „Time period (Zeitraum)“ einen Zeitraum aus der Dropdown-Liste aus.• Wählen Sie in Action (Aktion) das Amazon SNS-Thema aus der Dropdown-Liste aus, wenn es

konfiguriert ist. Wählen Sie andernfalls Create an Amazon SNS topic (&SNS;-Thema erstellen) aus,um direkt zur Amazon SNS-Konsole zu wechseln. Erstellen Sie dort das Amazon SNS-Thema undrichten Sie für einen Benutzer in Ihrem Athena-Konto ein Abonnement für das Thema ein. WeitereInformationen finden Sie unter Erstellen eines Amazon SNS-Themas im Handbuch „Erste Schritte”für Amazon Simple Notification Service.

6. Wählen Sie Create (Erstellen) aus, wenn Sie ein neues Limit erstellen, oder Save (Speichern), wennSie ein vorhandenes Limit bearbeiten. Wenn Sie ein vorhandenes Limit bearbeiten, aktualisieren Siedie Registerkarte Overview (Übersicht) für die Arbeitsgruppe, um das aktualisierte Limit anzuzeigen.

276

https://console.aws.amazon.com/sns/v2/home

https://docs.aws.amazon.com/sns/latest/gsg/creating-an-sns-topic.html

Amazon Athena BenutzerhandbuchGrundlagen zu Tags

Markieren von ArbeitsgruppenEin Tag besteht aus einem Schlüssel und einem Wert, die Sie beide selbst definieren können. WennSie eine Arbeitsgruppe markieren, weisen Sie ihr benutzerdefinierte Metadaten zu. Mit Tags könnenSie AWS-Ressourcen auf unterschiedliche Weise kategorisieren (z. B. nach Zweck, Eigentümer oderUmgebung). Für Athena ist die Arbeitsgruppe die Ressource, die Sie markieren können. So könnenSie beispielsweise eine Reihe von Tags für Arbeitsgruppen in Ihrem Konto erstellen, mit deren Hilfe SieEigentümer von Arbeitsgruppen nachverfolgen oder Arbeitsgruppen anhand ihres Zwecks identifizierenkönnen. Wir empfehlen die Verwendung der Bewährten Methoden für das AWS Tagging zum Erstelleneines konsistenten Satzes von Tags, um die Anforderungen Ihres Unternehmens zu erfüllen.

Sie können mit Tags arbeiten, indem Sie die Athena-Konsole oder die API-Operationen verwenden.

Themen• Grundlagen zu Tags (p. 277)• Tag-Einschränkungen (p. 278)• Arbeiten mit Tags in der Konsole (p. 278)• Arbeiten mit Tags mithilfe der API-Aktionen (p. 280)• Tagbasierte IAM-Zugriffssteuerungsrichtlinien (p. 281)

Grundlagen zu TagsEin Tag ist eine Markierung, die Sie einer Athena-Ressource zuordnen. Jeder Tag besteht aus einemSchlüssel und einem optionalen Wert, beides können Sie bestimmen.

Mit Tags können Sie AWS-Ressourcen auf unterschiedliche Weise kategorisieren. Sie können zum Beispieleine Reihe von Tags für die Arbeitsgruppen in Ihrem Konto definieren, um die Eigentümer oder den Zweckder einzelnen Arbeitsgruppen nachzuverfolgen.

Sie können Tags beim Erstellen einer neuen Athena-Arbeitsgruppe hinzufügen. Außerdem können SieTags einer bestehenden Arbeitsgruppe hinzufügen, in dieser bearbeiten oder aus dieser entfernen. Siekönnen einen Tag in der Konsole bearbeiten. Wenn Sie die API-Operationen zur Bearbeitung eines Tagsverwenden, entfernen Sie den alten Tag, und fügen Sie einen neuen hinzu. Wenn Sie eine Arbeitsgruppelöschen, werden alle Tags dazu ebenfalls gelöscht. Andere Arbeitsgruppen in Ihrem Konto verwendenweiterhin diese Tags.

Athena weist nicht automatisch Tags zu Ihren Ressourcen, etwa Ihren Arbeitsgruppen, zu. Sie können Tag-Schlüssel und Werte bearbeiten und Tags jederzeit von einer Arbeitsgruppe entfernen. Sie können denWert eines Tags zwar auf eine leere Zeichenfolge, jedoch nicht Null festlegen. Fügen Sie keine doppeltenTag-Schlüssel gleichzeitig derselben Arbeitsgruppe hinzu. In diesem Fall gibt Athena eine Fehlermeldungaus. Wenn Sie eine Arbeitsgruppe mit einem vorhandenen Tagschlüssel in einer separaten TagResource-Aktion markieren, überschreibt der neue Tagwert den alten.

In IAM können Sie steuern, welche Benutzer in Ihrem AWS-Konto zum Erstellen, Bearbeiten, Entfernenoder Auflisten von Tags berechtigt sind. Weitere Informationen finden Sie unter the section called “Tag-Richtlinienbeispiele” (p. 281).

Die vollständige Liste der Amazon Athena-Tag-Aktionen finden Sie in den API-Aktionsnamen im AmazonAthena-API-Referenz.

Sie können die gleichen Tags für die Fakturierung verwenden. Weitere Informationen finden Sie unterVerwendung von Tags für die Fakturierung im AWS Billing and Cost Management-Benutzerhandbuch.

277





Amazon Athena BenutzerhandbuchTag-Einschränkungen

Weitere Informationen finden Sie unter Tag-Einschränkungen (p. 278).

Tag-EinschränkungenFür Tags gelten zwei Einschränkungen:

• In Athena, können Sie Arbeitsgruppen markieren. Abfragen können nicht markiert werden.• Die maximale Anzahl der Tags pro Arbeitsgruppe ist 50. Um innerhalb dieser grenze zu bleiben, prüfen

und entfernen Sie nicht verwendete Tags.• Jeder Tag muss für jede Arbeitsgruppe eindeutig sein, und jeder Tag kann nur einen Wert haben. Fügen

Sie keine doppelten Tag-Schlüssel gleichzeitig derselben Arbeitsgruppe hinzu. In diesem Fall gibt Athenaeine Fehlermeldung aus. Wenn Sie eine Arbeitsgruppe mit einem vorhandenen Tagschlüssel in einerseparaten TagResource-Aktion markieren, überschreibt der neue Tagwert den alten.

• Die Tagschlüssellänge ist 1-128 Unicode-Zeichen in UTF-8.• Die Tagwertlänge ist 0-256 Unicode-Zeichen in UTF-8.

Tagging-Operationen, wie etwa das Hinzufügen, Bearbeiten, Entfernen oder Auflisten von Tags,erfordern, dass Sie für die Arbeitsgruppenressource einen ARN angeben.

• Athena ermöglicht die Verwendung von Buchstaben, Ziffern, Leerräumen in UTF-8 sowie der folgendenZeichen: + - = . _ : / @.

• Bei Tag-Schlüsseln und -Werten muss die Groß-/Kleinschreibung beachtet werden.• Verwenden Sie nicht das Präfix "aws:" in Tagschlüsseln. Dieses Präfix ist für AWS reserviert. Sie

können keine Tag-Schlüssel oder mit diesem Präfix bearbeiten oder löschen. Tags mit diesem Präfixwerden nicht für Ihr Tags-pro-Ressource-Limit angerechnet.

• Die von Ihnen zugewiesenen Tags sind nur für Ihr AWS-Konto verfügbar.

Arbeiten mit Tags in der KonsoleMithilfe der Athena-Konsole können Sie sehen, welche Tags von den einzelnen Arbeitsgruppen in IhremKonto verwendet werden. Sie können Tags nur nach Arbeitsgruppe anzeigen. Sie können auch dieAthena-Konsole verwenden, um Tags von jeweils einer Arbeitsgruppe anzuwenden, zu bearbeiten oder zuentfernen.

Sie können Arbeitsgruppen mithilfe der Tags, die Sie erstellt haben, suchen.

Themen• Anzeigen von Tags für einzelne Arbeitsgruppen (p. 278)• Hinzufügen und Löschen von Tags für einzelne Arbeitsgruppen (p. 279)

Anzeigen von Tags für einzelne ArbeitsgruppenSie können Tags für eine einzelne Arbeitsgruppe in der Athena-Konsole anzeigen.

Wählen Sie zur Anzeige einer Liste der Tags für Arbeitsgruppe die Arbeitsgruppe aus, wählen Sie ViewDetails (Details anzeigen) und dann die Registerkarte Tags. Die Liste der Tags für die Arbeitsgruppe wirdangezeigt. Sie können auch Tags in einer Arbeitsgruppe anzeigen, wenn Sie die Option Edit Workgroup(Arbeitsgruppe bearbeiten) auswählen.

Wählen Sie zur Suche nach Tags die Registerkarte Tags und dann Manage Tags (Tags verwalten). GebenSie dann in das Suchwerkzeug den Namen eines Tags ein.

278

Amazon Athena BenutzerhandbuchHinzufügen und Löschen von

Tags für einzelne Arbeitsgruppen

Hinzufügen und Löschen von Tags für einzelneArbeitsgruppenSie können Tags für einzelne Arbeitsgruppen direkt auf der Registerkarte Workgroups (Arbeitsgruppen)verwalten.

So fügen Sie Tags beim Erstellen einer neuen Arbeitsgruppe hinzu:

Note

Stellen Sie sicher, dass Sie einem Benutzer IAM-Berechtigungen für die Aktionen TagResourceund CreateWorkGroup geben, wenn Sie ihm erlauben möchten, bei der Erstellung einerArbeitsgruppe in der Konsole Tags hinzuzufügen oder Tags bei CreateWorkGroup einzugeben.

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/.2. Wählen Sie im Navigationsmenü die Registerkarte Workgroups (Arbeitsgruppen).3. Wählen Sie Create workgroup (Arbeitsgruppe erstellen), und füllen Sie die Werte nach Bedarf ein. Die

detaillierten Schritte finden Sie unter Erstellen von Arbeitsgruppen (p. 262).4. Fügen Sie einen oder mehrere Tags hinzu, indem Sie Schlüssel und Werte angeben. Fügen Sie keine

doppelten Tag-Schlüssel gleichzeitig derselben Arbeitsgruppe hinzu. In diesem Fall gibt Athena eineFehlermeldung aus. Weitere Informationen finden Sie unter Tag-Einschränkungen (p. 278).

5. Wählen Sie anschließend „Create Workgroup (Arbeitsgruppe erstellen)“.

So fügen Sie einen Tag einer vorhandenen Arbeitsgruppe hinzu oder bearbeiten ihn:

Note

Stellen Sie sicher, dass Sie einem Benutzer IAM-Berechtigungen für die Aktionen TagResourceund CreateWorkGroup geben, wenn Sie ihm erlauben möchten, bei der Erstellung einerArbeitsgruppe in der Konsole Tags hinzuzufügen oder Tags bei CreateWorkGroup einzugeben.

1. Öffnen Sie die Athena-Konsole unter https://console.aws.amazon.com/athena/, wählen Sie dieRegisterkarte Workgroups (Arbeitsgruppen), und wählen Sie die Arbeitsgruppe aus.

2. Wählen Sie View details (Details anzeigen) oder Edit workgroup (Arbeitsgruppe bearbeiten).3. Wählen Sie die Registerkarte Tags aus.4. Wählen Sie auf der Registerkarte Tags die Option Manage tags (Tags verwalten), und geben

Sie dann Schlüssel und Wert für jeden Tag an. Weitere Informationen finden Sie unter Tag-Einschränkungen (p. 278).

279



Amazon Athena BenutzerhandbuchArbeiten mit Tags mithilfe der API-Aktionen

5. Klicken Sie abschließend auf Save.

So löschen Sie einen Tag aus einer einzelnen Arbeitsgruppe:

1. Öffnen Sie die Athena-Konsole, und wählen Sie die Registerkarte Workgroups (Arbeitsgruppen) aus.2. Wählen Sie in der Arbeitsgruppenliste die Arbeitsgruppe sowie View details (Details anzeigen) und

dann die Registerkarte Tags.3. Wählen Sie auf der Registerkarte Tags die Option Manage tags (Tags verwalten).4. Wählen Sie in der Tagliste die Schaltfläche delete (löschen) (ein Kreuz) für den Tag und dann Save

(Speichern).

Arbeiten mit Tags mithilfe der API-AktionenSie können auch die API-Operation CreateWorkGroup mit dem optionalen Tag-Parameter verwenden,mit dem Sie einen oder mehrere Tags für die Arbeitsgruppe eingeben können. Zum Hinzufügen, Entfernenoder Auflisten von Tags können Sie die folgenden AWS-API-Operationen verwenden: TagResource,UntagResource und ListTagsForResource.

Tag-API-Aktionen in Athena

API-Name Aktionsbeschreibung

TagResource Hinzufügen oder Überschreiben eines odermehrerer Tags für die Arbeitsgruppe mit demangegebenen ARN.

UntagResource Löschen eines oder mehrerer Tags aus derArbeitsgruppe mit dem angegebenen ARN.

ListTagsForResource Auflisten eines oder mehrerer Tags aus derArbeitsgruppenressource mit dem angegebenenARN.

Weitere Informationen finden Sie im Amazon Athena-API-Referenz.

280


Amazon Athena BenutzerhandbuchTagbasierte IAM-Zugriffssteuerungsrichtlinien

Example TagResource

Im folgenden Beispiel fügen wir zwei Tags workgroupA hinzu:

List<Tag> tags = new ArrayList<>();tags.add(new Tag().withKey("tagKey1").withValue("tagValue1"));tags.add(new Tag().withKey("tagKey2").withValue("tagValue2"));

TagResourceRequest request = new TagResourceRequest() .withResourceARN("arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA") .withTags(tags);

client.tagResource(request);

Note

Fügen Sie keine doppelten Tag-Schlüssel gleichzeitig derselben Arbeitsgruppe hinzu. In diesemFall gibt Athena eine Fehlermeldung aus. Wenn Sie eine Arbeitsgruppe mit einem vorhandenenTagschlüssel in einer separaten TagResource-Aktion markieren, überschreibt der neue Tagwertden alten.

Example UntagResource

Im folgenden Beispiel entfernen wir tagKey2 aus workgroupA:

List<String> tagKeys = new ArrayList<>();tagKeys.add("tagKey2");

UntagResourceRequest request = new UntagResourceRequest() .withResourceARN("arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA") .withTagKeys(tagKeys);

client.untagResource(request);

Example ListTagsForResource

Im folgenden Beispiel listen wir die Tags für workgroupA auf:

ListTagsForResourceRequest request = new ListTagsForResourceRequest() .withResourceARN("arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA");

ListTagsForResourceResult result = client.listTagsForResource(request);

List<Tag> resultTags = result.getTags();

Tagbasierte IAM-ZugriffssteuerungsrichtlinienMit Tags können Sie eine IAM-Richtlinie schreiben, die den Bedingungsblock zum Steuern des Zugriffs aufArbeitsgruppen basierend auf ihren Tags enthält.

Tag-RichtlinienbeispieleExample 1. Grundlegende Markierungsrichtlinie

Die folgende IAM-Richtlinie ermöglicht Ihnen das Ausführen von Abfragen und die Interaktion mit Tags fürdie Arbeitsgruppe mit dem Namen workgroupA:

281

Amazon Athena BenutzerhandbuchTag-Richtlinienbeispiele

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "athena:ListWorkGroups", "athena:GetExecutionEngine", "athena:GetExecutionEngines", "athena:GetNamespace", "athena:GetCatalogs", "athena:GetNamespaces", "athena:GetTables", "athena:GetTable" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "athena:StartQueryExecution", "athena:GetQueryResults", "athena:DeleteNamedQuery", "athena:GetNamedQuery", "athena:ListQueryExecutions", "athena:StopQueryExecution", "athena:GetQueryResultsStream", "athena:GetQueryExecutions", "athena:ListNamedQueries", "athena:CreateNamedQuery", "athena:GetQueryExecution", "athena:BatchGetNamedQuery", "athena:BatchGetQueryExecution", "athena:GetWorkGroup", "athena:TagResource", "athena:UntagResource", "athena:ListTagsForResource" ], "Resource": "arn:aws:athena:us-east-1:123456789012:workgroup/workgroupA" } ]}

Example 2: Richtlinienblock, der Aktionen auf einer Arbeitsgruppe auf der Grundlage einesTagschlüssel-/Tagwert-Paares verweigert

Tags, die einer bestehenden Arbeitsgruppe zugeordnet sind, werden als Ressourcen-Tags bezeichnet.Ressourcen-Tags ermöglichen das Schreiben von Richtlinienblöcken wie den folgenden, die dieaufgeführten Aktionen auf mit dem Tagschlüssel-/Tagwert-Paar markierten Arbeitsgruppen verweigern, wieetwa: stack, production.

{ "Effect": "Deny", "Action": [ "athena:StartQueryExecution", "athena:GetQueryResults", "athena:DeleteNamedQuery", "athena:UpdateWorkGroup", "athena:GetNamedQuery", "athena:ListQueryExecutions", "athena:GetWorkGroup", "athena:StopQueryExecution", "athena:GetQueryResultsStream",

282

Amazon Athena BenutzerhandbuchTag-Richtlinienbeispiele

"athena:GetQueryExecutions", "athena:ListNamedQueries", "athena:CreateNamedQuery", "athena:GetQueryExecution", "athena:BatchGetNamedQuery", "athena:BatchGetQueryExecution", "athena:TagResource", "athena:UntagResource", "athena:ListTagsForResource" ], "Resource": "arn:aws:athena:us-east-1:123456789012:workgroup/*", "Condition": { "StringEquals": { "aws:ResourceTag/stack": "production" } }}

Example 3. Richtlinienblock, der Tags ändernde Aktionsanfragen auf die angegebenen Tagsbeschränkt

Als Parameter an eine Tags ändernde API-Aktion übergebene Tags, wie etwa CreateWorkGroup mitTags, TagResource oder UntagResource werden als Anforderungs-Tags bezeichnet. VerwendenSie diese Tags, wie in dem folgenden Richtlinienblockbeispiel gezeigt. Die ermöglicht CreateWorkGroupnur, wenn bei der Erstellung einer Arbeitsgruppe einer der beinhalteten Tags ein Tag mit dem Schlüsselcostcentermit einem der zulässigen Tagwerte ist: 1, 2 oder 3.

Hinweis: Stellen Sie sicher, dass Sie einem Benutzer IAM-Berechtigungen für die API-OperationenTagResource und CreateWorkGroup geben, wenn sie bei CreateWorkGroup Tags eingeben könnensollen.

{ "Effect": "Allow", "Action": [ "athena:CreateWorkGroup", "athena:TagResource" ], "Resource": "arn:aws:athena:us-east-1:123456789012:workgroup/*", "Condition": { "StringEquals": { "aws:RequestTag/costcenter": [ "1", "2", "3" ] } }}

283

Amazon Athena BenutzerhandbuchProtokollieren von Amazon Athena-

API-Aufrufen mit AWS CloudTrail

Überwachungsprotokolle undFehlerbehebung

Untersuchen Sie Athena-Anfragen mit CloudTrail-Protokollen und Fehlerbehebungsabfragen.

Themen• Protokollieren von Amazon Athena-API-Aufrufen mit AWS CloudTrail (p. 284)• Fehlersuche (p. 287)

Protokollieren von Amazon Athena-API-Aufrufen mitAWS CloudTrail

Athena ist in AWS CloudTrail integriert, einen Service, der die Aktionen eines Benutzers, einer Rolle odereines AWS-Service in Athena protokolliert.

CloudTrail erfasst alle API-Aufrufe für Athena als Ereignisse. Zu den erfassten Aufrufen gehören Aufrufevon der Athena-Konsole und Code-Aufrufe der Athena-API-Operationen. Wenn Sie einen Trail erstellen,können Sie die kontinuierliche Bereitstellung von CloudTrail-Ereignissen an einen Amazon S3-Bucketaktivieren, einschließlich Ereignissen für Athena. Auch wenn Sie keinen Trail konfigurieren, können Sie dieneuesten Ereignisse in der CloudTrail-Konsole in Event history (Ereignisverlauf) anzeigen.

Mit den von CloudTrail gesammelten Informationen können Sie die an Athena gestellte Anforderung, dieIP-Adresse, von der die Anforderung gestellt wurde, den Initiator sowie den Zeitpunkt der Anforderung undweitere Angaben bestimmen.

Weitere Informationen zu CloudTrail finden Sie im AWS CloudTrail User Guide.

Sie können mit Athena auch CloudTrail-Protokolldateien abfragen. Weitere Informationen finden Sie unterAbfragen von AWS CloudTrail CloudTrail-Protokollen (p. 190) und CloudTrail SerDe (p. 294).

Athena-Informationen in CloudTrailCloudTrail wird beim Erstellen Ihres AWS-Kontos für Sie aktiviert. Die in Athena auftretenden Aktivitätenwerden als CloudTrail-Ereignis zusammen mit anderen AWS-Serviceereignissen in Event history(Ereignisverlauf) aufgezeichnet. Sie können die neusten Ereignisse in Ihrem AWS-Konto anzeigen, suchenund herunterladen. Weitere Informationen finden Sie unter Anzeigen von Ereignissen mit dem CloudTrail-API-Ereignisverlauf.

Erstellen Sie für eine fortlaufende Aufzeichnung der Ereignisse in Ihrem AWS-Konto, darunter Ereignissefür Athena, einen Trail. Ein Trail ermöglicht CloudTrail die Übermittlung von Protokolldateien an einenAmazon S3-Bucket. Wenn Sie einen Pfad in der Konsole anlegen, gilt dieser standardmäßig für alleAWS-Regionen. Der Trail protokolliert Ereignisse aus allen Regionen in der AWS-Partition und stellt dieProtokolldateien in dem Amazon S3-Bucket bereit, den Sie angeben. Darüber hinaus können Sie andereAWS-Services konfigurieren, um die in den CloudTrail-Protokollen erfassten Ereignisdaten weiter zuanalysieren und entsprechend zu agieren. Weitere Informationen finden Sie unter:

• Übersicht zum Erstellen eines Pfads• In CloudTrail unterstützte Services und Integrationen

284

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations

Amazon Athena BenutzerhandbuchGrundlagen zu Athena-Protokolldateieinträgen

• Konfigurieren von Amazon SNS-Benachrichtigungen für CloudTrail• Empfangen von CloudTrail-Protokolldateien aus mehreren Regionen und EmpfangenCloudTrail von

Protokolldateien aus mehreren Konten

Alle Athena-Aktionen werden von CloudTrail protokolliert und in der Amazon Athena-API-Referenzdokumentiert. Zum Beispiel generieren Aufrufe der Aktionen StartQueryExecution und GetQueryResultsEinträge in den CloudTrail-Protokolldateien.

Jedes Event oder jeder Protokolleintrag enthält Informationen über den Ersteller der Anfrage. Anhand derIdentitätsinformationen zur Benutzeridentität können Sie Folgendes bestimmen:

• Ob die Anfrage mit Root- oder AWS Identity and Access Management-Benutzeranmeldeinformationen(IAM) ausgeführt wurde.

• Ob die Anfrage mit temporären Sicherheitsanmeldeinformationen für eine Rolle oder einen föderiertenBenutzer ausgeführt wurde.

• Ob die Anfrage von einem anderen AWS-Service getätigt wurde.

Weitere Informationen finden Sie unter CloudTrail-Element "userIdentity".

Grundlagen zu Athena-ProtokolldateieinträgenEin Trail ist eine Konfiguration, durch die Ereignisse an den von Ihnen angegebenen Amazon S3-Bucket übermittelt werden. CloudTrail-Protokolldateien können einen oder mehrere Einträge enthalten.Ein Ereignis stellt eine einzelne Anfrage aus einer beliebigen Quelle dar und enthält unter anderemInformationen über die angeforderte Aktion, das Datum und die Uhrzeit der Aktion sowie über dieAnfrageparameter. CloudTrail-Protokolldateien sind kein geordnetes Stacktrace der öffentlichen API-Aufrufe und erscheinen daher nicht in einer bestimmten Reihenfolge.

In den folgenden Beispielen finden Sie CloudTrail-Protokolleinträge für:

• StartQueryExecution (erfolgreich) (p. 285)• StartQueryExecution (fehlgeschlagen) (p. 286)• CreateNamedQuery (p. 286)

StartQueryExecution (erfolgreich){ "eventVersion":"1.05", "userIdentity":{ "type":"IAMUser", "principalId":"EXAMPLE_PRINCIPAL_ID", "arn":"arn:aws:iam::123456789012:user/johndoe", "accountId":"123456789012", "accessKeyId":"EXAMPLE_KEY_ID", "userName":"johndoe" }, "eventTime":"2017-05-04T00:23:55Z", "eventSource":"athena.amazonaws.com", "eventName":"StartQueryExecution", "awsRegion":"us-east-1", "sourceIPAddress":"77.88.999.69", "userAgent":"aws-internal/3", "requestParameters":{ "clientRequestToken":"16bc6e70-f972-4260-b18a-db1b623cb35c", "resultConfiguration":{ "outputLocation":"s3://athena-johndoe-test/test/"

285

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html




https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html

Amazon Athena BenutzerhandbuchGrundlagen zu Athena-Protokolldateieinträgen

}, "query":"Select 10" }, "responseElements":{ "queryExecutionId":"b621c254-74e0-48e3-9630-78ed857782f9" }, "requestID":"f5039b01-305f-11e7-b146-c3fc56a7dc7a", "eventID":"c97cf8c8-6112-467a-8777-53bb38f83fd5", "eventType":"AwsApiCall", "recipientAccountId":"123456789012"}

StartQueryExecution (fehlgeschlagen){ "eventVersion":"1.05", "userIdentity":{ "type":"IAMUser", "principalId":"EXAMPLE_PRINCIPAL_ID", "arn":"arn:aws:iam::123456789012:user/johndoe", "accountId":"123456789012", "accessKeyId":"EXAMPLE_KEY_ID", "userName":"johndoe" }, "eventTime":"2017-05-04T00:21:57Z", "eventSource":"athena.amazonaws.com", "eventName":"StartQueryExecution", "awsRegion":"us-east-1", "sourceIPAddress":"77.88.999.69", "userAgent":"aws-internal/3", "errorCode":"InvalidRequestException", "errorMessage":"Invalid result configuration. Should specify either output location or result configuration", "requestParameters":{ "clientRequestToken":"ca0e965f-d6d8-4277-8257-814a57f57446", "query":"Select 10" }, "responseElements":null, "requestID":"aefbc057-305f-11e7-9f39-bbc56d5d161e", "eventID":"6e1fc69b-d076-477e-8dec-024ee51488c4", "eventType":"AwsApiCall", "recipientAccountId":"123456789012"}

CreateNamedQuery{ "eventVersion":"1.05", "userIdentity":{ "type":"IAMUser", "principalId":"EXAMPLE_PRINCIPAL_ID", "arn":"arn:aws:iam::123456789012:user/johndoe", "accountId":"123456789012", "accessKeyId":"EXAMPLE_KEY_ID", "userName":"johndoe" }, "eventTime":"2017-05-16T22:00:58Z", "eventSource":"athena.amazonaws.com", "eventName":"CreateNamedQuery", "awsRegion":"us-west-2", "sourceIPAddress":"77.88.999.69", "userAgent":"aws-cli/1.11.85 Python/2.7.10 Darwin/16.6.0 botocore/1.5.48",

286

Amazon Athena BenutzerhandbuchFehlersuche

"requestParameters":{ "name":"johndoetest", "queryString":"select 10", "database":"default", "clientRequestToken":"fc1ad880-69ee-4df0-bb0f-1770d9a539b1" }, "responseElements":{ "namedQueryId":"cdd0fe29-4787-4263-9188-a9c8db29f2d6" }, "requestID":"2487dd96-3a83-11e7-8f67-c9de5ac76512", "eventID":"15e3d3b5-6c3b-4c7c-bc0b-36a8dd95227b", "eventType":"AwsApiCall", "recipientAccountId":"123456789012"},

FehlersucheVerwenden Sie diese Dokumentationsthemen für die Fehlerbehebung in Amazon Athena.

• Service Limits (p. 357)• Einschränkungen (p. 343)• Nicht unterstützte DDLs (p. 325)• Namen für Tabellen, Datenbanken und Spalten (p. 35)• Datentypen (p. 316)• Unterstützte SerDes- und Daten-Formate (p. 289)• Komprimierungsformate (p. 314)• Reservierte Wörter (p. 36)• Fehlerbehebung bei Arbeitsgruppen (p. 268)

Verwenden Sie weiterhin die folgenden AWS-Ressourcen:

• Athena-Themen im AWS-Wissenszentrum• Athena-Diskussionsforum• Athena-Postings im AWS Big Data Blog

287

https://aws.amazon.com/premiumsupport/knowledge-center/#athena

https://forums.aws.amazon.com/forum.jspa?forumID=242

http://aws.amazon.com/blogs/big-data/tag/amazon-athena/

Amazon Athena BenutzerhandbuchVerwenden eines SerDe

SerDe-ReferenzAthena unterstützt mehrere SerDe-Bibliotheken zur Analyse von Daten mit unterschiedlichenDatenformaten wie CSV, JSON, Parquet und ORC. Athena unterstützt keine benutzerdefinierten SerDes.

Themen• Verwenden eines SerDe (p. 288)• Unterstützte SerDes- und Daten-Formate (p. 289)• Komprimierungsformate (p. 314)

Verwenden eines SerDeEin SerDe (Serializer/Deserializer) ist eine Methode, mit der Athena mit Daten in verschiedenen Formateninteragiert.

Es ist der von Ihnen angegebene SerDe und nicht die DDL, die zur Definition des Tabellenschemasverwendet wurde. Anders ausgedrückt kann der SerDe die DDL-Konfiguration überschreiben, die Sie inAthena beim Erstellen der Tabelle festgelegt haben.

SO verwenden Sie SerDe-AbfragenUm einen SerDe beim Erstellen einer Tabelle in Athena zu verwenden, nutzen Sie eine der folgendenMethoden:

• Verwenden Sie DDL-Anweisungen, um die Lese- und Schreibvorgänge für Tabellendaten zubeschreiben und geben Sie kein ROW FORMAT an, wie in diesem Beispiel. Dadurch wird das Auflistendes tatsächlichen SerDe-Typs übersprungen und der native LazySimpleSerDe wird standardmäßigverwendet.

In der Regel verwendet Athena den LazySimpleSerDe, wenn Sie kein ROW FORMAT angeben oder wennSie ROW FORMAT DELIMITED angeben.

ROW FORMATDELIMITED FIELDS TERMINATED BY ','ESCAPED BY '\\'COLLECTION ITEMS TERMINATED BY '|'MAP KEYS TERMINATED BY ':'

• Geben Sie den von Athena beim Lesen und Schreiben von Tabellendaten verwendeten SerDe-Typexplizit an. Geben Sie auch zusätzliche Eigenschaften in SERDEPROPERTIES wie in diesem Beispiel an.

ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe'WITH SERDEPROPERTIES ('serialization.format' = ',','field.delim' = ',','collection.delim' = '|','mapkey.delim' = ':','escape.delim' = '\\')

288

Amazon Athena BenutzerhandbuchUnterstützte SerDes- und Daten-Formate

Unterstützte SerDes- und Daten-FormateAthena unterstützt das Erstellen von Tabellen und das Abfragen von Daten aus Dateien im CSV-, TSV-und JSON-Format sowie im benutzerdefinierten, durch Trennzeichen getrennten Format; aus Daten ausHadoop-bezogenen Formaten wie ORC, Apache Avro und Parquet, aus Logstash-Protokollen, aus AWSCloudTrail-Protokollen und aus Apache WebServer-Protokollen.

Note

Die in diesem Abschnitt aufgeführten Formate werden von Athena für das Lesen von Datenverwendet. Weitere Informationen zu Formaten, die Athena zum Schreiben von Daten beimAusführen von CTAS-Abfragen verwendet, finden Sie unter Erstellen einer Tabelle ausAbfrageergebnissen (CTAS) (p. 126).

Zum Erstellen von Tabellen und zum Abfragen von Daten in diesen Formaten in Athena geben Sie eineKlasse vom Typ "serializer-deserializer" (SerDe) an, sodass Athena weiß, welches Format verwendet wirdund wie die Daten analysiert werden.

Diese Tabelle enthält die Datenformate, die in Athena unterstützt werden, sowie die entsprechendenSerDe-Bibliotheken.

Ein SerDe ist eine benutzerdefinierte Bibliothek, die festlegt, wie der von Athena verwendete Datenkatalogdie Daten verarbeitet. Sie geben einen SerDe-Typ an, indem Sie diesen explizit in Athena im ROWFORMAT-Teil Ihrer CREATE TABLE-Anweisung aufführen. In einigen Fällen können Sie den SerDe-Namenweglassen, da Athena standardmäßig einige SerDe-Typen für bestimmte Arten von Datenformatenverwendet.

Unterstützte Formate für Daten und SerDes

Datenformat Beschreibung In Athena unterstützte SerDe-Typen

CSV (Comma Separated Values,durch Komma getrennte Werte)

Für Daten im CSV-Format stelltjede Zeile einen Datensatz darund jeder Datensatz bestehtaus mehreren durch Kommatagetrennten Feldern.

• Verwenden Sie denLazySimpleSerDe für CSV-und TSV-Dateien sowie fürbenutzerdefinierte, durchTrennzeichen getrennteDateien (p. 304), wennIhre Daten keine Werte inAnführungszeichen enthalten.

• Verwenden Sie denOpenCSVSerDe zurVerarbeitung von CSV-Daten (p. 295), wennIhre Daten Werte inAnführungszeichen oderandere Trenn- oder Escape-Zeichen enthalten.

TSV (Tab-Separated Values,tabulatorgetrennte Werte)

Bei Daten im TSV-Format stelltjede Zeile einen Datensatz darund jeder Datensatz besteht ausmehreren durch Tabulatorengetrennten Feldern.

Verwenden Sie denLazySimpleSerDe für CSV-und TSV-Dateien sowie fürbenutzerdefinierte, durchTrennzeichen getrennteDateien (p. 304) und geben Siedas Trennzeichen als FIELDSTERMINATED BY '\t' an.

289

Amazon Athena BenutzerhandbuchUnterstützte SerDes- und Daten-Formate

Datenformat Beschreibung In Athena unterstützte SerDe-Typen

Benutzerdefiniert, durchTrennzeichen getrennt

Bei Daten in diesem Formatstellt jede Zeile einen Datensatzdar. Die Datensätze sind durchbenutzerdefinierte Trennzeichengetrennt.

Verwenden Sie denLazySimpleSerDe für CSV-und TSV-Dateien sowie fürbenutzerdefinierte, durchTrennzeichen getrennteDateien (p. 304) und geben Siebenutzerdefinierte Trennzeichenan.

JSON (JavaScript ObjectNotation)

Bei JSON-Daten stellt jede Zeileeinen Datensatz dar und jederDatensatz besteht aus Attribut/Werte-Paaren und Arrays, diedurch Komma getrennt sind.

• Verwenden Sie den Hive JSONSerDe (p. 301).

• Verwenden Sie den OpenXJSON SerDe (p. 302).

Apache Avro Ein Format zum Speichern vonDaten in Hadoop, bei dem JSON-basierte Schemas zum Erfassenvon Werten verwendet werden.

Verwenden Sie den AvroSerDe (p. 291).

ORC (Optimized Row Columnar) Ein Format für die optimiertespaltenbasierte Speicherung vonHive-Daten.

Verwenden Sie den ORC-SerDe (p. 309) und die ZLIB-Komprimierung.

Apache Parquet Ein Format für diespaltenbasierte Speicherung vonDaten in Hadoop.

Verwenden Sie den ParquetSerDe (p. 312) und dieSNAPPY-Komprimierung.

Logstash-Protokolle Ein Format zum Speichern vonProtokollen in Logstash.

Verwenden Sie den GrokSerDe (p. 298).

Apache WebServer-Protokolle Ein Format zum Speichernvon Protokollen in ApacheWebServer.

Verwenden Sie denRegexSerDe zur Verarbeitungvon Apache Webserver-Protokollen (p. 293).

CloudTrail-Protokolle Ein Format zum Speichern vonProtokollen in CloudTrail.

• Verwenden Sie den CloudTrailSerDe (p. 294) zumAbfragen der meisten Felder inCloudTrail-Protokollen.

• Verwenden Sie den OpenXJSON SerDe (p. 302) fürFelder, bei denen das Formatvom Service abhängt. WeitereInformationen finden Sie unterCloudTrail SerDe (p. 294).

Themen• Avro SerDe (p. 291)• RegexSerDe zur Verarbeitung von Apache Webserver-Protokollen (p. 293)• CloudTrail-SerDe (p. 294)• OpenCSVSerDe für CSV-Verarbeitung (p. 295)• Grok SerDe (p. 298)

290

Amazon Athena BenutzerhandbuchAvro SerDe

• JSON SerDe-Bibliotheken (p. 301)• LazySimpleSerDe für CSV- und TSV-Dateien sowie für benutzerdefinierte, durch Trennzeichen

getrennte Dateien (p. 304)• ORC SerDe (p. 309)• Parquet SerDe (p. 312)

Avro SerDeSerDe-NameAvro SerDe

Name der Bibliothekorg.apache.hadoop.hive.serde2.avro.AvroSerDe

BeispieleAthena unterstützt aus Sicherheitsgründen nicht die Verwendung von avro.schema.url zur Angabedes Tabellenschemas. Verwenden Sie avro.schema.literal. Sie können Apache avro-tools-<version>.jar mit dem Parameter getschema verwenden, um ein Schema aus Daten im Avro-Formatzu extrahieren. Dadurch erhalten Sie ein Schema, das Sie in Ihrer WITH SERDEPROPERTIES-Anweisungnutzen können. Beispiel:

java -jar avro-tools-1.8.2.jar getschema my_data.avro

Die Datei avro-tools-<version>.jar befindet sich im Unterverzeichnis java Ihrer installierten Avro-Version. Informationen zum Herunterladen von Avro finden Sie unter Apache Avro Releases. Informationenzum direkten Herunterladen der Apache Avro-Tools finden Sie unter Apache Avro Tools Maven Repository.

Nach dem Abrufen eines Schemas können Sie mit einer CREATE TABLE-Anweisung eine Athena-Tabellebasierend auf in Amazon S3 gespeicherten Avro-Daten erstellen. In ROW FORMAT müssen Sie Avro SerDewie folgt angeben: ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'.Wie im folgenden Beispiel gezeigt, müssen Sie das Schema mithilfe der Klausel WITH SERDEPROPERTIESangeben, zusätzlich zur Angabe der Spaltennamen und der entsprechenden Datentypen für die Tabelle.

Note

Sie können Daten in anderen Regionen als der Region abfragen, in der Athena ausgeführtwird. Neben den Athena-Standardgebühren fallen auch die Amazon S3-Standardgebührenfür regionenübergreifende Datenübertragung an. Ersetzen Sie zum Senken derDatenübertragungskosten myregion in s3://athena-examples-myregion/path/to/data/durch die Regions-ID der Region, in der Sie Athena ausführen, z. B. s3://athena-examples-us-east-1/path/to/data/.

CREATE EXTERNAL TABLE flights_avro_example ( yr INT, flightdate STRING, uniquecarrier STRING, airlineid INT, carrier STRING, flightnum STRING, origin STRING, dest STRING, depdelay INT, carrierdelay INT,

291

https://cwiki.apache.org/confluence/display/Hive/AvroSerDe

https://cwiki.apache.org/confluence/display/Hive/AvroSerDe

http://avro.apache.org/releases.html#Download

https://mvnrepository.com/artifact/org.apache.avro/avro-tools

Amazon Athena BenutzerhandbuchAvro SerDe

weatherdelay INT)PARTITIONED BY (year STRING)ROW FORMATSERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'WITH SERDEPROPERTIES ('avro.schema.literal'='{ "type" : "record", "name" : "flights_avro_subset", "namespace" : "default", "fields" : [ { "name" : "yr", "type" : [ "null", "int" ], "default" : null }, { "name" : "flightdate", "type" : [ "null", "string" ], "default" : null }, { "name" : "uniquecarrier", "type" : [ "null", "string" ], "default" : null }, { "name" : "airlineid", "type" : [ "null", "int" ], "default" : null }, { "name" : "carrier", "type" : [ "null", "string" ], "default" : null }, { "name" : "flightnum", "type" : [ "null", "string" ], "default" : null }, { "name" : "origin", "type" : [ "null", "string" ], "default" : null }, { "name" : "dest", "type" : [ "null", "string" ], "default" : null }, { "name" : "depdelay", "type" : [ "null", "int" ], "default" : null }, { "name" : "carrierdelay", "type" : [ "null", "int" ], "default" : null }, { "name" : "weatherdelay", "type" : [ "null", "int" ], "default" : null } ]}')STORED AS AVROLOCATION 's3://athena-examples-myregion/flight/avro/';

Führen Sie die MSCK REPAIR TABLE-Anweisung auf der Tabelle aus, um die Partitionsmetadaten zuaktualisieren.

MSCK REPAIR TABLE flights_avro_example;

292

Amazon Athena BenutzerhandbuchRegexSerDe zur Verarbeitung von

Apache Webserver-Protokollen

Fragen Sie die am häufigsten genutzten 10 Abflugstädte, gemessen an der Anzahl der Abflüge, ab.

SELECT origin, count(*) AS total_departuresFROM flights_avro_exampleWHERE year >= '2000'GROUP BY originORDER BY total_departures DESCLIMIT 10;

Note

Die Daten der Flugtabelle stammen aus Flights, die vom US-amerikanischen Straßenverkehrsamt,Büro für Transportstatisiken bereitgestellt wird. Vom Original entsättigt.

RegexSerDe zur Verarbeitung von ApacheWebserver-ProtokollenSerDe-NameRegexSerDe

Name der BibliothekRegexSerDe

BeispieleIm folgenden Beispiel wird eine Tabelle aus CloudFront-Protokollen mit der RegExSerDe aus dem TutorialAthenaErste Schritte erstellt.

Note


CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_logs ( `Date` DATE, Time STRING, Location STRING, Bytes INT, RequestIP STRING, Method STRING, Host STRING, Uri STRING, Status INT, Referrer STRING, os STRING, Browser STRING, BrowserVersion STRING ) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ( "input.regex" = "^(?!#)([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+[^\(]+[\(]([^\;]+).*\%20([^\/]+)[\/](.*)$"

293

http://www.transtats.bts.gov/DL_SelectFields.asp?Table_ID=236&DB_Short_Name=On-Time

http://www.transtats.bts.gov/

https://hive.apache.org/javadocs/r1.2.2/api/org/apache/hadoop/hive/serde2/RegexSerDe.html

Amazon Athena BenutzerhandbuchCloudTrail-SerDe

) LOCATION 's3://athena-examples-myregion/cloudfront/plaintext/';

CloudTrail-SerDeAWS CloudTrail ist ein Service zur Aufzeichnung von AWS-API-Aufrufen und Ereignissen für AWS-Konten.CloudTrail generiert verschlüsselte Protokolle und speichert sie in Amazon S3. Mithilfe von Athena könnenSie diese Protokolle direkt aus Amazon S3 abfragen, wenn Sie die LOCATION der Protokolle angeben.

Um CloudTrail-Protokolle in Athena abzufragen, erstellen Sie aus den Protokollen eine Tabelle unddeserialisieren Sie die Protokolldaten mit dem CloudTrail-SerDe (Serializer/Deserializer).

Zusätzlich zur Verwendung des CloudTrail-SerDe ist für einige Instances der Einsatz eines anderes SerDeoder eine JSON-Datenextraktion erforderlich. Bestimmte Felder der CloudTrail-Protokolle sind STRING-Werte und können – abhängig vom Service – variable Datenformate aufweisen. Daher können sie vomCloudTrail-SerDe nicht vorhersagbar deserialisiert werden. Zum Abfragen der folgenden Felder ermittelnSie das Datenmuster und setzen dann einen anderen SerDe ein, beispielsweise den OpenX JSON-SerDe (p. 302). Alternativ können Sie die Daten aus diesen Feldern mit den JSON_EXTRACT-Funktionenextrahieren. Weitere Informationen finden Sie unter Extracting Data From JSON (p. 163).

• requestParameters

• responseElements

• additionalEventData

• serviceEventDetails

SerDe-NameCloudTrail SerDe

Name der Bibliothekcom.amazon.emr.hive.serde.CloudTrailSerde

BeispieleIm folgenden Beispiel wird der CloudTrail-SerDe mit fiktionalen Protokollen verwendet, um eine auf diesenbasierende Tabelle zu erstellen.

In diesem Beispiel werden die Felder requestParameters, responseElements undadditionalEventData als Teil des in JSON verwendeten Datentyps STRUCT eingebunden. ExtrahierenSie die Daten aus diesen Feldern mit den JSON_EXTRACT-Funktionen. Weitere Informationen finden Sieunter Extracting Data From JSON (p. 163).

CREATE EXTERNAL TABLE cloudtrail_logs (eventversion STRING,userIdentity STRUCT< type:STRING, principalid:STRING, arn:STRING, accountid:STRING, invokedby:STRING, accesskeyid:STRING, userName:STRING,sessioncontext:STRUCT<attributes:STRUCT< mfaauthenticated:STRING, creationdate:STRING>,sessionIssuer:STRUCT<

294

Amazon Athena BenutzerhandbuchOpenCSVSerDe für CSV-Verarbeitung

type:STRING, principalId:STRING, arn:STRING, accountId:STRING, userName:STRING>>>,eventTime STRING,eventSource STRING,eventName STRING,awsRegion STRING,sourceIpAddress STRING,userAgent STRING,errorCode STRING,errorMessage STRING,requestParameters STRING,responseElements STRING,additionalEventData STRING,requestId STRING,eventId STRING,resources ARRAY<STRUCT< ARN:STRING, accountId:STRING, type:STRING>>,eventType STRING,apiVersion STRING,readOnly STRING,recipientAccountId STRING,serviceEventDetails STRING,sharedEventID STRING,vpcEndpointId STRING)ROW FORMAT SERDE 'com.amazon.emr.hive.serde.CloudTrailSerde'STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://cloudtrail_bucket_name/AWSLogs/Account_ID/';

Die folgende Abfrage gibt die in einem Zeitraum von 24 Stunden erfolgten Anmeldungen zurück:

SELECT useridentity.username, sourceipaddress, eventtime, additionaleventdataFROM default.cloudtrail_logsWHERE eventname = 'ConsoleLogin' AND eventtime >= '2017-02-17T00:00:00Z' AND eventtime < '2017-02-18T00:00:00Z';

Weitere Informationen finden Sie unter Querying AWS CloudTrail Logs (p. 190).

OpenCSVSerDe für CSV-VerarbeitungWenn Sie in Athena eine Tabelle aus CSV-Daten erstellen, müssen Sie bestimmen, welche Arten vonWerten sie enthält:

• Wenn die Daten Werte in doppelten Anführungszeichen (") enthalten, können Sie OpenCSV SerDeverwenden, um die Werte in Athena zu deserialisieren. Achten Sie in den folgenden Abschnitten auf dasVerhalten dieses SerDe mit STRING-Datentypen.

• Wenn die Daten keine Werte in doppelten Anführungszeichen (") enthalten, müssen Sie keine SerDeangeben. In diesem Fall verwendet Athena den Standard LazySimpleSerDe. Weitere Informationenfinden Sie unter LazySimpleSerDe für CSV- und TSV-Dateien sowie für benutzerdefinierte, durchTrennzeichen getrennte Dateien (p. 304).

295

https://cwiki.apache.org/confluence/display/Hive/CSV+Serde


CSV SerDe (OpenCSVSerDe)Der OpenCSV SerDe verhält sich wie folgt:

• Konvertiert alle Spaltentypwerte in STRING.• Um andere Datentypen als STRING zu erkennen, wird der Presto-Parser benötigt und die Werte vonSTRING in diese Datentypen konvertiert, sofern sie erkannt werden.

• Verwendet doppelte Anführungszeichen (") als Standard-Anführungszeichen und ermöglicht es Ihnen,Trennzeichen, Anführungszeichen und Escape-Zeichen wie die Folgenden anzugeben:

WITH SERDEPROPERTIES ("separatorChar" = ",", "quoteChar" = "`", "escapeChar" = "\\" )

• Es ist kein direktes Escape für \t oder \n möglich. Um ein Escape dafür durchzuführen, verwenden Sie"escapeChar" = "\\". Sehen Sie sich dazu auch das Beispiel in diesem Thema an.

• Eingebettete Zeilenumbrüche in CSV-Dateien werden nicht unterstützt.• Leere Felder in Spalten, die als numerischer Datentyp definiert sind, werden nicht unterstützt.

Note

Wenn Sie Athena mit OpenCSVSerDe verwenden, wandelt SerDe alle Spaltentypen in STRINGum. Anschließend parst der Parser in Athena die Werte aus STRING in echte Typen, abhängigdavon, was er erkennt. Beispielsweise parst er die Werte in die Datentypen BOOLEAN, BIGINT,INT und DOUBLE, wenn er sie unterscheiden kann. Weisen die Werte in TIMESTAMP das UNIX-Format auf, parst Athena sie als TIMESTAMP. Weisen die Werte in TIMESTAMP das Hive-Formatauf, parst Athena sie als INT. Werte des Typs DATE werden ebenfalls als INT geparst.Um weitere Spalten in den gewünschten Typ in einer Tabelle umzuwandeln, können Sie eineAnsicht über die Tabelle erstellen (p. 121) und CAST für die Umwandlung in den gewünschten Typverwenden.

Für andere Datentypen als STRING verhält sich dieser SerDe wie folgt, wenn der Parser in Athena sieerkennen kann:

• Erkennt die Datentypen BOOLEAN, BIGINT, INT und DOUBLE und analysiert sie unverändert.• Erkennt den Datentyp TIMESTAMP, wenn er im UNIX-Format (yyyy-mm-dd hh:mm:ss[.f...]) mit

dem Typ LONG angegeben ist.• TIMESTAMP im JDBC-kompatiblen java.sql.Timestamp-Format (z. B. "YYYY-MM-DDHH:MM:SS.fffffffff" mit einer Präzision von 9 Dezimalstellen) wird nicht unterstützt. Verwenden Siebeim Verarbeiten von CSV-Daten aus Hive das UNIX-Format für TIMESTAMP.

• Erkennt den Datentyp DATE, wenn er im UNIX-Format (YYYY-MM-DD) mit dem Typ LONG angegeben ist.• DATE wird in anderen Formaten nicht unterstützt. Verwenden Sie beim Verarbeiten von CSV-Daten aus

Hive das UNIX-Format für DATE.

Example Beispiel: Escape von \t oder \n

Sehen Sie sich die folgenden Testdaten an:

" \\t\\t\\n 123 \\t\\t\\n ",abc" 456 ",xyz

Die folgende Anweisung erstellt eine Tabelle in Athena mit "escapeChar" = "\\".

CREATE EXTERNAL TABLE test1 (f1 string,s2 string)

296



ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde' WITH SERDEPROPERTIES ("separatorChar" = ",", "escapeChar" = "\\") LOCATION 's3://user-test-region/dataset/test1/'

Anschließen führen Sie die folgende Abfrage aus:

select * from test1;

Sie gibt das folgende Ergebnis zurück, wobei ein ordnungsgemäßes Escape für \t oder \n durchgeführtwird:

f1 s2\t\t\n 123 \t\t\n abc456 xyz

SerDe-Name

CSV SerDe

Name der Bibliothek

Um diesen SerDe zu verwenden, geben Sie dessen vollständig qualifizierten Klassennamen im ROWFORMAT an. Geben Sie außerdem die Trennzeichen innerhalb von SERDEPROPERTIES wie folgt an:

...ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'WITH SERDEPROPERTIES ( "separatorChar" = ",", "quoteChar" = "`", "escapeChar" = "\\")

Beispiel

In diesem Beispiel wird davon ausgegangen, dass Daten in CSV unter s3://mybucket/mycsv/ mitfolgendem Inhalt gespeichert ist:

"a1","a2","a3","a4""1","2","abc","def""a","a1","abc3","ab4"

Verwenden Sie eine CREATE TABLE-Anweisung, um eine Athena-Tabelle basierend auf den Daten zuerstellen, und verweisen Sie im ROW FORMAT auf die OpenCSVSerDe-Klasse. Geben Sie außerdemSerDe-Eigenschaften für Trennzeichen, Anführungszeichen und Escape-Zeichen wie folgt an:

CREATE EXTERNAL TABLE myopencsvtable ( col1 string, col2 string, col3 string, col4 string)ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'WITH SERDEPROPERTIES ( 'separatorChar' = ',', 'quoteChar' = '"', 'escapeChar' = '\\' )

297


Amazon Athena BenutzerhandbuchGrok SerDe

STORED AS TEXTFILELOCATION 's3://location/of/csv/';

Fragen Sie alle Werte in der Tabelle ab:

SELECT * FROM myopencsvtable;

Die Abfrage gibt die folgenden Werte zurück:

col1 col2 col3 col4-----------------------------a1 a2 a3 a41 2 abc defa a1 abc3 ab4

Note


Grok SerDeBeim Logstash Grok SerDe handelt es sich um eine Bibliothek mit einer Reihe spezifischer Muster fürdie Deserialisierung unstrukturierter Textdaten (in der Regel Protokolle). Jedes Grok-Muster ist einbenannter regulärer Ausdruck. Sie können diese Deserialisierungsmuster identifizieren und bei Bedarfwiederverwenden. Dies macht die Verwendung von Grok einfacher als die Verwendung regulärerAusdrücke. Grok bietet eine Reihe vordefinierter Muster. Sie können auch benutzerdefinierte Mustererstellen.

Um beim Erstellen einer Tabelle in Athena den Grok SerDe anzugeben, verwenden Sie die KlauselROW FORMAT SERDE 'com.amazonaws.glue.serde.GrokSerDe', gefolgt von der Klausel WITHSERDEPROPERTIES, die die Muster angibt, mit denen eine Übereinstimmung in Ihren Daten erzielt werdensoll. Dabei gilt:

• Der input.format-Ausdruck definiert die Muster, mit denen in den Daten eine Übereinstimmung erzieltwerden soll. Er ist erforderlich.

• Der input.grokCustomPatterns-Ausdruck definiert ein benanntes benutzerdefiniertes Muster,das Sie anschließend innerhalb des input.format-Ausdrucks verwenden können. Der Schritt istoptional. Um mehrere Mustereinträge im input.grokCustomPatterns-Ausdruck einzuschließen,verwenden Sie das Zeilenumbruchszeichen (\n), um diese zu trennen, wie im Folgenden dargestellt:'input.grokCustomPatterns'='INSIDE_QS ([^\"]*)\nINSIDE_BRACKETS ([^\\]]*)').

• Die Klauseln STORED AS INPUTFORMAT und OUTPUTFORMAT sind erforderlich.• Die Klausel LOCATION gibt einen Amazon S3-Bucket an, der mehrere Datenobjekte enthalten kann. Alle

Datenobjekte im Bucket werden deserialisiert, um die Tabelle zu erstellen.

BeispieleDiese Beispiele basieren auf der Liste vordefinierter Grok-Muster. Weitere Informationen finden Sie auf derSeite zu vordefinierten Mustern.

Beispiel 1

Dieses Beispiel verwendet Quelldaten von in s3://mybucket/groksample/ gespeicherten Postfix-E-Mail-Protokolleinträgen.

298



https://github.com/elastic/logstash/blob/v1.4.2/patterns/grok-patterns

https://github.com/elastic/logstash/blob/v1.4.2/patterns/grok-patterns


Feb 9 07:15:00 m4eastmail postfix/smtpd[19305]: B88C4120838: connect from unknown[192.168.55.4]Feb 9 07:15:00 m4eastmail postfix/smtpd[20444]: B58C4330038: client=unknown[192.168.55.4]Feb 9 07:15:03 m4eastmail postfix/cleanup[22835]: BDC22A77854: message-id=<[email protected]>

Die folgende Anweisung erstellt eine Tabelle namens mygroktable in Athena aus den Quelldaten.Dies erfolgt unter Verwendung eines benutzerdefinierten Musters und der von Ihnen angegebenenvordefinierten Muster.

CREATE EXTERNAL TABLE `mygroktable`( syslogbase string, queue_id string, syslog_message string )ROW FORMAT SERDE 'com.amazonaws.glue.serde.GrokSerDe'WITH SERDEPROPERTIES ( 'input.grokCustomPatterns' = 'POSTFIX_QUEUEID [0-9A-F]{7,12}', 'input.format'='%{SYSLOGBASE} %{POSTFIX_QUEUEID:queue_id}: %{GREEDYDATA:syslog_message}' )STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://mybucket/groksample/';

Beginnen Sie mit einem einfachen Muster, beispielsweise mit %{NOTSPACE:column}, um zuerst dieSpalten zuzuordnen, und spezialisieren Sie diese dann bei Bedarf.

Beispiel 2

Im folgenden Beispiel erstellen Sie eine Abfrage für Log4j-Protokolle. Die Einträge der Beispielprotokolleweisen folgendes Format auf:

2017-09-12 12:10:34,972 INFO - processType=AZ, processId=ABCDEFG614B6F5E49, status=RUN,threadId=123:amqListenerContainerPool23[P:AJ|ABCDE9614B6F5E49||2017-09-12T12:10:11.172-0700],executionTime=7290, tenantId=12456, userId=123123f8535f8d76015374e7a1d87c3c, shard=testapp1,jobId=12312345e5e7df0015e777fb2e03f3c, messageType=REAL_TIME_SYNC,action=receive, hostname=1.abc.def.com

So fragen Sie diese Protokolldaten ab:

• Fügen Sie das Grok-Muster für jede Spalte zum input.format hinzu. Fügen Sie beispielsweisefür timestamp %{TIMESTAMP_ISO8601:timestamp} hinzu. Fügen Sie für loglevel%{LOGLEVEL:loglevel} hinzu.

• Stellen Sie sicher, dass das Muster in input.format exakt mit dem Format des Protokollsübereinstimmt, indem Sie die Bindestriche (-) und die Kommata zuweisen, die die Einträge imProtokollformat trennen.

CREATE EXTERNAL TABLE bltest ( timestamp STRING, loglevel STRING, processtype STRING, processid STRING, status STRING,

299


threadid STRING, executiontime INT, tenantid INT, userid STRING, shard STRING, jobid STRING, messagetype STRING, action STRING, hostname STRING )ROW FORMAT SERDE 'com.amazonaws.glue.serde.GrokSerDe'WITH SERDEPROPERTIES ("input.grokCustomPatterns" = 'C_ACTION receive|send',"input.format" = "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:loglevel} - processType=%{NOTSPACE:processtype}, processId=%{NOTSPACE:processid}, status=%{NOTSPACE:status}, threadId=%{NOTSPACE:threadid}, executionTime=%{POSINT:executiontime}, tenantId=%{POSINT:tenantid}, userId=%{NOTSPACE:userid}, shard=%{NOTSPACE:shard}, jobId=%{NOTSPACE:jobid}, messageType=%{NOTSPACE:messagetype}, action=%{C_ACTION:action}, hostname=%{HOST:hostname}") STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://mybucket/samples/';

Beispiel 3Das folgende Beispiel für die Abfrage von Amazon S3-Protokollen zeigt den'input.grokCustomPatterns'-Ausdruck, der zwei Mustereinträge enthält, die durch dasZeilenumbruchszeichen (\n) getrennt werden. Dies ist im folgenden Ausschnitt der Beispielabfragedargestellt: 'input.grokCustomPatterns'='INSIDE_QS ([^\"]*)\nINSIDE_BRACKETS ([^\\]]*)')

CREATE EXTERNAL TABLE `s3_access_auto_raw_02`( `bucket_owner` string COMMENT 'from deserializer', `bucket` string COMMENT 'from deserializer', `time` string COMMENT 'from deserializer', `remote_ip` string COMMENT 'from deserializer', `requester` string COMMENT 'from deserializer', `request_id` string COMMENT 'from deserializer', òperation` string COMMENT 'from deserializer', `key` string COMMENT 'from deserializer', `request_uri` string COMMENT 'from deserializer', `http_status` string COMMENT 'from deserializer', èrror_code` string COMMENT 'from deserializer', `bytes_sent` string COMMENT 'from deserializer', òbject_size` string COMMENT 'from deserializer', `total_time` string COMMENT 'from deserializer', `turnaround_time` string COMMENT 'from deserializer', `referrer` string COMMENT 'from deserializer', ùser_agent` string COMMENT 'from deserializer', `version_id` string COMMENT 'from deserializer')ROW FORMAT SERDE 'com.amazonaws.glue.serde.GrokSerDe' WITH SERDEPROPERTIES ( 'input.format'='%{NOTSPACE:bucket_owner} %{NOTSPACE:bucket} \\[%{INSIDE_BRACKETS:time}\\] %{NOTSPACE:remote_ip} %{NOTSPACE:requester} %{NOTSPACE:request_id} %{NOTSPACE:operation} %{NOTSPACE:key} \"?%{INSIDE_QS:request_uri}\"? %{NOTSPACE:http_status} %{NOTSPACE:error_code} %{NOTSPACE:bytes_sent} %{NOTSPACE:object_size} %{NOTSPACE:total_time} %{NOTSPACE:turnaround_time} \"?%{INSIDE_QS:referrer}\"? \"?%{INSIDE_QS:user_agent}\"? %{NOTSPACE:version_id}', 'input.grokCustomPatterns'='INSIDE_QS ([^\"]*)\nINSIDE_BRACKETS ([^\\]]*)') STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat' OUTPUTFORMAT

300

Amazon Athena BenutzerhandbuchJSON SerDe-Bibliotheken

'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'LOCATION 's3://bucket-for-service-logs/s3_access/'

JSON SerDe-BibliothekenIn Athena stehen Ihnen zwei SerDe-Bibliotheken für die Verarbeitung von Daten im JSON-Format bereit:

• Der native Hive JSON SerDe (p. 301)• Der OpenX JSON SerDe (p. 302)

SerDe-NamenHive-JsonSerDe

Openx-JsonSerDe

BibliotheksnamenNutzen Sie einen der Folgenden:

org.apache.hive.hcatalog.data.JsonSerDe

org.openx.data.jsonserde.JsonSerDe

Hive JSON SerDeDer Hive JSON SerDe verarbeitet JSON-Daten, in der Regel Ereignisse. Diese Ereignisse werden alsJSON-kodierte Textblöcke dargestellt, die jeweils durch eine neue Zeile voneinander getrennt sind.

Mit dem Hive JSON SerDe können Sie auch komplexere JSON-kodierte Daten mit verschachteltenStrukturen analysieren. Dafür wird jedoch eine entsprechende DDL benötigt, welche die komplexenDatentypen darstellt. Weitere Informationen finden Sie unter Beispiel: Deserialisieren verschachtelterJSON-Daten (p. 303).

Bei diesem SerDe sind doppelte Schlüssel in map- (oder struct-)Schlüsselnamen nicht zulässig.

Note


Die folgende DDL-Anweisung verwendet den Hive JSON SerDe:

CREATE EXTERNAL TABLE impressions ( requestbegintime string, adid string, impressionid string, referrer string, useragent string, usercookie string,

301

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-JSON

https://github.com/rcongiu/Hive-JSON-Serde

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-JSON



ip string, number string, processid string, browsercookie string, requestendtime string, timers struct < modellookup:string, requesttime:string >, threadid string, hostname string, sessionid string) PARTITIONED BY (dt string)ROW FORMAT serde 'org.apache.hive.hcatalog.data.JsonSerDe'with serdeproperties ( 'paths'='requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip' )LOCATION 's3://myregion.elasticmapreduce/samples/hive-ads/tables/impressions';

OpenX JSON SerDeOpenX SerDe wird von Athena zum Deserialisieren von Daten verwendet. Darunter wird die Umwandlungaus dem JSON-Format zur Vorbereitung auf die Serialisierung zum Parquet- oder ORC-Format verstanden.Dies ist eine der beiden Deserialisierungsoptionen, die Sie verwenden können, abhängig davon, welche dievon Ihnen benötigte Funktionalität bietet. Die andere Option ist Hive JsonSerDe.

Dieser SerDe besitzt einige nützliche Eigenschaften, die Sie beim Erstellen von Tabellen in Athenaangeben können, um die Behandlung von Inkonsistenzen in den Daten zu unterstützen:

ignore.malformed.json

Optional. Bei Festlegung auf TRUE können Sie eine fehlerhafte JSON-Syntax überspringen. DerStandardwert ist FALSE.

dots.in.keys

Optional. Der Standardwert ist FALSE. Bei Festlegung auf TRUE kann der SerDe die Punkte inSchlüsselnamen durch Unterstriche ersetzen. Wenn der JSON-Datensatz beispielsweise einenSchlüssel mit dem Namen "a.b" enthält, können Sie diese Eigenschaft verwenden, um denSpaltennamen als "a_b" in Athena zu definieren. Standardmäßig (ohne diesen SerDe) lässt Athenakeine Punkte in Spaltennamen zu.

case.insensitive

Optional. Standardmäßig erfordert Athena, dass alle Schlüssel in Ihrem JSON-DatensatzKleinbuchstaben verwenden. Der Standardwert ist TRUE. Bei Festlegung auf TRUE wandelt der SerDealle Großbuchstaben in Kleinbuchstaben um. Die Verwendung von WITH SERDE PROPERTIES("case.insensitive"= FALSE;) ermöglicht Ihnen die Verwendung von Schlüsselnamen in IhrenDaten, die Groß- und Kleinbuchstaben unterscheiden.

ColumnToJsonKeyMappings

Optional. Ordnet Spaltennamen zu JSON-Schlüsseln zu, die nicht mit den Spaltennamenidentisch sind. Dies ist nützlich, wenn die JSON-Daten Schlüssel enthalten, bei denen es sich umSchlüsselwörter (p. 36) handelt. Wenn Sie beispielsweise einen JSON-Schlüssel mit dem Namentimestamp verwenden, legen Sie diesen Parameter auf {"ts": "timestamp"} fest, um diesenSchlüssel einer Spalte mit dem Namen ts zuzuordnen. Dieser Parameter nimmt Werte des TypsZeichenfolge. Er verwendet das Schlüsselmuster ^\S+$ und das Wertmuster ^(?!\s*$).+.

Bei diesem SerDe sind doppelte Schlüssel in map- (oder struct-)Schlüsselnamen nicht zulässig.

302


Die folgende DDL-Anweisung verwendet den OpenX JSON SerDe:

CREATE EXTERNAL TABLE impressions ( requestbegintime string, adid string, impressionId string, referrer string, useragent string, usercookie string, ip string, number string, processid string, browsercokie string, requestendtime string, timers struct< modellookup:string, requesttime:string>, threadid string, hostname string, sessionid string) PARTITIONED BY (dt string)ROW FORMAT serde 'org.openx.data.jsonserde.JsonSerDe'with serdeproperties ( 'paths'='requestbegintime, adid, impressionid, referrer, useragent, usercookie, ip' )LOCATION 's3://myregion.elasticmapreduce/samples/hive-ads/tables/impressions';

Beispiel: Deserialisieren verschachtelter JSON-DatenDas Deserialisieren von JSON-Daten kann beim Erstellen einer Tabelle in Athena eine Herausforderungdarstellen.

Beim Umgang mit komplexen verschachtelten JSON-Daten können Probleme auftreten. WeitereInformationen zu diesen Problemen und deren Behebung finden Sie im AWS-Wissenszentrum im Artikelzum Thema Ich erhalte beim Lesen von JSON-Daten in Amazon Athena Fehlermeldungen.

Weitere Informationen zu bekannten Szenarien sowie Abfrage-Tipps finden Sie auf der Seite zum ThemaCreate Tables in Amazon Athena from Nested JSON and Mappings Using JSONSerDe.

Das folgende Beispiel zeigt einen einfachen Ansatz zum Erstellen einer Athena-Tabelle aus Daten mitverschachtelten Strukturen in JSON. Für die Analyse von JSON-kodierten Daten in Athena muss jedesJSON-Dokument eine eigene Zeile aufweisen und jeweils durch eine neue Zeile voneinander getrennt sein.

Bei diesem Beispiel werden JSON-kodierte Daten mit folgender Struktur vorausgesetzt:

{"DocId": "AWS","User": { "Id": 1234, "Username": "bob1234", "Name": "Bob","ShippingAddress": {"Address1": "123 Main St.","Address2": null,"City": "Seattle","State": "WA" },"Orders": [ { "ItemId": 6789, "OrderDate": "11/11/2017" }, {

303

https://aws.amazon.com/premiumsupport/knowledge-center/error-json-athena/

http://aws.amazon.com/blogs/big-data/create-tables-in-amazon-athena-from-nested-json-and-mappings-using-jsonserde/

Amazon Athena BenutzerhandbuchLazySimpleSerDe für CSV- und TSV-Dateien sowie für

benutzerdefinierte, durch Trennzeichen getrennte Dateien

"ItemId": 4352, "OrderDate": "12/12/2017" } ] }}

Der folgende CREATE TABLE-Befehl nutzt den Openx-JsonSerDe mit Sammlungsdatentypen wie structund array, um Gruppen von Objekten einzurichten. Jedes JSON-Dokument ist in einer eigenen Zeileaufgeführt und diese sind durch eine neue Zeile voneinander getrennt. Um Fehler zu vermeiden, enthaltendie abgefragten Daten keine doppelten Schlüssel in structund Map-Schlüsselnamen. DoppelteSchlüssel sind nicht zulässig in Map- (oder struct-)Schlüsselnamen.

CREATE external TABLE complex_json ( docid string, `user` struct< id:INT, username:string, name:string, shippingaddress:struct< address1:string, address2:string, city:string, state:string >, orders:array< struct< itemid:INT, orderdate:string > > > )ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'LOCATION 's3://mybucket/myjsondata/';

LazySimpleSerDe für CSV- und TSV-Dateien sowiefür benutzerdefinierte, durch Trennzeichen getrennteDateienDiese SerDe-Angabe ist optional. Dies ist der SerDe für Daten in CSV-, TSV- und benutzerdefinierten,durch Trennzeichen getrennten Formaten, die Athena standardmäßig verwendet. Dieser SerDe wirdverwendet, wenn Sie keinen SerDe, sondern nur ROW FORMAT DELIMITED angeben. Verwenden Siediesen SerDe, wenn Ihre Daten keine in Anführungszeichen eingeschlossenen Werte enthalten.

Name der BibliothekDer Klassebibliotheksname für den LazySimpleSerDe istorg.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe. Weitere Informationen finden Sie unterLazySimpleSerDe.

BeispieleDie folgenden Beispiele zeigen, wie Sie Tabellen aus CSV- und TSV-Dateien in Athena mit demLazySimpleSerDe erstellen. Zum Deserialisieren benutzerdefinierter, durch Trennzeichen getrennterDateien mit diesem SerDe geben Sie die Trennzeichen ähnlich wie in den folgenden Beispielen gezeigt an.

304


https://hive.apache.org/javadocs/r2.1.1/api/org/apache/hadoop/hive/serde2/lazy/LazySimpleSerDe.html



• CSV-Beispiel (p. 305)• TSV-Beispiel (p. 307)

Note


Note


CSV-Beispiel

Verwenden Sie die CREATE TABLE-Anweisung zum Erstellen einer Athena-Tabelle basierend auf den inAmazon S3 gespeicherten Daten in CSV.

CREATE EXTERNAL TABLE flight_delays_csv ( yr INT, quarter INT, month INT, dayofmonth INT, dayofweek INT, flightdate STRING, uniquecarrier STRING, airlineid INT, carrier STRING, tailnum STRING, flightnum STRING, originairportid INT, originairportseqid INT, origincitymarketid INT, origin STRING, origincityname STRING, originstate STRING, originstatefips STRING, originstatename STRING, originwac INT, destairportid INT, destairportseqid INT, destcitymarketid INT, dest STRING, destcityname STRING, deststate STRING, deststatefips STRING, deststatename STRING, destwac INT, crsdeptime STRING, deptime STRING, depdelay INT, depdelayminutes INT, depdel15 INT, departuredelaygroups INT, deptimeblk STRING, taxiout INT, wheelsoff STRING, wheelson STRING,

305





taxiin INT, crsarrtime INT, arrtime STRING, arrdelay INT, arrdelayminutes INT, arrdel15 INT, arrivaldelaygroups INT, arrtimeblk STRING, cancelled INT, cancellationcode STRING, diverted INT, crselapsedtime INT, actualelapsedtime INT, airtime INT, flights INT, distance INT, distancegroup INT, carrierdelay INT, weatherdelay INT, nasdelay INT, securitydelay INT, lateaircraftdelay INT, firstdeptime STRING, totaladdgtime INT, longestaddgtime INT, divairportlandings INT, divreacheddest INT, divactualelapsedtime INT, divarrdelay INT, divdistance INT, div1airport STRING, div1airportid INT, div1airportseqid INT, div1wheelson STRING, div1totalgtime INT, div1longestgtime INT, div1wheelsoff STRING, div1tailnum STRING, div2airport STRING, div2airportid INT, div2airportseqid INT, div2wheelson STRING, div2totalgtime INT, div2longestgtime INT, div2wheelsoff STRING, div2tailnum STRING, div3airport STRING, div3airportid INT, div3airportseqid INT, div3wheelson STRING, div3totalgtime INT, div3longestgtime INT, div3wheelsoff STRING, div3tailnum STRING, div4airport STRING, div4airportid INT, div4airportseqid INT, div4wheelson STRING, div4totalgtime INT, div4longestgtime INT, div4wheelsoff STRING, div4tailnum STRING, div5airport STRING, div5airportid INT, div5airportseqid INT, div5wheelson STRING,

306



div5totalgtime INT, div5longestgtime INT, div5wheelsoff STRING, div5tailnum STRING) PARTITIONED BY (year STRING) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' ESCAPED BY '\\' LINES TERMINATED BY '\n' LOCATION 's3://athena-examples-myregion/flight/csv/';

Führen Sie die MSCK REPAIR TABLE-Anweisung immer dann aus, wenn eine neue Partition zur Tabellehinzugefügt wurde, um die Partitionsmetadaten zu aktualisieren:

MSCK REPAIR TABLE flight_delays_csv;

Fragen Sie die 10 Routen ab, bei denen es zu einer Verzögerung von mehr als 1 Stunde kam:

SELECT origin, dest, count(*) as delaysFROM flight_delays_csvWHERE depdelayminutes > 60GROUP BY origin, destORDER BY 3 DESCLIMIT 10;

TSV-Beispiel

In diesem Beispiel wird angenommen, dass Quelldaten in TSV in s3://mybucket/mytsv/ gespeichertsind.

Verwenden Sie eine CREATE TABLE-Anweisung zum Erstellen einer Athena-Tabelle basierend auf den inAmazon S3 gespeicherten TSV-Daten. Beachten Sie, dass dieses Beispiel nicht auf eine SerDe-Klasse inROW FORMAT verweist, da der LazySimpleSerDe verwendet wird, und ein Verweis deshalb nicht benötigtwird. Bei diesem Beispiel werden SerDe-Eigenschaften für Zeichen und Zeilentrennzeichen sowie einEscape-Zeihen angegeben:

CREATE EXTERNAL TABLE flight_delays_tsv ( yr INT, quarter INT, month INT, dayofmonth INT, dayofweek INT, flightdate STRING, uniquecarrier STRING, airlineid INT, carrier STRING, tailnum STRING, flightnum STRING, originairportid INT, originairportseqid INT, origincitymarketid INT, origin STRING, origincityname STRING, originstate STRING, originstatefips STRING, originstatename STRING, originwac INT, destairportid INT, destairportseqid INT,

307



destcitymarketid INT, dest STRING, destcityname STRING, deststate STRING, deststatefips STRING, deststatename STRING, destwac INT, crsdeptime STRING, deptime STRING, depdelay INT, depdelayminutes INT, depdel15 INT, departuredelaygroups INT, deptimeblk STRING, taxiout INT, wheelsoff STRING, wheelson STRING, taxiin INT, crsarrtime INT, arrtime STRING, arrdelay INT, arrdelayminutes INT, arrdel15 INT, arrivaldelaygroups INT, arrtimeblk STRING, cancelled INT, cancellationcode STRING, diverted INT, crselapsedtime INT, actualelapsedtime INT, airtime INT, flights INT, distance INT, distancegroup INT, carrierdelay INT, weatherdelay INT, nasdelay INT, securitydelay INT, lateaircraftdelay INT, firstdeptime STRING, totaladdgtime INT, longestaddgtime INT, divairportlandings INT, divreacheddest INT, divactualelapsedtime INT, divarrdelay INT, divdistance INT, div1airport STRING, div1airportid INT, div1airportseqid INT, div1wheelson STRING, div1totalgtime INT, div1longestgtime INT, div1wheelsoff STRING, div1tailnum STRING, div2airport STRING, div2airportid INT, div2airportseqid INT, div2wheelson STRING, div2totalgtime INT, div2longestgtime INT, div2wheelsoff STRING, div2tailnum STRING, div3airport STRING, div3airportid INT, div3airportseqid INT,

308

Amazon Athena BenutzerhandbuchORC SerDe

div3wheelson STRING, div3totalgtime INT, div3longestgtime INT, div3wheelsoff STRING, div3tailnum STRING, div4airport STRING, div4airportid INT, div4airportseqid INT, div4wheelson STRING, div4totalgtime INT, div4longestgtime INT, div4wheelsoff STRING, div4tailnum STRING, div5airport STRING, div5airportid INT, div5airportseqid INT, div5wheelson STRING, div5totalgtime INT, div5longestgtime INT, div5wheelsoff STRING, div5tailnum STRING) PARTITIONED BY (year STRING) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' ESCAPED BY '\\' LINES TERMINATED BY '\n' LOCATION 's3://athena-examples-myregion/flight/tsv/';

Führen Sie die MSCK REPAIR TABLE-Anweisung immer dann aus, wenn eine neue Partition zur Tabellehinzugefügt wurde, um die Partitionsmetadaten zu aktualisieren:

MSCK REPAIR TABLE flight_delays_tsv;


SELECT origin, dest, count(*) as delaysFROM flight_delays_tsvWHERE depdelayminutes > 60GROUP BY origin, destORDER BY 3 DESCLIMIT 10;

Note


ORC SerDeSerDe-NameOrcSerDe

Name der BibliothekDies ist die SerDe-Klasse für Daten im ORC-Format. Sie übergibt das Objekt aus ORC an den Leser undden Schreiber: OrcSerDe

309



https://hive.apache.org/javadocs/r1.2.2/api/org/apache/hadoop/hive/ql/io/orc/OrcSerde.html

https://hive.apache.org/javadocs/r1.2.2/api/org/apache/hadoop/hive/ql/io/orc/OrcSerde.html


BeispieleNote


Im folgenden Beispiel wird eine Tabelle für Flugverspätungsdaten in ORC erstellt. Die Tabelle enthältPartitionen:

DROP TABLE flight_delays_orc;CREATE EXTERNAL TABLE flight_delays_orc ( yr INT, quarter INT, month INT, dayofmonth INT, dayofweek INT, flightdate STRING, uniquecarrier STRING, airlineid INT, carrier STRING, tailnum STRING, flightnum STRING, originairportid INT, originairportseqid INT, origincitymarketid INT, origin STRING, origincityname STRING, originstate STRING, originstatefips STRING, originstatename STRING, originwac INT, destairportid INT, destairportseqid INT, destcitymarketid INT, dest STRING, destcityname STRING, deststate STRING, deststatefips STRING, deststatename STRING, destwac INT, crsdeptime STRING, deptime STRING, depdelay INT, depdelayminutes INT, depdel15 INT, departuredelaygroups INT, deptimeblk STRING, taxiout INT, wheelsoff STRING, wheelson STRING, taxiin INT, crsarrtime INT, arrtime STRING, arrdelay INT, arrdelayminutes INT, arrdel15 INT, arrivaldelaygroups INT, arrtimeblk STRING,

310


cancelled INT, cancellationcode STRING, diverted INT, crselapsedtime INT, actualelapsedtime INT, airtime INT, flights INT, distance INT, distancegroup INT, carrierdelay INT, weatherdelay INT, nasdelay INT, securitydelay INT, lateaircraftdelay INT, firstdeptime STRING, totaladdgtime INT, longestaddgtime INT, divairportlandings INT, divreacheddest INT, divactualelapsedtime INT, divarrdelay INT, divdistance INT, div1airport STRING, div1airportid INT, div1airportseqid INT, div1wheelson STRING, div1totalgtime INT, div1longestgtime INT, div1wheelsoff STRING, div1tailnum STRING, div2airport STRING, div2airportid INT, div2airportseqid INT, div2wheelson STRING, div2totalgtime INT, div2longestgtime INT, div2wheelsoff STRING, div2tailnum STRING, div3airport STRING, div3airportid INT, div3airportseqid INT, div3wheelson STRING, div3totalgtime INT, div3longestgtime INT, div3wheelsoff STRING, div3tailnum STRING, div4airport STRING, div4airportid INT, div4airportseqid INT, div4wheelson STRING, div4totalgtime INT, div4longestgtime INT, div4wheelsoff STRING, div4tailnum STRING, div5airport STRING, div5airportid INT, div5airportseqid INT, div5wheelson STRING, div5totalgtime INT, div5longestgtime INT, div5wheelsoff STRING, div5tailnum STRING)PARTITIONED BY (year String)STORED AS ORCLOCATION 's3://athena-examples-myregion/flight/orc/'

311

Amazon Athena BenutzerhandbuchParquet SerDe

tblproperties ("orc.compress"="ZLIB");

Führen Sie die MSCK REPAIR TABLE-Anweisung auf der Tabelle aus, um die Partitionsmetadaten zuaktualisieren:

MSCK REPAIR TABLE flight_delays_orc;

Verwenden Sie diese Abfrage, um die 10 obersten Routen abzurufen, bei denen es zu einer Verzögerungvon mehr als 1 Stunde kam:

SELECT origin, dest, count(*) as delaysFROM flight_delays_orcWHERE depdelayminutes > 60GROUP BY origin, destORDER BY 3 DESCLIMIT 10;

Parquet SerDeSerDe-NameParquetHiveSerDe wird für im Parquet-Format gespeicherte Daten verwendet.

Name der BibliothekAthena verwendet diese Klasse, wenn in Parquet gespeicherte Daten deserialisiert werden müssen:org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe.

Beispiel: Abfragen einer in Parquet gespeicherten DateiNote


Verwenden Sie die folgende CREATE TABLE-Anweisung zum Erstellen einer Athena-Tabelle basierend aufden in Amazon S3 in Parquet gespeicherten Daten in CSV.

CREATE EXTERNAL TABLE flight_delays_pq ( yr INT, quarter INT, month INT, dayofmonth INT, dayofweek INT, flightdate STRING, uniquecarrier STRING, airlineid INT, carrier STRING, tailnum STRING, flightnum STRING, originairportid INT, originairportseqid INT,

312

https://cwiki.apache.org/confluence/display/Hive/Parquet

https://hive.apache.org/javadocs/r1.2.2/api/org/apache/hadoop/hive/ql/io/parquet/serde/ParquetHiveSerDe.html

Amazon Athena BenutzerhandbuchParquet SerDe

origincitymarketid INT, origin STRING, origincityname STRING, originstate STRING, originstatefips STRING, originstatename STRING, originwac INT, destairportid INT, destairportseqid INT, destcitymarketid INT, dest STRING, destcityname STRING, deststate STRING, deststatefips STRING, deststatename STRING, destwac INT, crsdeptime STRING, deptime STRING, depdelay INT, depdelayminutes INT, depdel15 INT, departuredelaygroups INT, deptimeblk STRING, taxiout INT, wheelsoff STRING, wheelson STRING, taxiin INT, crsarrtime INT, arrtime STRING, arrdelay INT, arrdelayminutes INT, arrdel15 INT, arrivaldelaygroups INT, arrtimeblk STRING, cancelled INT, cancellationcode STRING, diverted INT, crselapsedtime INT, actualelapsedtime INT, airtime INT, flights INT, distance INT, distancegroup INT, carrierdelay INT, weatherdelay INT, nasdelay INT, securitydelay INT, lateaircraftdelay INT, firstdeptime STRING, totaladdgtime INT, longestaddgtime INT, divairportlandings INT, divreacheddest INT, divactualelapsedtime INT, divarrdelay INT, divdistance INT, div1airport STRING, div1airportid INT, div1airportseqid INT, div1wheelson STRING, div1totalgtime INT, div1longestgtime INT, div1wheelsoff STRING, div1tailnum STRING, div2airport STRING, div2airportid INT,

313

Amazon Athena BenutzerhandbuchKomprimierungsformate

div2airportseqid INT, div2wheelson STRING, div2totalgtime INT, div2longestgtime INT, div2wheelsoff STRING, div2tailnum STRING, div3airport STRING, div3airportid INT, div3airportseqid INT, div3wheelson STRING, div3totalgtime INT, div3longestgtime INT, div3wheelsoff STRING, div3tailnum STRING, div4airport STRING, div4airportid INT, div4airportseqid INT, div4wheelson STRING, div4totalgtime INT, div4longestgtime INT, div4wheelsoff STRING, div4tailnum STRING, div5airport STRING, div5airportid INT, div5airportseqid INT, div5wheelson STRING, div5totalgtime INT, div5longestgtime INT, div5wheelsoff STRING, div5tailnum STRING)PARTITIONED BY (year STRING)STORED AS PARQUETLOCATION 's3://athena-examples-myregion/flight/parquet/'tblproperties ("parquet.compress"="SNAPPY");

Führen Sie die MSCK REPAIR TABLE-Anweisung auf der Tabelle aus, um die Partitionsmetadaten zuaktualisieren:

MSCK REPAIR TABLE flight_delays_pq;


SELECT origin, dest, count(*) as delaysFROM flight_delays_pqWHERE depdelayminutes > 60GROUP BY origin, destORDER BY 3 DESCLIMIT 10;

Note


KomprimierungsformateAthena unterstützt folgende Komprimierungsformate:

314



Amazon Athena BenutzerhandbuchKomprimierungsformate

Note

Die in diesem Abschnitt aufgeführten Komprimierungsformate werden für CREATETABLE (p. 330)-Abfragen verwendet. Für CTAS-Abfragen unterstützt Athena GZIP und SNAPPY(für Daten in Parquet und ORC). Wenn Sie ein Format weglassen, wird GZIP standardmäßigverwendet. Weitere Informationen finden Sie unter CREATE TABLE AS (p. 334).

• SNAPPY. Dies ist das Standard-Komprimierungsformat für Dateien im Parquet-Datenspeicherformat.• ZLIB. Dies ist das Standard-Komprimierungsformat für Dateien im ORC-Datenspeicherformat.• LZO• GZIP.

Athena bestimmt den Komprimierungstyp für Daten in den Formaten CSV, TSV und JSON anhand derDateierweiterung. Ist diese nicht vorhanden, werden die Daten nicht dekomprimiert. Wenn Ihre Datenkomprimiert sind, stellen Sie sicher, dass der Dateiname die Komprimierungserweiterung enthält, z. B.gz.

Verwenden Sie die GZIP-Komprimierung in Athena für die Abfrage von Amazon Kinesis Data Firehose-Protokollen. Athena und Amazon Kinesis Data Firehose unterstützen jeweils verschiedene Versionen vonSNAPPY, also ist GZIP das einzige kompatible Format.

315

Amazon Athena BenutzerhandbuchUnterstützte Datentypen

SQL-Referenz für Amazon AthenaAmazon Athena unterstützt eine Teilmenge von Data Definition Language (DDL)- und Data ManipulationLanguage (DML)-Anweisungen, -Funktionen, -Operatoren und -Datentypen. Mit einigen Ausnahmen basiertAthena DDL auf HiveQL DDL und Athena DML auf Presto 0.172.

Themen• Von Amazon Athena unterstützte Datentypen (p. 316)• DML-Abfragen, -Funktionen und -Operatoren (p. 317)• DDL-Anweisungen (p. 324)• Überlegungen und Einschränkungen für SQL-Abfragen in Amazon Athena (p. 343)

Von Amazon Athena unterstützte DatentypenWenn Sie CREATE TABLE (p. 330) ausführen, geben Sie Spaltennamen und den Datentyp an, den jedeSpalte enthalten kann. Athena unterstützt die unten aufgeführten Datentypen. Weitere Informationen zuden Datentypzuordnungen, die der JDBC-Treiber zwischen Athena, JDBC und Java unterstützt, finden Sieunter Datentypen im Installations- und Konfigurationsleitfaden für JDBC-Treiber. Weitere Informationen zuden Datentypzuordnungen, die der ODBC-Treiber zwischen Athena und SQL unterstützt, finden Sie unterDatentypen im Installations- und Konfigurationsleitfaden für ODBC-Treiber.

Unterstützte Datentypen

• BOOLEAN (p. 316)• Ganzzahltypen (p. 316)• Gleitkommatypen (p. 316)• Feste Präzisionstypen (p. 317)• Zeichenfolgentypen (p. 317)• BINARY (p. 317)• Datums- und Uhrzeittypen (p. 317)• Strukturelle Typen (p. 317)

• BOOLEAN. Die Werte sind true und false.• Ganzzahltypen

• TINYINT aus. Eine 8-Bit signierte INTEGER im Zweierkomplement-Format mit einem Mindestwert von-2^7 und einem Höchstwert von 2^7-1.

• SMALLINT Eine 16-Bit signierte INTEGER im Zweierkomplement-Format mit einem Mindestwert von-2^15 und einem Höchstwert von 2^15-1.

• INT. Athena kombiniert zwei verschiedene Implementierungen des Datentyps INTEGER. In DDL-Abfragen (Data Definition Language) verwendet Athena den Datentyp INT. In allen anderenAbfragen verwendet Athena den Datentyp INTEGER, wobei INTEGER als signierter 32-Bit-Wertim Zweierkomplement-Format mit einem Mindestwert von -2^31 und einem Höchstwert von2^31-1 dargestellt wird. Im JDBC-Treiber wird INTEGER zurückgegeben, um Kompatibilität mit dengeschäftlichen Analyseanwendungen zu gewährleisten.

• BIGINT. Eine 64-Bit signierte INTEGER im Zweierkomplement-Format mit einem Mindestwert von-2^63 und einem Höchstwert von 2^63-1.

• Gleitkommatypen• DOUBLE

316


https://prestodb.io/docs/0.172/index.html

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/SimbaAthenaJDBC_2.0.5/docs/Simba+Athena+JDBC+Driver+Install+and+Configuration+Guide.pdf#page=37

https://s3.amazonaws.com/athena-downloads/drivers/ODBC/SimbaAthenaODBC_1.0.5/Simba+Athena+ODBC+Install+and+Configuration+Guide.pdf#page=50

Amazon Athena BenutzerhandbuchDML-Abfragen, -Funktionen und -Operatoren

• FLOAT

• Fester Präzisionstyp• DECIMAL [ (precision, scale) ], wobei precision die Gesamtanzahl der Stellen und scale

(optional) die Anzahl der Nachkommastellen ist. Der Standardwert ist 0. Verwenden Sie z. B. dieseDefinitionen: DECIMAL(11,5), DECIMAL(15).

Um Dezimalwerte als Literale anzugeben, z. B. bei der Auswahl von Zeilen mit einem bestimmtenDezimalwert im DDL-Ausdruck einer Abfrage, legen Sie als Typdefinition DECIMAL fest und listen Siedie Dezimalwerte als Literalwert (in einfachen Anführungszeichen) in Ihrer Abfrage auf, wie in diesemBeispiel: decimal_value = DECIMAL '0.12'.

• Zeichenfolgentypen• CHAR aus. Zeichendaten mit fester Länge, die zwischen 1 und 255 Zeichen liegen muss, z. B.char(10). Weitere Informationen finden Sie unter CHAR Hive Data Type.

• VARCHAR Zeichendaten mit variabler Länge, die zwischen 1 und 65535 Zeichen liegen muss, z. B.varchar(10). Weitere Informationen finden Sie unter VARCHAR Hive Data Type.

• BINARY (für Daten in Parquet)• Datums- und Uhrzeittypen

• DATE, im UNIX-Format, wie z. B. YYYY-MM-DD.• TIMESTAMP Datum und Uhrzeit eines Zeitpunkts im UNiX-Format, z. B. yyyy-mm-ddhh:mm:ss[.f...]. Beispiel, TIMESTAMP '2008-09-15 03:04:05.324'. Dieses Formatverwendet die Zeitzone der Sitzung.

• Strukturelle Typen• ARRAY < data_type >• MAP < primitive_type, data_type >• STRUCT < col_name : data_type [COMMENT col_comment] [, ...] >

DML-Abfragen, -Funktionen und -OperatorenAthena DML-Abfrageanweisungen basieren auf Presto 0.172. Weitere Informationen zu diesen Funktionenfinden Sie unter Funktionen und Operatoren in Presto 0.172 in der Open-Source-Presto-Dokumentation.Im Presto-Funktionen (p. 323)-Thema finden Sie Links zu bestimmten Unterabschnitten dieserDokumentation.

Athena unterstützt nicht alle Presto-Funktionen und es gibt einige signifikante Unterschiede. WeitereInformationen finden Sie in den Referenzthemen für spezifische Anweisungen in diesem Abschnitt undÜberlegungen und Einschränkungen (p. 343).

Themen• SELECT (p. 317)• INSERT INTO (p. 321)• Presto-Funktionen in Amazon Athena (p. 323)

SELECTRuft Zeilen von null oder mehr Tabellen ab.

Syntax

[ WITH with_query [, ...] ]

317

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-char

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-varchar



Amazon Athena BenutzerhandbuchSELECT

SELECT [ ALL | DISTINCT ] select_expression [, ...][ FROM from_item [, ...] ][ WHERE condition ][ GROUP BY [ ALL | DISTINCT ] grouping_element [, ...] ][ HAVING condition ][ UNION [ ALL | DISTINCT ] union_query ][ ORDER BY expression [ ASC | DESC ] [ NULLS FIRST | NULLS LAST] [, ...] ][ LIMIT [ count | ALL ] ]

Parameter[ WITH with_query [, ....] ]

Mit WITH können Sie verschachtelte Abfragen reduzieren oder Unterabfragen vereinfachen.

Die Verwendung der Klausel WITH zum Erstellen von rekursiven Abfragen wird nicht unterstützt.

Die Klausel WITH geht der SELECT-Liste in einer Abfrage voraus und legt eine oder mehrereUnterabfragen für die Verwendung in der SELECT-Abfrage fest.

Jede Unterabfrage definiert eine temporäre Tabelle ähnlich wie eine Ansichtdefinition, die mit derFROM-Klausel referenziert werden kann. Die Tabellen werden nur verwendet, wenn die Abfrageausgeführt wird.

Die Syntax von with_query lautet:

subquery_table_name [ ( column_name [, ...] ) ] AS (subquery)

Wobei gilt:• subquery_table_name ist ein eindeutiger Name für eine temporäre Tabelle, die die Ergebnisse

der Unterabfrage mit WITH-Klausel definiert. Jede subquery muss einen Tabellennamen erhalten,der in der FROM-Klausel referenziert werden kann.

• column_name [, ...] ist eine optionale Liste der ausgegebenen Spaltennamen. Die Anzahlder Spaltennamen muss größer als oder gleich der Anzahl der Spalten sein, die von der subquerydefiniert wird.

• subquery ist eine Abfrageanweisung.[ ALL | DISTINCT ] select_expr

select_expr legt die auszuwählenden Zeilen fest.

ALL ist die Standardeinstellung. Bei Verwendung von ALL wird dies so behandelt, als wäre kein Wertangegeben worden. Alle Zeilen aller Spalten werden einschließlich Duplikaten ausgewählt.

Verwenden Sie DISTINCT, um nur eindeutige Werte zurückzugeben, wenn eine Spalte Duplikatwerteenthält.

FROM from_item [,...]

Gibt die Eingabe der Abfrage an, wobei from_item eine Ansicht, ein JOIN-Konstrukt oder eineUnterabfrage wie unten beschrieben sein kann.

from_item kann eines der Folgenden sein:• table_name [ [ AS ] alias [ (column_alias [, ...]) ] ]

Hier ist table_name der Name der Zieltabelle, aus der Zeilen ausgewählt werden. alias ist derName für die Ausgabe der SELECT-Anweisung und column_alias definiert die Spalten für denangegebenen alias.

318


-ODER-• join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]

Hierbei ist join_type eines der Folgenden:• [ INNER ] JOIN

• LEFT [ OUTER ] JOIN

• RIGHT [ OUTER ] JOIN

• FULL [ OUTER ] JOIN

• CROSS JOIN

• ON join_condition | USING (join_column [, ...]) Wobei Sie durch Verwenden vonjoin_condition die Spaltennamen für JOIN-Schlüssel in mehreren Tabellen angeben können.Für die Verwendung von join_column muss join_column in beiden Tabellen vorhanden sein.

[ WHERE condition ]

Filterergebnisse gemäß der festgelegten condition.[ GROUP BY [ ALL | DISTINCT ] grouping_expressions [, ...] ]

Teilt die Ausgabe der SELECT-Anweisung in Zeilen mit passenden Werten.

Über ALL und DISTINCT wird festgelegt, ob für Duplikate jeweils eine eigene Ausgabezeile angelegtwird. Wenn nichts angegeben ist, wird von ALL ausgegangen.

grouping_expressions ermöglicht Ihnen, komplexe Gruppierungsoperationen auszuführen.

Das grouping_expressions-Element kann eine Funktion, wie z. B. SUM, AVG oder COUNT sein,die auf Eingabespalten angewendet wird, oder eine Ordinalzahl, über die eine Ausgabespalte nachPosition (beginnend mit 1) ausgewählt wird.

Mithilfe von GROUP BY-Ausdrücken kann die Ausgabe nach Eingabespaltennamen gruppiert werden,die nicht in der Ausgabe der SELECT-Anweisung auftauchen.

Alle Ausgabeausdrücke müssen entweder Aggregatfunktionen oder Spalten sein, die in der GROUPBY-Klausel vorhanden sind.

Sie können mit einer einzelnen Abfrage eine Analyse durchführen, für die mehrere Spaltensätzezusammengefasst werden müssen.

In diesen komplexen Gruppierungsoperationen werden Ausdrücke, die Eingabespalten umfasst, nichtunterstützt. Es sind nur Spaltennamen oder Ordinalzahlen zulässig.

Oft können Sie mit UNION ALL dieselben Ergebnisse erzielen wie mit diesen GROUP BY-Operationen.Abfragen, in denen GROUP BY verwendet wird, haben jedoch den Vorteil, dass die Daten einmaligausgelesen werden, wohingegen bei UNION ALL die zugrunde liegenden Daten dreimal ausgelesenwerden, was zu uneinheitlichen Ergebnissen führen kann, wenn die Datenquelle sich geändert hat.

GROUP BY CUBE erzeugt alle möglichen Gruppierungskombinationen für eine bestimmteSpaltengruppe. GROUP BY ROLLUP erzeugt alle möglichen Zwischensummen für eine bestimmteSpaltengruppe.

[ HAVING condition ]

Wird in Aggregatfunktionen und der GROUP BY-Klausel verwendet. Kontrolliert, welche Gruppenausgewählt werden und schließt Gruppen aus, die die condition nicht erfüllen. Diese Filterung wirdnach der Berechnung der Gruppierungs- und Aggregatfunktionen ausgeführt.

[ UNION [ ALL | DISTINCT ] union_query] ]

Kombiniert die Ergebnisse mehrerer SELECT-Anweisungen in eine einzelne Abfrage. Über ALL oderDISTINCT wird festgelegt, welche Zeilen im Endergebnis enthalten sind.

319


ALL bewirkt, dass alle Zeilen aufgenommen werden, auch wenn die Zeilen identisch sind.

DISTINCT bewirkt, dass nur eindeutige Zeilen in die kombinierte Ergebnismenge aufgenommenwerden. DISTINCT ist der Standard.

Mehrere UNION-Klauseln werden von links nach rechts verarbeitet, sofern Sie keine Klammernverwenden, um die Verarbeitungsreihenfolge explizit festzulegen.

[ ORDER BY expression [ ASC | DESC ] [ NULLS FIRST | NULLS LAST] [, ...] ]

Sortiert eine Ergebnisgruppe nach einem oder mehreren Ausgabe-expression.

Wenn die Klausel mehrere Ausdrücke enthält, wird die Ergebnisgruppe nach dem ersten expressionsortiert. Danach wird der zweite expression auf die Zeilen mit passenden Werten aus dem erstenAusdruck angewendet usw.

Jeder expression kann Ausgabespalten aus SELECT oder eine Ordinalzahl für eine Ausgabespaltenach Position (beginnend mit 1) festlegen.

ORDER BY wird im letzten Schritt nach GROUP BY- und HAVING-Klauseln ausgewertet. Über ASC undDESC wird festgelegt, ob die Ergebnisse in auf- oder absteigender Reihenfolge sortiert werden.

Die Standardnullsortierung ist NULLS LAST unabhängig von auf- oder absteigender Sortierreihenfolge.LIMIT [ count | ALL ]

Beschränkt die Anzahl der Zeilen in der Ergebnisgruppe auf count. LIMIT ALL entspricht demWeglassen der LIMIT-Klausel. Wenn die Abfrage keine ORDER BY-Klausel enthält, werden dieErgebnisse zufällig angezeigt.

TABLESAMPLE BERNOULLI | SYSTEM (percentage)

Optionaler Operator zur Auswahl von Zeilen aus einer Tabelle basierend auf einerStichprobenmethode.

Mit BERNOULLI wird jede Zeile mit einer Wahrscheinlichkeit von percentage als Teil der Stichprobeausgewählt. Alle physischen Blöcke der Tabelle werden gescannt und bestimmte Zeilen werdenbasierend auf einem Vergleich zwischen dem percentage der Stichproben und einem zufälligen, zurLaufzeit berechneten Wert übersprungen.

Mit SYSTEM wird die Tabelle in logische Datensegmente unterteilt. Aus der Tabelle werden Stichprobenmit dieser Granularität entnommen.

Es werden entweder alle Zeilen aus einem bestimmten Segment ausgewählt oder das Segment wirdbasierend auf einem Vergleich zwischen dem percentage der Stichprobe und einem zufälligen,während der Laufzeit berechneten Wert übersprungen. SYTSTEM-Stichproben sind abhängig vomConnector. Mit dieser Methode kann keine unabhängige Stichprobenwahrscheinlichkeit garantiertwerden.

[ UNNEST (array_or_map) [WITH ORDINALITY] ]

Erweitert ein Array oder eine Zuordnung in eine Beziehung. Arrays werden in eine einzelne Spalteerweitert. Zuordnungen werden in zwei Spalten (Schlüssel und Wert) erweitert.

Sie können UNNEST mit mehreren Argumenten verwenden, die in mehrere Spalten mit so vielen Zeilenwie das höchste Kardinalitätsargument erweitert werden.

Andere Spalten werden mit Nullen aufgefüllt.

Die WITH ORDINALITY-Klausel fügt eine Ordinalitätsspalte am Ende hinzu.

UNNEST wird normalerweise mit einem JOIN verwendet und kann auf Spalten von Beziehungen linksdes JOIN verweisen.

320

Amazon Athena BenutzerhandbuchINSERT INTO

BeispieleSELECT * FROM table;

SELECT os, COUNT(*) count FROM cloudfront_logs WHERE date BETWEEN date '2014-07-05' AND date '2014-08-05' GROUP BY os;

Weitere Beispiele finden Sie unter Abfragen von Daten aus Amazon Athena-Tabellen (p. 81).

INSERT INTOFügt neue Zeilen in eine Zieltabelle ein, basierend auf einer SELECT-Abfrageanweisung, die in einerQuelltabelle ausgeführt wird, oder basierend auf einem Satz von VALUES, der als Teil der Anweisungbereitgestellt wird. Wenn die Quelltabelle auf zugrunde liegenden Daten in einem Format wie CSV oderJSON basiert und die Zieltabelle auf einem anderen Format wie Parquet oder ORC basiert, könnenSie INSERT INTO-Abfragen verwenden, um ausgewählte Daten in das Format der Zieltabelle zutransformieren.

Überlegungen und EinschränkungenBeachten Sie Folgendes, wenn Sie INSERT-Abfragen mit Athena verwenden.

Important

Wenn Sie eine INSERT-Abfrage für eine Tabelle mit zugrunde liegenden Daten ausführen,die in Amazon S3 verschlüsselt sind, werden die Ausgabedateien, die die INSERT-Abfrageschreibt, standardmäßig nicht verschlüsselt. Wir empfehlen, INSERT-Abfrageergebnisse zuverschlüsseln, wenn Sie in Tabellen mit verschlüsselten Daten einfügen. Weitere Informationenzum Verschlüsseln von Abfrageergebnissen mithilfe der Konsole finden Sie unter Verschlüsselnder in Amazon S3 gespeicherten Abfrageergebnisse (p. 212). Um die Verschlüsselung mit derAWS CLI oder der Athena-API zu aktivieren, verwenden Sie die EncryptionConfiguration-Eigenschaften der StartQueryExecution-Aktion, um die Amazon S3-Verschlüsselungsoptionenentsprechend Ihren Anforderungen anzugeben.

Unterstützte Formate und SerDesSie können eine INSERT-Abfrage für Tabellen ausführen, die aus Daten mit den folgenden Formaten undSerDes erstellt wurden.

Datenformat SerDe

Avro org.apache.hadoop.hive.serde2.avro.AvroSerDe

JSON org.apache.hive.hcatalog.data.JsonSerDe

ORC org.apache.hadoop.hive.ql.io.orc.OrcSerde

Parquet org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe

Textdatei org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe

Note

CSV-, TSV- und benutzerdefinierte, durchTrennzeichen getrennte Dateien werdenunterstützt.

321


Amazon Athena BenutzerhandbuchINSERT INTO

Bucket-Tabellen werden nicht unterstützt

INSERT INTO wird für Bucket-Tabellen nicht unterstützt. Weitere Informationen finden Sie unter Bucketingim Vergleich zur Partitionierung (p. 131).

Partitionslimits

Die Anweisung INSERT INTO unterstützt das Schreiben von maximal 100 Partitionen in die Zieltabelle.Wenn Sie die SELECT-Klausel für eine Tabelle mit mehr als 100 Partitionen ausführen, schlägt die Abfragefehl, es sei denn, die SELECT-Abfrage ist auf 100 Partitionen oder weniger beschränkt.

In Amazon S3 geschriebene Dateien

Athena schreibt Dateien in die Quelldatenspeicherorte in Amazon S3 als Ergebnis des INSERT-Befehls.Jede INSERT-Operation erstellt eine neue Datei, anstatt an eine vorhandene Datei anzuhängen. DieDateispeicherorte hängen von der Struktur der Tabelle und ggf. der SELECT-Abfrage ab. Athena generierteine Datenmanifestdatei für jede INSERT-Abfrage. Das Manifest verfolgt die Dateien, die die Abfragegeschrieben hat. Es wird im Verzeichnis der Athena-Abfrageergebnisse in Amazon S3 gespeichert.Wenn eine Abfrage fehlschlägt, verfolgt das Manifest auch Dateien, die die Abfrage schreiben wollte. DasManifest ist nützlich für die Identifizierung verwaister Dateien, die aus einer fehlgeschlagenen Abfrageresultieren. Weitere Informationen finden Sie unter Arbeiten mit Abfrageergebnissen, Ausgabedateien unddem Abfrageverlauf (p. 115).

INSERT INTO...SELECT

Gibt die Abfrage an, die für eine Tabelle ausgeführt werden soll, source_table, die festlegt, welcheZeilen in eine zweite Tabelle eingefügt werden sollen, destination_table. Wenn die SELECT-AbfrageSpalten in der source_table angibt, müssen die Spalten genau mit denen in der destination_tableübereinstimmen.

Weitere Informationen zu SELECT-Abfragen finden Sie unter SELECT (p. 317).

Syntax

INSERT INTO destination_table SELECT select_query FROM source_table_or_view

Beispiele

Wählen Sie alle Zeilen in der vancouver_pageviews-Tabelle aus und fügen Sie sie in diecanada_pageviews-Tabelle ein:

INSERT INTO canada_pageviews SELECT * FROM vancouver_pageviews;

Wählen Sie nur die Zeilen in der vancouver_pageviews-Tabelle aus, in denen die date-Spalte einenWert zwischen 2019-07-01 und 2019-07-31 hat, und fügen Sie sie dann in canada_july_pageviewsein:

INSERT INTO canada_july_pageviewsSELECT *FROM vancouver_pageviewsWHERE date BETWEEN date '2019-07-01'

322

Amazon Athena BenutzerhandbuchPresto-Funktionen

AND '2019-07-31';

Wählen Sie die Werte in den Spalten city und state in der cities_usa-Tabelle nur aus den Zeilenmit dem Wert usa in der country-Spalte aus und fügen Sie sie in die Spalten city und state in dercities_world-Tabelle ein:

INSERT INTO cities_usa (city,state)SELECT city,stateFROM cities_world WHERE country='usa'

INSERT INTO...VALUES

Fügt Zeilen in eine vorhandene Tabelle ein, indem Spalten und Werte angegeben werden. AngegebeneSpalten und zugehörige Datentypen müssen genau mit den Spalten und Datentypen in der Zieltabelleübereinstimmen.

Important

Wir raten davon ab, Zeilen mit VALUES einzufügen, da Athena Dateien für jede INSERT-Operationgeneriert. Dies kann dazu führen, dass viele kleine Dateien erstellt werden und die Abfrageleistungder Tabelle beeinträchtigen. Um Dateien zu identifizieren, die eine INSERT-Abfrage erstellt,überprüfen Sie die Datenmanifestdatei. Weitere Informationen finden Sie unter Arbeiten mitAbfrageergebnissen, Ausgabedateien und dem Abfrageverlauf (p. 115).

Syntax

INSERT INTO destination_table [(col1,col2,...)] VALUES (col1value,col2value,...)[, (col1value,col2value,...)][, ...]

Beispiele

In den folgenden Beispielen hat die Tabelle "cities" drei Spalten: id, city, state, state_motto. Die ID-Spalte hat den Typ INT und alle anderen Spalten haben den Typ VARCHAR.

Fügen Sie eine einzelne Zeile in die cities-Tabelle ein, wobei alle Spaltenwerte angegeben sind:

INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice')

Fügen Sie zwei Zeilen in die cities-Tabelle ein:

INSERT INTO cities VALUES (1,'Lansing','MI','Si quaeris peninsulam amoenam circumspice'), (3,'Boise','ID','Esto perpetua')

Presto-Funktionen in Amazon AthenaDie Athena-Abfrage-Engine basiert auf Presto 0.172. Weitere Informationen zu diesen Funktionen findenSie unter Funktionen und Operatoren in Presto 0.172 sowie in den spezifischen Abschnitten der Presto-Dokumentation, auf die unten verwiesen wird.

Nicht alle Presto-Funktionen werden von Athena unterstützt. Weitere Informationen finden Sie unterÜberlegungen und Einschränkungen (p. 343).

323



Amazon Athena BenutzerhandbuchDDL-Anweisungen

• Logische Operatoren• Vergleichsfunktionen und Operatoren• Bedingte Ausdrücke• Konvertierungsfunktionen• Mathematische Funktionen und Operatoren• Bitweise-Funktionen• Dezimale Funktionen und Operatoren• Zeichenfolgen-Funktionen und -Operatoren• Binäre Funktionen• Datums- und Zeitfunktionen und -Operatoren• Funktionen für reguläre Ausdrücke• JSON-Funktionen und -Operatoren• URL-Funktionen• Aggregationsfunktionen• Fensterfunktionen• Farb-Funktionen• Array-Funktionen und -Operatoren• Zuordnungs-Funktionen und -Operatoren• Lambda-Ausdrücke und -Funktionen• Teradata-Funktionen

DDL-AnweisungenNutzen Sie die folgenden DDL-Anweisungen direkt in Athena.

Die Athena-Abfrage-Engine basiert auf HiveQL DDL.

Athena unterstützt nicht alle DDL-Anweisungen und es gibt einige Unterschiede zwischen HiveQL DDLund Athena DDL. Weitere Informationen finden Sie in den Referenzthemen in diesem Abschnitt und Nichtunterstützte DDLs (p. 325).

Themen• Nicht unterstützte DDLs (p. 325)• ALTER DATABASE SET DBPROPERTIES (p. 326)• ALTER TABLE ADD PARTITION (p. 327)• ALTER TABLE DROP PARTITION (p. 328)• ALTER TABLE RENAME PARTITION (p. 328)• ALTER TABLE SET LOCATION (p. 329)• ALTER TABLE SET TBLPROPERTIES (p. 329)• CREATE DATABASE (p. 330)• CREATE TABLE (p. 330)• CREATE TABLE AS (p. 334)• CREATE VIEW (p. 336)• DESCRIBE TABLE (p. 337)• DESCRIBE VIEW (p. 337)

324

https://prestodb.io/docs/0.172/functions/logical.html

https://prestodb.io/docs/0.172/functions/comparison.html

https://prestodb.io/docs/0.172/functions/conditional.html

https://prestodb.io/docs/0.172/functions/conversion.html

https://prestodb.io/docs/0.172/functions/math.html

https://prestodb.io/docs/0.172/functions/bitwise.html

https://prestodb.io/docs/0.172/functions/decimal.html

https://prestodb.io/docs/0.172/functions/string.html

https://prestodb.io/docs/0.172/functions/binary.html

https://prestodb.io/docs/0.172/functions/datetime.html

https://prestodb.io/docs/0.172/functions/regexp.html

https://prestodb.io/docs/0.172/functions/json.html

https://prestodb.io/docs/0.172/functions/url.html

https://prestodb.io/docs/0.172/functions/aggregate.html

https://prestodb.io/docs/0.172/functions/window.html

https://prestodb.io/docs/0.172/functions/color.html

https://prestodb.io/docs/0.172/functions/array.html

https://prestodb.io/docs/0.172/functions/map.html


https://prestodb.io/docs/0.172/functions/teradata.html


Amazon Athena BenutzerhandbuchNicht unterstützte DDLs

• DROP DATABASE (p. 338)• DROP TABLE (p. 338)• DROP VIEW (p. 339)• MSCK REPAIR TABLE (p. 339)• SHOW COLUMNS (p. 339)• SHOW CREATE TABLE (p. 340)• SHOW CREATE VIEW (p. 340)• SHOW DATABASES (p. 340)• SHOW PARTITIONS (p. 341)• SHOW TABLES (p. 341)• SHOW TBLPROPERTIES (p. 342)• SHOW VIEWS (p. 342)

Nicht unterstützte DDLsDie folgenden nativen Hive-DDLs werden von Athena nicht unterstützt:

• ALTER INDEX• ALTER TABLE table_name ARCHIVE PARTITION• ALTER TABLE table_name CLUSTERED BY• ALTER TABLE table_name EXCHANGE PARTITION• ALTER TABLE table_name NOT CLUSTERED• ALTER TABLE table_name NOT SKEWED• ALTER TABLE table_name NOT SORTED• ALTER TABLE table_name NOT STORED AS DIRECTORIES• ALTER TABLE table_name partitionSpec ADD COLUMNS• ALTER TABLE table_name partitionSpec CHANGE COLUMNS• ALTER TABLE table_name partitionSpec COMPACT• ALTER TABLE table_name partitionSpec CONCATENATE• ALTER TABLE table_name partitionSpec REPLACE COLUMNS• ALTER TABLE table_name partitionSpec SET FILEFORMAT• ALTER TABLE table_name RENAME TO• ALTER TABLE table_name SET SKEWED LOCATION• ALTER TABLE table_name SKEWED BY• ALTER TABLE table_name TOUCH• ALTER TABLE table_name UNARCHIVE PARTITION• COMMIT• CREATE INDEX• CREATE ROLE• CREATE TABLE table_name LIKE existing_table_name• CREATE TEMPORARY MACRO• DELETE FROM• DESCRIBE DATABASE• DFS

325

Amazon Athena BenutzerhandbuchALTER DATABASE SET DBPROPERTIES

• DROP INDEX• DROP ROLE• DROP TEMPORARY MACRO• EXPORT TABLE• GRANT ROLE• IMPORT TABLE• INSERT INTO• LOCK DATABASE• LOCK TABLE• REVOKE ROLE• ROLLBACK• SHOW COMPACTIONS• SHOW CURRENT ROLES• SHOW GRANT• SHOW INDEXES• SHOW LOCKS• SHOW PRINCIPALS• SHOW ROLE GRANT• SHOW ROLES• SHOW TRANSACTIONS• START TRANSACTION• UNLOCK DATABASE• UNLOCK TABLE

ALTER DATABASE SET DBPROPERTIESErstellt eine oder mehrere Eigenschaften für eine Datenbank. Sie können DATABASE und SCHEMAverwenden, beides hat dieselbe Bedeutung.

Syntax

ALTER (DATABASE|SCHEMA) database_name SET DBPROPERTIES ('property_name'='property_value' [, ...] )

ParameterSET DBPROPERTIES ('property_name'='property_value' [, ...]

Gibt eine Eigenschaft (oder mehrere) für die Datenbank mit dem Namen property_name an.Der Wert für jede dieser Eigenschaften wird entsprechend als property_value festgelegt. Sollteproperty_name bereits vorhanden sein, wird der alte Wert mit property_value überschrieben.

Beispiele

ALTER DATABASE jd_datasets

326

Amazon Athena BenutzerhandbuchALTER TABLE ADD PARTITION

SET DBPROPERTIES ('creator'='John Doe', 'department'='applied mathematics');

ALTER SCHEMA jd_datasets SET DBPROPERTIES ('creator'='Jane Doe');

ALTER TABLE ADD PARTITIONErstellt eine oder mehrere Partitionsspalten für die Tabelle. Jede Partition besteht aus einer oder mehrerenunterschiedlichen Spaltenname/Wert-Kombinationen. Für jede angegebene Kombination wird ein eigenesDatenverzeichnis erstellt. Dies kann die Abfrageleistung in einigen Fällen verbessern. Partitionierte Spaltensind nicht in den Tabellendaten selbst vorhanden. Falls Sie also einen Spaltennamen angeben, der miteiner Spalte in der Tabelle übereinstimmt, wird ein Fehler ausgegeben. Weitere Informationen finden Sieauf der Seite zum Partitionieren von Daten (p. 39).

SyntaxALTER TABLE table_name ADD [IF NOT EXISTS] PARTITION (partition_col1_name = partition_col1_value [,partition_col2_name = partition_col2_value] [,...]) [LOCATION 'location1'] [PARTITION (partition_colA_name = partition_colA_value [,partition_colB_name = partition_colB_value [,...])] [LOCATION 'location2'] [,...]

Parameter[IF NOT EXISTS]

Führt in dem Fall, dass bereits eine Partition mit derselben Definition vorhanden ist, zu einerFehlerunterdrückung.

PARTITION (partition_col_name = partition_col_value [,...])

Erstellt eine Partition mit den von Ihnen angegebenen Spaltenname/Wert-Kombinationen. BindenSie partition_col_value nur als Zeichenfolgenzeichen ein, wenn der Datentyp der Spalte eineZeichenfolge ist.

[LOCATION 'location']

Gibt das Verzeichnis an, in dem die in der vorherigen Anweisung definierten Partitionen gespeichertwerden.

BeispieleALTER TABLE orders ADD PARTITION (dt = '2016-05-14', country = 'IN');

ALTER TABLE orders ADD PARTITION (dt = '2016-05-14', country = 'IN') PARTITION (dt = '2016-05-15', country = 'IN');

327

Amazon Athena BenutzerhandbuchALTER TABLE DROP PARTITION

ALTER TABLE orders ADD PARTITION (dt = '2016-05-14', country = 'IN') LOCATION 's3://mystorage/path/to/INDIA_14_May_2016/' PARTITION (dt = '2016-05-15', country = 'IN') LOCATION 's3://mystorage/path/to/INDIA_15_May_2016/';

ALTER TABLE DROP PARTITIONLöscht eine oder mehrere angegebene Partitionen für die benannte Tabelle.

Syntax

ALTER TABLE table_name DROP [IF EXISTS] PARTITION (partition_spec) [, PARTITION (partition_spec)]

Parameter[IF EXISTS]

Unterdrückt die Fehlermeldung, wenn die angegebene Partition nicht vorhanden ist.PARTITION (partition_spec)

Jede partition_spec gibt eine Spaltenname/Spaltenwert-Kombination in Form vonpartition_col_name = partition_col_value [,...] an.

Beispiele

ALTER TABLE orders DROP PARTITION (dt = '2014-05-14', country = 'IN');

ALTER TABLE orders DROP PARTITION (dt = '2014-05-14', country = 'IN'), PARTITION (dt = '2014-05-15', country = 'IN');

ALTER TABLE RENAME PARTITIONBenennt die Partitionsspalte partition_spec für die Tabelle namens table_name innew_partition_spec um.

Syntax

ALTER TABLE table_name PARTITION (partition_spec) RENAME TO PARTITION (new_partition_spec)

ParameterPARTITION (partition_spec)

Jede partition_spec gibt eine Spaltenname/Spaltenwert-Kombination in Form vonpartition_col_name = partition_col_value [,...] an.

328

Amazon Athena BenutzerhandbuchALTER TABLE SET LOCATION

BeispieleALTER TABLE orders PARTITION (dt = '2014-05-14', country = 'IN') RENAME TO PARTITION (dt = '2014-05-15', country = 'IN');

ALTER TABLE SET LOCATIONÄndert den Speicherort für die Tabelle namens table_nameund optional eine Partition mitpartition_spec.

SyntaxALTER TABLE table_name [ PARTITION (partition_spec) ] SET LOCATION 'new location'

ParameterPARTITION (partition_spec)

Gibt die Partition mit partition_spec-Parametern an, dessen Speicherort Sie ändernmöchten. partition_spec gibt eine Name/Wert-Kombination einer Spalte im Formular auspartition_col_name = partition_col_value.

SET LOCATION 'new location'

Gibt den neuen Speicherort an. Es muss sich dabei um einen Amazon S3-Speicherort handeln.Weitere Informationen zur Syntax finden Sie unter Tabellenort in Amazon S3 (p. 38).

BeispieleALTER TABLE customers PARTITION (zip='98040', state='WA') SET LOCATION 's3://mystorage/custdata/';

ALTER TABLE SET TBLPROPERTIESFügt benutzerdefinierte Metadateneigenschaften zu einer Tabelle hinzu und legt deren zugewiesene Wertefest.

Verwaltete Tabellen werden nicht unterstützt, so dass die Einstellung 'EXTERNAL'='FALSE' keineAuswirkungen hat.

SynopsisALTER TABLE table_name SET TBLPROPERTIES ('property_name' = 'property_value' [ , ... ])

ParameterSET TBLPROPERTIES ('property_name' = 'property_value' [ , ... ])

Gib die Metadateneigenschaften, die als property_name hinzugefügt werden, und den jeweiligenWert als property value an. Wenn property_name bereits vorhanden ist, wird der Wert aufproperty_value zurückgesetzt.

329

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-ManagedandExternalTables

Amazon Athena BenutzerhandbuchCREATE DATABASE

BeispieleALTER TABLE orders SET TBLPROPERTIES ('notes'="Please don't drop this table.");

CREATE DATABASEErstellt eine Datenbank. Sie können DATABASE oder SCHEMA gleichwertig verwenden. Sie haben dieselbeBedeutung.

SynopsisCREATE (DATABASE|SCHEMA) [IF NOT EXISTS] database_name [COMMENT 'database_comment'] [LOCATION 'S3_loc'] [WITH DBPROPERTIES ('property_name' = 'property_value') [, ...]]

Parameter[IF NOT EXISTS]

Führt dazu, dass der Fehler unterdrückt wird, wenn eine Datenbank mit dem Namen database_namebereits vorhanden ist.

[COMMENT database_comment]

Legt den Metadatenwert für die integrierte Metadateneigenschaft namens comment und den Wert, denSie für database_comment angeben, fest.

[LOCATION S3_loc]

Legt den Speicherort fest, an dem Datenbankdateien und Metaspeicher als S3_loc abgelegt werden.Der Speicherort muss ein Amazon S3-Speicherort sein.

[WITH DBPROPERTIES ('property_name' = 'property_value') [, ...] ]

Ermöglicht Ihnen, benutzerdefinierte Metadateneigenschaften für die Datenbankdefinition festzulegen.

BeispieleCREATE DATABASE clickstreams;

CREATE DATABASE IF NOT EXISTS clickstreams COMMENT 'Site Foo clickstream data aggregates' LOCATION 's3://myS3location/clickstreams/' WITH DBPROPERTIES ('creator'='Jane D.', 'Dept.'='Marketing analytics');

CREATE TABLEErstellt eine Tabelle mit dem Namen und den Parametern, den bzw. die Sie angeben.

SyntaxCREATE [EXTERNAL] TABLE [IF NOT EXISTS]

330

Amazon Athena BenutzerhandbuchCREATE TABLE

[db_name.]table_name [(col_name data_type [COMMENT col_comment] [, ...] )] [COMMENT table_comment] [PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)] [ROW FORMAT row_format] [STORED AS file_format] [WITH SERDEPROPERTIES (...)] ] [LOCATION 's3_loc'] [TBLPROPERTIES ( ['has_encrypted_data'='true | false',] ['classification'='aws_glue_classification',] property_name=property_value [, ...] ) ]

Parameter[EXTERNAL]

Gibt an, dass die Tabelle auf einer Datendatei basiert, die in Amazon S3 an dem von Ihnenangegebenen LOCATION vorhanden ist. Wenn Sie eine externe Tabelle erstellen, müssen diereferenzierten Daten mit dem Standardformat oder dem Format übereinstimmen, das Sie über dieKlauseln ROW FORMAT, STORED AS und WITH SERDEPROPERTIES festlegen.

[IF NOT EXISTS]

Führt dazu, dass die Fehlermeldung unterdrückt wird, wenn eine Tabelle mit dem Namen table_namebereits vorhanden ist.

[db_name.]table_name

Gibt einen Namen für die zu erstellende Tabelle an. Der optionale Parameter db_name gibt dieDatenbank an, in der die Tabelle gespeichert ist. Ist nichts angegeben, wird von der aktuellenDatenbank ausgegangen. Schließen Sie table_name in Anführungszeichen ein, wenn derTabellenname Zahlen enthält, zum Beispiel "table123". Wenn table_name mit einem Unterstrichbeginnt, verwenden Sie Backticks, beispielsweise `_mytable`. Sonderzeichen (außer Unterstriche)werden nicht unterstützt.

Bei Athena-Tabellennamen wird die Groß-/Kleinschreibung berücksichtigt. Wenn Sie mit Apache Sparkarbeiten, beachten Sie, dass Spark Tabellennamen in Kleinbuchstaben erfordert.

[ ( col_name data_type [COMMENT col_comment] [, ...] ) ]

Gibt den Datentyp und den Namen jeder zu erstellenden Spalten an. Spaltennamen lassen außerUnterstrichen (_) keine Sonderzeichen zu. Falls col_name mit einem Unterstrich beginnt, schließenSie den Spaltennamen in Backticks ein, beispielsweise `_mycolumn`.

Beim Wert data_type kann es sich um den folgenden Typ handeln:• BOOLEAN Die Werte sind true und false.• TINYINT Eine 8-Bit signierte INTEGER im Zweierkomplement-Format mit einem Mindestwert von

-2^7 und einem Höchstwert von 2^7-1.• SMALLINT Eine 16-Bit signierte INTEGER im Zweierkomplement-Format mit einem Mindestwert von

-2^15 und einem Höchstwert von 2^15-1.• INT. Athena kombiniert zwei verschiedene Implementierungen des Datentyps INTEGER. In DDL-

Abfragen (Data Definition Language) verwendet Athena den Datentyp INT. In allen anderenAbfragen verwendet Athena den Datentyp INTEGER, wobei INTEGER als signierter 32-Bit-Wertim Zweierkomplement-Format mit einem Mindestwert von -2^31 und einem Höchstwert von2^31-1 dargestellt wird. Im JDBC-Treiber wird INTEGER zurückgegeben, um Kompatibilität mit dengeschäftlichen Analyseanwendungen zu gewährleisten.

• BIGINT. Eine 64-Bit signierte INTEGER im Zweierkomplement-Format mit einem Mindestwert von-2^63 und einem Höchstwert von 2^63-1.

• DOUBLE

331


• FLOAT

• DECIMAL [ (precision, scale) ], wobei precision die Gesamtanzahl der Stellen undscale (optional) die Anzahl der Nachkommastellen ist. Der Standardwert ist 0. Verwenden Sie z. B.diese Definitionen: DECIMAL(11,5), DECIMAL(15).

Um Dezimalwerte als Literale anzugeben, z. B. bei der Auswahl von Zeilen mit einem bestimmtenDezimalwert im DDL-Ausdruck einer Abfrage, legen Sie als Typdefinition DECIMAL fest und listenSie die Dezimalwerte als Literalwert (in einfachen Anführungszeichen) in Ihrer Abfrage auf, wie indiesem Beispiel: decimal_value = DECIMAL '0.12'.

• CHAR Zeichendaten mit fester Länge, die zwischen 1 und 255 Zeichen liegen muss, z. B. char(10).Weitere Informationen finden Sie unter CHAR Hive Data Type.

• VARCHAR Zeichendaten mit variabler Länge, die zwischen 1 und 65535 Zeichen liegen muss, z. B.varchar(10). Weitere Informationen finden Sie unter VARCHAR Hive Data Type.

• BINARY (für Daten in Parquet)• Typen für Datum und Uhrzeit• DATE, im UNIX-Format, wie z. B. YYYY-MM-DD.• TIMESTAMP Datum und Uhrzeit eines Zeitpunkts im UNiX-Format, z. B. yyyy-mm-ddhh:mm:ss[.f...]. Beispiel, TIMESTAMP '2008-09-15 03:04:05.324'. Dieses Formatverwendet die Zeitzone der Sitzung.

• ARRAY < data_type >• MAP < primitive_type, data_type >• STRUCT < col_name : data_type [COMMENT col_comment] [, ...] >

[COMMENT table_comment]

Erstellt die Tabelleneigenschaft comment und füllt diese mit dem von Ihnen angegebenentable_comment.

[PARTITIONED BY (col_name data_type [ COMMENT col_comment ], ... ) ]

Erstellt eine partitionierte Tabelle mit einer oder mehreren Partitionsspalten, bei denen col_name,data_type und col_comment angegeben sind. Eine Tabelle kann eine oder mehrere Partitionenumfassen. Diese bestehen aus einem eindeutigen Spaltennamen und einer Wertekombination.Für jede angegebene Kombination wird ein eigenes Datenverzeichnis erstellt. Dies kann dieAbfrageleistung in einigen Fällen verbessern. In den Tabellendaten selbst sind keine partitioniertenSpalten vorhanden. Wenn Sie einen Wert für col_name verwenden, der mit einer Tabellenspalteidentisch ist, erhalten Sie einen Fehler. Weitere Informationen finden Sie auf der Seite zumPartitionieren von Daten (p. 39).

Note

Nach dem Erstellen einer Tabelle mit Partitionen führen Sie eine weitere Abfrage aus, dieaus der Klausel MSCK REPAIR TABLE (p. 339) besteht, um die Partitionsmetadatenaufzufrischen, beispielsweise MSCK REPAIR TABLE cloudfront_logs;.

[ROW FORMAT row_format]

Gibt das Zeilenformat der Tabelle und deren zugrunde liegenden Quelldaten an, wenn zutreffend. Fürrow_format können Sie mit der Klausel DELIMITED ein oder mehrere Trennzeichen angeben, oderalternativ die Klausel SERDE verwenden, wie unten beschrieben. Wenn ROW FORMAT ausgelassenwurde oder ROW FORMAT DELIMITED angegeben ist, wird ein nativer SerDe verwendet.• [DELIMITED FIELDS TERMINATED BY char [ESCAPED BY char]]• [DELIMITED COLLECTION ITEMS TERMINATED BY char]• [MAP KEYS TERMINATED BY char]• [LINES TERMINATED BY char]

332

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-char

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Types#LanguageManualTypes-varchar


• [NULL DEFINED AS char] -- (Hinweis: Ab Hive 0.13 verfügbar)

--ODER--• SERDE 'serde_name' [WITH SERDEPROPERTIES ("property_name" = "property_value",

"property_name" = "property_value" [, ...] )]

serde_name gibt den zu verwendenden SerDe an. Die Klausel WITH SERDEPROPERTIESermöglicht Ihnen, eine oder mehrere benutzerdefinierte Eigenschaften bereitzustellen, die vomSerDe unterstützt werden.

[STORED AS Dateiformat]

Gibt das Dateiformat für Tabellendaten an. Wenn nichts angegeben ist, wird standardmäßig TEXTFILEverwendet. Optionen für file_format sind:• SEQUENCEFILE• TEXTFILE• RCFILE• ORC• PARQUET• AVRO• INPUTFORMAT input_format_classname OUTPUTFORMAT output_format_classname

[LOCATION 'S3_loc']

Gibt den Speicherort der zugrunde liegenden Daten in Amazon S3 an, aus denen die Tabelleerstellt wurde, beispielsweise 's3://mystorage/'. Weitere Informationen zu Überlegungen zumDatenformat und zu Berechtigungen finden Sie auf der Seite über Anforderungen für Tabellen inAthena und Daten in Amazon S3 (p. 32).

Verwenden Sie einen abschließenden Schrägstrich für Ihren Ordner oder Bucket. Verwenden Siekeine Dateinamen oder glob-Zeichen.

Verwenden Sie: s3://mybucket/key/

Nicht verwenden: s3://path_to_bucket s3://path_to_bucket/* s3://path_to-bucket/mydatafile.dat

[TBLPROPERTIES ( ['has_encrypted_data'='true | false',] ['classification'='aws_glue_classification',]property_name=property_value [, ...] ) ]

Gibt zusätzlich zu den vordefinierten Tabelleneigenschaften wie "comment" benutzerdefinierteSchlüssel/Wert-Paare in Form von Metadaten für die Tabellendefinition an.

Athena verfügt über die integrierte Eigenschaft has_encrypted_data. Setzen Sie diese Eigenschaftauf true, um anzugeben, dass das zugrunde liegende Dataset, das durch LOCATION festgelegtist, verschlüsselt ist. Wenn dies ausgelassen wird und die Einstellungen der Arbeitsgruppeclientseitige Einstellungen nicht überschreiben, wird false angenommen. Wenn nichts angegebenoder die Eigenschaft auf false gesetzt ist, schlägt die Abfrage fehl, wenn die zugrundeliegenden Daten verschlüsselt sind. Weitere Informationen finden Sie unter Konfigurieren vonVerschlüsselungsoptionen (p. 210).

Zum Ausführen von ETL-Aufträgen erfordert AWS Glue das Erstellen einer Tabelle mit derclassification-Eigenschaft, um den Datentyp für AWS Glue als csv, parquet, orc, avro oderjson festzulegen. Beispiel, 'classification'='csv'. ETL-Aufträge schlagen fehl, wenn Siediese Eigenschaft nicht festlegen. Sie können diese nachträglich über die AWS Glue-Konsole, die APIoder die CLI angeben. Weitere Informationen finden Sie auf der Seite zum Thema Verwenden vonAWS Glue-Aufträgen für ETL mit Athena (p. 58) und Autorisieren von Aufträgen in Glue im AWS Glue-Entwicklerhandbuch.

333


Amazon Athena BenutzerhandbuchCREATE TABLE AS

Beispiele

CREATE EXTERNAL TABLE IF NOT EXISTS mydatabase.cloudfront_logs ( Date DATE, Time STRING, Location STRING, Bytes INT, RequestIP STRING, Method STRING, Host STRING, Uri STRING, Status INT, Referrer STRING, os STRING, Browser STRING, BrowserVersion STRING ) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe' WITH SERDEPROPERTIES ( "input.regex" = "^(?!#)([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+([^ ]+)\\s+[^\(]+[\(]([^\;]+).*\%20([^\/]+)[\/](.*)$" ) LOCATION 's3://athena-examples/cloudfront/plaintext/';

CREATE TABLE ASErstellt eine neue Tabelle mit den Ergebnissen einer SELECT (p. 317)-Abfrage. Um eine leere Tabelle zuerstellen, verwenden Sie CREATE TABLE (p. 330).

Themen• Syntax (p. 317)• CTAS-Tabelleneigenschaften (p. 335)• Beispiele (p. 336)

Syntax

CREATE TABLE table_name[ WITH ( property_name = expression [, ...] ) ]AS query[ WITH [ NO ] DATA ]

Wobei gilt:

WITH ( property_name = expression [, ...] )

Eine Liste der optionalen CTAS-Tabelleneigenschaften, von denen einige für das Datenspeicherformatspezifisch sind. Siehe CTAS-Tabelleneigenschaften (p. 335).

query

Eine SELECT (p. 317)-Abfrage, die verwendet wird, um eine neue Tabelle zu erstellen.

Important

Wenn Sie eine Abfrage mit Partitionen erstellen möchten, geben Sie die Namen derpartitionierten Spalten am Ende der Liste in der Liste der Spalten in der SELECT Anweisungan.

334

Amazon Athena BenutzerhandbuchCREATE TABLE AS

[ WITH [ NO ] DATA ]

Wenn WITH NO DATA verwendet wird, wird eine neue leere Tabelle mit demselben Schema wie dieursprüngliche Tabelle erstellt.

CTAS-TabelleneigenschaftenJede CTAS-Tabelle in Athena verfügt über eine Liste der optionalen CTAS-Tabelleneigenschaften, dieSie mit WITH (property_name = expression [, ...] ) angeben. Informationen zur Verwendungdieser Parameter finden Sie unter Beispiele für CTAS-Abfragen (p. 132).

WITH (property_name = expression [, ...], )

external_location = [location]

Der Speicherort, an dem Athena Ihre CTAS-Abfrage in Amazon S3 speichert, z. B. WITH(external_location ='s3://my-bucket/tables/parquet_table/'). DieseEigenschaft ist optional. Wenn Sie keinen Speicherort angeben und Ihre Arbeitsgruppe keineclientseitigen Einstellungen überschreibt (p. 261), speichert Athena die CTAS Abfrageergebnissein external_location = 's3://aws-athena-query-results-<account>-<region>/<query-name-or-unsaved>/<year>/<month>/<date>/<query-id>/' und verwendetdenselben Pfad nicht erneut. Wenn Sie den Speicherort manuell angeben, stellen Sie sicher, dassder Amazon S3-Speicherort über keine Daten verfügt. Athena versucht niemals, Ihre Daten zulöschen. Wenn Sie den gleichen Speicherort erneut verwenden möchten, bereinigen Sie die Datenmanuell, andernfalls wird Ihre CTAS-Abfrage fehlschlagen.

Wenn die Arbeitsgruppe, in der eine Abfrage ausgeführt werden wird, mit einemerzwungenen Speicherort für Abfrageergebnisse (p. 261) konfiguriert ist, dürfen Sie keinenexternal_location für die CTAS-Abfrage angeben. Wenn dies der Fall ist, gibt Athenaeine Fehlermeldung aus und Abfragen, die einen external_location angibt, schlagen fehl.Die folgende Abfrage schlägt beispielsweise fehl, wenn Sie die Verwendung eines eigenenSpeicherorts für die Arbeitsgruppe erzwingen: CREATE TABLE <DB>.<TABLE1> WITH(format='Parquet', external_location='s3://my_test/test/') AS SELECT *FROM <DB>.<TABLE2> LIMIT 10;

Um den für die Arbeitsgruppe angegebenen Ergebnisspeicherort zu erhalten, zeigen Sie dieArbeitsgruppendetails an (p. 265).

format = [format]

Das Datenformat für die CTAS-Abfrageergebnisse, z. B. ORC, PARQUET, AVRO, JSON oderTEXTFILE. Beispiel, WITH (format = 'PARQUET'). Wenn nichts angegeben ist, wirdstandardmäßig PARQUET verwendet. Der Name dieses Parameters, format, muss inKleinbuchstaben angegeben werden oder Ihre CTAS-Abfrage schlägt fehl.

partitioned_by = ( [col_name,…])

Optional. Eine Array-Liste der Spalten, nach denen die CTAS-Tabelle partitioniert wird. Stellen Siesicher, dass die Namen der partitionierten Spalten am Ende der Liste in der Liste der Spalten inder SELECT-Anweisung aufgeführt werden.

bucketed_by( [bucket_name,…])

Eine Array-Liste der Buckets zum Gruppieren von Daten. Wenn nicht angegeben, gruppiertAthena Ihre Daten nicht in dieser Abfrage.

bucket_count = [int]

Die Anzahl der Buckets für das Bucketing Ihrer Daten. Wenn nicht angegeben, gruppiert AthenaIhre Daten nicht.

335

Amazon Athena BenutzerhandbuchCREATE VIEW

orc_compression = [format]

Der Komprimierungstyp für ORC-Daten. Beispiel, WITH (orc_compression = 'ZLIB').Wenn nicht angegeben, wird die GZIP-Komprimierung standardmäßig für ORC und andereDatenspeicherformate verwendet, die von CTAS unterstützt werden.

parquet_compression = [format]

Der Komprimierungstyp für Parquet-Daten. Beispiel, WITH (parquet_compression ='SNAPPY'). Wenn nicht angegeben, wird die GZIP-Komprimierung standardmäßig für Parquetund andere Datenspeicherformate verwendet, die von CTAS unterstützt werden.

field_delimiter = [delimiter]

Optionale und speziell für Text-basierte Datenspeicherformate. Das Feldtrennzeichen für Dateienin CSV-, TSV- und Textdateien. Beispiel, WITH (field_delimiter = ','). Wenn Sie keinFeldtrennzeichen angeben, wird \001 standardmäßig verwendet.

BeispieleSiehe Beispiele für CTAS-Abfragen (p. 132).

CREATE VIEWErstellt eine neue Ansicht aus einer angegebenen SELECT-Abfrage. Die Ansicht ist eine logische Tabelle,auf die in zukünftigen Abfragen verwiesen werden kann. Ansichten enthalten keine Daten und schreibenkeine Daten. Stattdessen wird die in der Ansicht angegebene Abfrage jedes Mal ausgeführt, wenn Sie ineiner anderen Abfrage auf die Ansicht verweisen.

Mit der optionalen OR REPLACE-Klausel können Sie die vorhandene Ansicht aktualisieren, indem Sie sieersetzen. Weitere Informationen finden Sie unter Erstellen von Ansichten (p. 124).

SyntaxCREATE [ OR REPLACE ] VIEW view_name AS query

BeispieleVerwenden Sie zum Erstellen einer Ansicht test aus der Tabelle orders eine Abfrage wie die folgende:

CREATE VIEW test ASSELECT orderkey, orderstatus, totalprice / 2 AS halfFROM orders;

Verwenden Sie zum Erstellen einer Ansicht orders_by_date aus der Tabelle orders die folgendeAbfrage:

CREATE VIEW orders_by_date ASSELECT orderdate, sum(totalprice) AS priceFROM ordersGROUP BY orderdate;

Verwenden Sie zum Aktualisieren einer vorhandenen Ansicht ein Beispiel wie das folgende:

336

Amazon Athena BenutzerhandbuchDESCRIBE TABLE

CREATE OR REPLACE VIEW test ASSELECT orderkey, orderstatus, totalprice / 4 AS quarterFROM orders;

Siehe auch SHOW COLUMNS (p. 339), SHOW CREATE VIEW (p. 340), DESCRIBE VIEW (p. 337)und DROP VIEW (p. 339).

DESCRIBE TABLEZeigt die Liste der Spalten, einschließlich Partitionsspalten, für die benannte Spalte an. Auf diese Weisekönnen Sie die Attribute einer komplexen Spalte untersuchen.

SyntaxDESCRIBE [EXTENDED | FORMATTED] [db_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )]

Parameter[EXTENDED | FORMATTED]

Bestimmt das Format der Ausgabe. Wenn Sie EXTENDED angeben, werden alle Metadaten für dieTabelle in einer mit Thrift serialisierten Form ausgegeben. Dies ist in erster Linie für das Debuggingnützlich und nicht für die allgemeine Verwendung. Verwenden Sie FORMATTED oder lassen Sie dieKlausel weg, um die Metadaten in einem Tabellenformat anzuzeigen.

[PARTITION partition_spec]

Listet die Metadaten für die Partition mit partition_spec auf, sofern enthalten.[col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )* ]

Gibt die zu untersuchende Spalte und die zu untersuchenden Attribute an. Sie können.field_name für ein Element einer Struktur, '$elem$' für ein Array-Element, '$key$' für einenZuordnungsschlüssel und '$value$' für einen Zuordnungswert angeben. Sie können dies rekursivangeben, um die komplexe Spalte eingehender zu prüfen.

Beispiele

DESCRIBE orders;

DESCRIBE VIEWZeigt die Liste der Spalten für die benannte Ansicht an. Auf diese Weise können Sie die Attribute einerkomplexen Ansicht untersuchen.

SyntaxDESCRIBE [view_name]

BeispielDESCRIBE orders;

337

Amazon Athena BenutzerhandbuchDROP DATABASE

Siehe auch SHOW COLUMNS (p. 339), SHOW CREATE VIEW (p. 340), SHOW VIEWS (p. 342) undDROP VIEW (p. 339).

DROP DATABASEEntfernt die benannte Datenbank aus dem Katalog. Wenn die Datenbank Tabellen enthält, müssen Siedie Tabellen entweder vor dem Ausführen von DROP DATABASE löschen oder die CASCADE-Klauselverwenden. Sie können DATABASE oder SCHEMA gleichwertig verwenden. Sie haben dieselbe Bedeutung.

SynopsisDROP {DATABASE | SCHEMA} [IF EXISTS] database_name [RESTRICT | CASCADE]

Parameter[IF EXISTS]

Falls database_name nicht vorhanden ist, wird der Fehler unterdrückt.[RESTRICT|CASCADE]

Legt fest, wie Tabellen in database_name während der DROP-Operation behandelt werden. WennSie RESTRICT angeben, wird die Datenbank nicht gelöscht, wenn sie Tabellen enthält. Dies ist dasStandardverhalten. Wenn Sie CASCADE angeben, werden die Datenbank und alle darin enthaltenenTabellen gelöscht.

BeispieleDROP DATABASE clickstreams;

DROP SCHEMA IF EXISTS clickstreams CASCADE;

DROP TABLEEntfernt die Metadatendefinition für die Tabelle table_name. Wenn Sie eine externe Tabelle löschen,bleiben die zugrunde liegenden Daten erhalten, da alle Tabellen in Athena EXTERNAL sind.

SyntaxDROP TABLE [IF EXISTS] table_name

Parameter[ IF EXISTS ]

Falls table_name nicht vorhanden ist, wird der Fehler unterdrückt.

BeispieleDROP TABLE fulfilled_orders;

338

Amazon Athena BenutzerhandbuchDROP VIEW

DROP TABLE IF EXISTS fulfilled_orders;

DROP VIEWLöscht eine vorhandene Ansicht. Mit der optionalen IF EXISTS-Klausel wird der Fehler unterdrückt, fallsdie Ansicht nicht existiert.

Weitere Informationen finden Sie unter Löschen von Ansichten (p. 126).

Syntax

DROP VIEW [ IF EXISTS ] view_name

Beispiele

DROP VIEW orders_by_date

DROP VIEW IF EXISTS orders_by_date

Siehe auch CREATE VIEW (p. 336), SHOW COLUMNS (p. 339), SHOW CREATE VIEW (p. 340),SHOW VIEWS (p. 342) und DESCRIBE VIEW (p. 337).

MSCK REPAIR TABLEStellt Partitionen und Daten, die mit Partitionen verknüpft sind, wieder her. Verwenden Sie dieseAnweisung, wenn Sie Partitionen zum Katalog hinzufügen. Möglicherweise dauert es etwas, bis allePartitionen hinzugefügt wurden. Wird das Zeitlimit für diese Operation überschritten, ist der Status"unvollständig", da nur einige Partitionen zum Katalog hinzugefügt wurden. Führen Sie die Anweisung fürdiese Tabelle so lange aus, bis alle Partitionen hinzugefügt wurden. Weitere Informationen finden Sie aufder Seite zum Partitionieren von Daten (p. 39).

Syntax

MSCK REPAIR TABLE table_name

Beispiele

MSCK REPAIR TABLE orders;

SHOW COLUMNSListet die Spalten im Schema für eine Tabelle oder eine Ansicht auf.

Syntax

SHOW COLUMNS IN table_name|view_name

339

Amazon Athena BenutzerhandbuchSHOW CREATE TABLE

BeispieleSHOW COLUMNS IN clicks;

SHOW CREATE TABLEAnalysiert eine vorhandene Tabelle namens table_name, um die Abfrage zu erzeugen, mit der sie erstelltwurde.

SyntaxSHOW CREATE TABLE [db_name.]table_name

ParameterTABLE [db_name.]table_name

Der Parameter db_name ist optional. Wird er nicht angegeben, wird als Standardkontext die aktuelleDatenbank verwendet.

Note

Der Tabellenname ist erforderlich.

BeispieleSHOW CREATE TABLE orderclickstoday;

SHOW CREATE TABLE `salesdata.orderclickstoday`;

SHOW CREATE VIEWZeigt die SQL-Anweisung an, die die angegebene Ansicht erstellt.

SyntaxSHOW CREATE VIEW view_name

BeispieleSHOW CREATE VIEW orders_by_date

Weitere Informationen finden Sie auch unter CREATE VIEW (p. 336) und DROP VIEW (p. 339).

SHOW DATABASESListet alle Datenbanken auf, die im Metastore definiert sind. Sie können DATABASES oder SCHEMASverwenden. Sie haben dieselbe Bedeutung.

340

Amazon Athena BenutzerhandbuchSHOW PARTITIONS

SynopsisSHOW {DATABASES | SCHEMAS} [LIKE 'regular_expression']

Parameter[LIKE 'regular_expression']

Filtert die Liste der Datenbanken nach dem von Ihnen spezifizierten regular_expression.Platzhalter können entweder mit * (beliebiges Zeichen) oder mit | (Auswahl zwischen Zeichen)angegeben werden.

BeispieleSHOW SCHEMAS;

SHOW DATABASES LIKE '*analytics';

SHOW PARTITIONSListet alle Partitionen in einer Tabelle auf.

SyntaxSHOW PARTITIONS table_name

BeispieleSHOW PARTITIONS clicks;

SHOW TABLESListet alle Basistabellen und Ansichten in einer Datenbank auf.

SyntaxSHOW TABLES [IN database_name] ['regular_expression']

Parameter[IN database_name]

Gibt den database_name an, aus der die Tabellen aufgeführt werden. Wird dies nicht angegeben,wird die Datenbank des aktuellen Kontexts verwendet.

['regular_expression']

Filtert die Liste der Tabellen nach dem von Ihnen spezifizierten regular_expression. Lediglich derPlatzhalter *, der für ein beliebiges Zeichen steht, und das Zeichen |, welches eine Auswahl zwischenZeichen anzeigt, können verwendet werden.

341

Amazon Athena BenutzerhandbuchSHOW TBLPROPERTIES

BeispieleSHOW TABLES;

SHOW TABLES IN marketing_analytics 'orders*';

SHOW TBLPROPERTIESListet Tabelleneigenschaften für die benannte Tabelle auf.

SyntaxSHOW TBLPROPERTIES table_name [('property_name')]

Parameter[('property_name')]

Falls angegeben, wird nur der Wert der Eigenschaft property_name aufgelistet.

BeispieleSHOW TBLPROPERTIES orders;

SHOW TBLPROPERTIES orders('comment');

SHOW VIEWSListet die Ansichten in der angegebenen Datenbank oder in der aktuellen Datenbank auf, wenn Sie denDatenbanknamen weglassen. Verwenden Sie die optionale LIKE-Klausel mit einem regulären Ausdruck,um die Liste der Ansichtsnamen einzugrenzen.

Athena gibt eine Liste der Werte des Typs STRING zurück, wobei jeder Wert der Name einer Ansicht ist.

SyntaxSHOW VIEWS [IN database_name] LIKE ['regular_expression']

Parameter

[IN database_name]

Gibt den database_name an, aus der die Ansichten aufgeführt werden. Wird dies nicht angegeben,wird die Datenbank des aktuellen Kontexts verwendet.

[LIKE 'regular_expression']

Filtert die Liste der Ansichten nach dem von Ihnen spezifizierten regular_expression. Lediglich derPlatzhalter *, der für ein beliebiges Zeichen steht, und das Zeichen |, welches eine Auswahl zwischenZeichen anzeigt, können verwendet werden.

342


BeispieleSHOW VIEWS;

SHOW VIEWS IN marketing_analytics LIKE 'orders*';

Siehe auch SHOW COLUMNS (p. 339), SHOW CREATE VIEW (p. 340), DESCRIBE VIEW (p. 337)und DROP VIEW (p. 339).

Überlegungen und Einschränkungen für SQL-Abfragen in Amazon Athena

• Gespeicherte Prozeduren werden nicht unterstützt.• Die maximale Anzahl von Partitionen, die Sie mit den CREATE TABLE AS SELECT (CTAS)-

Anweisungen erstellen können, ist 100. Weitere Informationen finden Sie unter CREATE TABLEAS (p. 334).

• PREPARED-Anweisungen werden nicht unterstützt. Sie können EXECUTE nicht mit USING ausführen.• CREATE TABLE LIKE wird nicht unterstützt.• DESCRIBE INPUT und DESCRIBE OUTPUT werden nicht unterstützt.• EXPLAIN-Anweisungen werden nicht unterstützt.• Verbundene Presto-Konstruktoren werden nicht unterstützt. Sie können mit Datenquellen verbinden.

Weitere Informationen finden Sie unter Die Verwendung von (p. 66).• Wenn Sie Spalten mit komplexen Datentypen (array, map, struct) abfragen und zum Speichern von

Daten Parquet verwenden, liest Athena derzeit eine vollständige Datenzeile, anstatt wie erwartet selektivnur die angegebenen Spalten zu lesen. Dies ist ein bekanntes Problem.

343

https://prestodb.io/docs/0.172/connector.html

Amazon Athena BenutzerhandbuchCodebeispiele

Codebeispiele, Service Limits undvorheriger JDBC-Treiber

Verwenden Sie die folgenden Beispiele, um Athena-Anwendungen auf Basis des AWS SDK for Java zuerstellen.

Verwenden Sie die Links in diesem Abschnitt zur Verwendung der vorherigen Version des JDBC-Treibers.

Informationen zu den Service Limits.

Themen• Codebeispiele (p. 344)• Verwenden von JDBC-Treibern einer früheren Version (p. 352)• Service Limits (p. 357)

CodebeispieleVerwenden Sie die Beispiele in diesem Thema als Ausgangspunkt, um Athena-Anwendungen mit demSDK for Java 2.x zu schreiben.

• Java-Codebeispiele• Konstanten (p. 344)• Erstellen eines Clients für den Zugriff auf Athena (p. 345)• Verwenden von Abfrageausführungen

• Starten der Abfrageausführung (p. 345)• Anhalten der Abfrageausführung (p. 348)• Auflisten von Abfrageausführungen (p. 349)

• Arbeiten mit benannten Abfragen• Erstellen einer benannten Abfrage (p. 350)• Löschen einer benannten Abfrage (p. 350)• Auflisten von Abfrageausführungen (p. 349)

Note

In diesen Beispielen werden Konstanten (wie z. B. ATHENA_SAMPLE_QUERY) für Zeichenfolgenverwendet, die in einer Klassendeklaration ExampleConstants.java definiert sind. ErsetzenSie diese Konstanten durch eigene Zeichenfolgen oder definierte Konstanten.

KonstantenDie Klasse ExampleConstants.java demonstriert, wie man eine Tabelle abfragt, die mit dem TutorialErste Schritte (p. 25) in Athena erstellt wurde.

344

Amazon Athena BenutzerhandbuchErstellen eines Clients für den Zugriff auf Athena

package aws.example.athena;

public class ExampleConstants {

public static final int CLIENT_EXECUTION_TIMEOUT = 100000; public static final String ATHENA_OUTPUT_BUCKET = "s3://my-athena-bucket"; // This example demonstrates how to query a table created by the "Getting Started" tutorial in Athena public static final String ATHENA_SAMPLE_QUERY = "SELECT elb_name, " + " count(1)" + " FROM elb_logs" + " Where elb_response_code = '200'" + " GROUP BY elb_name" + " ORDER BY 2 DESC limit 10;"; public static final long SLEEP_AMOUNT_IN_MS = 1000; public static final String ATHENA_DEFAULT_DATABASE = "default";

}

Erstellen eines Clients für den Zugriff auf AthenaDie Klasse AthenaClientFactory.java zeigt, wie Sie einen Amazon Athena-Client erstellen undkonfigurieren.


import software.amazon.awssdk.auth.credentials.InstanceProfileCredentialsProvider;import software.amazon.awssdk.regions.Region;import software.amazon.awssdk.services.athena.AthenaClient;import software.amazon.awssdk.services.athena.AthenaClientBuilder;

/** * AthenaClientFactory * ------------------------------------- * This code shows how to create and configure an Amazon Athena client. */public class AthenaClientFactory { /** * AthenaClientClientBuilder to build Athena with the following properties: * - Set the region of the client * - Use the instance profile from the EC2 instance as the credentials provider * - Configure the client to increase the execution timeout. */ private final AthenaClientBuilder builder = AthenaClient.builder() .region(Region.US_WEST_2) .credentialsProvider(InstanceProfileCredentialsProvider.create());

public AthenaClient createClient() { return builder.build(); }}

Starten der AbfrageausführungDas StartQueryExample zeigt, wie Sie eine Anfrage an Athena zur Ausführung absenden, auf dieErgebnisse warten und dann die Ergebnisse verarbeiten.


import software.amazon.awssdk.services.athena.AthenaClient;

345

Amazon Athena BenutzerhandbuchStarten der Abfrageausführung

import software.amazon.awssdk.services.athena.model.*;import software.amazon.awssdk.services.athena.paginators.GetQueryResultsIterable;

import java.util.List;

/** * StartQueryExample * ------------------------------------- * This code shows how to submit a query to Athena for execution, wait till results * are available, and then process the results. */public class StartQueryExample { public static void main(String[] args) throws InterruptedException { // Build an AthenaClient client AthenaClientFactory factory = new AthenaClientFactory(); AthenaClient athenaClient = factory.createClient();

String queryExecutionId = submitAthenaQuery(athenaClient);

waitForQueryToComplete(athenaClient, queryExecutionId);

processResultRows(athenaClient, queryExecutionId); }

/** * Submits a sample query to Athena and returns the execution ID of the query. */ private static String submitAthenaQuery(AthenaClient athenaClient) { // The QueryExecutionContext allows us to set the Database. QueryExecutionContext queryExecutionContext = QueryExecutionContext.builder() .database(ExampleConstants.ATHENA_DEFAULT_DATABASE).build();

// The result configuration specifies where the results of the query should go in S3 and encryption options ResultConfiguration resultConfiguration = ResultConfiguration.builder() // You can provide encryption options for the output that is written. // .withEncryptionConfiguration(encryptionConfiguration) .outputLocation(ExampleConstants.ATHENA_OUTPUT_BUCKET).build();

// Create the StartQueryExecutionRequest to send to Athena which will start the query. StartQueryExecutionRequest startQueryExecutionRequest = StartQueryExecutionRequest.builder() .queryString(ExampleConstants.ATHENA_SAMPLE_QUERY) .queryExecutionContext(queryExecutionContext) .resultConfiguration(resultConfiguration).build();

StartQueryExecutionResponse startQueryExecutionResponse = athenaClient.startQueryExecution(startQueryExecutionRequest); return startQueryExecutionResponse.queryExecutionId(); }

/** * Wait for an Athena query to complete, fail or to be cancelled. This is done by polling Athena over an * interval of time. If a query fails or is cancelled, then it will throw an exception. */

private static void waitForQueryToComplete(AthenaClient athenaClient, String queryExecutionId) throws InterruptedException { GetQueryExecutionRequest getQueryExecutionRequest = GetQueryExecutionRequest.builder() .queryExecutionId(queryExecutionId).build();

GetQueryExecutionResponse getQueryExecutionResponse; boolean isQueryStillRunning = true;

346

Amazon Athena BenutzerhandbuchStarten der Abfrageausführung

while (isQueryStillRunning) { getQueryExecutionResponse = athenaClient.getQueryExecution(getQueryExecutionRequest); String queryState = getQueryExecutionResponse.queryExecution().status().state().toString(); if (queryState.equals(QueryExecutionState.FAILED.toString())) { throw new RuntimeException("Query Failed to run with Error Message: " + getQueryExecutionResponse .queryExecution().status().stateChangeReason()); } else if (queryState.equals(QueryExecutionState.CANCELLED.toString())) { throw new RuntimeException("Query was cancelled."); } else if (queryState.equals(QueryExecutionState.SUCCEEDED.toString())) { isQueryStillRunning = false; } else { // Sleep an amount of time before retrying again. Thread.sleep(ExampleConstants.SLEEP_AMOUNT_IN_MS); } System.out.println("Current Status is: " + queryState); } }

/** * This code calls Athena and retrieves the results of a query. * The query must be in a completed state before the results can be retrieved and * paginated. The first row of results are the column headers. */ private static void processResultRows(AthenaClient athenaClient, String queryExecutionId) { GetQueryResultsRequest getQueryResultsRequest = GetQueryResultsRequest.builder() // Max Results can be set but if its not set, // it will choose the maximum page size // As of the writing of this code, the maximum value is 1000 // .withMaxResults(1000) .queryExecutionId(queryExecutionId).build();

GetQueryResultsIterable getQueryResultsResults = athenaClient.getQueryResultsPaginator(getQueryResultsRequest);

for (GetQueryResultsResponse Resultresult : getQueryResultsResults) { List<ColumnInfo> columnInfoList = Resultresult.resultSet().resultSetMetadata().columnInfo(); List<Row> results = Resultresult.resultSet().rows(); processRow(results, columnInfoList); } }

private static void processRow(List<Row> row, List<ColumnInfo> columnInfoList) { for (ColumnInfo columnInfo : columnInfoList) { switch (columnInfo.type()) { case "varchar": // Convert and Process as String break; case "tinyint": // Convert and Process as tinyint break; case "smallint": // Convert and Process as smallint break; case "integer": // Convert and Process as integer break; case "bigint": // Convert and Process as bigint break; case "double": // Convert and Process as double

347

Amazon Athena BenutzerhandbuchAnhalten der Abfrageausführung

break; case "boolean": // Convert and Process as boolean break; case "date": // Convert and Process as date break; case "timestamp": // Convert and Process as timestamp break; default: throw new RuntimeException("Unexpected Type is not expected" + columnInfo.type()); } } }}

Anhalten der AbfrageausführungDas StopQueryExecutionExample führt eine Beispielabfrage aus, stoppt die Abfrage sofort undüberprüft den Status der Abfrage, um sicherzustellen, dass sie abgebrochen wurde.


import software.amazon.awssdk.services.athena.AthenaClient;import software.amazon.awssdk.services.athena.model.*;

/** * StopQueryExecutionExample * ------------------------------------- * This code runs an example query, immediately stops the query, and checks the status of the query to * ensure that it was cancelled. */public class StopQueryExecutionExample { public static void main(String[] args) throws Exception { // Build an Athena client AthenaClientFactory factory = new AthenaClientFactory(); AthenaClient athenaClient = factory.createClient();

String sampleQueryExecutionId = submitAthenaQuery(athenaClient);

// Submit the stop query Request StopQueryExecutionRequest stopQueryExecutionRequest = StopQueryExecutionRequest.builder() .queryExecutionId(sampleQueryExecutionId).build();

StopQueryExecutionResponse stopQueryExecutionResponse = athenaClient.stopQueryExecution(stopQueryExecutionRequest);

// Ensure that the query was stopped GetQueryExecutionRequest getQueryExecutionRequest = GetQueryExecutionRequest.builder() .queryExecutionId(sampleQueryExecutionId).build();

GetQueryExecutionResponse getQueryExecutionResponse = athenaClient.getQueryExecution(getQueryExecutionRequest); if (getQueryExecutionResponse.queryExecution() .status() .state() .equals(QueryExecutionState.CANCELLED)) { // Query was cancelled.

348

Amazon Athena BenutzerhandbuchAuflisten von Abfrageausführungen

System.out.println("Query has been cancelled"); } }

/** * Submits an example query and returns a query execution ID of a running query to stop. */ public static String submitAthenaQuery(AthenaClient athenaClient) { QueryExecutionContext queryExecutionContext = QueryExecutionContext.builder() .database(ExampleConstants.ATHENA_DEFAULT_DATABASE).build();

ResultConfiguration resultConfiguration = ResultConfiguration.builder() .outputLocation(ExampleConstants.ATHENA_OUTPUT_BUCKET).build();

StartQueryExecutionRequest startQueryExecutionRequest = StartQueryExecutionRequest.builder() .queryExecutionContext(queryExecutionContext) .queryString(ExampleConstants.ATHENA_SAMPLE_QUERY) .resultConfiguration(resultConfiguration).build();

StartQueryExecutionResponse startQueryExecutionResponse = athenaClient.startQueryExecution(startQueryExecutionRequest);

return startQueryExecutionResponse.queryExecutionId();

}}

Auflisten von AbfrageausführungenDas ListQueryExecutionsExample zeigt, wie Sie eine Liste von Abfrageausführungs-IDs abrufen.


import software.amazon.awssdk.services.athena.AthenaClient;import software.amazon.awssdk.services.athena.model.ListQueryExecutionsRequest;import software.amazon.awssdk.services.athena.model.ListQueryExecutionsResponse;import software.amazon.awssdk.services.athena.paginators.ListQueryExecutionsIterable;


/** * ListQueryExecutionsExample * ------------------------------------- * This code shows how to obtain a list of query execution IDs. */public class ListQueryExecutionsExample { public static void main(String[] args) throws Exception { // Build an Athena client AthenaClientFactory factory = new AthenaClientFactory(); AthenaClient athenaClient = factory.createClient();

// Build the request ListQueryExecutionsRequest listQueryExecutionsRequest = ListQueryExecutionsRequest.builder().build();

// Get the list results. ListQueryExecutionsIterable listQueryExecutionResponses = athenaClient.listQueryExecutionsPaginator(listQueryExecutionsRequest);

349

Amazon Athena BenutzerhandbuchErstellen einer benannten Abfrage

for (ListQueryExecutionsResponse listQueryExecutionResponse : listQueryExecutionResponses) { List<String> queryExecutionIds = listQueryExecutionResponse.queryExecutionIds(); // process queryExecutionIds.

System.out.println(queryExecutionIds); }

}}

Erstellen einer benannten AbfrageDas CreateNamedQueryExample zeigt, wie Sie eine benannte Abfrage erstellen.


import software.amazon.awssdk.services.athena.AthenaClient;import software.amazon.awssdk.services.athena.model.CreateNamedQueryRequest;import software.amazon.awssdk.services.athena.model.CreateNamedQueryResponse;

/** * CreateNamedQueryExample * ------------------------------------- * This code shows how to create a named query. */public class CreateNamedQueryExample { public static void main(String[] args) throws Exception { // Build an Athena client AthenaClientFactory factory = new AthenaClientFactory(); AthenaClient athenaClient = factory.createClient();

// Create the named query request. CreateNamedQueryRequest createNamedQueryRequest = CreateNamedQueryRequest.builder() .database(ExampleConstants.ATHENA_DEFAULT_DATABASE) .queryString(ExampleConstants.ATHENA_SAMPLE_QUERY) .description("Sample Description") .name("SampleQuery2").build();

// Call Athena to create the named query. If it fails, an exception is thrown. CreateNamedQueryResponse createNamedQueryResult = athenaClient.createNamedQuery(createNamedQueryRequest); }}

Löschen einer benannten AbfrageDas DeleteNamedQueryExample zeigt, wie Sie eine benannte Abfrage mithilfe der ID der benanntenAbfrage löschen.


import software.amazon.awssdk.services.athena.AthenaClient;import software.amazon.awssdk.services.athena.model.CreateNamedQueryRequest;import software.amazon.awssdk.services.athena.model.CreateNamedQueryResponse;import software.amazon.awssdk.services.athena.model.DeleteNamedQueryRequest;import software.amazon.awssdk.services.athena.model.DeleteNamedQueryResponse;

/** * DeleteNamedQueryExample

350

Amazon Athena BenutzerhandbuchAuflisten benannter Abfragen

* ------------------------------------- * This code shows how to delete a named query by using the named query ID. */public class DeleteNamedQueryExample { private static String getNamedQueryId(AthenaClient athenaClient) { // Create the NameQuery Request. CreateNamedQueryRequest createNamedQueryRequest = CreateNamedQueryRequest.builder() .database(ExampleConstants.ATHENA_DEFAULT_DATABASE) .queryString(ExampleConstants.ATHENA_SAMPLE_QUERY) .name("SampleQueryName") .description("Sample Description").build();

// Create the named query. If it fails, an exception is thrown. CreateNamedQueryResponse createNamedQueryResponse = athenaClient.createNamedQuery(createNamedQueryRequest); return createNamedQueryResponse.namedQueryId(); }

public static void main(String[] args) throws Exception { // Build an Athena client AthenaClientFactory factory = new AthenaClientFactory(); AthenaClient athenaClient = factory.createClient();

String sampleNamedQueryId = getNamedQueryId(athenaClient);

// Create the delete named query request DeleteNamedQueryRequest deleteNamedQueryRequest = DeleteNamedQueryRequest.builder() .namedQueryId(sampleNamedQueryId).build();

// Delete the named query DeleteNamedQueryResponse deleteNamedQueryResponse = athenaClient.deleteNamedQuery(deleteNamedQueryRequest); }}

Auflisten benannter AbfragenDas ListNamedQueryExample zeigt, wie Sie eine Liste von IDs benannter Abfragen abrufen.


import software.amazon.awssdk.services.athena.AthenaClient;import software.amazon.awssdk.services.athena.model.ListNamedQueriesRequest;import software.amazon.awssdk.services.athena.model.ListNamedQueriesResponse;import software.amazon.awssdk.services.athena.paginators.ListNamedQueriesIterable;


/** * ListNamedQueryExample * ------------------------------------- * This code shows how to obtain a list of named query IDs. */public class ListNamedQueryExample { public static void main(String[] args) throws Exception { // Build an Athena client AthenaClientFactory factory = new AthenaClientFactory(); AthenaClient athenaClient = factory.createClient();

// Build the request ListNamedQueriesRequest listNamedQueriesRequest = ListNamedQueriesRequest.builder().build();

351

Amazon Athena BenutzerhandbuchJDBC-Treiber einer früheren Version

// Get the list results. ListNamedQueriesIterable listNamedQueriesResponses = athenaClient.listNamedQueriesPaginator(listNamedQueriesRequest);

// Process the results. for (ListNamedQueriesResponse listNamedQueriesResponse : listNamedQueriesResponses) { List<String> namedQueryIds = listNamedQueriesResponse.namedQueryIds(); // process named query IDs

System.out.println(namedQueryIds); }

}}

Verwenden von JDBC-Treibern einer früherenVersion

Wir empfehlen, die neueste Version des JDBC-Treibers zu verwenden. Weitere Informationen finden Sieunter Verwenden von Athena mit dem JDBC-Treiber (p. 76). Links zu früheren Version 2.x-Treibern undSupport-Materialien finden Sie unten, falls für Ihre Anwendung erforderlich.

JDBC-Treiber einer früheren Version

JDBC-Treiber,Version

Downloads

JDBC 4.2-und JDK 8.0-kompatibel –AthenaJDBC42-2.0.8.jar

2.0.8JDBC 4.1-und JDK 7.0-kompatibel –AthenaJDBC41-2.0.8.jar

VersionshinweiseLizenzvereinbarungHinweise

Installations-undKonfigurationshandbuch(PDF)

Migrationsleitfaden(PDF)






2.0.6





352






























Amazon Athena BenutzerhandbuchAnweisungen zu JDBC-Treiberversion 1.1.0

JDBC-Treiber,Version

Downloads












Anweisungen zu JDBC-Treiberversion 1.1.0Dieser Abschnitt enthält einen Link zum Herunterladen der Version 1.1.0 des JDBC-Treibers. Es wirddringend empfohlen, zur aktuellen Treiberversion zu migrieren. Weitere Informationen finden Sie imMigrationsleitfaden für den JDBC-Treiber.

Version 1.0.1 und frühere Versionen des JDBC-Treibers sind veraltet.

Die JDBC-Treiberversion 1.1.0 ist mit JDBC 4.1 und JDK 7.0 kompatibel. Verwenden Sie den folgendenLink, um den Treiber herunterzuladen: AthenaJDBC41-1.1.0.jar. Laden Sie auch die Treiberlizenz und dieDrittanbieterlizenzen für den Treiber herunter. Verwenden Sie die AWS-CLI mit dem folgenden Befehl:aws s3 cp s3://path_to_the_driver [local_directory]. Befolgen Sie dann die weiterenAnweisungen in diesem Abschnitt.

Note

Die folgenden Anweisungen gelten speziell für JDBC-Version 1.1.0 und frühere Versionen.

JDBC-Treiberversion 1.1.0: Angabe der VerbindungszeichenfolgeVerwenden Sie zum Angeben der URL der JDBC-Treiberverbindung in Ihrer benutzerdefinierte Anwendungdie Zeichenfolge in folgendem Format:

jdbc:awsathena://athena.{REGION}.amazonaws.com:443

wobei {REGION} eine Regionskennung wie us-west-2 ist. Weitere Informationen zu Athena-Regionenfinden Sie unter Regionen.

353























https://s3.amazonaws.com/athena-downloads/drivers/JDBC/AthenaJDBC_1.1.0/AthenaJDBC41-1.1.0.jar

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/AthenaJDBC_1.1.0/docs/LICENSE.txt

https://s3.amazonaws.com/athena-downloads/drivers/JDBC/AthenaJDBC_1.1.0/docs/third-party-licenses.txt



JDBC-Treiberversion 1.1.0: Angabe des Klassennamens desJDBC-TreibersUm den Treiber in benutzerdefinierten Anwendungen verwenden zu können, richten Sie den Java-Klassenpfad so ein, dass er auf den Speicherort der JAR-Datei verweist, die Sie aus Amazon S3 https://s3.amazonaws.com/athena-downloads/drivers/JDBC/AthenaJDBC_1.1.0/AthenaJDBC41-1.1.0.jarheruntergeladen haben. Dadurch sind die Klassen in der JAR verfügbar. Die Haupt-JDBC-Treiberklasse istcom.amazonaws.athena.jdbc.AthenaDriver.

JDBC-Treiberversion 1.1.0: Angabe der Anmeldeinformationenfür den JDBC-TreiberStellen Sie JDBC-Treiber-Anmeldeinformationen für Ihre Anwendung bereit, um Zugriff auf AWS-Servicesund -Ressourcen wie z. B. Athena und Amazon S3-Buckets zu erhalten.

So stellen Sie die Anmeldeinformationen im Java-Code für Ihre Anwendung bereit:

1. Verwenden Sie eine Klasse, die den AWSCredentialsProvider implementiert.2. Richten Sie die JDBC-Eigenschaft aws_credentials_provider_class so ein, dass sie mit dem

Klassennamen identisch ist, und binden Sie sie in Ihren Klassenpfad ein.3. Um Konstruktorparameter einzuschließen, richten Sie die JDBC-Eigenschaft

aws_credentials_provider_arguments wie im folgenden Abschnitt zu Konfigurationsoptionenbeschrieben ein.

Eine weitere Möglichkeit, Anmeldeinformationen für BI-Tools wie SQL Workbench bereitzustellen, bestehtdarin, die für JDBC verwendeten Anmeldeinformationen als AWS-Zugriffsschlüssel und geheimen AWS-Schlüssel für die JDBC-Eigenschaften für Benutzer und Passwort bereitzustellen.

Benutzer, die Verbindungen über den JDBC-Treiber herstellen und deren Profilen benutzerdefinierteZugriffsrichtlinien angefügt sind, benötigen zusätzlich zu den in der Amazon Athena-API-Referenzaufgelisteten Berechtigungen auch Berechtigungen für Richtlinienaktionen.

Richtlinien für JDBC-Treiberversion 1.1.0Sie müssen JDBC-Benutzern erlauben, bestimmte richtlinienspezifische Aktionen auszuführen. Wenn diefolgenden Aktionen nicht erlaubt werden, können Benutzer Datenbanken und Tabellen nicht anzeigen:

• athena:GetCatalogs

• athena:GetExecutionEngine

• athena:GetExecutionEngines

• athena:GetNamespace

• athena:GetNamespaces

• athena:GetTable

• athena:GetTables

JDBC-Treiberversion 1.1.0: Konfigurieren der JDBC-TreiberoptionenSie können die folgenden Optionen für JDBC-Treiberversion 1.1.0 konfigurieren. Mit dieserVersion des Treibers können Sie auch Parameter in der Standard-JDBC-URL-Syntax

354



http://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/AWSCredentialsProvider.html



übergeben, z. B.: jdbc:awsathena://athena.us-west-1.amazonaws.com:443?max_error_retries=20&connection_timeout=20000.

Optionen für JDBC-Treiberversion 1.0.1

Eigenschaftenname Beschreibung StandardwertIsterforderlich

s3_staging_dir Der S3-Speicherort, an den die Abfrageausgabegeschrieben wird, z. B. s3://query-results-bucket/folder/, wird unter Settings in derAthena-Konsole (https://console.aws.amazon.com/athena/) festgelegt. Der JDBC-Treiber weist Athenaan, die Ergebnisse zu lesen und dem BenutzerDatenzeilen zurückzugeben.

– Ja

query_results_encryption_optionDie Verschlüsselungsmethode, die für das vons3_staging_dir angegebene Verzeichnisverwendet wird. Wenn keine Methode angegebenwird, wird der Speicherort nicht verschlüsselt.Gültige Werte sind SSE_S3, SSE_KMS, undCSE_KMS.

– Nein

query_results_aws_kms_keyDie Schlüssel-ID des AWS-Kundenmasterschlüssels(Customer Master Key, CMK), der verwendet wird,wenn für query_results_encryption_optionSSE-KMS oder CSE-KMS festgelegt wird. Beispiel,123abcde-4e56-56f7-g890-1234h5678i9j.

– Nein

aws_credentials_provider_classDie Klassenname desAnmeldeinformationsanbieters, der dieAWSCredentialsProvider-Schnittstelleimplementiert

– Nein

aws_credentials_provider_argumentsArgumente für den Constructor desAnmeldeinformationsanbieters als durch Kommagetrennte Werte

– Nein

max_error_retries Die maximale Anzahl an erneuten Versuchen, dieder JDBC-Client für Anforderungen an Athenaunternimmt

10 Nein

connection_timeout Die maximale Dauer in Millisekunden für dasHerstellen einer Verbindung zu Athena, bevor einVersuch beendet wird

10.000 Nein

socket_timeout Die maximale Dauer in Millisekunden, die auf einenSocket gewartet wird, um Daten an Athena zusenden

10.000 Nein

retry_base_delay Die minimale Verzögerung in Millisekundenzwischen erneuten Verbindungsversuchen zuAthena

100 Nein

retry_max_backoff_timeDie maximale Verzögerung in Millisekundenzwischen erneuten Verbindungsversuchen zuAthena

1000 Nein

355




Eigenschaftenname Beschreibung StandardwertIsterforderlich

log_path Der lokale Pfad der Athena-JDBC-Treiberprotokolle.Wenn kein Protokollpfad angegeben wird, werdenkeine Protokolldateien erstellt.

– Nein

log_level Die Protokollebene der Athena-JDBC-Treiberprotokolle Zulässige Werte: INFO, DEBUG,WARN, ERROR, ALL, OFF, FATAL, TRACE.

– Nein

Beispiele: Verwenden der JDBC-Treiberversion 1.1.0 mit demJDKDie folgenden Codebeispiele zeigen, wie die JDBC-Treiberversion 1.1.0 in einer Java-Anwendungverwendet werden kann. Bei diesen Beispielen wird davon ausgegangen, dass das AWS Java-SDKin Ihrem Klassenpfad enthalten ist, insbesondere das Modul aws-java-sdk-core, welches dieBerechtigungspakete (com.amazonaws.auth.*) enthält, auf die in den Beispielen verwiesen wird.

Example Beispiel: Erstellung einer Treiberversion 1.0.1

Properties info = new Properties(); info.put("user", "AWSAccessKey"); info.put("password", "AWSSecretAccessKey"); info.put("s3_staging_dir", "s3://S3 Bucket Location/"); info.put("aws_credentials_provider_class","com.amazonaws.auth.DefaultAWSCredentialsProviderChain"); Class.forName("com.amazonaws.athena.jdbc.AthenaDriver"); Connection connection = DriverManager.getConnection("jdbc:awsathena://athena.us-east-1.amazonaws.com:443/", info);

Die folgenden Beispiele zeigen die verschiedenen Möglichkeiten für die Verwendung eines Anbietersvon Anmeldeinformationen, der die Schnittstelle AWSCredentialsProvider implementiert, mit dervorherigen Version des JDBC-Treibers.

Example Beispiel: Verwenden eines Anbieters von Anmeldeinformationen für JDBC-Treiber 1.0.1

Properties myProps = new Properties(); myProps.put("aws_credentials_provider_class","com.amazonaws.auth.PropertiesFileCredentialsProvider"); myProps.put("aws_credentials_provider_arguments","/Users/myUser/.athenaCredentials");

In diesem Fall sollte die Datei /Users/myUser/.athenaCredentials Folgendes enthalten:

accessKey = ACCESSKEYsecretKey = SECRETKEY

Ersetzen Sie den richtigen Teil der Zuordnungen durch die AWS-Zugriffsschlüssel und geheimen SchlüsselIhres Kontos.

356

Amazon Athena BenutzerhandbuchService Limits

Example Beispiel: Verwendung eines Anbieters für Anmeldeinformationen mit mehrerenArgumenten

Dieses Beispiel zeigt einen Anbieter von Anmeldeinformationen,CustomSessionsCredentialsProvider, der einen Zugriffsschlüssel und geheimen Schlüsselzusätzlich zu einem Sitzungstoken verwendet. CustomSessionsCredentialsProvider dient nur alsBeispiel und ist nicht im Treiber enthalten. Die Signatur der Klasse sieht wie folgt aus:

public CustomSessionsCredentialsProvider(String accessId, String secretKey, String token) { //... }

Sie würden dann die Eigenschaften wie folgt festlegen:

Properties myProps = new Properties(); myProps.put("aws_credentials_provider_class","com.amazonaws.athena.jdbc.CustomSessionsCredentialsProvider"); String providerArgs = "My_Access_Key," + "My_Secret_Key," + "My_Token"; myProps.put("aws_credentials_provider_arguments",providerArgs);

Note

Wenn Sie den InstanceProfileCredentialsProvider verwenden, müssen Sie keineArgumente für Anmeldeinformationsanbieter angeben, da diese über das Amazon EC2-Instance-Profil für die Instance bereitgestellt werden, auf der Sie Ihre Anwendung ausführen. Siewürden jedoch weiterhin die Eigenschaft aws_credentials_provider_class mit diesemKlassennamen einrichten.

Richtlinien für JDBC-Treiberversionen vor Version 1.1.0Verwenden Sie diese veralteten Aktionen in Richtlinien nur mit JDBC-Treibern vor Version 1.1.0. Wenn Sieein Upgrade des JDBC-Treibers vornehmen, müssen Sie Richtlinienanweisungen, die veraltete Aktionenzulassen oder verweigern, entsprechend durch die nachstehend aufgeführten API-Aktionen ersetzen, daandernfalls Fehler auftreten.

Veraltete richtlinienspezifische Aktion Entsprechende Athena-API-Aktion

athena:RunQuery athena:StartQueryExecution

athena:CancelQueryExecution athena:StopQueryExecution

athena:GetQueryExecutions athena:ListQueryExecutions

Service LimitsNote

Sie können sich an den AWS Support wenden, um eine Erhöhung des Grenzwerts für die hieraufgeführten Limits zu beantragen.

• Standardmäßig ermöglichen die Limits für Ihr Konto, Folgendes zu übermitteln:• 20 DDL-Abfragen gleichzeitig. Zu DDL-Abfragen gehören CREATE TABLE- und CREATE TABLE ADDPARTITION-Abfragen.

357

https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/InstanceProfileCredentialsProvider.html



• 20 DML-Abfragen gleichzeitig. Zu DML-Abfragen gehören SELECT- und CREATE TABLE AS-(CTAS)-Abfragen.

Nachdem Sie die Abfragen an Athena übermittelt haben, werden diese verarbeitet, indem Ressourcen jenach der Gesamtauslastung des Services sowie der Anzahl eingehender Anfragen zugewiesen werden.Wir überwachen den Service fortlaufend und passen ihn an, damit Ihre Abfragen so schnell wie möglichverarbeitet werden.

Athena-Service Limits werden auf allen Arbeitsgruppen in dem Konto verwendet.

Hierbei handelt es sich um weiche Limits und Sie können eine Erhöhung der Limits anfordern. DieseLimits in Athena sind definiert als die Anzahl der Abfragen, die gleichzeitig an den Service übermitteltwerden können. Sie können bis zu zwanzig Abfragen des gleichen Typs (DDL oder DML) gleichzeitigabsenden. Wenn Sie eine Abfrage übermitteln, die die Obergrenze für Abfragen überschreitet, wird vonder Athena-API eine Fehlermeldung angezeigt: „Sie haben die Obergrenze für die Anzahl an Abfragen,die Sie gleichzeitig ausführen können, überschritten. Reduzieren Sie die Anzahl der gleichzeitigenAbfragen, die von diesem Konto abgesendet werden. Wenden Sie sich an den Kundensupport, um eineErhöhung der Obergrenze für gleichzeitige Abfragen zu beantragen.“

• Wenn Sie Athena in Regionen nutzen, in denen AWS Glue verfügbar ist, führen Sie eine Migration zuAWS Glue-Datenkatalog durch. Weitere Informationen finden Sie auf der Seite zum Schritt-für-Schritt-Upgrade auf den AWS Glue-Datenkatalog (p. 60).• Wenn Sie eine Migration zu AWS Glue-Datenkatalog durchgeführt haben, finden Sie Informationen zu

Service Limits für Tabellen, Datenbanken und Partitionen in Athena unter AWS Glue-Limits.• Wenn Sie keine Migration zu AWS Glue-Datenkatalog durchgeführt haben, ist die Anzahl der

Partitionen pro Tabelle 20.000. Sie können eine Erhöhung des Limits anfordern.• Möglicherweise stoßen Sie auf ein Limit für Amazon S3-Buckets pro Konto. Dieses beträgt 100.

Außerdem benötigt Athena zum Protokollieren der Ergebnisse einen separaten Bucket.• Das Abfrage-Timeout ist 30 Minuten.• Die maximal zulässige Länge einer Abfragezeichenfolge ist 262144 Byte, wobei die Zeichenfolgen in

UTF-8 kodiert sind. Verwenden Sie diese Tipps (p. 35) für die Benennung von Spalten, Tabellen undDatenbanken Athena.

• Die maximale Anzahl der Arbeitsgruppen, die Sie pro Region in Ihrem Konto erstellen können, ist 1000.• Für Athena-APIs gelten die folgenden Standardlimits für die Anzahl der Aufrufe der API pro Konto (nicht

pro Abfrage):

API-Name Standardanzahlder Aufrufe proSekunde

Burst-Kapazität

BatchGetNamedQuery, ListNamedQueries,ListQueryExecutions

5 bis zu 10

CreateNamedQuery, DeleteNamedQuery,GetNamedQuery

5 bis zu 20

BatchGetQueryExecution 20 bis zu 40

StartQueryExecution, StopQueryExecution 20 bis zu 80

GetQueryExecution, GetQueryResults 100 bis zu 200

Beispielsweise können Sie für StartQueryExecution bis zu 20 Aufrufe pro Sekunde tätigen. Wenndiese API 4 Sekunden lang nicht aufgerufen wird, sammelt Ihr Konto zudem eine Burst-Kapazität von

358


https://docs.aws.amazon.com/glue/latest/dg/troubleshooting-service-limits.html



bis zu 80 Aufrufen. In diesem Fall kann Ihre Anwendung im Burst-Modus bis zu 80 Aufrufe für diese APIdurchführen.

Wenn Sie bei Verwendung einer dieser APIs das Standardlimit für die Anzahl von Aufrufen pro Sekundeoder die Burst-Kapazität in Ihrem Konto überschreiten, gibt die Athena-API eine Fehlermeldungähnlich der folgenden aus: ""ClientError: Beim Aufruf der <API_name>-Operation ist ein Fehler(ThrottlingException) aufgetreten. Rate überschritten." Reduzieren Sie die Anzahl der Aufrufe proSekunde oder die Burst-Kapazität für die API für dieses Konto. Sie können AWS Support kontaktieren,um eine Erhöhung des Limits zu beantragen.

359



DokumentverlaufLetzte Aktualisierung der Dokumentation: 18. September 2019

Änderung Beschreibung Veröffentlichungsdatum

Abschnitt für denneuen INSERTINTO-Befehlund aktualisierteStandortinformationenfürAbfrageergebnissezur UnterstützungvonDatenmanifestdateienhinzugefügt.

Weitere Informationen finden Sie unter INSERTINTO (p. 321) und Arbeiten mit Abfrageergebnissen,Ausgabedateien und dem Abfrageverlauf (p. 115).

18. September2019

Ein Abschnitt zurUnterstützung vonSchnittstellen-VPC-Endpunkten(PrivateLink)wurde hinzugefügt.Aktualisierte JDBC-Treiber. AktualisierteInformationen zuerweiterten VPC-Flow-Protokollen.

Weitere Informationen finden Sie unter Herstellen einerVerbindung mit Amazon Athena über einen Schnittstellen-VPC-Endpunkt (p. 241), Abfragen von Amazon VPC-Flow-Protokollen (p. 204) und Verwenden von Athena mit demJDBC-Treiber (p. 76).

11. September2019

Abschnitt zurIntegration mit AWSLake Formationhinzugefügt.

Weitere Informationen finden Sie unter Verwenden vonAthena zum Abfragen von Daten, die in AWS Lake Formationregistriert sind (p. 243).

26. Juni 2019

Der Abschnitt"Sicherheit"wurde ausKonsistenzgründenmit anderen AWS-Services aktualisiert.

Weitere Informationen finden Sie unter AmazonAthenaSicherheit (p. 209).

26. Juni 2019

Abschnitt zumAbfragen von AWSWAF-Protokollenhinzugefügt.

Weitere Informationen finden Sie unter Abfragen von AWSWAF-Protokollen (p. 206).

31. Mai 2019

Veröffentlichungder neuen Versiondes ODBC-Treibersmit Unterstützungfür Athena-Arbeitsgruppen.

Informationen zum Herunterladen der ODBC-Treiberversion 1.0.5 und der zugehörigen Dokumentationfinden Sie unter Verbindung zu Amazon Athena mitODBC (p. 78). Informationen zu dieser Version finden Sieunter Versionshinweise für ODBC-Treiber.

Suchen Sie für weitere Informationen nach „Arbeitsgruppe“ inder ODBC-Treiber-Installations- und Konfigurationsanleitung,

5. März 2019

360




Änderung Beschreibung VeröffentlichungsdatumVersion 1.0.5. Wenn Sie Tags für Arbeitsgruppenverwenden, gibt es keine Änderungen an der ODBC-Treiber-Verbindungszeichenfolge. Um Tags zu verwenden,aktualisieren Sie auf die neueste Version des ODBC-Treibers(die aktuelle Version).

Diese Treiberversion ermöglicht Ihnen die Verwendung vonAthena API-Arbeitsgruppen-Aktionen (p. 268) zum Erstellenund Verwalten von Arbeitsgruppen und Athena-API-Tag-Aktionen (p. 280) zum Hinzufügen, Auflisten oder Entfernenvon Tags auf Arbeitsgruppen. Stellen vor Beginn sicher, dassSie über Berechtigungen auf Ressourcenebene in IAM fürAktionen auf Arbeitsgruppen und Tags verfügen.

Hinzufügung derTag-Unterstützungfür Arbeitsgruppen inAmazon Athena.

Ein Tag besteht aus einem Schlüssel und einem Wert,die Sie beide selbst definieren können. Wenn Sie eineArbeitsgruppe markieren, weisen Sie ihr benutzerdefinierteMetadaten zu. Sie können Tags zu Arbeitsgruppenhinzufügen, um Sie zu kategorisieren; verwenden Siedazu AWS Tagging – bewährte Methoden. Sie könnenmit Tags den Zugriff auf Arbeitsgruppen einschränkenund Kosten nachverfolgen. Erstellen Sie beispielsweiseeine Arbeitsgruppe für jede Kostenstelle. Wenn Sie diesenArbeitsgruppen dann Tags hinzufügen, können Sie IhreAthena-Ausgaben für jede Kostenstelle nachverfolgen.Weitere Informationen finden Sie unter Verwendungvon Tags für die Fakturierung im AWS Billing and CostManagement-Benutzerhandbuch.

22. Februar 2019

Verbesserung desOpenX JSON SerDein Athena.

Die Verbesserungen beinhalten u. a. Folgendes:

• Unterstützung für die EigenschaftConvertDotsInJsonKeysToUnderscores. Beider Einstellung TRUE kann der SerDe die Punkte inSchlüsselnamen durch Unterstriche ersetzen. Wenn derJSON-Datensatz beispielsweise einen Schlüssel mit demNamen "a.b" enthält, können Sie diese Eigenschaftverwenden, um den Spaltennamen als "a_b" in Athenazu definieren. Der Standardwert ist FALSE. Standardmäßigerlaubt Athena keine Punkte in Spaltennamen.

• Unterstützung für die Eigenschaft case.insensitive.Standardmäßig erfordert Athena, dass alle Schlüssel inIhrem JSON-Datensatz Kleinbuchstaben verwenden.Die Verwendung von WITH SERDE PROPERTIES("case.insensitive"= FALSE;) ermöglicht Ihnendie Verwendung von Schlüsselnamen in Ihren Daten,die Groß- und Kleinbuchstaben unterscheiden. DerStandardwert ist TRUE. Bei Festlegung auf TRUE wandeltder SerDe alle Großbuchstaben in Kleinbuchstaben um.

Weitere Informationen finden Sie unter the section called“OpenX JSON SerDe” (p. 302).

18. Februar 2019

361







Hinzufügung derUnterstützung fürArbeitsgruppen.

Verwenden Sie Arbeitsgruppen zum Trennen von Benutzern,Teams, Anwendungen oder Workloads sowie zur Einrichtungvon Grenzwerten für die Datenmenge, die jede Abfrageoder die gesamte Arbeitsgruppe verarbeiten kann. DaArbeitsgruppen als IAM-Ressourcen fungieren, könnenSie Berechtigungen auf Ressourcenebene verwenden,um den Zugriff auf eine bestimmte Arbeitsgruppe zusteuern. Sie können auch abfragebezogene Metriken inAmazon CloudWatch anzeigen, durch die Konfiguration vonLimits für die gescannten Daten Ihre Kosten kontrollieren,Schwellenwerte einrichten und Aktionen auslösen,wie etwa Amazon SNS-Alarm auslösen, wenn dieseSchwellenwerte überschritten werden. Weitere Informationenfinden Sie unter Verwenden von Arbeitsgruppen zumAusführen von Abfragen (p. 251) und Kontrollieren vonKosten und Überwachung von Abfragen mit CloudWatch-Metriken (p. 270).

18. Februar 2019

Unterstützung fürdas Analysierenvon Protokollenaus Netzwerk-Load-Balancerhinzugefügt.

Athena-Beispiel Abfragen für das Analysieren vonProtokollen aus Netzwerk-Load-Balancer hinzugefügt.Diese Protokolle erhalten detaillierte Informationenüber die Transport Layer Security(TLS)-Anfragen, diean Netzwerk-Load-Balancer gesendet werden. Siekönnen diese Zugriffsprotokolle für die Analyse vonDatenverkehrsmustern und zur Problembehebungverwenden. Weitere Informationen finden Sie unter thesection called “Abfragen von Netzwerk-Load-Balancer-Protokollen” (p. 200).

24. Januar 2019

Die neuen Versionender JDBC- undODBC-Treiber mitUnterstützung fürVerbundzugriffauf die Athena-API mit AD FS undSAML 2.0 (SecurityAssertion MarkupLanguage 2.0)wurden veröffentlicht.

Ab dieser Treiberversion wird der Verbundzugriff aufAthena für Active Directory Federation Service (AD FS 3.0)unterstützt. Der Zugriff wird durch die Versionen von JDBC-bzw. ODBC-Treibern hergestellt, die SAML 2.0 unterstützen.Informationen zur Konfiguration des Verbundzugriffs auf dieAthena-API finden Sie unter the section called “Aktivierendes föderierten Zugriffs auf die Athena-API” (p. 236).

10. November2018

362



ZusätzlicheUnterstützungfür detaillierteZugriffskontrolle aufDatenbanken undTabellen in Athena.Darüber hinauswurden Richtlinien zuAthena hinzugefügt,mit denen SieDatenbank- undTabellenmetadatenin der Data Catalogverschlüsselnkönnen.

Unterstützung für das Erstellen identitätsbasierter(IAM-)Richtlinien, die eine differenzierte Zugriffskontrollefür Ressourcen im AWS Glue-Datenkatalog ermöglichen,wie beispielsweise in Athena verwendete Datenbanken undTabellen, hinzugefügt.

Außerdem können Sie Datenbank- und Tabellenmetadatenin der Data Catalog verschlüsseln, indem Sie spezifischeRichtlinien zu Athena hinzufügen.

Details dazu finden Sie unter Zugriffskontrollrichtlinien.

15. Oktober 2018

Unterstützung fürCREATE TABLEAS SELECT-Anweisungenhinzugefügt.

WeitereVerbesserungen ander Dokumentationvorgenommen.

Unterstützung für CREATE TABLE AS SELECT-Anweisungen hinzugefügt. Weitere Informationenfinden Sie unter Erstellen einer Tabelle ausAbfrageergebnissen (p. 126), Überlegungen undEinschränkungen (p. 127) und Beispiele (p. 132).

10. Oktober 2018

ODBC-TreiberVersion 1.0.3freigegeben,mit Support fürStreaming vonErgebnissen stattderen Abruf aufSeiten.


Der ODBC-Treiber Version 1.0.3 unterstützt Streaming-Ergebnisse und umfasst auch Verbesserungen,Fehlerbehebungen und eine aktualisierte Dokumentationfür "Verwendung von SSL mit einem Proxy-Server". WeitereInformationen finden Sie in den Versionshinweisen zumTreiber.

Informationen zum Herunterladen der ODBC-Treiberversion 1.0.3 und der zugehörigen Dokumentationfinden Sie unter Verbindung zu Amazon Athena mitODBC (p. 78).

6. September2018

JDBC-TreiberVersion 2.0.5freigegeben, mitStandard-Supportfür Streaming vonErgebnissen stattderen Abruf aufSeiten.


JDBC-Treiber 2.0.5 freigegeben, mit Standard-Support fürStreaming von Ergebnissen statt deren Abruf auf Seiten.Weitere Informationen finden Sie unter Verwenden vonAthena mit dem JDBC-Treiber (p. 76).

Informationen zum Streaming von Ergebnissen erhalten Sie,wenn Sie im Installations- und Konfigurationsleitfaden für denJDBC-Treiber nach UseResultsetStreaming suchen.

16. August 2018

363

https://docs.aws.amazon.com/athena/latest/ug/access.html






Dokumentationzum Abfragen vonAmazon VirtualPrivate Cloud-Flow-Protokollen, diedirekt in AmazonS3 in einem GZIP-Format gespeichertwerden können,aktualisiert.

Beispiele fürdie Abfrage vonALB-Protokollenaktualisiert.

Dokumentation zum Abfragen von Amazon Virtual PrivateCloud-Flow-Protokollen, die direkt in Amazon S3 in einemGZIP-Format gespeichert werden können, aktualisiert.Weitere Informationen finden Sie unter Abfragen vonAmazon VPC-Flow-Protokollen (p. 204).

Beispiele für die Abfrage von ALB-Protokollen aktualisiert.Weitere Informationen finden Sie unter Abfragen vonApplication Load Balancer-Protokollen (p. 202).

7. August 2018

Unterstützungfür Ansichtenhinzugefügt.ZusätzlicheRichtlinienfür Schema-Manipulationenfür verschiedeneDatenspeicherformate.

Unterstützung für Ansichten hinzugefügt. WeitereInformationen finden Sie unter Arbeiten mitAnsichten (p. 121).

In diesem Abschnitt wurden Anleitungen zum Umgang mitSchema-Updates für verschiedene Datenspeicherformateergänzt. Weitere Informationen finden Sie unter Verarbeitenvon Schema-Updates (p. 136).

5. Juni 2018

Die Standard-Obergrenze fürgleichzeitigeAbfragen wurde vonfünf auf zwanzigangehoben.

Sie können bis zu 20 DDL-Abfragen und 20 SELECT-Abfragen gleichzeitig absenden und ausführen. WeitereInformationen finden Sie unter Service Limits (p. 357).

17. Mai 2018

Es wurden neueRegisterkartenfür Abfragen undeine Möglichkeitzur Konfigurationder automatischenVervollständigungim Query Editor(Abfrage-Editor)hinzugefügt.

Es wurden neue Registerkarten für Abfragen undeine Möglichkeit zur Konfiguration der automatischenVervollständigung im Query Editor (Abfrage-Editor)hinzugefügt. Weitere Informationen finden Sie unter Über dieKonsole (p. 29).

8. Mai 2018

JDBC-Treiberversion2.0.2 wurdefreigegeben.

Neue Version des JDBC-Treibers (Version 2.0.2) wurdefreigegeben. Weitere Informationen finden Sie unterVerwenden von Athena mit dem JDBC-Treiber (p. 76).

19. April 2018

AutomatischeVervollständigungfür die Eingabe vonAbfragen in derAthena-Konsolehinzugefügt.

Automatische Vervollständigung für die Eingabe vonAbfragen in der Athena-Konsole hinzugefügt.

6. April 2018

364



Möglichkeit,Athena-Tabellenfür CloudTrail-Protokolldateiendirekt aus derCloudTrail-Konsolezu erstellen, wurdehinzugefügt.

Möglichkeit, Athena-Tabellen für CloudTrail-Protokolldateienautomatisch direkt aus der CloudTrail-Konsole zu erstellen,wurde hinzugefügt. Weitere Informationen finden Sie unterErstellen einer Tabelle für CloudTrail-Protokolle in derCloudTrail-Konsole (p. 191).

15. März 2018

Unterstützungfür das sichereAuslagern vonZwischendaten aufDatenträger, umAbfragen mit GROUPBY auszuführen,hinzugefügt.

Es wurde eine Möglichkeit für das Auslagern vonZwischendaten auf Festplatte bei arbeitsspeicherintensivenAbfragen, die die GROUP BY-Klausel verwenden,hinzugefügt. Dadurch wird die Zuverlässigkeit solcherAbfragen verbessert und die Fehlermeldung "Query resourceexhausted" (Abfrage-Ressource aufgebraucht) vermieden.Weitere Informationen finden Sie im Versionshinweis für 2.Februar 2018 (p. 15).

2. Februar 2018

Unterstützung fürPresto-Version 0.172hinzugefügt.

Upgrade der zugrunde liegenden Engine in Amazon Athenaauf eine Version, die auf Presto-Version 0.172 basiert.Weitere Informationen finden Sie im Versionshinweis für19. Januar 2018 (p. 15).

19. Januar 2018

Unterstützung fürden ODBC-Treiberhinzugefügt.

Unterstützung für die Verbindungserstellung von Athena zumODBC-Treiber hinzugefügt. Weitere Informationen finden Sieunter Verbindung zu Amazon Athena mit ODBC.

13. November2017

Unterstützung fürdie Regionen Asien-Pazifik (Seoul),Asien-Pazifik(Mumbai) undEuropa (London)hinzugefügt.Unterstützung fürdie Abfrage vonkoordinatenbasiertenDaten hinzugefügt.

Unterstützung für die Abfrage von koordinatenbasiertenDaten und die Regionen Asien-Pazifik (Seoul), Asien-Pazifik (Mumbai) und Europa (London) hinzugefügt.Weitere Informationen finden Sie unter Abfragen vonkoordinatenbasierten Daten und Regionen und Endpunktevon AWS.

1. November2017

Europa (Frankfurt)wird nun unterstützt.

Europa (Frankfurt) wird nun unterstützt. Eine Liste derunterstützten Regionen finden Sie unter Regionen undEndpunkte von AWS.

19. Oktober 2017

Unterstützung fürbenannte Athena-Abfragen mit AWSCloudFormationhinzugefügt.

Unterstützung für das Erstellen benannter Athena-Abfragenmit AWS CloudFormation hinzugefügt. Weitere Informationenfinden Sie unter AWS::Athena::NamedQuery im AWSCloudFormation-Benutzerhandbuch.

3. Oktober 2017

Asien-Pazifik(Sydney) wird nununterstützt.

Asien-Pazifik (Sydney) wird nun unterstützt. Eine Liste derunterstützten Regionen finden Sie unter Regionen undEndpunkte von AWS.

25. September2017

365

https://docs.aws.amazon.com/athena/latest/ug/connect-with-odbc.html

https://docs.aws.amazon.com/athena/latest/ug/querying-geospatial-data.html

https://docs.aws.amazon.com/athena/latest/ug/querying-geospatial-data.html





https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-athena-named-query.html





Abschnitt zumAbfragen von AWS-Serviceprotokollenund verschiedenenDatentypen (darunterZuordnungen,Arrays,verschachtelte Datensowie JSON-Daten)zum Handbuchhinzugefügt.

Beispiele für Abfragen von AWS-Serviceprotokollen (p. 190)und für Abfragen verschiedener Datentypen in Athenahinzugefügt. Weitere Informationen finden Sie unterAusführen von SQL-Abfragen mit Amazon Athena (p. 81).

5. September2017

AWS Glue-Datenkatalog wirdnun unterstützt.

Integration mit dem AWS Glue-Datenkatalog sowie einenMigrationsassistenten für das Update vom verwaltetenAthena-Datenkatalog zum AWS Glue-Datenkataloghinzugefügt. Weitere Informationen finden Sie unterIntegration mit AWS Glue und AWS Glue.

14. August 2017

Unterstützungfür Grok SerDehinzugefügt.

Unterstützung für den Grok-SerDe zum einfachenMustervergleich von Datensätzen in unstrukturiertenTextdateien (z. B. Protokolle) hinzugefügt. WeitereInformationen finden Sie unter Grok-SerDe.Tastenkombinationen zum Durchblättern der Abfrageverläufemithilfe der Konsole hinzugefügt (STRG+⇧/⇩ bei Windows,CMD+⇧/⇩ bei Mac).

4. August 2017

Asien-Pazifik (Tokio)wird nun unterstützt.

Unterstützung für Asien-Pazifik (Tokio) und Asien-Pazifik(Singapur) hinzugefügt. Eine Liste der unterstütztenRegionen finden Sie unter Regionen und Endpunkte vonAWS.

22. Juni 2017

Europa (Irland) wirdnun unterstützt.

Europa (Irland) wird nun unterstützt. Weitere Informationenfinden Sie unter Regionen und Endpunkte von AWS.

8. Juni 2017

Unterstützung für dieAmazon Athena-APIund die AWS-CLIhinzugefügt.

Unterstützung für die Amazon Athena-API und die AWS-CLI für Athena hinzugefügt. JDBC-Treiber auf Version 1.1.0aktualisiert.

19. Mai 2017

Unterstützungfür Amazon S3-Datenverschlüsselunghinzugefügt.

Unterstützung für die Amazon S3-Datenverschlüsselungund eine veröffentlichte JDBC-Treiberaktualisierung(Version 1.0.1) mit Verschlüsselungsunterstützung sowieVerbesserungen und Fehlerbehebungen hinzugefügt.Weitere Informationen finden Sie unter Verschlüsselung imRuhezustand (p. 210).

4. April 2017

366

https://docs.aws.amazon.com/athena/latest/ug/glue-athena.html


https://docs.aws.amazon.com/athena/latest/ug/grok.html






AWS CloudTrailSerDe hinzugefügt.

AWS CloudTrail SerDe sowie Leistungsverbesserungenund Partitionsfehlerkorrekturen hinzugefügt. WeitereInformationen finden Sie unter CloudTrail-SerDe (p. 294).

• Verbesserte Leistung beim Scannen einer großenPartitionsanzahl.

• Verbesserte Leistung bei dem Vorgang MSCK RepairTable.

• Möglichkeit hinzugefügt, nicht in der primären Regiongespeicherte Amazon S3-Daten abzufragen. Nebenden Athena-Standardgebühren fallen auch die AmazonS3-Standardgebühren für regionenübergreifendeDatenübertragung an.

24. März 2017

USA Ost (Ohio) wirdnun unterstützt.

Unterstützung für Avro SerDe (p. 291) und OpenCSVSerDefür CSV-Verarbeitung (p. 295), USA Ost (Ohio) sowie dieMassenbearbeitung von Spalten im Konsolenassistentenhinzugefügt. Die Leistung bei großen Parquet-Tabellenwurde verbessert.

20. Februar 2017

Erstveröffentlichung des Amazon Athena-Benutzerhandbuchs.

November 2016

367


AWS-GlossarDie aktuelle AWS-Terminologie finden Sie im AWS-Glossar im AWS General Reference.

368

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

amazon athena - benutzerhandbuch · amazon athena benutzerhandbuch amazon's trademarks and...

Documents