

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.

# Verwalten des Datenkatalogs
<a name="manage-catalog"></a>

 Das AWS Glue Data Catalog ist ein zentrales Metadaten-Repository, das strukturelle und betriebliche Metadaten für Ihre Amazon S3 S3-Datensätze speichert. Eine effektive Data-Catalog-Verwaltung ist entscheidend für die Aufrechterhaltung der Datenqualität, Leistung, Sicherheit und Verwaltung.

 Wenn Sie diese Methoden zur Data-Catalog-Verwaltung verstehen und anwenden, können Sie sicherstellen, dass Ihre Metadaten korrekt, leistungsfähig, sicher und gut verwaltet bleiben, während sich Ihre Datenlandschaft weiterentwickelt. 

In diesem Abschnitt werden die folgenden Aspekte der Data-Catalog-Verwaltung behandelt:
+ *Aktualisierung des Tabellenschemas und der Partitionen*   Während sich Ihre Daten weiterentwickeln, müssen Sie möglicherweise das im Datenkatalog definierte Tabellenschema oder die Partitionsstruktur aktualisieren. Weitere Informationen darüber, wie Sie diese Aktualisierungen mithilfe von AWS Glue ETL programmgesteuert vornehmen können, finden Sie unter. [Aktualisieren des Schemas und Hinzufügen neuer Partitionen im Datenkatalog mit AWS Glue-ETL-Aufträgen](update-from-job.md)
+ *Verwalten von Spaltenstatistiken*: Präzise Spaltenstatistiken helfen dabei, Abfragepläne zu optimieren und die Leistung zu verbessern. Weitere Informationen zum Generieren, Aktualisieren und Verwalten von Spaltenstatistiken finden Sie unter [Optimieren der Abfrageleistung mithilfe von Spaltenstatistiken](column-statistics.md). 
+  *Den Datenkatalog verschlüsseln* Um vertrauliche Metadaten zu schützen, können Sie Ihren Datenkatalog mit () verschlüsseln. AWS Key Management Service AWS KMS In diesem Abschnitt erfahren Sie, wie Sie die Verschlüsselung für Ihren Datenkatalog aktivieren und verwalten können. 
+ *Sichern des Datenkatalogs mit AWS Lake Formation*   Lake Formation bietet einen umfassenden Ansatz für die Sicherheit und Zugriffskontrolle von Data Lakes. Sie können Lake Formation verwenden, um den Zugriff auf Ihren Datenkatalog und die zugrunde liegenden Daten zu sichern und zu steuern. 

**Topics**
+ [Aktualisieren des Schemas und Hinzufügen neuer Partitionen im Datenkatalog mit AWS Glue-ETL-Aufträgen](update-from-job.md)
+ [Optimieren der Abfrageleistung mithilfe von Spaltenstatistiken](column-statistics.md)
+ [Verschlüsseln Ihres Data Catalog](catalog-encryption.md)
+ [Sicherung Ihres Datenkatalogs mit Lake Formation](secure-catalog.md)
+ [Arbeiten mit AWS Glue Data Catalog Ansichten in AWS Glue](catalog-views.md)

# Aktualisieren des Schemas und Hinzufügen neuer Partitionen im Datenkatalog mit AWS Glue-ETL-Aufträgen
<a name="update-from-job"></a>

Der ETL-Auftrag zum Extrahieren, Transformieren oder Laden kann neue Tabellenpartitionen im Zieldatenspeicher erstellen. Das Datensatzschema kann sich im Zeitverlauf entwickeln und vom AWS Glue-Data-Catalog-Schema mit der Zeit abweichen. AWS Glue ETL-Aufträge stellen mehrere Features bereit, die Sie im ETL-Skript verwenden können, um das Schema und die Partitionen im Data Catalog zu aktualisieren. Mit diesen Features können Sie die Ergebnisse der ETL-Arbeit im Data Catalog anzeigen, ohne den Crawler erneut ausführen zu müssen.

## Neue Partitionen
<a name="update-from-job-partitions"></a>

Wenn Sie die neuen Partitionen in anzeigen möchten AWS Glue Data Catalog, können Sie einen der folgenden Schritte ausführen:
+ Führen Sie nach Abschluss des Auftrags den Crawler erneut aus und zeigen Sie die neuen Partitionen auf der Konsole an, wenn der Crawler beendet ist.
+ Wenn der Auftrag abgeschlossen ist, können Sie sofort die neuen Partitionen auf der Konsole anzeigen, ohne den Crawler erneut ausführen zu müssen. Sie können dieses Feature aktivieren, indem Sie Ihrem ETL-Skript einige Codezeilen hinzufügen, wie in den folgenden Beispielen gezeigt. Der Code verwendet das `enableUpdateCatalog`-Argument, um anzuzeigen, dass der Data Catalog während der Auftragsausführung aktualisiert werden soll, wenn die neuen Partitionen erstellt werden.

**Methode 1**  
Übergeben Sie `enableUpdateCatalog` und `partitionKeys` an ein Optionsargument.  

```
additionalOptions = {"enableUpdateCatalog": True}
additionalOptions["partitionKeys"] = ["region", "year", "month", "day"]


sink = glueContext.write_dynamic_frame_from_catalog(frame=last_transform, database=<target_db_name>,
                                                    table_name=<target_table_name>, transformation_ctx="write_sink",
                                                    additional_options=additionalOptions)
```

```
val options = JsonOptions(Map(
    "path" -> <S3_output_path>, 
    "partitionKeys" -> Seq("region", "year", "month", "day"), 
    "enableUpdateCatalog" -> true))
val sink = glueContext.getCatalogSink(
    database = <target_db_name>, 
    tableName = <target_table_name>, 
    additionalOptions = options)sink.writeDynamicFrame(df)
```

**Methode 2**  
Übergeben Sie `enableUpdateCatalog` und `partitionKeys` in `getSink()` und rufen Sie `setCatalogInfo()` auf dem `DataSink`-Objekt auf.  

```
sink = glueContext.getSink(
    connection_type="s3", 
    path="<S3_output_path>",
    enableUpdateCatalog=True,
    partitionKeys=["region", "year", "month", "day"])
sink.setFormat("json")
sink.setCatalogInfo(catalogDatabase=<target_db_name>, catalogTableName=<target_table_name>)
sink.writeFrame(last_transform)
```

```
val options = JsonOptions(
   Map("path" -> <S3_output_path>, 
       "partitionKeys" -> Seq("region", "year", "month", "day"), 
       "enableUpdateCatalog" -> true))
val sink = glueContext.getSink("s3", options).withFormat("json")
sink.setCatalogInfo(<target_db_name>, <target_table_name>)
sink.writeDynamicFrame(df)
```

Jetzt können Sie neue Katalogtabellen erstellen, vorhandene Tabellen mit einem geänderten Schema aktualisieren und neue Tabellenpartitionen in den Data Catalog einfügen – unter Verwendung eines AWS Glue-ETL-Auftrags, ohne dass Crawler erneut ausgeführt werden müssen.

## Aktualisieren des Tabellenschemas
<a name="update-from-job-updating-table-schema"></a>

