

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden Sie AWS Glue Data Catalog , um eine Verbindung zu Ihren Daten herzustellen
<a name="data-sources-glue"></a>

Athena verwendet die AWS Glue Data Catalog , um Metadaten wie Tabellen- und Spaltennamen für Ihre in Amazon S3 gespeicherten Daten zu speichern. Diese Metadateninformationen werden zu den Datenbanken, Tabellen und Ansichten, die Sie im Athena-Abfrage-Editor sehen.

Wenn Sie Athena mit dem verwenden AWS Glue Data Catalog, können Sie AWS Glue damit Datenbanken und Tabellen (Schema) erstellen, die in Athena abgefragt werden sollen, oder Sie können Athena verwenden, um ein Schema zu erstellen und sie dann in und verwandten Diensten zu verwenden. AWS Glue 

Um Schemainformationen für zu definieren AWS Glue, können Sie ein Formular in der Athena-Konsole verwenden, den Abfrage-Editor in Athena verwenden oder einen AWS Glue Crawler in der Konsole erstellen. AWS Glue AWS Glue Crawler leiten automatisch Datenbank- und Tabellenschemas aus Ihren Daten in Amazon S3 ab. Die Verwendung eines Formulars bietet mehr Anpassungsmöglichkeiten. Das Schreiben eigener `CREATE TABLE`-Aussagen erfordert mehr Aufwand, bietet aber die meiste Kontrolle. Weitere Informationen finden Sie unter [CREATE TABLE](create-table.md).