Wenn Sie das Schema der Data-Catalog-Tabelle überschreiben möchten, ist dies folgendermaßen möglich:
+ Führen Sie nach Abschluss des Auftrags den Crawler erneut aus und stellen Sie sicher, dass der Crawler so konfiguriert ist, dass auch die Tabellendefinition aktualisiert wird. Zeigen Sie die neuen Partitionen in der Konsole zusammen mit allen Schemaaktualisierungen an, nachdem der Crawler beendet wurde. Weitere Informationen finden Sie unter [Konfigurieren eines Crawlers mithilfe der API](https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html#crawler-configure-changes-api).
+ Wenn der Auftrag endet, können Sie das geänderte Schema sofort in der Konsole anzeigen, ohne den Crawler erneut ausführen zu müssen. Sie können dieses Feature aktivieren, indem Sie Ihrem ETL-Skript einige Codezeilen hinzufügen, wie in den folgenden Beispielen gezeigt. Der Code verwendet `enableUpdateCatalog` mit dem Wert „true“ und `updateBehavior` mit dem Wert `UPDATE_IN_DATABASE`, damit während der Auftragsausführung das Schema überschrieben wird und neue Partitionen in den Data Catalog eingefügt werden.

------
#### [ Python ]

```
additionalOptions = {
    "enableUpdateCatalog": True, 
    "updateBehavior": "UPDATE_IN_DATABASE"}
additionalOptions["partitionKeys"] = ["partition_key0", "partition_key1"]

sink = glueContext.write_dynamic_frame_from_catalog(frame=last_transform, database=<dst_db_name>,
    table_name=<dst_tbl_name>, transformation_ctx="write_sink",
    additional_options=additionalOptions)
job.commit()
```

------
#### [ Scala ]

```
val options = JsonOptions(Map(
    "path" -> outputPath, 
    "partitionKeys" -> Seq("partition_0", "partition_1"), 
    "enableUpdateCatalog" -> true))
val sink = glueContext.getCatalogSink(database = nameSpace, tableName = tableName, additionalOptions = options)
sink.writeDynamicFrame(df)
```

------

Sie können den `updateBehavior`-Wert auch auf `LOG` festlegen, wenn das Tabellenschema nicht überschrieben werden soll, die neuen Partitionen aber hinzugefügt werden sollen. Der Standardwert von `updateBehavior` ist `UPDATE_IN_DATABASE`. Wenn Sie also nicht explizit einen anderen Wert angeben, wird das Tabellenschema überschrieben.

Wenn `enableUpdateCatalog` nicht auf „true“ festgelegt ist, aktualisiert der ETL-Auftrag die Tabelle im Data Catalog nicht, unabhängig von der Option, die für `updateBehavior` ausgewählt ist. 

## Erstellen neuer Tabellen
<a name="update-from-job-creating-new-tables"></a>

Sie können dieselben Optionen auch verwenden, um eine neue Tabelle im Data Catalog zu erstellen. Sie können die Datenbank und den neuen Tabellennamen mit `setCatalogInfo` angeben.

------
#### [ Python ]

```
sink = glueContext.getSink(connection_type="s3", path="s3://path/to/data",
    enableUpdateCatalog=True, updateBehavior="UPDATE_IN_DATABASE",
    partitionKeys=["partition_key0", "partition_key1"])
sink.setFormat("<format>")
sink.setCatalogInfo(catalogDatabase=<dst_db_name>, catalogTableName=<dst_tbl_name>)
sink.writeFrame(last_transform)
```

------
#### [ Scala ]

```
val options = JsonOptions(Map(
    "path" -> outputPath, 
    "partitionKeys" -> Seq("<partition_1>", "<partition_2>"), 
    "enableUpdateCatalog" -> true, 
    "updateBehavior" -> "UPDATE_IN_DATABASE"))
val sink = glueContext.getSink(connectionType = "s3", connectionOptions = options).withFormat("<format>")
sink.setCatalogInfo(catalogDatabase = “<dst_db_name>”, catalogTableName = “<dst_tbl_name>”)
sink.writeDynamicFrame(df)
```

------

## Einschränkungen
<a name="update-from-job-restrictions"></a>

Beachten Sie die folgenden Einschränkungen:
+ Es werden nur Amazon Simple Storage Service (Amazon S3)-Ziele unterstützt.
+ Das `enableUpdateCatalog`-Feature wird für reglementierte Tabellen nicht unterstützt.
+ Es werden nur die folgenden Formate unterstützt: `json`, `csv`, `avro` und `parquet`.
+ Um Tabellen mit der `parquet` Klassifizierung zu erstellen oder zu aktualisieren, müssen Sie den AWS Glue optimierten Parquet Writer for verwenden DynamicFrames. Dies kann mit einem der folgenden Schritte erreicht werden:
  + Wenn Sie eine vorhandene Tabelle im Katalog mit `parquet`-Klassifizierung aktualisieren, muss die `"useGlueParquetWriter"`-Tabelleneigenschaft der Tabelle auf `true` festgelegt sein, bevor Sie sie aktualisieren. Sie können diese Eigenschaft über das AWS Glue APIs /SDK, über die Konsole oder über eine Athena-DDL-Anweisung festlegen.   
![\[Bearbeitungsfeld für Eigenschaften der Katalogtabelle in der Konsole. AWS Glue\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/edit-table-property.png)

    Sobald die Katalogtabelleneigenschaft festgelegt ist, können Sie den folgenden Codeausschnitt verwenden, um die Katalogtabelle mit den neuen Daten zu aktualisieren:

    ```
    glueContext.write_dynamic_frame.from_catalog(
        frame=frameToWrite,
        database="dbName",
        table_name="tableName",
        additional_options={
            "enableUpdateCatalog": True,
            "updateBehavior": "UPDATE_IN_DATABASE"
        }
    )
    ```
  + Wenn die Tabelle noch nicht im Katalog vorhanden ist, können Sie die `getSink()`-Methode in Ihrem Skript mit `connection_type="s3"` verwenden, um die Tabelle und ihre Partitionen dem Katalog hinzuzufügen und die Daten in Amazon S3 zu schreiben. Geben Sie das entsprechende `partitionKeys` und `compression` für Ihren Workflow an.

    ```
    s3sink = glueContext.getSink(
        path="s3://bucket/folder/",
        connection_type="s3",
        updateBehavior="UPDATE_IN_DATABASE",
        partitionKeys=[],
        compression="snappy",
        enableUpdateCatalog=True
    )
        
    s3sink.setCatalogInfo(
        catalogDatabase="dbName", catalogTableName="tableName"
    )
        
    s3sink.setFormat("parquet", useGlueParquetWriter=True)
    s3sink.writeFrame(frameToWrite)
    ```
  + Der `glueparquet` Formatwert ist eine ältere Methode zur Aktivierung des AWS Glue Parquet Writers.
+ Wenn `updateBehavior` auf `LOG` festgelegt ist, werden neue Partitionen nur hinzugefügt, wenn das `DynamicFrame`-Schema äquivalent zu den in der Data-Catalog-Tabelle definierten Spalten ist oder eine Teilmenge dieser Spalten enthält.
+ Schemaaktualisierungen werden für nicht partitionierte Tabellen nicht unterstützt (ohne Verwendung der Option „partitionKeys“).
+ Die partitionKeys müssen für den im ETL-Skript übergebenen Parameter und die partitionKeys im Tabellenschema des Data Catalogs äquivalent sein und in der gleichen Reihenfolge vorliegen.
+ Diese Funktion unterstützt derzeit noch keine updating/creating Tabellen, in denen die Aktualisierungsschemas verschachtelt sind (z. B. Arrays innerhalb von Strukturen).

Weitere Informationen finden Sie unter [Programmieren von Spark-Skripte](aws-glue-programming.md).

# Arbeiten mit MongoDB-Verbindungen in ETL-Aufträgen
<a name="integrate-with-mongo-db"></a>

Sie können eine Verbindung für MongoDB erstellen und diese Verbindung dann in Ihrem AWS Glue-Auftrag nutzen. Weitere Informationen finden Sie [MongoDB-Verbindungen](aws-glue-programming-etl-connect-mongodb-home.md) im AWS Glue Programmierhandbuch. `url`, `username` und `password` für die Verbindung werden in der MongoDB-Verbindung gespeichert. Andere Optionen können in Ihrem ETL-Auftraggskript mit dem `additionalOptions`-Parameter von `glueContext.getCatalogSource` festgelegt werden. Weitere Optionen können Folgendes umfassen:
+ `database`: (Erforderlich) Die MongoDB-Datenbank, aus der gelesen werden soll.
+ `collection`: (Erforderlich) Die MongoDB-Sammlung, aus der gelesen werden soll.

Indem Sie die `database`- und `collection`-Informationen innerhalb des ETL-Auftragsskripts verwenden, können Sie dieselbe Verbindung für mehrere Aufträge verwenden.

1. Erstellen Sie eine AWS Glue Data Catalog Verbindung für die MongoDB-Datenquelle. Unter [„connectionType“: „mongodb“](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-mongodb) finden Sie eine Beschreibung der Verbindungsparameter. Sie können die Verbindung über die Konsole APIs oder CLI herstellen.

1. Erstellen Sie eine Datenbank in AWS Glue Data Catalog , um die Tabellendefinitionen für Ihre MongoDB-Daten zu speichern. Weitere Informationen finden Sie unter [Erstellen von Datenbanken](define-database.md).

1. Erstellen Sie einen Crawler, der das Crawling der Daten in der MongoDB mit den Informationen in der Verbindung ausführt, um eine Verbindung mit der MongoDB herzustellen. Der Crawler erstellt die Tabellen in der AWS Glue Data Catalog , die die Tabellen in der MongoDB-Datenbank beschreiben, die Sie in Ihrem Job verwenden. Weitere Informationen finden Sie unter [Verwenden von Crawlern zum Auffüllen des Datenkatalogs](add-crawler.md).

1. Erstellen Sie einen Auftrag mit einem benutzerdefinierten Skript. Sie können den Job mit der Konsole APIs oder der CLI erstellen. Weitere Informationen finden Sie unter [Hinzufügen von Aufträgen in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/add-job.html).

1. Wählen Sie die Datenziele Ihres Auftrags aus. Die Tabellen, die das Datenziel repräsentieren, können in Ihrem Data Catalog definiert werden, oder Ihr Auftrag kann die Zieltabellen erstellen, wenn er ausgeführt wird. Beim Verfassen des Auftrags wählen Sie einen Zielspeicherort aus. Wenn das Ziel eine Verbindung benötigt, wird auch die Verbindung in Ihrem Auftrag referenziert. Wenn Ihr Auftrag mehrere Datenziele benötigt, können Sie sie später hinzufügen, indem Sie das Skript bearbeiten.

1. Passen Sie die Auftragsverarbeitungsumgebung an, indem Sie Argumente für Ihren Auftrag und das generierte Skript bereitstellen. 

   Hier sehen Sie ein Beispiel für das Erstellen eines `DynamicFrame` aus der MongoDB-Datenbank basierend auf der in Data Catalog definierten Tabellenstruktur. Der Code verwendet `additionalOptions` zur Bereitstellung der zusätzlichen Datenquelleninformationen:

------
#### [  Scala  ]

   ```
   val resultFrame: DynamicFrame = glueContext.getCatalogSource(
           database = catalogDB, 
           tableName = catalogTable, 
           additionalOptions = JsonOptions(Map("database" -> DATABASE_NAME, 
                   "collection" -> COLLECTION_NAME))
         ).getDynamicFrame()
   ```

------
#### [  Python  ]

   ```
   glue_context.create_dynamic_frame_from_catalog(
           database = catalogDB,
           table_name = catalogTable,
           additional_options = {"database":"database_name", 
               "collection":"collection_name"})
   ```

------

1. Führen Sie den Auftrag entweder on demand oder über einen Auslöser aus.

# Optimieren der Abfrageleistung mithilfe von Spaltenstatistiken
<a name="column-statistics"></a>

Sie können Statistiken auf Spaltenebene für AWS Glue Data Catalog Tabellen in Datenformaten wie Parquet, ORC, JSON, ION, CSV und XML berechnen, ohne zusätzliche Datenpipelines einzurichten. Spaltenstatistiken helfen Ihnen dabei, Datenprofile zu verstehen, indem sie Einblicke in die Werte innerhalb einer Spalte gewinnen. 

Der Datenkatalog unterstützt die Generierung von Statistiken für Spaltenwerte wie Minimalwert, Maximalwert, Gesamtzahl der Nullwerte, Gesamtzahl unterschiedlicher Werte, durchschnittliche Länge von Werten und Gesamtzahl der Vorkommen von wahren Werten. AWS Analysedienste wie Amazon Redshift und Amazon Athena können diese Spaltenstatistiken verwenden, um Abfrageausführungspläne zu generieren und den optimalen Plan auszuwählen, der die Abfrageleistung verbessert.

Es gibt drei Szenarien für die Generierung von Spaltenstatistiken: 

 **Automatisch**   
AWS Glue unterstützt die automatische Generierung von Spaltenstatistiken auf Katalogebene, sodass automatisch Statistiken für neue Tabellen in der generiert werden können. AWS Glue Data Catalog

**Geplant**  
AWS Glue unterstützt die Planung der Generierung von Spaltenstatistiken, sodass sie automatisch nach einem wiederkehrenden Zeitplan ausgeführt werden kann.   
Bei der geplanten Statistikberechnung aktualisiert der Task für Spaltenstatistiken die Gesamtstatistiken auf Tabellenebene, z. B. Min., Max und Durchschnitt, mit den neuen Statistiken, sodass Abfrage-Engines genaue Statistiken und up-to-date Statistiken zur Optimierung der Abfrageausführung erhalten. 

**On-Demand**  
Verwenden Sie diese Option, um bei Bedarf Spaltenstatistiken zu generieren. Dies ist nützlich für Ad-hoc-Analysen oder wenn Statistiken sofort berechnet werden müssen. 

Sie können so konfigurieren, dass die Aufgabe zur Generierung von Spaltenstatistiken mithilfe von AWS Glue Konsolen- und AWS CLI AWS Glue API-Vorgängen ausgeführt wird. Wenn Sie den Prozess starten, AWS Glue wird ein Spark-Job im Hintergrund gestartet und die AWS Glue Tabellenmetadaten im Datenkatalog aktualisiert. Sie können Spaltenstatistiken über die AWS Glue Konsole AWS CLI oder durch Aufrufen des [GetColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetColumnStatisticsForTable.html)API-Vorgangs anzeigen.

**Anmerkung**  
Wenn Sie Lake-Formation-Berechtigungen verwenden, um den Zugriff auf die Tabelle zu steuern, erfordert die von der Aufgabe für Spaltenstatistiken übernommene Rolle vollständigen Tabellenzugriff, um Statistiken zu generieren.

 Das folgende Video veranschaulicht, wie Sie die Abfrageleistung mithilfe von Spaltenstatistiken verbessern. 

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/zUHEXJdHUxs?si=HjyhpoALR6RXJz2i/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/zUHEXJdHUxs?si=HjyhpoALR6RXJz2i)


**Topics**
+ [Voraussetzungen für die Generierung von Spaltenstatistiken](column-stats-prereqs.md)
+ [Automatisches Generieren von Spaltenstatistiken](auto-column-stats-generation.md)
+ [Planmäßige Generierung von Spaltenstatistiken](generate-column-stats.md)
+ [On-Demand-Generierung von Spaltenstatistiken](column-stats-on-demand.md)
+ [Anzeigen von Spaltenstatistiken](view-column-stats.md)
+ [Anzeigen von Spaltenstatistik-Aufgabenläufen](view-stats-run.md)
+ [Beenden des Spaltenstatistik-Aufgabenlaufs](stop-stats-run.md)
+ [Löschen von Spaltenstatistiken](delete-column-stats.md)
+ [Überlegungen und Einschränkungen](column-stats-notes.md)

# Voraussetzungen für die Generierung von Spaltenstatistiken
<a name="column-stats-prereqs"></a>

Um Spaltenstatistiken zu erstellen oder zu aktualisieren, übernimmt die Statistikgenerierungsaufgabe in Ihrem Namen eine AWS Identity and Access Management (IAM)-Rolle. Basierend auf den der Rolle erteilten Berechtigungen kann die Aufgabe zur Generierung von Spaltenstatistiken die Daten aus dem Amazon-S3-Datenspeicher lesen.

Wenn Sie die Aufgabe zur Generierung von Spaltenstatistiken konfigurieren, AWS Glue können Sie eine Rolle erstellen, die die `AWSGlueServiceRole` AWS verwaltete Richtlinie sowie die erforderliche Inline-Richtlinie für die angegebene Datenquelle umfasst. 

Wenn Sie eine vorhandene Rolle für das Generieren von Spaltenstatistiken angeben, stellen Sie sicher, dass dieser die `AWSGlueServiceRole`-Richtlinie oder eine gleichwertige Version dieser Richtlinie (oder eine reduzierte Version) sowie die erforderlichen Inline-Richtlinien enthält. Führen Sie diese Schritte aus, um eine neue IAM-Rolle zu erstellen:

**Anmerkung**  
 Um Statistiken für von Lake Formation verwaltete Tabellen zu generieren, benötigt die IAM-Rolle, die zum Generieren von Statistiken verwendet wird, vollständigen Tabellenzugriff. 

Wenn Sie die Aufgabe zur Generierung von Spaltenstatistiken konfigurieren, AWS Glue können Sie eine Rolle erstellen, die die `AWSGlueServiceRole` AWS verwaltete Richtlinie sowie die erforderliche Inline-Richtlinie für die angegebene Datenquelle umfasst. Sie können auch eine Rolle erstellen, die in der folgenden Richtlinie aufgeführten Berechtigungen anhängen und diese Rolle der Aufgabe zur Generierung von Spaltenstatistiken hinzufügen.

**So erstellen Sie eine IAM-Rolle für die Generierung von Spaltenstatistiken**

1. Eine Anleitung zum Erstellen einer IAM;-Rolle finden Sie unter [Erstellen von IAM-Rollen für AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html).

1. Um eine bestehende Rolle zu aktualisieren, wechseln Sie in der IAM-Konsole zu der IAM-Rolle, die beim Generieren von Spaltenstatistiken verwendet wird.

1. Wählen Sie in der Registerkarte **Berechtigungen hinzufügen** die Option **Richtlinien anfügen** aus. Wählen Sie im neu geöffneten Browserfenster die Option `AWSGlueServiceRole` AWS Verwaltete Richtlinie aus.

1. Sie müssen außerdem Berechtigungen zum Lesen von Daten am Amazon-S3-Speicherort hinzufügen.

   Wählen Sie im Abschnitt **Berechtigungen hinzufügen** die Option **Richtlinie erstellen** aus. Erstellen Sie im neu geöffneten Browserfenster eine neue Richtlinie, die Sie mit Ihrer Rolle verwenden möchten.

1. Wählen Sie auf der Seite **Richtlinie erstellen** die Registerkarte **JSON** aus. Kopieren Sie den folgenden `JSON`-Code in das Richtlinien-Editor-Feld.
**Anmerkung**  
Ersetzen Sie in den folgenden Richtlinien die Konto-ID durch eine gültige AWS-Konto und `region` durch die Region der Tabelle sowie `bucket-name` durch den Amazon S3 S3-Bucket-Namen.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "S3BucketAccess",
               "Effect": "Allow",
               "Action": [
                   "s3:ListBucket",
                   "s3:GetObject"
               ],
               "Resource": [
               	"arn:aws:s3:::amzn-s3-demo-bucket/*",
   							"arn:aws:s3:::amzn-s3-demo-bucket"
               ]
           }
        ]
   }
   ```

------

1. (Optional) Wenn Sie Lake-Formation-Berechtigungen verwenden, um Zugriff auf Ihre Daten zu gewähren, sind für die IAM-Rolle `lakeformation:GetDataAccess`-Berechtigungen erforderlich.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "LakeFormationDataAccess",
         "Effect": "Allow",
         "Action": "lakeformation:GetDataAccess",
         "Resource": [
           "*"
         ]
       }
     ]
   }
   ```