## Weitere Ressourcen
<a name="glue-additional-resources"></a>
+ *Weitere Informationen zu finden Sie unter [Datenkatalog und Crawler AWS Glue im AWS Glue Entwicklerhandbuch](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html). AWS Glue Data Catalog*
+ Einen anschaulichen Artikel zur Verwendung von AWS Glue und Athena zur Verarbeitung von XML-Daten finden Sie unter Verarbeiten [und Analysieren stark verschachtelter und großer XML-Dateien mithilfe von AWS Glue Amazon Athena](https://aws.amazon.com/blogs/big-data/process-and-analyze-highly-nested-and-large-xml-files-using-aws-glue-and-amazon-athena/) im AWS Big Data-Blog.
+ Separate Gebühren fallen an für. AWS Glue Weitere Informationen finden Sie unter [AWS Glue Preise](https://aws.amazon.com/glue/pricing).

**Topics**
+ [Weitere Ressourcen](#glue-additional-resources)
+ [Datenkataloge in Athena registrieren und verwenden](gdc-register.md)
+ [Einen Datenkatalog von einem anderen Konto aus registrieren](data-sources-glue-cross-account.md)
+ [Zugriff auf Datenkataloge mit IAM-Richtlinien steuern](datacatalogs-iam-policy.md)
+ [Verwenden Sie ein Formular in der Athena-Konsole, um eine AWS Glue Tabelle hinzuzufügen](data-sources-glue-manual-table.md)
+ [Einen Crawler verwenden, um eine Tabelle hinzuzufügen](schema-crawlers.md)
+ [Optimieren Sie Abfragen mit AWS Glue Partitionsindexierung und Filterung](glue-best-practices-partition-index.md)
+ [Verwenden Sie die AWS CLI , um eine AWS Glue Datenbank und ihre Tabellen neu zu erstellen](glue-recreate-db-and-tables-cli.md)
+ [Tabellen für ETL-Aufträge erstellen](schema-classifier.md)
+ [Arbeiten Sie mit CSV-Daten in AWS Glue](schema-csv.md)
+ [Arbeiten Sie mit Geodaten in AWS Glue](schema-geospatial.md)

# Datenkataloge in Athena registrieren und verwenden
<a name="gdc-register"></a>

Athena unterstützt die Bereitstellung und Verbindung zu mehreren Datenkatalogen. 
+ Sie können Amazon Redshift Redshift-Daten in Athena einbinden AWS Glue Data Catalog und von Athena abfragen, ohne Daten kopieren oder verschieben zu müssen. Weitere Informationen finden Sie unter [Integrieren von Amazon-Redshift-Daten in AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/managing-namespaces-datacatalog.html).
+  Stellen Sie mithilfe von AWS Glue Verbindungen eine Connect AWS Glue Data Catalog zu externen Datenquellen her und erstellen Sie Verbundkataloge, um die Berechtigungen für die Daten mit detaillierter Zugriffskontrolle mithilfe von Lake Formation zentral zu verwalten. Weitere Informationen finden Sie unter [Ihre Verbindung als Glue-Datenkatalog registrieren](register-connection-as-gdc.md).
+ Erstellen Sie Kataloge aus Amazon S3 Tabellen-Buckets und verwenden Sie Lake Formation, um Zugriffsberechtigungen zentral zu verwalten und den Benutzerzugriff auf Objekte innerhalb des Tabellen-Buckets einzuschränken. Weitere Informationen finden Sie unter [Arbeiten mit Amazon-S3-Tables und Tabellen-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables.html) im Amazon-S3-Benutzerhandbuch.

**Anmerkung**  
Für jeden Glue-Katalog können Sie nur einen mehrstufigen Katalog wie `123412341234:my_catalog/my_child` registrieren. Sie können keinen einstufigen Katalog wie `123412341234:linkcontainer` oder `my_catalog` registrieren. Einstufige Kataloge können nur abgefragt werden, indem der Glue-Datenkatalog direkt in der Athena-Abfrage verwendet wird. Weitere Informationen finden Sie unter [AWS Glue Datenkataloge in Athena abfragen](gdc-register-query-the-data-source.md). 

**Topics**
+ [Redshift-Datenkataloge in Athena registrieren](gdc-register-rs.md)
+ [Verbundkataloge in Athena registrieren](gdc-register-federated.md)
+ [Registrieren Sie Bucket-Kataloge von S3-Tabellen und fragen Sie Tabellen von Athena ab](gdc-register-s3-table-bucket-cat.md)
+ [AWS Glue Datenkataloge in Athena abfragen](gdc-register-query-the-data-source.md)

# Redshift-Datenkataloge in Athena registrieren
<a name="gdc-register-rs"></a>

Athena kann Daten lesen und schreiben, die in Redshift-Clustern oder Serverless Namespaces gespeichert sind, die in AWS Glue Data Catalog registriert wurden. Dies funktioniert zusammen mit AWS Lake Formation, was für zentrale Sicherheit und Steuerung sorgt, sicherstellt, dass der Datenzugriff über verschiedene Abfrage-Engines hinweg konsistent verwaltet wird, und es werden detaillierte Zugriffskontrollen für die gemeinsam genutzten Redshift-Daten aufrechterhalten.

## Überlegungen und Einschränkungen
<a name="gdc-register-rs-considerations-and-limitations"></a>
+ **Materialisierte Ansichten** – Materialisierte Ansichten von Amazon Redshift können von Athena abgefragt werden, aber das Erstellen materialisierter Ansichten mit Athena oder Spark wird nicht unterstützt.
+ DDL-Operationen, einschließlich der Einstellung von AWS Glue Data Catalog Konfigurationen und Vorgängen in verwalteten Amazon Redshift Redshift-Speichertabellen, werden nicht unterstützt.

## Voraussetzungen
<a name="gdc-register-rs-prerequisites"></a>

Bevor Sie einen AWS Glue Datenkatalog von Athena abfragen können, müssen Sie die folgenden Aufgaben ausführen:

1. Erstellen und registrieren Sie einen Amazon-Redshift-Cluster oder einen Serverless Namespace für AWS Glue Data Catalog. Weitere Informationen finden Sie unter [Registrierung eines Clusters auf AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/mgmt/register-cluster.html) oder [Registrierung von Namespaces auf AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless_datasharing-register-namespace.html) im Amazon Redshift Management-Handbuch.

1. Erstellen Sie einen Datenkatalog AWS Lake Formation aus dem registrierten Namespace. Weitere Informationen finden Sie unter [Erstellen von Amazon Redshift Redshift-Verbundkatalogen im AWS Lake Formation Entwicklerhandbuch](https://docs.aws.amazon.com/lake-formation/latest/dg/create-ns-catalog.html).

1. (Optional) Verwenden Sie Lake Formation, um differenzierte Zugriffskontrollen für den Katalog festzulegen. Weitere Informationen finden Sie im [Entwicklerhandbuch unter Integrieren Ihrer Daten AWS Glue Data Catalog in den](https://docs.aws.amazon.com/lake-formation/latest/dg/bring-your-data-overview.html) AWS Lake Formation .

## Einen Redshift-Datenkatalog in der Athena-Konsole registrieren
<a name="gdc-register-rs-console-steps"></a>

Um einen Redshift-Datenkatalog in der Athena-Konsole zu registrieren, führen Sie die folgenden Schritte aus.

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).

1. Wählen Sie im Navigationsbereich **Datenquellen und Kataloge** aus.

1. Wählen Sie auf der Seite **Datenquellen und Kataloge** die Option **Datenquellen erstellen** aus.

1. Wählen Sie für **Eine Datenquelle auswählen** die Option **Amazon S3 - AWS Glue Data Catalog**.

1. Wählen Sie im **AWS Glue Data Catalog**-Abschnitt für **Datenquellenkonto** die Option **AWS Glue Data Catalog in diesem Konto**.

1. Wählen **Sie unter Tabelle erstellen oder Katalog registrieren** die Option **Neuen AWS Glue Katalog registrieren** aus.

1. Geben Sie im Abschnitt **Datenquellendetails** für **Datenquellenname** den Namen ein, den Sie verwenden möchten, um die Datenquelle in Ihren SQL-Abfragen anzugeben, oder verwenden Sie den generierten Standardnamen.

1. Wählen Sie unter **Katalog** die Option **Durchsuchen** aus, um nach einer Liste von AWS Glue Katalogen im selben Konto zu suchen. Wenn Ihnen keine Kataloge angezeigt werden, erstellen Sie einen in der [AWS Glue -Konsole](https://console.aws.amazon.com/glue/). 

1. **Wählen **Sie im Dialogfeld „ AWS Glue Kataloge durchsuchen**“ den Katalog aus, den Sie verwenden möchten, und klicken Sie dann auf „Auswählen“.**

1. (Optional) Geben Sie unter **Tags** alle key/value Paare ein, die Sie der Datenquelle zuordnen möchten.

1. Wählen Sie **Weiter** aus.

1. Überprüfen Sie auf der Seite **Überprüfen und erstellen** die Richtigkeit der eingegebenen Informationen und wählen Sie dann **Datenquelle erstellen**.

# Verbundkataloge in Athena registrieren
<a name="gdc-register-federated"></a>

Nachdem Sie Verbindungen zu Verbunddatenquellen hergestellt haben, können Sie diese als Verbunddatenkataloge registrieren, um die Datenermittlung zu vereinfachen und den Datenzugriff mithilfe von Lake Formation mit differenzierten Berechtigungen verwalten. Weitere Informationen finden Sie unter [Ihre Verbindung als Glue-Datenkatalog registrieren](register-connection-as-gdc.md).

## Überlegungen und Einschränkungen
<a name="gdc-register-federated-consideration"></a>
+ DDL-Operationen werden in Verbundkatalogen nicht unterstützt. 
+ Sie können die folgenden Konnektoren registrieren, um sie AWS Glue für eine differenzierte Zugriffskontrolle zu integrieren:
  + [Azure Data Lake-Speicher](connectors-adls-gen2.md)
  + [Azure Synapse](connectors-azure-synapse.md)
  + [BigQuery](connectors-bigquery.md)
  + [CMDB](connectors-cmdb.md)
  + [Db2](connectors-ibm-db2.md)
  + [Db2 i-Serie](connectors-ibm-db2-as400.md)
  + [DocumentDB](connectors-docdb.md)
  + [DynamoDB](connectors-dynamodb.md)
  + [Google Cloud-Speicher](connectors-gcs.md)
  + [HBase](connectors-hbase.md)
  + [MySQL](connectors-mysql.md)
  + [OpenSearch](connectors-opensearch.md)
  + [Oracle](connectors-oracle.md)
  + [PostgreSQL](connectors-postgresql.md)
  + [Redshift](connectors-redshift.md)
  + [SAP HANA](connectors-sap-hana.md)
  + [Snowflake](connectors-snowflake.md)
  + [SQL Server](connectors-microsoft-sql-server.md)
  + [Timestream](connectors-timestream.md)
  + [TPC-DS](connectors-tpcds.md)
+ Wenn Sie einen Ressourcenlink für den Glue-Connection-Verbund erstellen, muss der Name des [Ressourcenlinks](https://docs.aws.amazon.com/lake-formation/latest/dg/create-resource-link-database.html) mit dem Datenbanknamen des Erzeugers übereinstimmen.
+ Derzeit werden nur Tabellen- und Spaltennamen in Kleinbuchstaben erkannt, auch wenn in der Datenquelle nicht zwischen Groß- und Kleinschreibung unterschieden wird.

# Registrieren Sie Bucket-Kataloge von S3-Tabellen und fragen Sie Tabellen von Athena ab
<a name="gdc-register-s3-table-bucket-cat"></a>

Tabellen-Buckets für Amazon S3 sind ein Bucket-Typ in Amazon S3, der speziell zum Speichern von Tabellendaten in Apache-Iceberg-Tabellen entwickelt wurde. Tabellen-Buckets automatisieren Tabellenverwaltungsaufgaben wie Komprimierung, Snapshot-Verwaltung und Garbage Collection, um die Abfrageleistung kontinuierlich zu optimieren und die Kosten zu minimieren. Egal, ob Sie gerade erst anfangen oder Tausende von Tabellen in Ihrer Iceberg-Umgebung haben, Tabellen-Buckets vereinfachen Data Lakes in jeder Größenordnung. Weitere Informationen finden Sie unter [Tabellen-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets.html).

## Überlegungen und Einschränkungen
<a name="gdc-register-s3-table-consideration"></a>
+ Alle DDL-Operationen, die für Iceberg-Tabellen unterstützt werden, werden für S3-Tabellen unterstützt, mit den folgenden Ausnahmen:
  + `ALTER TABLE RENAME`, `CREATE VIEW` und `ALTER DATABASE` werden nicht unterstützt.
  + `OPTIMIZE` und `VACUUM` – Sie können die Komprimierung und die Snapshot-Verwaltung in S3 verwalten. Weitere Informationen finden Sie unter [Wartungsdokumentation für S3-Tabellen](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-maintenance.html).
+ DDL-Abfragen auf S3-Tabellen, die als Athena-Datenquellen registriert sind, werden nicht unterstützt.
+ Die Wiederverwendung von Abfrageergebnissen wird nicht unterstützt.
+ In Arbeitsgruppen mit aktivierter SSE-KMS- und CSE-KMS-Verschlüsselung können Sie keine Schreibvorgänge wie `INSERT`, `UPDATE`, `DELETE` oder `MERGE` für S3-Tabellen ausführen.
+ In Arbeitsgruppen, in denen die Option „Zahlung durch den S3-Anforderer“ aktiviert ist, können Sie keine DML-Operationen für S3-Tabellen ausführen.

## S3-Tabellen von Athena abfragen
<a name="gdc-register-s3-table-prereq-setup"></a>

**Diese erforderlichen Schritte vor der Arbfrage von S3-Tabellen in Athena ausführen**

1. Erstellen eines S3-Tabellen-Buckets. Weitere Informationen erhalten Sie unter [Erstellen eines Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets-create.html) im Benutzerhandbuch für Amazon Simple Storage Service. 

1. Stellen Sie sicher, dass die Integration Ihrer Tabellen-Buckets mit AWS Glue Data Catalog erfolgreich ist. Informationen zu den erforderlichen Berechtigungen und Einrichtungsschritten finden Sie unter [Voraussetzungen für die Integration von S3 Tables](https://docs.aws.amazon.com/glue/latest/dg/s3tables-catalog-prerequisites.html) und [Aktivieren der Integration von S3 Tables mit Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/enable-s3-tables-catalog-integration.html) im AWS Glue Entwicklerhandbuch.

1. Erteilen Sie für den Prinzipal, den Sie zum Ausführen von Abfragen mit Athena verwenden, Berechtigungen für den S3-Tabellenkatalog mit einem der folgenden Ansätze: 

   **Option 1: Verwenden Sie IAM-Berechtigungen**

   Wenn Sie die IAM-Zugriffskontrolle verwenden, benötigt Ihr Principal Berechtigungen sowohl für AWS Glue Data Catalog Ressourcen als auch für Amazon S3 Tables-Ressourcen.

   Die folgende Liste enthält alle `s3tables` Berechtigungen, die für die Ausführung unterstützter DDL- oder DML-Operationen für Ihre S3-Tabellen in Athena erforderlich sind:
   + `s3tables:GetTableBucket`
   + `s3tables:GetNamespace`
   + `s3tables:GetTable`
   + `s3tables:GetTableData`
   + `s3tables:PutTableData`
   + `s3tables:ListNamespaces`
   + `s3tables:ListTables`
   + `s3tables:DeleteNamespace`
   + `s3tables:DeleteTable`
   + `s3tables:CreateNamespace`
   + `s3tables:CreateTable`
   + `s3tables:UpdateTableMetadataLocation`

   Wenden Sie diese Berechtigungen auf bestimmte S3-Tabellen-Bucket- und S3-Tabellenressourcen an oder verwenden Sie `*` sie als Ressource, um Zugriff auf alle Tabellen-Buckets und Tabellen in Ihrem Konto zu gewähren. Diese Berechtigungen können mit der [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html)verwalteten Richtlinie kombiniert werden, um die vollständige Funktionalität zu ermöglichen.

   **Option 2: Verwenden Sie Lake Formation Formation-Berechtigungen**

   Um eine differenzierte Zugriffskontrolle zu ermöglichen, können Sie Lake Formation Formation-Berechtigungen für den S3-Tabellenkatalog gewähren, entweder über die Lake Formation Formation-Konsole oder. AWS CLI Dazu müssen Sie Ihre S3-Tabellen-Buckets als Lake Formation Formation-Datenstandort registrieren. Weitere Informationen finden Sie unter [Erstellen eines Amazon S3 S3-Tables-Katalogs AWS Glue Data Catalog im](https://docs.aws.amazon.com/lake-formation/latest/dg/create-s3-tables-catalog.html) Lake Formation Developer Guide.

------
#### [ AWS-Managementkonsole ]

   1. Öffnen Sie die AWS Lake Formation Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) und melden Sie sich als Data Lake-Administrator an. Weitere Informationen zum Erstellen eines Data-Lake-Administrators finden Sie unter [Create a data lake administrator (Data-Lake-Administrator erstellen)](https://docs.aws.amazon.com/lake-formation/latest/dg/initial-lf-config.html#create-data-lake-admin).

   1. Wählen Sie im Navigationsbereich **Data permissions (Datenberechtigungen)** und dann **Grant (Erteilen)** aus. 

   1. Wählen Sie auf der Seite **Berechtigungen erteilen** unter **Princizale** den Prinzipal aus, den Sie verwenden möchten, um eine Anfrage von Athena einzureichen.

   1. Wählen Sie unter **LF-Tags or catalog resources (LF-Tags oder Katalogressourcen)** die Option **Named Data Catalog resources (Benannte Datenkatalogressourcen)**.

   1. Wählen Sie für **Catalogs (Kataloge)** einen Glue-Datenkatalog, den Sie im Rahmen der Integration Ihres Tabellen-Buckets erstellt haben. Zum Beispiel :s3tablescatalog/*<accoundID>*. *amzn-s3-demo-bucket*

   1. Wählen Sie für **Katalogberechtigungen** die Option **Super aus.**

   1. Wählen Sie **Grant (Erteilen)**.

------
#### [ AWS CLI ]

   Führen Sie den folgenden Befehl mit der Data Lake-Administratorrolle für Lake Formation aus, um Zugriff auf den Prinzipal zu gewähren, den Sie zum Einreichen von Abfragen von Athena verwenden. 

   ```
   aws lakeformation grant-permissions \
   --region <region (Example,us-east-1)> \
   --cli-input-json \
   '{
       "Principal": {
           "DataLakePrincipalIdentifier": "<user or role ARN (Example, arn:aws:iam::<Account ID>:role/ExampleRole>"
       },
       "Resource": {
           "Catalog": {
               "Id":"<Account ID>:s3tablescatalog/amzn-s3-demo-bucket"
           }
       },
       "Permissions": ["ALL"]
   }'
   ```

------

**Abfragen für S3-Tabellen einreichen**

1. Reichen Sie eine `CREATE DATABASE`-Anfrage von Athena mit dem oben gewährten Benutzer/der oben gewährten Rolle ein. In diesem Beispiel ist `s3tablescatalog` der übergeordnete Glue-Datenkatalog erstellt aus der Integration und ` s3tablescatalog/amzn-s3-demo-bucket` ist der untergeordnete Glue-Datenkatalog, der für jeden S3-Tabellen-Bucket erstellt wurde. Es gibt zwei Möglichkeiten, Abfragen durchzuführen.

------
#### [ Option 1 ]

   Geben Sie den untergeordneten Glue-Datenkatalog (`s3tablescatalog/amzn-s3-demo-bucket`) direkt von der Konsole aus an oder AWS CLI.

   **Verwenden AWS-Managementkonsole**

   1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).

   1. Wählen Sie in der linken Navigationsleiste für **Datenquellenname** die Option **AwsDataCatalog**.

   1. Wählen Sie für **Catalog** die Option ***amzn-s3-demo-bucket*s3tablescatalog/** aus.

   1. Geben Sie im Abfrage-Editor eine Abfrage ein wie `CREATE DATABASE test_namespace`.

   **Verwenden AWS CLI**

   Führen Sie den folgenden Befehl aus.

   ```
   aws athena start-query-execution \ 
   --query-string 'CREATE DATABASE `test_namespace`' \ 
   --query-execution-context '{"Catalog": "s3tablescatalog/amzn-s3-demo-bucket"}' \
   --work-group "primary"
   ```

------
#### [ Option 2 ]

   Erstellen Sie den Athena-Datenkatalog aus dem untergeordneten Glue-Datenkatalog in der Athena-Konsole und geben Sie ihn als Katalog in der Abfrage an. Weitere Informationen finden Sie unter [S3-Tabellen-Bucket-Kataloge als Athena-Datenquellen registrieren](#gdc-register-s3-table-console-steps).

------

1. Verwenden Sie die Datenbank, die Sie im vorherigen Schritt erstellt haben, und erstellen Sie mit `CREATE TABLE` eine Tabelle. Das folgende Beispiel erstellt eine Tabelle in der *`test_namespace`*-Datenbank, die Sie zuvor im `s3tablescatalog/amzn-s3-demo-bucket`-Glue-Katalog erstellt haben.

------
#### [ AWS-Managementkonsole ]

   1. Wählen Sie in der linken Navigationsleiste für **Datenquellenname** die Option **AwsDataCatalog**.

   1. Wählen Sie für **Catalog** die Option ***amzn-s3-demo-bucket*s3tablescatalog/** aus.

   1. Wählen Sie für **Datenbank** die Option **test\$1namespace** aus.

   1. Führen Sie im Abfrage-Editor die folgende Abfrage aus.

      ```
      CREATE TABLE daily_sales (
              sale_date date,
              product_category
              string, sales_amount double)
      PARTITIONED BY (month(sale_date))
      TBLPROPERTIES ('table_type' = 'iceberg')
      ```

------
#### [ AWS CLI ]

   Führen Sie den folgenden Befehl aus.

   ```
   aws athena start-query-execution \
   --query-string "CREATE TABLE daily_sales (
           sale_date date,
           product_category
           string, sales_amount double)
   PARTITIONED BY (month(sale_date))
   TBLPROPERTIES ('table_type' = 'iceberg')" \
   --query-execution-context '{"Catalog": "s3tablescatalog/amzn-s3-demo-bucket", "Database":"test_namespace"}' \
   --work-group "primary"
   ```

------

1. Fügen Sie Daten in die Tabelle ein, die Sie im vorherigen Schritt erstellt haben.

------
#### [ AWS-Managementkonsole ]

   1. Wählen Sie in der linken Navigationsleiste für **Datenquellenname** die Option. **AwsDataCatalog**

   1. Wählen Sie für **Catalog** die Option ***amzn-s3-demo-bucket*s3tablescatalog/** aus.

   1. Wählen Sie für **Datenbank** die Option **test\$1namespace** aus.

   1. Führen Sie im Abfrage-Editor die folgende Abfrage aus.

      ```
      INSERT INTO daily_sales
      VALUES 
          (DATE '2024-01-15', 'Laptop', 900.00),
          (DATE '2024-01-15', 'Monitor', 250.00),
          (DATE '2024-01-16', 'Laptop', 1350.00),
          (DATE '2024-02-01', 'Monitor', 300.00);
      ```

------
#### [ AWS CLI ]

   Führen Sie den folgenden Befehl aus.

   ```
   aws athena start-query-execution \
   --query-string "INSERT INTO \"s3tablescatalog/amzn-s3-demo-bucket\".test_namespace.daily_sales
   VALUES 
   (DATE '2024-01-15', 'Laptop', 900.00),
   (DATE '2024-01-15', 'Monitor', 250.00),
   (DATE '2024-01-16', 'Laptop', 1350.00),
   (DATE '2024-02-01', 'Monitor', 300.00)"\ 
   --work-group "primary"
   ```

------

1. Nachdem Sie Daten in die Tabelle eingefügt haben, können Sie sie abfragen.

------
#### [ AWS-Managementkonsole ]

   1. Wählen Sie in der linken Navigationsleiste für **Datenquellenname** die Option. **AwsDataCatalog**

   1. Wählen Sie für **Catalog** die Option ***amzn-s3-demo-bucket*s3tablescatalog/** aus.

   1. Wählen Sie für **Datenbank** die Option **test\$1namespace** aus.

   1. Führen Sie im Abfrage-Editor die folgende Abfrage aus.

      ```
      SELECT
          product_category,
          COUNT(*) AS units_sold,
          SUM(sales_amount) AS total_revenue,
          AVG(sales_amount) AS average_price
      FROM
          daily_sales
      WHERE
          sale_date BETWEEN DATE '2024-02-01' 
                       AND DATE '2024-02-29'
      GROUP BY
          product_category
      ORDER BY
          total_revenue DESC
      ```

------
#### [ AWS CLI ]

   Führen Sie den folgenden Befehl aus.

   ```
   aws athena start-query-execution \
   --query-string "SELECT product_category,
       COUNT(*) AS units_sold,
       SUM(sales_amount) AS total_revenue,
       AVG(sales_amount) AS average_price
   FROM \"s3tablescatalog/amzn-s3-demo-bucket\".test_namespace.daily_sales
   WHERE sale_date BETWEEN DATE '2024-02-01' AND DATE '2024-02-29'
   GROUP BY product_category
   ORDER BY total_revenue DESC"\
   --work-group "primary"
   ```

------

## S3-Tabellen in Athena erstellen
<a name="gdc-create-s3-tables-athena"></a>

Athena unterstützt das Erstellen von Tabellen in vorhandenen S3-Tabellen-Namespaces oder in Athena erstellten Namespaces mit `CREATE DATABASE`-Anweisungen. Um eine S3-Tabelle aus Athena zu erstellen, ist die Syntax dieselbe wie beim [Erstellen einer regulären Iceberg-Tabelle](querying-iceberg-creating-tables.md), außer dass Sie `LOCATION` nicht angeben, wie im folgenden Beispiel gezeigt.

```
CREATE TABLE
[db_name.]table_name (col_name data_type [COMMENT col_comment] [, ...] )
[PARTITIONED BY (col_name | transform, ... )]
[TBLPROPERTIES ([, property_name=property_value] )]
```

Sie können S3-Tabellen auch mit Anweisungen CREATE TABLE AS SELECT (CTAS) erstellen. Weitere Informationen finden Sie unter [CTAS für S3-Tabellen](#ctas-s3-tables).

## S3-Tabellen-Bucket-Kataloge als Athena-Datenquellen registrieren
<a name="gdc-register-s3-table-console-steps"></a>

Um S3-Tabellen-Bucket-Kataloge in der Athena-Konsole zu registrieren, führen Sie die folgenden Schritte aus.

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).

1. Wählen Sie im Navigationsbereich **Datenquellen und Kataloge** aus.

1. Wählen Sie auf der Seite **Datenquellen und Kataloge** die Option **Datenquellen erstellen** aus.

1. Wählen Sie für **Eine Datenquelle auswählen** die Option **Amazon S3 - AWS Glue Data Catalog**.

1. Wählen Sie im **AWS Glue Data Catalog**-Abschnitt für **Datenquellenkonto** die Option **AWS Glue Data Catalog in diesem Konto**.

1. Wählen **Sie für Tabelle erstellen oder Katalog registrieren die Option Neuen Katalog** **registrieren aus. AWS Glue **

1. Geben Sie im Abschnitt **Datenquellendetails** für **Datenquellenname** den Namen ein, den Sie verwenden möchten, um die Datenquelle in Ihren SQL-Abfragen anzugeben, oder verwenden Sie den generierten Standardnamen.

1. Wählen Sie unter **Katalog** die Option **Durchsuchen** aus, um nach einer Liste von AWS Glue Katalogen im selben Konto zu suchen. Wenn Ihnen keine Kataloge angezeigt werden, erstellen Sie einen in der [AWS Glue -Konsole](https://console.aws.amazon.com/glue/). 

1. **Wählen **Sie im Dialogfeld „ AWS Glue Kataloge durchsuchen**“ den Katalog aus, den Sie verwenden möchten, und klicken Sie dann auf „Auswählen“.**

1. (Optional) Geben Sie unter **Tags** alle key/value Paare ein, die Sie der Datenquelle zuordnen möchten.

1. Wählen Sie **Weiter** aus.

1. Überprüfen Sie auf der Seite **Überprüfen und erstellen** die Richtigkeit der eingegebenen Informationen und wählen Sie dann **Datenquelle erstellen**.

## CTAS für S3-Tabellen
<a name="ctas-s3-tables"></a>

Amazon Athena unterstützt jetzt Operationen CREATE TABLE AS SELECT (CTAS) für S3-Tabellen. Mit dieser Feature können Sie neue S3-Tabellen auf der Grundlage der Ergebnisse einer SELECT-Abfrage erstellen. 

Bei der Erstellung einer CTAS-Abfrage für eine S3-Tabelle gibt es einige wichtige Unterschiede zu Standard-Athena-Tabellen:
+ Sie müssen die Speicherort-Eigenschaft weglassen, da S3-Tabellen ihre eigenen Speicherorte automatisch verwalten.
+ Die `table_type`-Eigenschaft ist standardmäßig auf `ICEBERG`, sodass Sie sie in Ihrer Abfrage nicht explizit angeben müssen.
+ Wenn Sie kein Format angeben, verwendet das System automatisch `PARQUET` als Standardformat für Ihre Daten.
+ Alle anderen Eigenschaften folgen derselben Syntax wie normale Iceberg-Tabellen.

Bevor Sie S3-Tabellen mithilfe von CTAS erstellen, stellen Sie sicher, dass Sie die erforderlichen Berechtigungen in IAM oder konfiguriert haben. AWS Lake Formation Insbesondere benötigen Sie Berechtigungen, um Tabellen im S3-Taballen-Katalog zu erstellen. Ohne diese Berechtigungen schlagen Ihre CTAS-Operationen fehl.

**Anmerkung**  
Wenn Ihre CTAS-Abfrage fehlschlägt, müssen Sie möglicherweise Ihre Tabelle mithilfe der [S3 Tabellen-API](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-delete.html) löschen, bevor Sie versuchen, Ihre Abfrage erneut auszuführen. Sie können die `DROP TABLE`-Athena-Anweisungen nicht verwenden, um die Tabelle zu entfernen, die teilweise durch die Abfrage erstellt wurde. 

**Beispiel**

```
CREATE TABLE "s3tablescatalog/amzn-s3-demo-bucket"."namespace"."s3-table-name"
WITH (
    format = 'PARQUET'
)
AS SELECT *
FROM source_table;
```

# AWS Glue Datenkataloge in Athena abfragen
<a name="gdc-register-query-the-data-source"></a>

Um Datenkataloge von Athena abzufragen, führen Sie einen der folgenden Schritte aus.
+ Registrieren Sie den Katalog in Athena als Datenquelle und verwenden Sie dann den Datenquellennamen, um den Katalog abzufragen. Bei dieser Verwendung sind die folgenden Abfragen gleichwertig.

  ```
  SELECT * FROM my_data_source.my_database.my_table
  ```
+ Wenn Sie einen Katalog abfragen, der nicht als Athena-Datenquelle registriert wurde, können Sie den vollständigen Pfad zum Katalog in Ihren `SELECT`-Abfragen angeben, wie im folgenden Beispiel.

  ```
  SELECT * FROM "my_catalog/my_subcatalog".my_database.my_table
  ```
+ Sie können dies auch über die tun. AWS-Managementkonsole

  1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/)

  1. Wählen Sie im Abfrage-Editor für **Datenquelle** die Option **AwsDataCatalog**.

  1. Für **Katalog** wählen Sie den Namem des Katalogs, den Sie verwenden möchten.

  1. Wählen Sie für **Datenbank** die Datenbank aus, die die Tabelle enthält, die Sie abfragen möchten.

  1. Geben Sie eine Abfrage wie `SELECT * FROM my_table` ein, und wählen Sie dann **Ausführen**.

# Einen Datenkatalog von einem anderen Konto aus registrieren
<a name="data-sources-glue-cross-account"></a>

Sie können die kontoübergreifende AWS Glue Katalogfunktion von Athena verwenden, um einen AWS Glue Katalog von einem anderen Konto als Ihrem eigenen zu registrieren. Nachdem Sie die erforderlichen IAM-Berechtigungen für AWS Glue konfiguriert und den Katalog als Athena-`DataCatalog`-Ressource registriert haben, können Sie Athena verwenden, um kontoübergreifende Abfragen auszuführen. Weitere Informationen zur Konfiguration der erforderlichen Berechtigungen finden Sie unter [Kontenübergreifenden Zugriff auf AWS Glue Datenkataloge konfigurieren](security-iam-cross-account-glue-catalog-access.md).

Das folgende Verfahren zeigt Ihnen, wie Sie Athena verwenden, um ein AWS Glue Data Catalog anderes Amazon Web Services Services-Konto als Ihr eigenes als Datenquelle zu konfigurieren.

## Registrieren von der Konsole
<a name="data-sources-glue-cross-account-console"></a>

1. Führen Sie die Schritte in [Kontenübergreifenden Zugriff auf AWS Glue Datenkataloge konfigurieren](security-iam-cross-account-glue-catalog-access.md) aus, um sicherzustellen, dass Sie über Berechtigungen zum Abfragen des Datenkatalogs im anderen Konto verfügen.

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Wenn der Navigationsbereich in der Konsole nicht sichtbar ist, wählen Sie das Erweiterungsmenü auf der linken Seite.  
![\[Wählen Sie das Erweiterungsmenü aus.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/nav-pane-expansion.png)

1. Wählen Sie **Datenquellen und Kataloge** aus.

1. Wählen Sie oben rechts **Create data source** (Datenquelle erstellen) aus.

1. **Wählen Sie auf der Seite „Datenquelle** auswählen“ für **Datenquellen** die Option **S3 - AWS Glue Data Catalog** und wählen Sie dann **Weiter**.

1. Wählen Sie auf der Seite **Enter data source details** (Details zur Datenquelle eingeben) im Abschnitt **AWS Glue Data Catalog** für **Choose an AWS Glue Data Catalog** (auswählen) die Option **AWS Glue Data Catalog in another account** (in einem anderen Konto) aus.

1. Geben Sie für **Data source details** (Datenquellen-Details) die folgenden Informationen ein:
   + **Data source name** (Datenquellenname) – Geben Sie den Namen ein, den Sie in Ihren SQL-Abfragen verwenden möchten, um auf den Datenkatalog im anderen Konto zu verweisen.
   + **Beschreibung** – (Optional) Geben Sie eine Beschreibung des Datenkatalogs im anderen Konto ein.
   + **Katalog-ID** – Geben Sie die 12-stellige Amazon-Web-Services-Konto-ID des Kontos ein, zu dem der Datenkatalog gehört. Die Amazon-Web-Services-Konto-ID ist die Katalog-ID.

1. (Optional) Geben Sie für **Tags** Schlüssel-Wert-Paare ein, die Sie mit der Datenquelle verknüpfen möchten. Weitere Informationen zu Tags erhalten Sie unter [Athena-Ressourcen markieren](tags.md).

1. Wählen Sie **Weiter** aus.

1. Überprüfen Sie auf der Seite **Review and create** (Überprüfen und erstellen) die von Ihnen bereitgestellten Informationen, und wählen Sie dann **Create data source** (Datenquelle erstellen) aus. Die Seite **Data source details** (Datenquellen-Details) listet die Datenbanken und Tags für den von Ihnen registrierten Datenkatalog auf.

1. Wählen Sie **Datenquellen und Kataloge** aus. Der von Ihnen registrierte Datenkatalog wird in der Spalte **Data source name** (Datenquellen-Name) aufgeführt.

1. Um Informationen zum Datenkatalog anzuzeigen oder zu bearbeiten, wählen Sie den Katalog und dann **Actions** (Aktionen), **Edit** (Bearbeiten) aus.

1. Um den neuen Datenkatalog zu löschen, wählen Sie den Katalog und dann **Actions** (Aktionen), **Delete** (Löschen) aus.

## Registrieren mithilfe von API-Operationen
<a name="data-sources-glue-cross-account-api"></a>

1. Der folgende `CreateDataCatalog` Anforderungstext registriert einen AWS Glue Katalog für den kontoübergreifenden Zugriff:

   ```
   # Example CreateDataCatalog request to register a cross-account Glue catalog:
   {
       "Description": "Cross-account Glue catalog",
       "Name": "ownerCatalog",
       "Parameters": {"catalog-id" : "<catalogid>"  # Owner's account ID
       },
       "Type": "GLUE"
   }
   ```

1. Der folgende Beispielcode verwendet einen Java-Client, um das `DataCatalog`-Objekt zu erstellen.

   ```
   # Sample code to create the DataCatalog through Java client
   CreateDataCatalogRequest request = new CreateDataCatalogRequest()
       .withName("ownerCatalog")
       .withType(DataCatalogType.GLUE)
       .withParameters(ImmutableMap.of("catalog-id", "<catalogid>"));
   
   athenaClient.createDataCatalog(request);
   ```

   Nach diesen Schritten sollte der Kreditnehmer sehen, *`ownerCatalog`* wann er den [ListDataCatalogs](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDataCatalogs.html)API-Vorgang aufruft.

## Registrieren Sie sich mit AWS CLI
<a name="data-sources-glue-cross-account-cli"></a>

Verwenden Sie den folgenden CLI-Beispielbefehl, um einen und AWS Glue Data Catalog von einem anderen Konto aus zu registrieren

```
aws athena create-data-catalog \
  --name cross_account_catalog \
  --type GLUE \
  --description "Cross Account Catalog" \
  --parameters catalog-id=<catalogid>
```

Weitere Informationen finden Sie unter [Kontenübergreifende AWS Glue Data Catalog Abfragen mithilfe von Amazon Athena](https://aws.amazon.com/blogs/big-data/query-cross-account-aws-glue-data-catalogs-using-amazon-athena/) im *AWS Big Data-Blog*.

# Zugriff auf Datenkataloge mit IAM-Richtlinien steuern
<a name="datacatalogs-iam-policy"></a>

Verwenden Sie zur Steuerung des Zugriffs auf Datenkataloge IAM-Berechtigungen auf Ressourcenebene oder identitätsbasierte IAM-Richtlinien. 

Das folgende Verfahren gilt speziell für Athena. 

IAM-spezifische Informationen finden Sie unter den Links am Ende dieses Abschnitts. Weitere Informationen zu JSON-Datenkatalog-Beispielrichtlinien finden Sie unter [Datenkatalog-Beispielrichtlinien](datacatalogs-example-policies.md).

**Verwenden Sie den visuellen Editor in der IAM-Konsole, um eine Datenkatalogrichtlinie zu erstellen**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Wählen Sie im Navigationsbereich auf der linken Seite **Policies** (Richtlinien) und dann **Create Policy** (Richtlinie erstellen) aus.

1. Wählen Sie auf der Registerkarte **Visual editor** (Visueller Editor) die Option **Choose a service** (Wählen Sie einen Service) aus. Wählen Sie dann Athena aus, um es der Richtlinie hinzuzufügen.

1. Wählen Sie **Select actions** (Aktionen auswählen) und dann die Aktionen aus, die Sie der Richtlinie hinzufügen möchten. Im visuellen Editor werden die in Athena verfügbaren Aktionen angezeigt. Weitere Informationen finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für Amazon Athena](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonathena.html) in der *Service-Autorisierungs-Referenz*.

1. Wählen Sie **Add actions** (Aktionen hinzufügen) aus, um eine bestimmte Aktion einzugeben, oder verwenden Sie Platzhalter (\$1), um mehrere Aktionen anzugeben. 

   Standardmäßig lässt die Richtlinie, die Sie erstellen, die Aktionen zu, die Sie auswählen. Wenn Sie eine oder mehrere Aktionen auswählen, die Berechtigungen auf Ressourcenebene für die `datacatalog`-Ressource in Athena unterstützen, listet der Editor die `datacatalog`-Ressource auf. 

1. Wählen Sie **Resources (Ressourcen)** aus, um die Datenkataloge für Ihre Richtlinie anzugeben. JSON-Datenkatalog-Beispielrichtlinien finden Sie unter [Datenkatalog-Beispielrichtlinien](datacatalogs-example-policies.md).

1. Geben Sie die `datacatalog`-Ressource wie folgt an:

   ```
   arn:aws:athena:<region>:<user-account>:datacatalog/<datacatalog-name>
   ```

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

1. Wählen Sie **Create policy** (Richtlinie erstellen) aus, um Ihre neue Richtlinie zu speichern.

1. Fügen Sie diese identitätsbasierte Richtlinie einem Benutzer, einer Gruppe oder Rolle an und geben Sie die `datacatalog`-Ressourcen an, auf die diese zugreifen dürfen.

Weitere Informationen finden Sie in den folgenden Themen in der *Service Authorization Reference* und im *IAM-Benutzerhandbuch*:
+ [Aktionen, Ressourcen und Bedingungsschlüssel für Amazon Athena](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonathena.html)
+ [Erstellen von Richtlinien mit dem visuellen Editor](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-visual-editor)
+ [Hinzufügen und Entfernen von IAM-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)
+ [Steuern des Zugriffs auf Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html#access_controlling-resources)

JSON-Datenkatalog-Beispielrichtlinien finden Sie unter [Datenkatalog-Beispielrichtlinien](datacatalogs-example-policies.md).

*Informationen zu AWS Glue Berechtigungen und AWS Glue Crawlerberechtigungen finden Sie unter [Einrichten von IAM-Berechtigungen für AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html) und [Crawler-Voraussetzungen](https://docs.aws.amazon.com/glue/latest/dg/crawler-prereqs.html) im Entwicklerhandbuch.AWS Glue *

Eine vollständige Liste mit Amazon-Athena-Aktionen finden Sie unter den Namen von API-Aktionen in der [Amazon-Athena-API-Referenz](https://docs.aws.amazon.com/athena/latest/APIReference/). 

# Datenkatalog-Beispielrichtlinien
<a name="datacatalogs-example-policies"></a>

In diesem Abschnitt finden Sie Beispielrichtlinien, die Sie verwenden können, um verschiedene Aktionen zu Datenkatalogen zu aktivieren.

Ein Datenkatalog ist eine IAM-Ressource, die von Athena verwaltet wird. Wenn Ihre Datenkatalogrichtlinie Aktionen verwendet, die `datacatalog` als Eingabe verwenden, müssen Sie daher den ARN des Datenkatalogs wie folgt angeben:

```
"Resource": [arn:aws:athena:<region>:<user-account>:datacatalog/<datacatalog-name>]
```

Der `<datacatalog-name>` ist der Name Ihres Datenkatalogs. Geben Sie diesen beispielsweise für einen Datenkatalog mit dem Namen `test_datacatalog` wie folgt als Ressource an:

```
"Resource": ["arn:aws:athena:us-east-1:123456789012:datacatalog/test_datacatalog"]
```

Eine vollständige Liste mit Amazon-Athena-Aktionen finden Sie unter den Namen von API-Aktionen in der [Amazon-Athena-API-Referenz](https://docs.aws.amazon.com/athena/latest/APIReference/). Weitere Informationen zu IAM-Richtlinien finden Sie unter [Erstellen von Richtlinien mit dem visuellen Editor](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-visual-editor) im *IAM-Benutzerhandbuch*. Weitere Informationen zum Erstellen von IAM-Richtlinien für Arbeitsgruppen finden Sie unter [Zugriff auf Datenkataloge mit IAM-Richtlinien steuern](datacatalogs-iam-policy.md).
+ [Example Policy for Full Access to All Data Catalogs](#datacatalog-policy-full-access-to-all-data-catalogs)
+ [Example Policy for Full Access to a Specified Data Catalog](#datacatalog-policy-full-access-to-a-specified-catalog)
+ [Example Policy for Querying a Specified Data Catalog](#datacatalog-policy-querying-a-specified-data-catalog)
+ [Example Policy for Management Operations on a Specified Data Catalog](#datacatalog-policy-management-operations-on-a-specified-catalog)
+ [Example Policy for Listing Data Catalogs](#datacatalog-policy-listing-data-catalogs)
+ [Example Policy for Metadata Operations on Data Catalogs](#datacatalog-policy-metadata-operations)

**Example Beispielrichtlinie für vollständigen Zugriff auf alle Datenkataloge**  
Die folgende Richtlinie erlaubt den vollständigen Zugriff auf alle möglicherweise in dem Konto vorhandenen Datenkatalogressourcen. Wir empfehlen, diese Richtlinie für die Benutzer in Ihrem Konto zu verwenden, die Datenkataloge für alle anderen Benutzer verwalten müssen.    
****  

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

**Example Beispielrichtlinie für vollständigen Zugriff auf einen angegebenen Datenkatalog**  
Die folgende Richtlinie gewährt vollständigen Zugriff auf eine einzelne Datenkatalogressource mit dem Namen `datacatalogA`. Sie können diese Richtlinie für Benutzer mit vollständiger Kontrolle über einen bestimmten Datenkatalog verwenden.    
****  

```
{ "Version":"2012-10-17",		 	 	  "Statement":[ { "Effect":"Allow", "Action":[
   "athena:ListDataCatalogs", "athena:ListWorkGroups", "athena:GetDatabase", "athena:ListDatabases",
   "athena:ListTableMetadata", "athena:GetTableMetadata" ], "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:DeleteWorkGroup", "athena:UpdateWorkGroup", "athena:GetWorkGroup",
   "athena:CreateWorkGroup" ], "Resource":[
      "arn:aws:athena:us-east-1:123456789012:workgroup/*"
   ] }, { "Effect":"Allow", "Action":[ "athena:CreateDataCatalog", "athena:DeleteDataCatalog",
   "athena:GetDataCatalog", "athena:GetDatabase", "athena:GetTableMetadata", "athena:ListDatabases",
   "athena:ListTableMetadata", "athena:UpdateDataCatalog" ],
      "Resource":"arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
   } ] }
```

**Example Beispielrichtlinie für die Abfrage eines angegebenen Datenkatalogs**  
In der folgenden Richtlinie ist ein Benutzer berechtigt, Abfragen in der angegebenen `datacatalogA` auszuführen. Der Benutzer darf keine Managementaufgaben für die Arbeitsgruppe selbst durchführen, sie also beispielsweise nicht aktualisieren oder löschen.     
****  

```
{ "Version":"2012-10-17",		 	 	  "Statement":[ { "Effect":"Allow", "Action":[
   "athena:StartQueryExecution" ], "Resource":[
      "arn:aws:athena:us-east-1:123456789012:workgroup/*"
   ] }, { "Effect":"Allow", "Action":[ "athena:GetDataCatalog" ], "Resource":[
      "arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
   ] } ] }
```

**Example Beispielrichtlinie für Verwaltungsvorgänge in einem angegebenen Datenkatalog**  
In der folgenden Richtlinie ist ein Benutzer berechtigt, einen Datenkatalog `datacatalogA` zu erstellen, zu löschen, Details darüber abzurufen und den Datenkatalog zu aktualisieren.     
****  

```
{ "Version":"2012-10-17",		 	 	  "Statement": [ { "Effect": "Allow", "Action": [
    "athena:CreateDataCatalog", "athena:GetDataCatalog", "athena:DeleteDataCatalog",
    "athena:UpdateDataCatalog" ], "Resource": [
        "arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
    ] } ] }
```

**Example Beispielrichtlinie für das Auflisten von Datenkatalogen**  
Mit der folgenden Richtlinie erhalten alle Benutzer die Berechtigung, alle Datenkataloge aufzulisten:    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "athena:ListDataCatalogs"
            ],
            "Resource": "*"
        }
    ]
}
```

**Example Beispielrichtlinie für Metadatenoperationen in Datenkatalogen**  
Die folgende Richtlinie ermöglicht Metadatenoperationen in Datenkatalogen:    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "athena:GetDatabase",
                "athena:GetTableMetadata",
                "athena:ListDatabases",
                "athena:ListTableMetadata"
            ],
            "Resource": "*"
        }
    ]
}
```

# Verwenden Sie ein Formular in der Athena-Konsole, um eine AWS Glue Tabelle hinzuzufügen
<a name="data-sources-glue-manual-table"></a>

Das folgende Verfahren zeigt Ihnen, wie Sie die Athena-Konsole verwenden, um eine Tabelle mithilfe des Formulars **Create Table From S3 bucket data** (Erstellen einer Tabelle aus S3-Bucket-Daten) hinzuzufügen.

**So fügen Sie eine Tabelle hinzu und geben Schemainformationen mithilfe eines Formulars ein**

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Wählen Sie im Abfrage-Editor neben **Tables and views** (Tabellen und Ansichten) **Create** (Erstellen) und danach **S3 bucket data** (S3-Bucket-Daten) aus.

1. Geben im Formular **Create Table From S3 bucket data** (Tabelle aus S3-Bucket-Daten erstellen) für **Table name** (Tabellenname) einen Namen für die Tabelle ein. Informationen über zulässige Zeichen für Datenbank-, Tabellen- und Spaltennamen in Athena finden Sie unter [Namen für Datenbanken, Tabellen und Spalten](tables-databases-columns-names.md).

1. Wählen Sie für **Database configuration** (Datenbankkonfiguration) eine vorhandene Datenbank aus oder erstellen Sie eine neue.

1. Geben Sie unter **Location of Input Data Set** (Speicherort des Eingabedatensatzes) den Pfad in Amazon S3 dem Ordner an, der den zu verarbeitende Datensatz enthält. Fügen Sie keinen Dateinamen in den Pfad ein. Athena scannt alle Dateien in dem von Ihnen angegebenen Ordner. Wenn Ihre Daten bereits partitioniert sind (z. B. 

    s3://amzn-s3-demo -bucket/logs/year=2004/month=12/day=11/), enter the base path only (for example, s3://amzn-s3-demo-bucket/logs/).

1. Wählen Sie für **Data Format** (Datenformat) eine der folgenden Optionen:
   + Wählen Sie als **Table type** (Tabellentyp) **Apache Hive**, **Apache Iceberg** oder **Delta Lake** aus. Athena verwendet den Tabellentyp Apache Hive als Standard. Informationen zum Abfragen von Apache-Iceberg-Tabellen in Athena finden Sie unter [Apache-Iceberg-Tabellen abfragen](querying-iceberg.md). Informationen zur Verwendung von Delta-Lake-Tabellen in Athena finden Sie unter [Delta-Lake-Tabellen von Linux Foundation abfragen](delta-lake-tables.md).
   + Wählen Sie für **File format** (Dateiformat) das Datei- oder Protokollformat aus, in dem Ihre Daten vorliegen.
     + Geben Sie für die Option **Textdatei mit benutzerdefinierten Trennzeichen** einen **Field terminator (Feldtrennzeichen)** an (d. h. ein Spaltentrennzeichen). Optional können Sie ein **Collection terminator** (Sammlungsendzeichen) angeben, das das Ende eines Array-Typs markiert, oder ein **Collection terminator** (Sammlungsendzeichen), das das Ende eines Zuordnungsdatentyps markiert.
   + **SerDe library** — Eine Bibliothek SerDe (Serializer-Deserializer) analysiert ein bestimmtes Datenformat, sodass Athena eine Tabelle dafür erstellen kann. Für die meisten Formate wird eine Standardbibliothek für Sie ausgewählt. SerDe Wählen Sie für die folgenden Formate eine Bibliothek entsprechend Ihren Anforderungen aus:
     + **Apache Web Logs** — Wählen Sie entweder die **GrokSerDe**Bibliothek **RegexSerDe**oder. Geben Sie für RegexSerDe einen regulären Ausdruck in das **Regex-Definitionsfeld** ein. Geben Sie für GrokSerDe eine Reihe benannter regulärer Ausdrücke für die `input.format` SerDe Eigenschaft ein. Benannte reguläre Ausdrücke sind einfacher zu lesen und zu verwalten als reguläre Ausdrücke. Weitere Informationen finden Sie unter [Apache-Protokollen in Amazon S3 abfragen](querying-apache-logs.md).
     + **CSV** — Wählen Sie aus, **LazySimpleSerDe**ob Ihre kommagetrennten Daten keine in Anführungszeichen eingeschlossenen Werte enthalten oder ob sie das `java.sql.Timestamp` Format verwenden. Wählen Sie **Open CSVSer De**, wenn Ihre Daten Anführungszeichen enthalten oder das numerische UNIX-Format für verwenden `TIMESTAMP` (z. B.`1564610311`). Weitere Informationen erhalten Sie unter [Lazy Simple SerDe für CSV-, TSV- und benutzerdefinierte Dateien](lazy-simple-serde.md) und [CSV SerDe für die Verarbeitung von CSV öffnen](csv-serde.md).
     + **JSON** — Wählen Sie entweder die **OpenX** - oder die **Hive SerDe JSON-Bibliothek**. Beide Formate erwarten, dass sich jedes JSON-Dokument in einer einzelnen Textzeile befindet und dass Felder nicht durch Zeilenumbruchzeichen getrennt werden. Das OpenX SerDe bietet einige zusätzliche Eigenschaften. Weitere Informationen zu diesen Eigenschaften finden Sie unter [OpenX JSON SerDe](openx-json-serde.md). Informationen zum Hive SerDe finden Sie unter. [Hive-JSON SerDe](hive-json-serde.md)

     Weitere Informationen zur Verwendung von SerDe Bibliotheken in Athena finden Sie unter[Wählen Sie eine SerDe für Ihre Daten](supported-serdes.md).

1. Bei **SerDe Eigenschaften** können Sie je nach verwendeter SerDe Bibliothek und Ihren Anforderungen Eigenschaften und Werte hinzufügen, bearbeiten oder entfernen.
   + Um eine SerDe Eigenschaft hinzuzufügen, wählen Sie ** SerDeEigenschaft hinzufügen**.
   + Geben Sie im Feld **Name** den Namen der Eigenschaft ein. 
   + Geben Sie im Feld **Value** (Wert) einen Wert für die Eigenschaft ein. 
   + Um eine SerDe Eigenschaft zu entfernen, wählen Sie **Entfernen**.

1. Wählen oder bearbeiten Sie für **Table properties** (Tabelleneigenschaften) die Tabelleneigenschaften entsprechend Ihren Anforderungen.
   + Wählen Sie für **Write compression** (Schreibkomprimierung) eine Komprimierungsoption aus. Die Verfügbarkeit der Option Schreibkomprimierung und der verfügbaren Komprimierungsoptionen hängt vom Datenformat ab. Weitere Informationen finden Sie unter [Komprimierung in Athena verwenden](compression-formats.md).
   + Wählen Sie für **Encryption** (Verschlüsselung) die Option **Encrypted data set** (Verschlüsselter Datensatz) aus, wenn die zugrunde liegenden Daten in Amazon S3 verschlüsselt sind. Diese Option setzt die `has_encrypted_data`-Tabelleneigenschaft in der `CREATE TABLE`-Anweisung auf wahr.

1. Geben Sie für **Column details** (Spaltendetails) die Namen und Datentypen der Spalten ein, die Sie der Tabelle hinzufügen möchten.
   + 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 Kommas getrennte Liste von Spalten im Format *column\$1name* *data\$1type* [*column\$1name**data\$1type*,...] ein, und wählen Sie dann **Hinzufügen**.

1. (Optional) Fügen Sie für **Partition details** (Details zur Partition) einen oder mehrere Spaltennamen und Datentypen hinzu. Die Partitionierung hält verwandte Daten basierend auf Spaltenwerten zusammen und kann dazu beitragen, die Menge der pro Abfrage gescannten Daten zu reduzieren. Weitere Informationen zur Partitionierung finden Sie unter [Ihre Daten partitionieren](partitions.md).

1. (Optional) Für das **Bucketing** können Sie eine oder mehrere Spalten angeben, die Zeilen enthalten, die Sie gruppieren möchten, und diese Zeilen dann in mehrere Buckets einfügen. Auf diese Weise können Sie nur den Bucket abfragen, den Sie lesen möchten, wenn der Bucket-Spaltenwert angegeben ist.
   + Wählen Sie für **Buckets** eine oder mehrere Spalten aus, die eine große Anzahl eindeutiger Werte enthalten (z. B. einen Primärschlüssel) und die häufig zum Filtern der Daten in Ihren Abfragen verwendet werden.
   + Geben Sie im Feld **Number of buckets** (Anzahl der Buckets) eine Zahl ein, die zulässt, dass Dateien die optimale Größe haben. Weitere Informationen finden Sie im AWS Big Data-Blog unter [Die 10 besten Tipps zur Leistungsoptimierung für Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/).
   + Um Ihre Bucket-Spalten anzugeben, verwendet die `CREATE TABLE`-Anweisung die folgende Syntax:

     ```
     CLUSTERED BY (bucketed_columns) INTO number_of_buckets BUCKETS
     ```
**Anmerkung**  
Die **Bucketing**-Option ist für die **Iceberg**-Tabellentypen nicht verfügbar.

1. Das **Preview table query** (Vorschau der Tabellenabfrage)-Feld zeigt die `CREATE TABLE`-Anweisung, die durch die Informationen generiert wird, die Sie in das Formular eingegeben haben. Die Vorschauanweisung kann nicht direkt bearbeitet werden. Um die Anweisung zu ändern, ändern Sie die Formularfelder über der Vorschau oder [erstellen Sie die Anweisung direkt](creating-tables-how-to.md#to-create-a-table-using-hive-ddl) im Abfrageeditor, anstatt das Formular zu verwenden. 

1. Wählen Sie **Create table** (Tabelle erstellen) aus, um die generierte Anweisung im Abfrage-Editor auszuführen und eine Tabelle zu erstellen.

# Einen Crawler verwenden, um eine Tabelle hinzuzufügen
<a name="schema-crawlers"></a>

AWS Glue Crawler helfen dabei, das Schema für Datensätze zu ermitteln und sie als Tabellen im Datenkatalog zu registrieren. AWS Glue Die Crawler gehen Ihre Daten durch und bestimmen das Schema. Darüber hinaus können Crawler Partitionen erkennen und registrieren. Weitere Informationen finden Sie unter [Definieren von Crawlern](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) im *AWS Glue -Entwicklerhandbuch*. Tabellen aus Daten, die erfolgreich gecrawlt wurden, können von Athena abgefragt werden.

**Anmerkung**  
Athena erkennt keine [Ausschlussmuster](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude), die Sie für einen AWS Glue Crawler angeben. Wenn Sie beispielsweise über einen Amazon-S3-Bucket verfügen, der sowohl `.csv`- als auch `.json`-Dateien enthält und Sie die `.json`-Dateien vom Crawler ausschließen, fragt Athena beide Dateigruppen ab. Um dies zu vermeiden, platzieren Sie die Dateien, die Sie ausschließen möchten, an einem anderen Speicherort. 

## Erstellen Sie einen Crawler AWS Glue
<a name="data-sources-glue-crawler-setup"></a>

Sie können einen Crawler erstellen, indem Sie in der Athena-Konsole beginnen und dann die AWS Glue -Konsole in integrierter Weise verwenden. Wenn Sie den Crawler erstellen, geben Sie einen Datenspeicherort in Amazon S3 an, der gecrawlt werden soll.

**Um einen Crawler von der AWS Glue Athena-Konsole aus zu erstellen**

1. Öffnen Sie die Athena-Konsole unter [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).

1. Wählen Sie im Abfrage-Editor neben **Tables and views** (Tabellen und Ansichten) **Create** (Erstellen) und danach **AWS Glue -Crawler** aus. 

1. 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 [Verwenden von AWS Glue Crawlern](#schema-crawlers) in diesem Handbuch und [Auffüllen des AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/populate-catalog-methods.html) im Entwicklerhandbuch.AWS Glue *

**Anmerkung**  
Athena erkennt keine [Ausschlussmuster](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude), die Sie für einen AWS Glue Crawler angeben. Wenn Sie beispielsweise über einen Amazon-S3-Bucket verfügen, der sowohl `.csv`- als auch `.json`-Dateien enthält und Sie die `.json`-Dateien vom Crawler ausschließen, fragt Athena beide Dateigruppen ab. Um dies zu vermeiden, platzieren Sie die Dateien, die Sie ausschließen möchten, an einem anderen Speicherort.

Nach einem Crawl weist der AWS Glue Crawler automatisch bestimmte Tabellenmetadaten zu, um die Kompatibilität mit anderen externen Technologien wie Apache Hive, Presto und Spark zu verbessern. Es kann vorkommen, dass der Crawler dabei Metadateneigenschaften falsch zuweist. Korrigieren Sie die Eigenschaften in manuell, AWS Glue bevor Sie die Tabelle mit Athena abfragen. Weitere Informationen finden Sie unter [Anzeigen und Bearbeiten von Tabellendetails](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details) im *AWS Glue -Entwicklerhandbuch*.

AWS Glue kann Metadaten falsch zuordnen, wenn eine CSV-Datei jedes Datenfeld in Anführungszeichen setzt, wodurch die Eigenschaft falsch dargestellt wird. `serializationLib` Weitere Informationen finden Sie unter [Umgang mit CSV-Daten in Anführungszeichen](schema-csv.md#schema-csv-quotes).

# Mehrere Datenquellen mit Crawlern verwenden
<a name="schema-crawlers-data-sources"></a>

Wenn ein AWS Glue Crawler Amazon S3 scannt und mehrere Verzeichnisse erkennt, verwendet er eine Heuristik, um zu ermitteln, wo sich das Stammverzeichnis für eine Tabelle in der Verzeichnisstruktur befindet und welche Verzeichnisse Partitionen für die Tabelle sind. In einigen Fällen, wenn in zwei oder mehr Verzeichnissen ein ähnliches Schema erkannt wird, kann es vorkommen, dass der Crawler diese als Partitionen statt als eigenständige Tabellen 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://amzn-s3-demo-bucket/folder1/table1/partition1/file.txt
s3://amzn-s3-demo-bucket/folder1/table1/partition2/file.txt
s3://amzn-s3-demo-bucket/folder1/table1/partition3/file.txt
s3://amzn-s3-demo-bucket/folder1/table2/partition4/file.txt
s3://amzn-s3-demo-bucket/folder1/table2/partition5/file.txt
```

Wenn das Schema für `table1` und `table2` ähnlich ist und eine einzelne Datenquelle auf `s3://amzn-s3-demo-bucket/folder1/` in AWS Glue eingestellt ist, kann der Crawler eine einzelne Tabelle mit zwei Partitionsspalten erstellen: eine Partitionsspalte, die `table1` und enthält`table2`, und eine zweite Partitionsspalte, die Through enthält. `partition1` `partition5`

Damit der AWS Glue Crawler zwei separate Tabellen erstellt, legen Sie fest, dass der Crawler über zwei Datenquellen verfügt, `s3://amzn-s3-demo-bucket/folder1/table1/` und zwar`s3://amzn-s3-demo-bucket/folder1/table2`, wie im folgenden Verfahren gezeigt.

**Um einem vorhandenen Crawler einen S3-Datenspeicher hinzuzufügen, finden Sie in AWS Glue**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).

1. Wählen Sie im Navigationsbereich **Crawlers (Crawler)** aus.

1. Wählen Sie den Link zu Ihrem Crawler und wählen Sie dann **Edit** (Bearbeiten). 

1. Für **Schritt 2: Auswählen von Datenquellen und Klassifizierern** wählen Sie **Edit** (Bearbeiten). 

1. Wählen Sie für **Datenquellen und -Kataloge** **Datenquelle hinzufügen** aus.

1. Wählen Sie im Dialogfeld **Add a data source** (Datenquelle hinzufügen) für den **S3 path** (S3-Pfad) **Browse** (Durchsuchen). 

1. Wählen Sie das Bucket aus, das Sie verwenden möchten, wählen Sie anschließend **Choose** (Auswählen).

   Die hinzugefügte Datenquelle wird in der **Data sources**-Liste (Datenquellenliste) erscheinen.

1. Wählen Sie **Weiter** aus.

1. Erstellen Sie auf der Seite **Configure security settings** (Sicherheitseinstellungen konfigurieren) eine IAM-Rolle für den Crawler und wählen Sie dann **Next** (Weiter).

1. Stellen Sie sicher, dass der S3-Pfad mit einem Schrägstrich endet, und wählen Sie dann **Add an S3 data source** (Hinzufügen einer S3-Datenquelle).

1. Wählen Sie auf der Seite **Set output and scheduling** (Ausgabe und Terminplanung festlegen) für die **Output configuration** (Ausgabe-Konfiguration) die Zieldatenbank.

1. Wählen Sie **Weiter** aus.

1. Überprüfen Sie auf der Seite **Review and update** (überprüfen und aktualisieren) die von Ihnen getroffenen Entscheidungen. Um einen Schritt zu bearbeiten, wählen Sie **Edit** (Bearbeiten).

1.  Wählen Sie **Aktualisieren** aus.

# Planen Sie einen Crawler ein, um den AWS Glue Data Catalog und Amazon S3 synchron zu halten
<a name="schema-crawlers-schedule"></a>

AWS Glue Crawler können so eingerichtet werden, dass sie nach einem Zeitplan oder bei Bedarf ausgeführt werden. Weitere Informationen finden Sie unter [Zeitpläne für Aufträge und Crawler](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html) im *AWS Glue -Entwicklerhandbuch*.

Wenn Sie Daten für eine partitionierte Tabelle zu einem festen Zeitpunkt erhalten, können Sie einen AWS Glue Crawler so einrichten, dass er planmäßig ausgeführt wird, um Tabellenpartitionen zu erkennen und zu aktualisieren. So müssen Sie keinen potenziell langen und aufwändigen `MSCK REPAIR`-Befehl oder manuell einen `ALTER TABLE ADD PARTITION`-Befehl ausführen. Weitere Informationen finden Sie unter [Tabellenpartitionen](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition) im *AWS Glue -Entwicklerhandbuch*.

# Optimieren Sie Abfragen mit AWS Glue Partitionsindexierung und Filterung
<a name="glue-best-practices-partition-index"></a>

Wenn Athena partitionierte Tabellen abfragt, ruft es die verfügbaren Tabellenpartitionen ab und filtert sie nach der für Ihre Abfrage relevanten Teilmenge. Wenn neue Daten und Partitionen hinzugefügt werden, ist mehr Zeit für die Verarbeitung der Partitionen erforderlich, und die Abfragelaufzeit kann sich erhöhen. Wenn Sie eine Tabelle mit einer großen Anzahl von Partitionen haben, die im Laufe der Zeit wächst, sollten Sie die AWS Glue -Partitionsindizierung und -filterung verwenden. Die Partitionsindizierung ermöglicht Athena, die Partitionsverarbeitung zu optimieren und die Abfrageleistung für stark partitionierte Tabellen zu verbessern. Das Einrichten der Partitionsfilterung in den Eigenschaften einer Tabelle ist ein zweistufiger Prozess:

1. Erstellen eines Partitionsindex in AWS Glue.

1. Aktivieren der Partitionsfilterung für die Tabelle.

## Erstellen eines Partitionsindex
<a name="glue-best-practices-partition-index-creating"></a>

Anweisungen zum Erstellen eines Partitionsindexes in AWS Glue finden Sie unter [Arbeiten mit Partitionsindizes](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) im AWS Glue Entwicklerhandbuch. Informationen zu den Einschränkungen von Partitionsindizes finden Sie im AWS Glue Abschnitt [Über Partitionsindizes](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html#partition-index-1) auf dieser Seite.

## Aktivieren der Partitionsfilterung
<a name="glue-best-practices-partition-filtering-enabling"></a>

Um die Partitionsfilterung für die Tabelle zu aktivieren, müssen Sie eine neue Tabelleneigenschaft in AWS Glue festlegen. Anweisungen zum Einstellen von Tabelleneigenschaften finden Sie auf der Seite [Partitionsprojektion einrichten](https://docs.aws.amazon.com/athena/latest/ug/partition-projection-setting-up.html). AWS Glue Wenn Sie die Tabellendetails in bearbeiten AWS Glue, fügen Sie dem Abschnitt **Tabelleneigenschaften** das folgende Schlüssel-Wert-Paar hinzu:
+ Fügen Sie für **Key (Schlüssel)** `partition_filtering.enabled` hinzu
+ Fügen Sie für **Wert** `true` hinzu

Sie können die Partitionsfilterung für diese Tabelle jederzeit deaktivieren, indem Sie den Wert `partition_filtering.enabled` auf `false` setzen.

Nachdem Sie die obigen Schritte ausgeführt haben, können Sie zur Athena-Konsole zurückkehren, um die Daten abzufragen.

Weitere Informationen zur Verwendung von Partitionsindizierung und Filterung finden Sie unter [Verbessern der Amazon Athena Athena-Abfrageleistung mithilfe von AWS Glue Data Catalog Partitionsindizes](https://aws.amazon.com/blogs/big-data/improve-amazon-athena-query-performance-using-aws-glue-data-catalog-partition-indexes/) im *AWS Big* Data-Blog.

# Verwenden Sie die AWS CLI , um eine AWS Glue Datenbank und ihre Tabellen neu zu erstellen
<a name="glue-recreate-db-and-tables-cli"></a>

Das direkte Umbenennen einer AWS Glue Datenbank ist nicht möglich, aber Sie können ihre Definition kopieren, die Definition ändern und die Definition verwenden, um die Datenbank mit einem anderen Namen neu zu erstellen. Ebenso können Sie die Definitionen der Tabellen in der alten Datenbank kopieren, die Definitionen ändern und die geänderten Definitionen verwenden, um die Tabellen in der neuen Datenbank neu zu erstellen.

**Anmerkung**  
 Die vorgestellte Methode kopiert keine Tabellenpartitionierung. 

Das folgende Verfahren für Windows setzt voraus, dass Ihr für die JSON-Ausgabe konfiguriert AWS CLI ist. Um das Standardausgabeformat in zu ändern AWS CLI, führen Sie den Befehl aus`aws configure`.

**Um eine AWS Glue Datenbank mit dem zu kopieren AWS CLI**

1. Führen Sie an einer Befehlszeile den folgenden AWS CLI Befehl aus, um die Definition der AWS Glue Datenbank abzurufen, die Sie kopieren möchten.

   ```
   aws glue get-database --name database_name
   ```

   Weitere Informationen über den Befehl `get-database` finden Sie unter [Datenbank holen](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html).

1. Speichern Sie die JSON-Ausgabe in einer Datei mit dem Namen der neuen Datenbank (z. B. `new_database_name.json`) auf Ihrem Desktop.

1. Öffnen Sie die Datei `new_database_name.json` in einem Text-Editor.

1. Führen Sie in der JSON-Dateie folgende Schritte aus:

   1. Entfernen Sie den äußeren `{ "Database":`-Eintrag und die entsprechende schließende Klammer `}` am Ende der Datei.

   1. Ändern Sie den `Name`-Eintrag in den neuen Datenbanknamen.

   1. Entfernen Sie das Feld `CatalogId`.

1. Speichern Sie die Datei.

1. Führen Sie an einer Befehlszeile den folgenden AWS CLI Befehl aus, um die geänderte Datenbankdefinitionsdatei zu verwenden, um die Datenbank mit dem neuen Namen zu erstellen.

   ```
   aws glue create-database --database-input "file://~/Desktop\new_database_name.json"
   ```

   Weitere Informationen über den Befehl `create-database` finden Sie unter [Datenbank erstellen](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-database.html). Informationen zum Laden von AWS CLI Parametern aus einer Datei finden Sie unter [Laden von AWS CLI Parametern aus einer Datei](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html) im *AWS Command Line Interface Benutzerhandbuch*.

1. Führen Sie den folgenden Befehl aus, um zu überprüfen AWS Glue, ob die neue Datenbank in erstellt wurde:

   ```
   aws glue get-database --name new_database_name
   ```

Jetzt sind Sie bereit, die Definition für eine Tabelle abzurufen, die Sie in die neue Datenbank kopieren möchten, die Definition zu ändern und die geänderte Definition zu verwenden, um die Tabelle in der neuen Datenbank neu zu erstellen. Durch dieses Verfahren wird der Tabellenname nicht geändert.

**Um eine AWS Glue Tabelle mit dem zu kopieren AWS CLI**

1. Führen Sie in einer Befehlszeile den folgenden AWS CLI Befehl aus.

   ```
   aws glue get-table --database-name database_name --name table_name
   ```

   Weitere Informationen über den Befehl `get-table` finden Sie unter [Tabelle holen](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-table.html).

1. Speichern Sie die JSON-Ausgabe in einer Datei mit dem Namen der Tabelle (z. *table\$1name* B. JSON) auf Ihrem Windows-Desktop.

1. Öffnen Sie die Datei in einem Text-Editor.

1. Entfernen Sie in der JSON-Datei den äußeren `{"Table": `-Eintrag und die entsprechende schließende Klammer `}` am Ende der Datei.

1. Entfernen Sie in der JSON-Datei die folgenden Einträge und ihre Werte:
   + `DatabaseName` – Dieser Eintrag ist nicht erforderlich, da der `create-table`-CLI-Befehl den `--database-name`-Parameter verwendet.
   + `CreateTime`
   + `UpdateTime`
   + `CreatedBy`
   + `IsRegisteredWithLakeFormation`
   + `CatalogId`
   + `VersionId`

1. Speichern Sie die Tabellendefinitionsdatei.

1. Führen Sie an einer Befehlszeile den folgenden AWS CLI Befehl aus, um die Tabelle in der neuen Datenbank neu zu erstellen:

   ```
   aws glue create-table --database-name new_database_name --table-input "file://~/Desktop\table_name.json"     
   ```

   Weitere Informationen über den Befehl `create-table` finden Sie unter [Datenbank erstellen](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-table.html).

   Die Tabelle erscheint jetzt in der neuen Datenbank in Athena AWS Glue und kann von Athena abgefragt werden.

1. Wiederholen Sie die Schritte, um jede weitere Tabelle in die neue Datenbank in AWS Glue zu kopieren.

# Tabellen für ETL-Aufträge erstellen
<a name="schema-classifier"></a>

Sie können Athena verwenden, um Tabellen zu erstellen, die für ETL-Jobs verwendet AWS Glue werden können. AWS Glue Jobs führen ETL-Operationen aus. Ein AWS Glue Job führt ein Skript aus, das Daten aus Quellen extrahiert, die Daten transformiert und in Ziele lädt. Weitere Informationen finden Sie unter [Authoring Jobs in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job-glue.html) im *AWS Glue Developer Guide*.

## Athena-Tabellen für AWS Glue ETL-Jobs erstellen
<a name="schema-etl-tables"></a>

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äge verwenden. Die Klassifizierungswerte können `avro`, `csv`, `json`, `orc`, `parquet` oder `xml` sein. Es folgt ein Beispiel für eine `CREATE TABLE`-Anweisung in Athena:

```
CREATE EXTERNAL TABLE sampleTable (
  column1 INT,
  column2 INT
  ) STORED AS PARQUET
  TBLPROPERTIES (
  'classification'='parquet')
```

Wenn die `classification` Tabelleneigenschaft bei der Erstellung der Tabelle nicht hinzugefügt wurde, können Sie sie über die AWS Glue Konsole hinzufügen.

**Um die Eigenschaft der Klassifikationstabelle mithilfe der AWS Glue Konsole hinzuzufügen**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Glue Konsole unter [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).

1. Wählen Sie im Navigationsbereich der Konsole **Tables** (Tabellen) aus.

1. Wählen Sie den Link für die Tabelle, die Sie bearbeiten möchten. Wählen Sie dann **Action** (Aktion), **Edit table** (Tabelle bearbeiten).

1. Scrollen Sie nach unten zum Abschnitt **Table properties** (Tabelleneigenschaften).

1. Wählen Sie **Hinzufügen** aus.

1. Geben Sie für **Key (Schlüssel)** **classification** ein.

1. Für **Value** (Wert), geben Sie einen Datentyp ein (z. B. **json**).

1. Wählen Sie **Speichern**.

   Im Abschnitt **Table details** (Angaben zur Tabelle) erscheint der von Ihnen eingegebene Datentyp im Feld **Classification** (Klassifizierung) der Tabelle.

Weitere Informationen finden Sie unter [Working with Tables](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) (Arbeiten mit Tabellen) im *AWS Glue -Entwicklerhandbuch*.

## ETL-Aufträgen zur Optimierung der Abfrageleistung verwenden
<a name="schema-etl-performance"></a>

AWS Glue Jobs können Ihnen helfen, Daten in ein Format umzuwandeln, das die Abfrageleistung in Athena optimiert. Datenformate wirken sich erheblich auf die Abfrageleistung und Abfragekosten in Athena aus.

AWS Glue unterstützt das Schreiben in die Datenformate Parquet und ORC. Sie können diese Feature verwenden, um Ihre Daten für die Verwendung in Athena zu transformieren. Weitere Informationen zur Verwendung von Parquet und ORC und anderen Möglichkeiten zur Leistungsverbesserung finden Sie unter [Top 10 der Leistungsoptimierungstipps für Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/).

**Anmerkung**  
Um die Wahrscheinlichkeit zu verringern, dass Athena die `SMALLINT` von einem AWS Glue ETL-Job erzeugten `TINYINT` Datentypen nicht lesen kann, konvertieren Sie `SMALLINT` und `TINYINT` zu, `INT` wenn Sie einen ETL-Job erstellen, der Daten in ORC konvertiert.

## Automatisieren Sie AWS Glue Jobs für ETL
<a name="schema-etl-automate"></a>

Sie können AWS Glue ETL-Jobs so konfigurieren, dass sie automatisch auf der Grundlage von Triggern ausgeführt werden. Diese Funktion ist ideal, wenn Daten von außen AWS in einem ansonsten suboptimalen Format für Abfragen in Athena in einen Amazon S3 S3-Bucket übertragen werden. *Weitere Informationen finden Sie unter [AWS Glue Jobs auslösen](https://docs.aws.amazon.com/glue/latest/dg/trigger-job.html) im Entwicklerhandbuch.AWS Glue *

# Arbeiten Sie mit CSV-Daten in AWS Glue
<a name="schema-csv"></a>

Auf dieser Seite wird beschrieben, wie Sie AWS Glue Schemas aus CSV-Dateien erstellen, deren Datenwerte für jede Spalte in Anführungszeichen gesetzt sind, oder aus CSV-Dateien, die Header-Werte enthalten.

## Umgang mit CSV-Daten in Anführungszeichen
<a name="schema-csv-quotes"></a>

Angenommen, eine CSV-Datei enthält Datenfelder, die in doppelte Anführungszeichen gesetzt sind, wie im folgenden Beispiel.

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

Um in Athena eine Abfrage für eine Tabelle auszuführen, die aus einer CSV-Datei mit Werten in Anführungszeichen erstellt wurde, müssen Sie die Tabelleneigenschaften ändern, AWS Glue um Open CSVSer De zu verwenden. Weitere Hinweise zu OpenCSV SerDe finden Sie unter. [CSV SerDe für die Verarbeitung von CSV öffnen](csv-serde.md)

**Um Tabelleneigenschaften in der Konsole zu bearbeiten AWS Glue**

1. Wählen Sie im Navigationsbereich der AWS Glue Konsole die Option **Tabellen** aus.

1. Wählen Sie den Link für die Tabelle, die Sie bearbeiten möchten. Wählen Sie dann **Action** (Aktion), **Edit table** (Tabelle bearbeiten).

1. Auf der Seite **Edit table** (Tabelle bearbeiten) nehmen Sie die folgenden Änderungen vor:
   + Geben Sie für **Serialization lib** (Serialisierungsbibliothek) `org.apache.hadoop.hive.serde2.OpenCSVSerde` ein.
   + Geben Sie für **Serde-Parameter** die folgenden Werte für die Schlüssel `escapeChar`, `quoteChar` und `separatorChar` ein: 
     + Geben Sie für `escapeChar` einen umgekehrten Schrägstrich (**\$1**) ein.
     + Geben Sie für `quoteChar` ein doppeltes Anführungszeichen (**"**) ein.
     + Geben Sie für `separatorChar` ein Komma (**,**) ein.

1. Wählen Sie **Speichern**.

Weitere Informationen finden Sie unter [Anzeigen und Bearbeiten von Tabellendetails](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details) im *AWS Glue -Entwicklerhandbuch*.

Sie können die AWS Glue Tabelleneigenschaften auch programmgesteuert aktualisieren. Verwenden Sie die AWS Glue [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html)API-Operation oder den AWS CLI Befehl [update-table](https://docs.aws.amazon.com/cli/latest/reference/glue/update-table.html), um den `SerDeInfo` Block in der Tabellendefinition zu ändern, wie im folgenden JSON-Beispiel.

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

## Umgang mit CSV-Dateien mit Kopfzeilen
<a name="schema-csv-headers"></a>

Wenn Sie eine Tabelle in Athena mit einer `CREATE TABLE`-Anweisung definieren, können Sie die Tabelleneigenschaft `skip.header.line.count` verwenden, um Header in Ihren CSV-Daten zu ignorieren, wie im folgenden Beispiel.

```
...
STORED AS TEXTFILE
LOCATION 's3://amzn-s3-demo-bucket/csvdata_folder/';
TBLPROPERTIES ("skip.header.line.count"="1")
```

Alternativ können Sie die CSV-Überschriften vorher entfernen, damit diese Informationen nicht in den Abfrageergebnissen 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 Skripten in AWS Glue einer Sprache schreiben, die eine Erweiterung des PySpark Python-Dialekts ist. Weitere Informationen finden Sie unter [Authoring Jobs in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job-glue.html) im *AWS Glue Developer Guide*.

Das folgende Beispiel zeigt eine Funktion in einem AWS Glue Skript, die einen dynamischen Frame ausgibt und die `writeHeader` Formatoption auf False setzt, wodurch die Header-Informationen entfernt werden: `from_options`

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

# Arbeiten Sie mit Geodaten in AWS Glue
<a name="schema-geospatial"></a>

AWS Glue unterstützt nicht nativ Wellknown Text (WKT), Well-known Binary (WKB) oder andere PostGIS-Datentypen. Der AWS Glue Klassifikator analysiert Geodaten und klassifiziert sie anhand unterstützter Datentypen für das Format, z. B. für CSV. `varchar` Wie bei anderen AWS Glue Tabellen müssen Sie möglicherweise die Eigenschaften von Tabellen aktualisieren, die aus Geodaten erstellt wurden, damit Athena diese Datentypen unverändert analysieren kann. Weitere Informationen erhalten Sie unter [Einen Crawler verwenden, um eine Tabelle hinzuzufügen](schema-crawlers.md) und [Arbeiten Sie mit CSV-Daten in AWS Glue](schema-csv.md). Athena ist möglicherweise nicht in der Lage, einige Geodatentypen in AWS Glue Tabellen unverändert zu analysieren. Weitere Informationen zum Arbeiten mit Geodaten in Athena finden Sie unter [Geodaten abfragen](querying-geospatial-data.md).