------

    Wenn der Amazon-S3-Speicherort bei Lake Formation registriert ist und für die IAM-Rolle, die von der Aufgabe zur Generierung von Spaltenstatistiken übernommen wurde, keine `IAM_ALLOWED_PRINCIPALS`-Gruppenberechtigungen für die Tabelle erteilt wurden, benötigt die Rolle `ALTER`- und `DESCRIBE`-Berechtigungen in Lake Formation für die Tabelle. Die Rolle, die für die Registrierung des Amazon-S3-Buckets verwendet wird, erfordert `INSERT`- und `DELETE`-Berechtigungen in Lake Formation für die Tabelle. 

   Wenn der Amazon-S3-Speicherort bei Lake Formation registriert ist und für die IAM-Rolle keine `IAM_ALLOWED_PRINCIPALS`-Gruppenberechtigungen für die Tabelle erteilt wurden, benötigt die Rolle `ALTER`-, `DESCRIBE`-, `INSERT`- und `DELETE`-Berechtigungen in Lake Formation für die Tabelle. 

1. Wenn Sie die Option `Automatic statistics generation` auf Katalogebene aktiviert haben, muss die IAM-Rolle über die `glue:UpdateCatalog`-Berechtigung oder die Lake-Formation-Berechtigung `ALTER CATALOG` für den Standarddatenkatalog verfügen. Sie können den `GetCatalog`-Vorgang verwenden, um die Katalogeigenschaften zu überprüfen. 

1. (Optional) Für die Aufgabe zur Generierung von Spaltenstatistiken, die verschlüsselte Amazon CloudWatch Logs -Schreibvorgänge durchführt, sind die folgenden Berechtigungen in der Schlüsselrichtlinie erforderlich.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "CWLogsKmsPermissions",
         "Effect": "Allow",
         "Action": [
           "logs:CreateLogGroup",
           "logs:CreateLogStream",
           "logs:PutLogEvents",
           "logs:AssociateKmsKey"
         ],
         "Resource": [
           "arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue:*"
         ]
       },
       {
         "Sid": "KmsPermissions",
         "Effect": "Allow",
         "Action": [
           "kms:GenerateDataKey",
           "kms:Decrypt",
           "kms:Encrypt"
         ],
         "Resource": [
           "arn:aws:kms:us-east-1:111122223333:key/arn of key used for ETL cloudwatch encryption"
         ],
         "Condition": {
           "StringEquals": {
             "kms:ViaService": [
               "glue.us-east-1.amazonaws.com"
             ]
           }
         }
       }
     ]
   }
   ```

------

1. Die Rolle, die Sie zum Ausführen der Spaltenstatistiken verwenden, muss die `iam:PassRole`-Berechtigung für die Rolle haben.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "iam:PassRole"
         ],
         "Resource": [
           "arn:aws:iam::111122223333:role/columnstats-role-name"
         ]
       }
     ]
   }
   ```

------

1. Wenn Sie eine IAM-Rolle für die Generierung von Spaltenstatistiken erstellen, muss für diese Rolle auch die folgende Vertrauensrichtlinie gelten, damit der Service die Rolle übernehmen kann. 

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "TrustPolicy",
         "Effect": "Allow",
         "Principal": {
           "Service": "glue.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

------

# Automatisches Generieren von Spaltenstatistiken
<a name="auto-column-stats-generation"></a>

Die automatische Generierung von Spaltenstatistiken ermöglicht es Ihnen, Statistiken für neue Tabellen in AWS Glue Data Catalog zu planen und automatisch zu berechnen. Wenn Sie die automatische Statistikgenerierung aktivieren, erkennt der Datenkatalog neue Tabellen mit bestimmten Datenformaten wie Parquet, JSON, CSV, XML, ORC, ION und Apache Iceberg sowie deren individuelle Bucket-Pfade. Mit einer einmaligen Katalogkonfiguration generiert der Datenkatalog Statistiken für diese Tabellen.

 Data–Lake-Administratoren können die Statistikgenerierung konfigurieren, indem sie den Standardkatalog in der Lake-Formation-Konsole auswählen und die Tabellenstatistik über die Option `Optimization configuration` aktivieren. Wenn Sie neue Tabellen erstellen oder bestehende Tabellen im Datenkatalog aktualisieren, erfasst der Datenkatalog wöchentlich die Anzahl der unterschiedlichen Werte (NDVs) für Apache Iceberg-Tabellen sowie zusätzliche Statistiken wie die Anzahl der Nullen, die maximale, minimale und durchschnittliche Länge für andere unterstützte Dateiformate. 

Wenn Sie die Statistikgenerierung auf Tabellenebene konfiguriert haben oder wenn Sie zuvor die Einstellungen für die Statistikgenerierung für eine Tabelle gelöscht haben, haben diese tabellenspezifischen Einstellungen Vorrang vor den Standardkatalogeinstellungen für die automatische Generierung von Spaltenstatistiken.

 Die Aufgabe zur automatischen Statistikgenerierung analysiert 50 % der Datensätze in den Tabellen, um Statistiken zu berechnen. Die automatische Generierung von Spaltenstatistiken stellt sicher, dass der Datenkatalog wöchentliche Kennzahlen enthält, die von Abfrage-Engines wie Amazon Athena und Amazon Redshift Spectrum verwendet werden können, um die Abfrageleistung zu verbessern und potenzielle Kosteneinsparungen zu erzielen. Es ermöglicht die Planung der Statistikgenerierung mithilfe AWS Glue APIs oder der Konsole und bietet so einen automatisierten Prozess ohne manuelles Eingreifen. 

**Topics**
+ [Aktivieren der automatischen Statistikgenerierung auf Katalogebene](enable-auto-column-stats-generation.md)
+ [Anzeigen von automatisierten Einstellungen auf Tabellenebene](view-auto-column-stats-settings.md)
+ [Deaktivierung der Generierung von Spaltenstatistiken auf Katalogebene](disable-auto-column-stats-generation.md)

# Aktivieren der automatischen Statistikgenerierung auf Katalogebene
<a name="enable-auto-column-stats-generation"></a>

Sie können die automatische Generierung von Spaltenstatistiken für alle neuen Apache-Iceberg-Tabellen und Tabellen in Nicht-OTF-Tabellenformaten (Parquet, JSON, CSV, XML, ORC, ION) im Datenkatalog aktivieren. Nachdem Sie die Tabelle erstellt haben, können Sie die Einstellungen für die Spaltenstatistik auch explizit manuell aktualisieren.

 Um die Datenkatalogeinstellungen zu aktualisieren, um die Katalogebene zu aktivieren, muss die verwendete IAM-Rolle über die `glue:UpdateCatalog` Berechtigung oder die Berechtigung für den AWS Lake Formation `ALTER CATALOG` Stammkatalog verfügen. Sie können die `GetCatalog`-API verwenden, um die Katalogeigenschaften zu überprüfen. 

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

**So aktivieren Sie die automatische Generierung von Spaltenstatistiken auf Kontoebene**

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

1. Wählen Sie in der linken Navigationsleiste die Option **Kataloge** aus.

1. Wählen Sie auf der Seite mit der **Katalogübersicht** unter **Optimierungskonfiguration** die Option **Bearbeiten** aus.   
![\[Im Screenshot werden die Optionen angezeigt, die zum Generieren von Spaltenstatistiken verfügbar sind.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/edit-column-stats-auto.png)

1. Wählen Sie auf der Seite **Konfiguration für die Tabellenoptimierung** die Option **Automatische Statistikgenerierung für die Tabellen des Katalogs aktivieren** aus.  
![\[Im Screenshot werden die Optionen angezeigt, die zum Generieren von Spaltenstatistiken verfügbar sind.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/edit-optimization-option.jpg)

1. Wählen Sie eine vorhandene IAM-Rolle aus oder erstellen Sie eine neue, die über die erforderlichen Berechtigungen zum Ausführen der Aufgabe für Spaltenstatistiken verfügt.

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

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

Sie können die Erfassung von Statistiken auf Katalogebene auch über die AWS CLI aktivieren. Führen Sie den folgenden Befehl aus AWS CLI, um die Erfassung von Statistiken auf Tabellenebene mithilfe von zu konfigurieren:

```
aws glue update-catalog --cli-input-json '{
    "name": "123456789012",
    "catalogInput": {
        "description": "Updating root catalog with role arn",
        "catalogProperties": {
            "customProperties": {
                "ColumnStatistics.RoleArn": "arn:aws:iam::"123456789012":role/service-role/AWSGlueServiceRole",
                "ColumnStatistics.Enabled": "true"
            }
        }
    }
}'
```

 Der obige Befehl ruft AWS Glue die `UpdateCatalog` Operation auf, die eine `CatalogProperties` Struktur mit den folgenden Schlüssel-Wert-Paaren für die Generierung von Statistiken auf Katalogebene verwendet: 
+ ColumnStatistics. RoleArn — ARN der IAM-Rolle, der für alle Aufgaben verwendet werden soll, die für die Generierung von Statistiken auf Katalogebene ausgelöst wurden
+ ColumnStatistics.Enabled — Boolescher Wert, der angibt, ob die Einstellungen auf Katalogebene aktiviert oder deaktiviert sind

------

# Anzeigen von automatisierten Einstellungen auf Tabellenebene
<a name="view-auto-column-stats-settings"></a>

 Wenn die Erfassung von Statistiken auf Katalogebene aktiviert ist, wird bei jeder Erstellung oder Aktualisierung einer Apache Hive-Tabelle oder einer Apache Iceberg-Tabelle über das SDK `CreateTable` oder `UpdateTable` APIs über AWS-Managementkonsole das SDK oder AWS-Glue-Crawler eine entsprechende Einstellung auf Tabellenebene für diese Tabelle erstellt. 

 Tabellen mit aktivierter automatischer Statistikgenerierung müssen eine der folgenden Eigenschaften aufweisen:
+ Verwenden eine `InputSerdeLibrary`, die mit org.apache.hadoop beginnt und bei der `TableType` `EXTERNAL_TABLE` entspricht.
+ Verwenden eine `InputSerdeLibrary`, die mit `com.amazon.ion` beginnt und bei der `TableType` `EXTERNAL_TABLE` entspricht.
+ Enthalten table\$1type: „ICEBERG“ in der Parameterstruktur. 

 Nachdem Sie eine Tabelle erstellt oder aktualisiert haben, können Sie die Tabellendetails überprüfen, um die Statistikgenerierung zu bestätigen. Die `Statistics generation summary` zeigt die `Schedule`-Eigenschaft an, die als `AUTO` festgelegt ist und deren `Statistics configuration`-Wert `Inherited from catalog` lautet. Jede Tabelleneinstellung mit der folgenden Konfiguration würde intern automatisch von Glue ausgelöst werden. 

![\[Ein Bild einer Hive-Tabelle mit Katalog-Level-Statistiksammlung wurde angewendet und Statistiken wurden gesammelt.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/auto-stats-summary.png)


# Deaktivierung der Generierung von Spaltenstatistiken auf Katalogebene
<a name="disable-auto-column-stats-generation"></a>

 Sie können die automatische Generierung von Spaltenstatistiken für neue Tabellen mithilfe der AWS Lake Formation Konsole, der API oder der `glue:UpdateCatalogSettings` API deaktivieren. `glue:DeleteColumnStatisticsTaskSettings` 

**So deaktivieren Sie die automatische Generierung von Spaltenstatistiken auf Kontoebene**

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

1. Wählen Sie in der linken Navigationsleiste die Option **Kataloge** aus.

1. Wählen Sie auf der Seite mit der **Katalogübersicht** unter **Optimierungskonfiguration** die Option **Bearbeiten** aus. 

1. Deaktivieren Sie auf der Seite **Konfiguration für die Tabellenoptimierung** die Option **Automatische Statistikgenerierung für die Tabellen des Katalogs aktivieren**.

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

# Planmäßige Generierung von Spaltenstatistiken
<a name="generate-column-stats"></a>

Gehen Sie wie folgt vor, um einen Zeitplan für die Generierung von Spaltenstatistiken in der [CreateColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-CreateColumnStatisticsTaskSettings)Operation AWS Glue Data Catalog AWS Glue Using the console AWS CLI, the oder the zu konfigurieren.

------
#### [ Console ]

**Generieren von Spaltenstatistiken mit der Konsole**

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

1. Wählen Sie „Datenkatalog-Tabellen“ aus.

1. Wählen Sie eine Tabelle aus der Liste aus. 

1. Wählen Sie im unteren Bereich der Seite **Tabellen** die Registerkarte **Spaltenstatistik**.

1. Sie können aus **Aktionen** auch unter **Spaltenstatistiken** die Option **Nach Zeitplan generieren** auswählen.

1. Konfigurieren Sie auf der Seite **Statistiken nach Zeitplan generieren** einen wiederkehrenden Zeitplan für die Ausführung der Spaltenstatistikaufgabe, indem Sie die Häufigkeit und die Startzeit auswählen. Sie können wählen, ob die Frequenz stündlich, täglich oder wöchentlich sein soll, oder Sie können einen Cron-Ausdruck definieren, um den Zeitplan zu spezifizieren.

   Ein Cron-Ausdruck ist eine Zeichenfolge, die ein Zeitplanmuster darstellt und aus 6 durch Leerzeichen getrennten Feldern besteht: \$1 \$1 \$1 \$1 \$1 <minute><hour><day of month><month><day of week><year>Um beispielsweise eine Aufgabe jeden Tag um Mitternacht auszuführen, wäre der Cron-Ausdruck: 0 0 \$1 \$1? \$1

   Weitere Informationen finden Sie unter [Cron-Ausdrücke](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html#CronExpressions).  
![\[Im Screenshot werden die Optionen angezeigt, die zum Generieren von Spaltenstatistiken verfügbar sind.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/generate-column-stats-schedule.png)

1. Wählen Sie als Nächstes die Spaltenoption aus, um Statistiken zu generieren.
   + **Alle Spalten**: Wählen Sie diese Option aus, um Statistiken für alle Spalten in der Tabelle zu generieren.
   + **Ausgewählte Spalten** – Wählen Sie diese Option aus, um Statistiken für bestimmte Spalten zu generieren. Sie können die Spalten in der Dropdown-Liste auswählen.

1. Wählen Sie eine IAM-Rolle oder erstellen Sie eine vorhandene Rolle, die über Berechtigungen zum Generieren von Statistiken verfügt. AWS Glue übernimmt diese Rolle, um Spaltenstatistiken zu generieren.

   Eine schnellere Methode besteht darin, die AWS Glue Konsole eine Rolle für Sie erstellen zu lassen. Die von ihr erstellte Rolle dient speziell der Generierung von Spaltenstatistiken und umfasst die `AWSGlueServiceRole` AWS verwaltete Richtlinie sowie die erforderliche Inline-Richtlinie für die angegebene Datenquelle. 

   Wenn Sie eine vorhandene Rolle für das Generieren von Spaltenstatistiken angeben, stellen Sie sicher, dass diese die `AWSGlueServiceRole`-Richtlinie oder eine gleichwertige Version dieser Richtlinie (oder eine reduzierte Version) sowie die erforderlichen Inline-Richtlinien enthält. 

1. (Optional) Wählen Sie als Nächstes eine Sicherheitskonfiguration aus, um für Protokolle die Verschlüsselung im Ruhezustand zu aktivieren.

1. (Optional) Sie können eine Stichprobengröße auswählen, indem Sie nur einen bestimmten Prozentsatz der Zeilen aus der Tabelle angeben, um Statistiken zu generieren. Der Standardwert ist „Alle Zeilen“. Verwenden Sie die Aufwärts- und Abwärtspfeile, um den Prozentwert zu erhöhen oder zu verringern. 

   Wir empfehlen, alle Zeilen in die Tabelle aufzunehmen, um genaue Statistiken zu berechnen. Verwenden Sie Beispielzeilen zur Generierung von Spaltenstatistiken nur dann, wenn Näherungswerte akzeptabel sind.

1. Wählen Sie **Statistiken generieren** aus, um die Aufgabe zur Generierung von Spaltenstatistiken auszuführen.

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

Sie können das folgende AWS CLI Beispiel verwenden, um einen Zeitplan für die Generierung von Spaltenstatistiken zu erstellen. Datenbankname, Tabellenname und Rolle sind erforderliche Parameter, und optionale Parameter sind Zeitplan, Katalog-ID, Stichprobengröße und column-name-list Sicherheitskonfiguration.

```
aws glue create-column-statistics-task-settings \ 
 --database-name 'database_name' \ 
 --table-name table_name \ 
 --role 'arn:aws:iam::123456789012:role/stats-role' \ 
 --schedule 'cron(0 0-5 14 * * ?)' \ 
 --column-name-list 'col-1' \  
 --catalog-id '123456789012' \ 
 --sample-size '10.0 ' \
 --security-configuration 'test-security'
```

Sie können Spaltenstatistiken auch generieren, indem Sie den Vorgang aufrufen. [StartColumnStatisticsTaskRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StartColumnStatisticsTaskRun)

------

# Verwalten des Zeitplans für die Generierung von Spaltenstatistiken
<a name="manage-column-stats-schedule"></a>

Sie können die Planungsvorgänge wie Aktualisieren, Starten, Stoppen und Löschen von Zeitplänen für die Erstellung von Spaltenstatistiken in AWS Glue verwalten. Sie können [API-Operationen für AWS GlueAWS CLI Konsolen- oder AWS Glue Spaltenstatistiken](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html) verwenden, um diese Aufgaben auszuführen.

**Topics**
+ [Aktualisieren des Zeitplans für die Generierung von Spaltenstatistiken](#update-column-stats-shedule)
+ [Beenden des Zeitplans für die Generierung von Spaltenstatistiken](#stop-column-stats-schedule)
+ [Fortsetzen des Zeitplans für die Generierung von Spaltenstatistiken](#resume-column-stats-schedule)
+ [Löschen des Zeitplans für die Generierung von Spaltenstatistiken](#delete-column-stats-schedule)

## Aktualisieren des Zeitplans für die Generierung von Spaltenstatistiken
<a name="update-column-stats-shedule"></a>

Sie können den Zeitplan aktualisieren, um die Aufgabe zur Generierung der Spaltenstatistiken nach deren Erstellung auszulösen. Sie können die AWS Glue Konsole verwenden oder den [UpdateColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-UpdateColumnStatisticsTaskSettings)Vorgang ausführen AWS CLI, um den Zeitplan für eine Tabelle zu aktualisieren. Die Parameter eines bestehenden Zeitplans, z. B. der Zeitplantyp (auf Abruf oder geplant) und andere optionale Parameter lassen sich ändern. 

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

**So aktualisieren Sie die Einstellungen für eine Aufgabe zur Generierung von Spaltenstatistiken**

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

1. Wählen Sie aus der Tabellenliste die Tabelle aus, die Sie aktualisieren möchten.

1. Wählen Sie im unteren Bereich der Detailseite der Tabelle die Option **Spaltenstatistiken**. 

1. Wählen Sie unter **Aktionen** die Option **Bearbeiten** aus, um den Zeitplan zu aktualisieren.

1. Nehmen Sie die gewünschten Änderungen am Zeitplan vor und wählen Sie **Speichern**.

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

 Wenn Sie die Funktion zur Generierung AWS Glue von Statistiken in der Konsole nicht verwenden, können Sie den Zeitplan mithilfe des `update-column-statistics-task-settings` Befehls manuell aktualisieren. Im folgenden Beispiel wird gezeigt, wie Sie Spaltenstatistiken mithilfe von AWS CLI aktualisieren. 

```
aws glue update-column-statistics-task-settings \ 
 --database-name 'database_name' \ 
 --table-name 'table_name' \ 
 --role arn:aws:iam::123456789012:role/stats_role \ 
 --schedule 'cron(0 0-5 16 * * ?)' \ 
 --column-name-list 'col-1' \
 --sample-size '20.0' \  
 --catalog-id '123456789012'\
 --security-configuration 'test-security'
```

------

## Beenden des Zeitplans für die Generierung von Spaltenstatistiken
<a name="stop-column-stats-schedule"></a>

 Wenn Sie die inkrementellen Statistiken nicht mehr benötigen, können Sie die geplante Generierung stoppen, um Ressourcen und Kosten zu sparen. Das Anhalten des Zeitplans hat keine Auswirkungen auf die zuvor generierten Statistiken. Sie können den Zeitplan nach Belieben fortsetzen. 

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

**So beenden Sie den Zeitplan für die Generierung von Spaltenstatistiken**

1. Wählen Sie in der AWS Glue Konsole unter Datenkatalog die Option **Tabellen** aus.

1. Wählen Sie eine Tabelle mit Spaltenstatistiken aus.

1. Wählen Sie auf der Seite **Tabellendetails** die Option **Spaltenstatistiken** aus.

1. Wählen Sie unter **Aktionen** die Option **Geplante Generierung** und dann **Pausieren** aus.

1. Bestätigen Sie mit **Pausieren**.

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

Um die Ausführung einer Aufgabe mit Spaltenstatistiken mithilfe von zu beenden AWS CLI, können Sie den folgenden Befehl verwenden: 

```
aws glue stop-column-statistics-task-run-schedule \
 --database-name ''database_name' \
 --table-name 'table_name'
```

Ersetzen Sie `database_name` und `table_name` durch die tatsächlichen Namen der Datenbank und Tabelle, für die Sie den Zeitplan für die Ausführung der Spaltenstatistikaufgabe beenden möchten.

------

## Fortsetzen des Zeitplans für die Generierung von Spaltenstatistiken
<a name="resume-column-stats-schedule"></a>

 Wenn Sie den Zeitplan für die Statistikgenerierung angehalten haben, AWS Glue können Sie den Zeitplan nach Belieben fortsetzen. Sie können den Zeitplan über die AWS Glue Konsole oder den AWS CLI[StartColumnStatisticsTaskRunSchedule](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StartColumnStatisticsTaskRunSchedule)Vorgang fortsetzen. 

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

**So setzen Sie den Zeitplan für die Generierung von Spaltenstatistiken fort**

1. Wählen Sie auf der AWS Glue Konsole unter Datenkatalog die Option **Tabellen** aus.

1. Wählen Sie eine Tabelle mit Spaltenstatistiken aus.

1. Wählen Sie auf der Seite **Tabellendetails** die Option **Spaltenstatistiken** aus.

1. Wählen Sie unter **Aktionen** die Option **Geplante Generierung** und dann **Fortsetzen** aus.

1. Bestätigen Sie mit **Fortsetzen**.

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

Ersetzen Sie `database_name` und `table_name` durch die tatsächlichen Namen der Datenbank und Tabelle, für die Sie den Zeitplan für die Ausführung der Spaltenstatistikaufgabe beenden möchten.

```
aws glue start-column-statistics-task-run-schedule \
 --database-name 'database_name' \
 --table-name 'table_name'
```

------

## Löschen des Zeitplans für die Generierung von Spaltenstatistiken
<a name="delete-column-stats-schedule"></a>

 Für eine optimale Abfrageleistung wird zwar generell empfohlen, up-to-date Statistiken zu verwalten, es gibt jedoch spezielle Anwendungsfälle, in denen es von Vorteil sein könnte, den Zeitplan für die automatische Generierung zu entfernen.
+ Bleiben die Daten relativ statisch, können die vorhandenen Spaltenstatistiken über einen längeren Zeitraum hinweg genau bleiben, wodurch die Notwendigkeit häufiger Aktualisierungen verringert wird. Das Löschen des Zeitplans kann unnötigen Ressourcenverbrauch und Overhead verhindern, der mit der Neugenerierung von Statistiken zu unveränderten Daten verbunden ist.
+ Wenn eine manuelle Steuerung der Statistikgenerierung bevorzugt wird. Durch das Löschen des automatischen Zeitplans können Administratoren die Spaltenstatistiken in bestimmten Intervallen oder nach wesentlichen Datenänderungen selektiv aktualisieren und den Prozess so an ihre Wartungsstrategien und Anforderungen an die Ressourcenzuweisung anpassen. 

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

**So löschen Sie den Zeitplan für die Generierung von Spaltenstatistiken**

1. Wählen Sie auf der AWS Glue Konsole unter Datenkatalog die Option **Tabellen** aus.

1. Wählen Sie eine Tabelle mit Spaltenstatistiken aus.

1. Wählen Sie auf der Seite **Tabellendetails** die Option **Spaltenstatistiken** aus.

1. Wählen Sie unter **Aktionen** die Option **Geplante Generierung** und dann **Löschen** aus.

1. Bestätigen Sie mit **Löschen**.

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

Ersetzen Sie `database_name` und `table_name` durch die tatsächlichen Namen der Datenbank und Tabelle, für die Sie den Zeitplan für die Ausführung der Spaltenstatistikaufgabe beenden möchten.

Sie können den Zeitplan für Spaltenstatistiken mithilfe der [DeleteColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-DeleteColumnStatisticsTaskSettings)API-Operation oder löschen AWS CLI. Das folgende Beispiel zeigt, wie der Zeitplan für die Generierung von Spaltenstatistiken mithilfe von AWS Command Line Interface (AWS CLI) gelöscht wird.

```
aws glue delete-column-statistics-task-settings \
    --database-name 'database_name' \
    --table-name 'table_name'
```

------

# On-Demand-Generierung von Spaltenstatistiken
<a name="column-stats-on-demand"></a>

Sie können die Aufgabe Spaltenstatistiken für die AWS Glue Data Catalog Tabellentask bei Bedarf ohne festen Zeitplan ausführen. Diese Option ist nützlich für Ad-hoc-Analysen oder wenn Statistiken sofort berechnet werden müssen.

Gehen Sie wie folgt vor, um bei Bedarf Spaltenstatistiken für die Datenkatalogtabellen mithilfe der AWS Glue Konsole oder zu generieren AWS CLI.

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

**Generieren von Spaltenstatistiken mit der Konsole**

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

1. Wählen Sie „Datenkatalog-Tabellen“ aus.

1.  Wählen Sie eine Tabelle aus der Liste aus. 

1. Wählen Sie im Menü **Aktionen** die Option **Statistiken generieren** aus.

   Sie können auch **Generieren**, **Generieren bei Bedarf** auf der Registerkarte **Spaltenstatistiken** unten auf der Seite **Tabellen** auswählen.

1. Folgen Sie den Schritten 7 bis 11 in [Planmäßige Generierung von Spaltenstatistiken](generate-column-stats.md), um Spaltenstatistiken für die Tabelle zu generieren.

1. Geben Sie auf der Seite **Statistiken generieren** die folgenden Optionen an:   
![\[Im Screenshot werden die Optionen angezeigt, die zum Generieren von Spaltenstatistiken verfügbar sind.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/generate-column-stats.png)
   + **Alle Spalten** – Wählen Sie diese Option aus, um Statistiken für alle Spalten in der Tabelle zu generieren.
   + **Ausgewählte Spalten** – Wählen Sie diese Option aus, um Statistiken für bestimmte Spalten zu generieren. Sie können die Spalten in der Dropdown-Liste auswählen.
   + **IAM-Rolle** – Wählen Sie **Neue IAM-Rolle erstellen** aus, um eine neue Rolle zu erstellen, die über die erforderlichen Berechtigungsrichtlinien verfügt, um die Aufgabe zur Generierung von Spaltenstatistiken auszuführen. Wählen Sie „Berechtigungsdetails anzeigen“ aus, um die Richtlinienerklärung zu überprüfen. Sie können auch eine IAM-Rolle in der Liste auswählen. Weitere Informationen zu den erforderlichen Berechtigungen finden Sie unter [Voraussetzungen für die Generierung von Spaltenstatistiken](column-stats-prereqs.md).

     AWS Glue nimmt die Berechtigungen der Rolle an, die Sie zum Generieren von Statistiken angeben. 

     Weitere Informationen zur Bereitstellung von Rollen für AWS Glue finden Sie unter [Identitätsbasierte Richtlinien](https://docs.aws.amazon.com/glue/latest/dg/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies) für. AWS Glue.
   + (Optional) Wählen Sie als Nächstes eine Sicherheitskonfiguration aus, um für Protokolle die Verschlüsselung im Ruhezustand zu aktivieren.
   + **Beispielzeilen** – Wählen Sie nur einen bestimmten Prozentsatz der Zeilen aus der Tabelle aus, um Statistiken zu generieren. Der Standardwert ist „Alle Zeilen“. Verwenden Sie die Aufwärts- und Abwärtspfeile, um den Prozentwert zu erhöhen oder zu verringern.
**Anmerkung**  
Wir empfehlen, alle Zeilen in die Tabelle aufzunehmen, um genaue Statistiken zu berechnen. Verwenden Sie Beispielzeilen zur Generierung von Spaltenstatistiken nur dann, wenn Näherungswerte akzeptabel sind.

   Wählen Sie **Statistik generieren** aus, um die Aufgabe auszuführen.

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

Dieser Befehl löst die Ausführung einer Spaltenstatistikaufgabe für die angegebene Tabelle aus. Sie müssen den Datenbanknamen, den Tabellennamen und eine IAM-Rolle mit Berechtigungen zum Generieren von Statistiken angeben. Optional können Sie Spaltennamen und einen Prozentsatz der Stichprobengröße für die Statistikberechnung angeben.

```
aws glue start-column-statistics-task-run \ 
    --database-name 'database_name \ 
    --table-name 'table_name' \ 
    --role 'arn:aws:iam::123456789012:role/stats-role' \
    --column-name 'col1','col2'  \
    --sample-size 10.0
```

Dieser Befehl startet eine Aufgabe zum Generieren von Spaltenstatistiken für die angegebene Tabelle. 

------

## Aktualisieren von Spaltenstatistiken bei Bedarf
<a name="update-column-stats-on-demand"></a>

 Die Pflege von up-to-date Spaltenstatistiken ist für den Abfrageoptimierer von entscheidender Bedeutung, um effiziente Ausführungspläne zu erstellen und so eine verbesserte Abfrageleistung, einen geringeren Ressourcenverbrauch und eine bessere Gesamtsystemleistung sicherzustellen. Dieser Prozess ist besonders wichtig nach erheblichen Datenänderungen, wie etwa beim Laden großer Datenmengen oder bei umfangreichen Änderungen, die bestehende Statistiken unbrauchbar machen können. 

Sie müssen die Aufgabe **Statistik generieren** explizit von der AWS Glue Konsole aus ausführen, um die Spaltenstatistiken zu aktualisieren. Der Datenkatalog aktualisiert die Statistiken nicht automatisch.

Wenn Sie die Funktion zur Generierung AWS Glue von Statistiken in der Konsole nicht verwenden, können Sie die Spaltenstatistiken mithilfe der [UpdateColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateColumnStatisticsForTable.html)API-Operation oder manuell aktualisieren AWS CLI. Im folgenden Beispiel wird gezeigt, wie Sie Spaltenstatistiken mithilfe von AWS CLI aktualisieren.

```
aws glue update-column-statistics-for-table --cli-input-json:

{
    "CatalogId": "111122223333",
    "DatabaseName": "database_name",
    "TableName": "table_name",
    "ColumnStatisticsList": [
        {
            "ColumnName": "col1",
            "ColumnType": "Boolean",
            "AnalyzedTime": "1970-01-01T00:00:00",
            "StatisticsData": {
                "Type": "BOOLEAN",
                "BooleanColumnStatisticsData": {
                    "NumberOfTrues": 5,
                    "NumberOfFalses": 5,
                    "NumberOfNulls": 0
                }
            }
        }
    ]
}
```

# Anzeigen von Spaltenstatistiken
<a name="view-column-stats"></a>

Nach erfolgreicher Generierung der Statistiken speichert Data Catalog diese Informationen für die kostenbasierten Optimierer in Amazon Athena und Amazon Redshift, um bei der Ausführung von Abfragen optimale Entscheidungen treffen zu können. Die Statistiken variieren je nach Spaltentyp.

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

**Anzeigen von Spaltenstatistiken für eine Tabelle**
+ Nach dem Ausführen der Spaltenstatistik-Aufgabe werden in der Registerkarte **Spaltenstatistiken** auf der Seite **Tabellendetails** die Statistiken für die Tabelle angezeigt.   
![\[Der Screenshot zeigt Spalten, die bei der letzten Ausführung generiert wurden.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/view-column-stats.png)

  Die folgenden Statistiken sind verfügbar:
  + Spaltenname: Der Spaltenname, der zur Generierung der Statistiken verwendet wurde.
  + Letzte Aktualisierung: Das Datum und die Uhrzeit der Erstellung.
  + Durchschnittliche Länge: durchschnittliche Länge der Werte in der Spalte.
  + Eindeutige Werte: Gesamtzahl der unterschiedlichen Werte in der Spalte. Wir schätzen die Anzahl unterschiedlicher Werte in einer Spalte mit einer relativen Fehlerquote von 5 %.
  + Höchstwert: der höchste Wert in der Spalte.
  + Mindestwert: der kleinste Wert in der Spalte. 
  + Maximale Länge: die Länge des höchsten Werts in der Spalte.
  + Null-Werte: die Anzahl der Null-Werte in der Spalte.
  + „Wahr“-Werte: die Anzahl der „Wahr“-Werte in der Spalte.
  + „Falsch“-Werte: die Anzahl der „Falsch“-Werte in der Spalte.
  + numFiles: Die Gesamtzahl der Dateien in der Tabelle. Dieser Wert ist auf der Registerkarte **Erweiterte Eigenschaften** verfügbar.

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

Im folgenden Beispiel wird gezeigt, wie Sie Spaltenstatistiken mithilfe von AWS CLI abrufen.

```
aws glue get-column-statistics-for-table \
    --database-name database_name \
    --table-name table_name \
    --column-names <column_name>
```

 Sie können die Spaltenstatistiken auch mithilfe der API-Operation anzeigen. [GetColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetColumnStatisticsForTable.html) 

------

# Anzeigen von Spaltenstatistik-Aufgabenläufen
<a name="view-stats-run"></a>

Nachdem Sie eine Aufgabe mit Spaltenstatistiken ausgeführt haben, können Sie die Details der Aufgabenausführung für eine Tabelle mithilfe der AWS Glue Konsole AWS CLI oder mithilfe von [GetColumnStatisticsTaskRuns](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-GetColumnStatisticsTaskRun)Operation untersuchen.

------
#### [ Console ]

**Anzeigen von Details zur Ausführung einer Spaltenstatistik-Aufgabe**

1. Wählen Sie auf der AWS Glue Konsole unter Datenkatalog die Option **Tabellen** aus.

1. Wählen Sie eine Tabelle mit Spaltenstatistiken aus.

1. Wählen Sie auf der Seite **Tabellendetails** die Option **Spaltenstatistiken** aus.

1. Wählen Sie **Ausführungen anzeigen** aus.

   Sie können Informationen zu allen Ausführungen in Verbindung mit der angegebenen Tabelle anzeigen.  
![\[Im Screenshot werden die Optionen angezeigt, die zum Generieren von Spaltenstatistiken verfügbar sind.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/view-column-stats-task-runs.png)

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

Ersetzen Sie Werte für `DatabaseName` und `TableName` im folgenden Beispiel durch den tatsächlichen Datenbank- und Tabellennamen.

```
aws glue get-column-statistics-task-runs --input-cli-json file://input.json
{
    "DatabaseName": "database_name",
    "TableName": "table_name"
}
```

------

# Beenden des Spaltenstatistik-Aufgabenlaufs
<a name="stop-stats-run"></a>

Sie können die Ausführung einer Spaltenstatistikaufgabe für eine Tabelle mithilfe der AWS Glue Konsole AWS CLI oder mithilfe von [StopColumnStatisticsTaskRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StopColumnStatisticsTaskRun)Operation beenden.

------
#### [ Console ]

**Einen Spaltenstatistik-Aufgabenlauf beenden Sie wie folgt:**

1. Wählen Sie in der AWS Glue Konsole unter Datenkatalog die Option **Tabellen** aus.

1. Wählen Sie die Tabelle mit der Spalte „Spaltenstatistik-Aufgabenlauf wird ausgeführt“ aus.

1. Wählen Sie auf der Seite **Tabellendetails** die Option **Spaltenstatistiken** aus.

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

   Wenn Sie die Aufgabe beenden, bevor die Ausführung abgeschlossen ist, werden keine Spaltenstatistiken für die Tabelle generiert.

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

Ersetzen Sie Werte für `DatabaseName` und `TableName` im folgenden Beispiel durch den tatsächlichen Datenbank- und Tabellennamen.

```
aws glue stop-column-statistics-task-run --input-cli-json file://input.json
{
    "DatabaseName": "database_name",
    "TableName": "table_name"
}
```

------

# Löschen von Spaltenstatistiken
<a name="delete-column-stats"></a>

Sie können Spaltenstatistiken mithilfe der [DeleteColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_DeleteColumnStatisticsForTable.html)API-Operation oder löschen AWS CLI. Das folgende Beispiel zeigt, wie Spaltenstatistiken mit AWS Command Line Interface (AWS CLI) gelöscht werden.

```
aws glue delete-column-statistics-for-table \
    --database-name 'database_name' \
    --table-name 'table_name' \
    --column-name 'column_name'
```

# Überlegungen und Einschränkungen
<a name="column-stats-notes"></a>

Die folgenden Überlegungen und Einschränkungen gelten für die Generierung von Spaltenstatistiken.

**Überlegungen**
+ Die Verwendung von Stichproben zur Generierung von Statistiken reduziert die Laufzeit, kann jedoch zu ungenauen Statistiken führen.
+ Data Catalog speichert keine unterschiedlichen Versionen der Statistiken.
+ Sie können pro Tabelle nur jeweils eine Aufgabe zur Erstellung von Statistiken gleichzeitig ausführen.
+ Wenn eine Tabelle mit einem AWS KMS Kundenschlüssel verschlüsselt ist, der bei Data Catalog registriert ist, AWS Glue verwendet denselben Schlüssel zum Verschlüsseln von Statistiken.

**Die Aufgabe für Spaltenstatistiken unterstützt das Generieren von Statistiken:**
+ Wenn die IAM-Rolle über vollständige Tabellenberechtigungen verfügt (IAM oder Lake Formation).
+ Wenn die IAM-Rolle im Lake-Formation-Hybridzugriffsmodus über Berechtigungen für die Tabelle verfügt.

**Die Aufgabe für Spaltenstatistiken unterstützt das Generieren von Statistiken in folgenden Fällen nicht:**
+ Tabellen mit zellbasierter Zutrittskontrolle von Lake Formation
+ Transaktionale Data Lakes – Linux Foundation Delta Lake, Apache Hudi
+ Tabellen in Verbunddatenbanken – Hive Metastore, Amazon Redshift Datashares
+ Verschachtelte Spalten, Arrays und Strukturdatentypen.
+ Tabellen, die von einem anderen Konto mit Ihnen geteilt werden

# Verschlüsseln Ihres Data Catalog
<a name="catalog-encryption"></a>

 Sie können Ihre im Ruhezustand gespeicherten Metadaten mithilfe von Verschlüsselungsschlüsseln schützen, die AWS Glue Data Catalog von AWS Key Management Service (AWS KMS) verwaltet werden. Sie können die Datenkatalogverschlüsselung für neue Datenkataloge mithilfe der **Datenkatalogeinstellungen** aktivieren. Sie können die Verschlüsselung für einen vorhandenen Datenkatalog nach Bedarf aktivieren oder deaktivieren. Wenn diese Option aktiviert ist, werden alle neuen Metadaten, die in den Katalog geschrieben werden, AWS Glue verschlüsselt, während vorhandene Metadaten unverschlüsselt bleiben. 

Ausführliche Informationen zur Verschlüsselung Ihres Datenkatalogs finden Sie unter [Verschlüsseln Ihres Data Catalog](encrypt-glue-data-catalog.md).

# Sicherung Ihres Datenkatalogs mit Lake Formation
<a name="secure-catalog"></a>

 AWS Lake Formation ist ein Service, der es einfacher macht, einen sicheren Data Lake einzurichten AWS. Er bietet einen zentralen Ort, an dem Sie Ihre Data Lakes erstellen und sicher verwalten können, indem Sie detaillierte Zugriffssteuerungsberechtigungen definieren. Lake Formation verwendet den Datenkatalog, um Metadaten zu Ihrem Data Lake zu speichern und abzurufen, z. B. Tabellendefinitionen, Schemainformationen und Einstellungen für die Datenzugriffssteuerung.

Sie können Ihren Amazon-S3-Datenspeicherort der Metadatentabelle oder -datenbank bei Lake Formation registrieren und damit Berechtigungen auf Metadatenebene für die Datenkatalogressourcen definieren. Sie können Lake Formation auch verwenden, um Speicherzugriffsberechtigungen für die in Amazon S3 gespeicherten zugrunde liegenden Daten im Auftrag integrierter Analyse-Engines zu verwalten.

Weitere Informationen finden Sie unter [Was ist AWS Lake Formation?](lake-formation/latest/dg/what-is-lake-formation.html) .

# Arbeiten mit AWS Glue Data Catalog Ansichten in AWS Glue
<a name="catalog-views"></a>

 Sie können Ansichten in den AWS Glue Data Catalog, allgemein als AWS Glue Data Catalog Ansichten bekannt, erstellen und verwalten. Diese Ansichten sind nützlich, da sie mehrere SQL-Abfrage-Engines unterstützen, sodass Sie über verschiedene AWS Dienste hinweg auf dieselbe Ansicht zugreifen können Amazon Athena, z. B. Amazon Redshift, und AWS Glue. Sie können Ansichten verwenden, die auf Apache Iceberg, Apache Hudi und Delta Lake basieren. 

 Indem Sie eine Ansicht im Datenkatalog erstellen, können Sie mithilfe von Ressourcenzuweisungen und tagbasierten Zugriffskontrollen Zugriff darauf gewähren. AWS Lake Formation Mit dieser Methode der Zugriffskontrolle müssen Sie keinen zusätzlichen Zugriff auf die Tabellen konfigurieren, auf die beim Erstellen der Ansicht verwiesen wird. Diese Methode zum Gewähren von Berechtigungen wird als Definer-Semantik bezeichnet, und diese Ansichten werden als Definer-Ansichten bezeichnet. Weitere Informationen zur Zugriffskontrolle finden Sie unter [Erteilen und Widerrufen von Berechtigungen für Datenkatalogressourcen](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) im AWS Lake Formation Entwicklerhandbuch. AWS Lake Formation

 Data-Catalog-Ansichten sind in folgenden Anwendungsfällen nützlich: 
+  **Präzisere Zugriffskontrolle** – Sie können eine Ansicht erstellen, die den Datenzugriff auf der Grundlage der vom Benutzer benötigten Berechtigungen einschränkt. Mithilfe von Ansichten im Datenkatalog können Sie beispielsweise verhindern, dass Mitarbeiter, die nicht in der Personalabteilung arbeiten, persönlich identifizierbare Informationen (PII) sehen. 
+  **Vollständige Ansichtsdefinition** – Durch das Anwenden von Filtern auf Ihre Ansicht im Datenkatalog stellen Sie sicher, dass die in der Ansicht verfügbaren Datensätze immer vollständig sind. 
+  **Verbesserte Sicherheit** – Die zum Erstellen der Ansicht verwendete Abfragedefinition muss vollständig sein, sodass Data-Catalog-Ansichten weniger anfällig für SQL-Befehle von böswilligen Akteuren sind. 
+  **Einfache gemeinsame Nutzung von Daten** — Nutzen Sie die kontenübergreifende Datenfreigabe in, um Daten mit anderen AWS Konten zu teilen, ohne Daten verschieben zu müssen. AWS Lake Formation

## Erstellen einer Data-Catalog-Ansicht
<a name="catalog-creating-view"></a>

 Sie können Datenkatalogansichten mit den AWS CLI und AWS Glue ETL-Skripts mit Spark SQL erstellen. Die Syntax für die Erstellung einer Data-Catalog-Ansicht beinhaltet die Angabe des Ansichtstyps als `MULTI DIALECT` und des `SECURITY` Prädikats als `DEFINER`, wodurch eine Definer-Ansicht angegeben wird. 

 Beispiel für eine SQL-Anweisung zum Erstellen einer Data-Catalog-Ansicht: 

```
CREATE PROTECTED MULTI DIALECT VIEW database_name.catalog_view SECURITY DEFINER
AS SELECT order_date, sum(totalprice) AS price
FROM source_table
GROUP BY order_date;
```

 Nachdem Sie eine Datenkatalogsicht erstellt haben, können Sie eine IAM-Rolle mit der AWS Lake Formation `SELECT`-Berechtigung für die Ansicht verwenden, um sie von Diensten wie Amazon Athena Amazon Redshift, oder AWS Glue ETL-Jobs abzufragen. Sie müssen keinen Zugriff auf die zugrunde liegenden Tabellen gewähren, auf die in der Ansicht verwiesen wird. 

 Weitere Informationen zum Erstellen und Konfigurieren von Datenkatalogsichten finden Sie unter [Erstellen von AWS Glue Datenkatalogansichten im AWS Lake Formation Entwicklerhandbuch](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html). 

## Unterstützte Ansichtsvorgänge
<a name="catalog-supported-view-operations"></a>

 Die folgenden Befehlsfragmente zeigen Ihnen verschiedene Möglichkeiten, mit Data-Catalog-Ansichten zu arbeiten: 

 **ANSICHT ERSTELLEN** 

 Erstellt eine Data-Catalog-Ansicht. Dies ist ein Beispiel für das Erstellen einer Ansicht aus einer vorhandenen Tabelle: 

```
CREATE PROTECTED MULTI DIALECT VIEW catalog_view 
SECURITY DEFINER AS SELECT * FROM my_catalog.my_database.source_table
```

 **ALTER VIEW** 

 Verfügbare Syntax: 

```
ALTER VIEW view_name [FORCE] ADD DIALECT AS query
ALTER VIEW view_name [FORCE] UPDATE DIALECT AS query
ALTER VIEW view_name DROP DIALECT
```

 Sie können die Option `FORCE ADD DIALECT` verwenden, um das Aktualisieren des Schemas und der Unterobjekte gemäß dem neuen Engine-Dialekt zu erzwingen. Beachten Sie, dass dies zu Abfragefehlern führen kann, wenn Sie nicht auch `FORCE` verwenden, um andere Engine-Dialekte zu aktualisieren. Hier ein Beispiel: 

```
ALTER VIEW catalog_view FORCE ADD DIALECTAS
SELECT order_date, sum(totalprice) AS priceFROM source_tableGROUP BY orderdate;
```

 Unten wird gezeigt, wie Sie eine Ansicht ändern, um den Dialekt zu aktualisieren: 

```
ALTER VIEW catalog_view UPDATE DIALECT AS
SELECT count(*) FROM my_catalog.my_database.source_table;
```

 **DESCRIBE VIEW** 

 Verfügbare Syntax für die Beschreibung einer Ansicht: 

 `SHOW COLUMNS {FROM|IN} view_name [{FROM|IN} database_name]`— Wenn der Benutzer über die erforderlichen AWS Glue AWS Lake Formation Rechte zur Beschreibung der Ansicht verfügt, kann er die Spalten auflisten. Unten sehen Sie einige Beispielbefehle zum Anzeigen von Spalten: 

```
SHOW COLUMNS FROM my_database.source_table;    
SHOW COLUMNS IN my_database.source_table;
```

 `DESCRIBE view_name`— Wenn der Benutzer über die erforderlichen AWS Lake Formation Rechte AWS Glue und Berechtigungen zur Beschreibung der Ansicht verfügt, kann er die Spalten in der Ansicht zusammen mit ihren Metadaten auflisten. 

 **DROP VIEW** 

 Verfügbare Syntax: 

```
DROP VIEW [ IF EXISTS ] view_name
```

 Das folgende Beispiel zeigt eine `DROP`-Anweisung, die testet, ob eine Ansicht vorhanden ist, bevor sie gelöscht wird: 

```
DROP VIEW IF EXISTS catalog_view;
```

 `SHOW CREATE VIEW view_name` – Zeigt die SQL-Anweisung an, die die angegebene Ansicht erstellt. Dies ist ein Beispiel für das Erstellen einer Data-Catalog-Ansicht: 

```
SHOW CREATE TABLE my_database.catalog_view;CREATE PROTECTED MULTI DIALECT VIEW my_catalog.my_database.catalog_view (
  net_profit,
  customer_id,
  item_id,
  sold_date)
TBLPROPERTIES (
  'transient_lastDdlTime' = '1736267222')
SECURITY DEFINER AS SELECT * FROM
my_database.store_sales_partitioned_lf WHERE customer_id IN (SELECT customer_id from source_table limit 10)
```

 **SHOW VIEWS** 

 Listet alle Ansichten im Katalog auf, z. B. reguläre Ansichten, Ansichten mit mehreren Dialekten (Multi-Dialect Views, MDV) und MDV ohne Spark-Dialekt. Die verfügbare Syntax lautet wie folgt: 

```
SHOW VIEWS [{ FROM | IN } database_name] [LIKE regex_pattern]:
```

 Im Folgenden finden Sie einen Beispielbefehl zum Anzeigen von Ansichten: 

```
SHOW VIEWS IN marketing_analytics LIKE 'catalog_view*';
```

 Weitere Informationen zum Erstellen und Konfigurieren von Datenkatalogansichten finden Sie unter [Erstellen von AWS Glue Datenkatalogansichten](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html) im AWS Lake Formation Entwicklerhandbuch. 

## Abfrage einer Data-Catalog-Ansicht
<a name="catalog-view-query"></a>

 Nachdem Sie eine Data-Catalog-Ansicht erstellt haben, können Sie die Ansicht abfragen. Die in Ihren AWS Glue Jobs konfigurierte IAM-Rolle muss über die Lake Formation **SELECT-Berechtigung** in der Datenkatalogansicht verfügen. Sie müssen keinen Zugriff auf die zugrunde liegenden Tabellen gewähren, auf die in der Ansicht verwiesen wird. 

 Sobald Sie alles eingerichtet haben, können Sie Ihre Ansicht abfragen. Sie können beispielsweise folgende Abfrage ausführen, um auf eine Ansicht zuzugreifen. 

```
SELECT * from my_database.catalog_view LIMIT 10;
```

## Einschränkungen
<a name="catalog-view-limitations"></a>

 Berücksichtigen Sie die folgenden Einschränkungen, wenn Sie Data-Catalog-Ansichten verwenden. 
+  Sie können Datenkatalogansichten nur mit AWS Glue Version 5.0 und höher erstellen. 
+  Der Data-Catalog-Ansicht-Definer muss `SELECT`-Zugriff auf die zugrunde liegenden Basistabellen haben, auf die in der Ansicht zugegriffen wird. Das Erstellen der Data-Catalog-Ansicht schlägt fehl, wenn einer bestimmten Basistabelle Lake-Formation-Filter zugewiesen wurden, die der Definier-Rolle zugewiesen wurden. 
+  Basistabellen dürfen nicht über die `IAMAllowedPrincipals`-Data-Lake-Berechtigung in AWS Lake Formation verfügen. Falls vorhanden, tritt der Fehler **Multi Dialect views may only referenzed tables without IAMAllowed Principals permissions**. 
+  Der Amazon S3-Standort der Tabelle muss als AWS Lake Formation Data Lake-Standort registriert sein. Wenn die Tabelle nicht registriert ist, tritt der Fehler `Multi Dialect views may only reference AWS Lake Formation managed tables` auf. Informationen zur Registrierung von Amazon Amazon S3 S3-Standorten finden Sie unter [Registrierung eines Amazon S3 S3-Standorts](https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html) im AWS Lake Formation Entwicklerhandbuch. AWS Lake Formation
+  Sie können nur `PROTECTED`-Data-Catalog-Ansichten erstellen. `UNPROTECTED`-Ansichten werden nicht unterstützt. 
+  Sie können in einer Datenkatalog-View-Definition nicht auf Tabellen in einem anderen AWS Konto verweisen. Sie können auch nicht auf eine Tabelle in demselben Konto verweisen, das sich in einer separaten Region befindet. 
+  Um Daten konto- oder regionsübergreifend freizugeben, muss die gesamte Ansicht mithilfe von AWS Lake Formation -Ressourcenlinks konto- und regionsübergreifend freigegeben werden. 
+  Benutzerdefinierte Funktionen (UDFs) werden nicht unterstützt. 
+  In Data-Catalog-Ansichten kann nicht auf andere Ansichten verwiesen werden. 