* durch den Namen der Workflow-Rolle.
| Richtlinientyp | Richtlinie |
| --- | --- |
| AWS verwaltete Richtlinie | AWSGlueConsoleFullAccess |
| Inline-Richtlinie (grundlegend) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/permissions-reference.html) |
| Inline-Richtlinie (für Operationen an kontrollierten Tabellen, einschließlich Operationen innerhalb von Transaktionen) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/permissions-reference.html) |
| Inline-Richtlinie (für die Zugriffskontrolle auf Metadaten mithilfe der Tag-Based Access Control (LF-TBAC) -Methode von Lake Formation) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/permissions-reference.html) |
| Inline-Richtlinie (Passrolle-Richtlinie für die Workflow-Rolle) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/permissions-reference.html) |
### Berechtigungen für Datenanalysten
| Richtlinientyp | Richtlinie |
| --- | --- |
| AWS verwaltete Richtlinie | AmazonAthenaFullAccess |
| Inline-Richtlinie (grundlegend) | {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"glue:GetTable",
"glue:GetTables",
"glue:SearchTables",
"glue:GetDatabase",
"glue:GetDatabases",
"glue:GetPartitions",
"lakeformation:GetResourceLFTags",
"lakeformation:ListLFTags",
"lakeformation:GetLFTag",
"lakeformation:SearchTablesByLFTags",
"lakeformation:SearchDatabasesByLFTags"
],
"Resource": "*"
}
]
} |
| (Optional) Inline-Richtlinie (für Operationen an kontrollierten Tabellen, einschließlich Operationen innerhalb von Transaktionen) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/permissions-reference.html) |
### Berechtigungen für Workflow-Rollen
Diese Rolle verfügt über die erforderlichen Berechtigungen, um einen Workflow auszuführen. Sie geben eine Rolle mit diesen Berechtigungen an, wenn Sie einen Workflow erstellen.
**Wichtig**
**Ersetzen Sie in den folgenden Richtlinien durch eine gültige AWS Regionskennung (z. B.`us-east-1`), ** durch eine gültige AWS Kontonummer, ** durch den Namen der Workflow-Rolle und ** durch den Amazon S3-Pfad zu Ihren AWS CloudTrail Protokollen.
| Richtlinientyp | Richtlinie |
| --- | --- |
| AWS verwaltete Richtlinie | AWSGlueServiceRole |
| Inline-Richtlinie (Datenzugriff) | {
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Lakeformation",
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess",
"lakeformation:GrantPermissions"
],
"Resource": "*"
}
]
} |
| Inline-Richtlinie (Passrolle-Richtlinie für die Workflow-Rolle) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/permissions-reference.html) |
| Inline-Richtlinie (für die Aufnahme von Daten außerhalb des Data Lake, AWS CloudTrail z. B. Logs) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/permissions-reference.html) |
# Ändern der Standardeinstellungen für Ihren Data Lake
Um die Abwärtskompatibilität mit zu gewährleistenAWS Glue, AWS Lake Formation verfügt über die folgenden anfänglichen Sicherheitseinstellungen:
+ Die `Super` Berechtigung wird der Gruppe `IAMAllowedPrincipals` für alle vorhandenen AWS Glue Datenkatalogressourcen erteilt.
+ Die Einstellungen „Nur IAM-Zugriffskontrolle verwenden“ sind für neue Datenkatalogressourcen aktiviert.
Diese Einstellungen bewirken, dass der Zugriff auf Datenkatalogressourcen und Amazon S3 S3-Standorte ausschließlich durch AWS Identity and Access Management (IAM-) Richtlinien gesteuert wird. Individuelle Genehmigungen für Lake Formation sind nicht gültig.
Die `IAMAllowedPrincipals` Gruppe umfasst alle IAM-Benutzer und -Rollen, denen aufgrund Ihrer IAM-Richtlinien Zugriff auf Ihre Datenkatalogressourcen gewährt wird. Die `Super` Berechtigung ermöglicht es einem Prinzipal, jeden unterstützten Lake Formation Formation-Vorgang in der Datenbank oder Tabelle auszuführen, für die sie erteilt wurde.
Gehen Sie wie folgt vor, um die Sicherheitseinstellungen so zu ändern, dass der Zugriff auf Datenkatalogressourcen (Datenbanken und Tabellen) über Lake Formation Formation-Berechtigungen verwaltet wird:
1. Ändern Sie die Standardsicherheitseinstellungen für neue Ressourcen. Detaillierte Anweisungen finden Sie unter [Ändern Sie das Standardberechtigungsmodell oder verwenden Sie den hybriden Zugriffsmodus](initial-lf-config.md#setup-change-cat-settings).
1. Ändern Sie die Einstellungen für vorhandene Datenkatalogressourcen. Detaillierte Anweisungen finden Sie unter [AWS GlueDatenberechtigungen für das AWS Lake Formation Modell aktualisieren](upgrade-glue-lake-formation.md).
**Ändern der Standardsicherheitseinstellungen mithilfe des Lake Formation `PutDataLakeSettings` API-Vorgangs**
Sie können die Standardsicherheitseinstellungen auch mithilfe des Lake Formation [PutDataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_PutDataLakeSettings.html)API-Vorgangs ändern. Diese Aktion verwendet als Argumente eine optionale Katalog-ID und eine [DataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_DataLakeSettings.html)Struktur.
Um Metadaten und die zugrundeliegende Datenzugriffskontrolle durch Lake Formation für neue Datenbanken und Tabellen durchzusetzen, codieren Sie die `DataLakeSettings` Struktur wie folgt.
**Anmerkung**
**Ersetzen Sie es durch eine gültige AWS Konto-ID und ** einen gültigen IAM-Benutzernamen. Sie können mehr als einen Benutzer als Data Lake-Administrator angeben.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
],
"CreateDatabaseDefaultPermissions": [],
"CreateTableDefaultPermissions": []
}
}
```
Sie können die Struktur auch wie folgt codieren. Das Weglassen des `CreateTableDefaultPermissions` Parameters `CreateDatabaseDefaultPermissions` oder entspricht der Übergabe einer leeren Liste.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
]
}
}
```
Durch diese Aktion werden der `IAMAllowedPrincipals` Gruppe effektiv alle Lake Formation Formation-Berechtigungen für neue Datenbanken und Tabellen entzogen. Wenn Sie eine Datenbank erstellen, können Sie diese Einstellung überschreiben.
Um Metadaten und die zugrundeliegende Datenzugriffskontrolle nur durch IAM für neue Datenbanken und Tabellen durchzusetzen, codieren Sie die `DataLakeSettings` Struktur wie folgt.
```
{
"DataLakeSettings": {
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam:::user/"
}
],
"CreateDatabaseDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
],
"CreateTableDefaultPermissions": [
{
"Principal": {
"DataLakePrincipalIdentifier": "IAM_ALLOWED_PRINCIPALS"
},
"Permissions": [
"ALL"
]
}
]
}
}
```
Dadurch erhält die `IAMAllowedPrincipals` Gruppe `Super` Lake Formation die Erlaubnis, neue Datenbanken und Tabellen zu verwenden. Wenn Sie eine Datenbank erstellen, können Sie diese Einstellung überschreiben.
**Anmerkung**
In der vorherigen `DataLakeSettings` Struktur ist der einzig zulässige Wert für `DataLakePrincipalIdentifier` ist`IAM_ALLOWED_PRINCIPALS`, und der einzig zulässige Wert für `Permissions` ist`ALL`.
# Implizite Lake Formation Formation-Berechtigungen
AWS Lake Formation gewährt Data Lake-Administratoren, Datenbankerstellern und Tabellenerstellern die folgenden impliziten Berechtigungen.
**Data Lake-Administratoren**
+ Sie haben `Describe` Zugriff auf alle Ressourcen im Datenkatalog, mit Ausnahme von Ressourcen, die von einem anderen Konto direkt für einen anderen Principal freigegeben wurden. Dieser Zugriff kann einem Administrator nicht entzogen werden.
+ Verfügen Sie überall im Data Lake über Berechtigungen zum Speicherort von Daten.
+ Kann jedem Prinzipal (auch sich selbst) Zugriff auf alle Ressourcen im Datenkatalog gewähren oder entziehen. Dieser Zugriff kann einem Administrator nicht entzogen werden.
+ Kann Datenbanken im Datenkatalog erstellen.
+ Kann einem anderen Benutzer die Erlaubnis erteilen, eine Datenbank zu erstellen.
Data Lake-Administratoren können Amazon S3 S3-Standorte nur registrieren, wenn sie über die entsprechenden IAM-Berechtigungen verfügen. Die in diesem Handbuch empfohlenen Data Lake-Administratorrichtlinien gewähren diese Berechtigungen. Außerdem verfügen Data Lake-Administratoren nicht über implizite Berechtigungen zum Löschen von Datenbanken oder alter/drop Tabellen, die von anderen erstellt wurden. Sie können sich jedoch selbst die entsprechenden Berechtigungen gewähren.
Weitere Informationen zu Data Lake-Administratoren finden Sie unter[Erstellen Sie einen Data Lake-Administrator](initial-lf-config.md#create-data-lake-admin).
**Ersteller des Katalogs**
+ Sie verfügen über alle Katalogberechtigungen für Kataloge, die sie erstellen, verfügen über Berechtigungen für Datenbanken und Tabellen, die sie im Katalog erstellen, und können anderen Hauptbenutzern desselben AWS Kontos die Berechtigung erteilen, Datenbanken und Tabellen im Katalog zu erstellen. Ein Katalogersteller, der auch über die `AWSLakeFormationCrossAccountManager` AWS verwaltete Richtlinie verfügt, kann anderen AWS Konten oder Organisationen Berechtigungen für den Katalog gewähren.
Data Lake-Administratoren können die Lake Formation Formation-Konsole oder die API verwenden, um Katalogersteller zu benennen.
**Anmerkung**
Katalogersteller verfügen nicht implizit über Berechtigungen für Datenbanken und Tabellen, die andere Benutzer im Katalog erstellen.
Weitere Informationen zum Erstellen von Katalogen finden Sie unter. [Bringen Sie Ihre Daten in die AWS Glue Data Catalog](bring-your-data-overview.md)
**Ersteller von Datenbanken**
+ Sie verfügen über alle Datenbankberechtigungen für Datenbanken, die sie erstellen, verfügen über Berechtigungen für Tabellen, die sie in der Datenbank erstellen, und können anderen Prinzipalen in demselben AWS Konto die Berechtigung erteilen, Tabellen in der Datenbank zu erstellen. Ein Datenbankersteller, der auch über die `AWSLakeFormationCrossAccountManager` AWS verwaltete Richtlinie verfügt, kann anderen AWS Konten oder Organisationen Berechtigungen für die Datenbank gewähren.
Data Lake-Administratoren können die Lake Formation Formation-Konsole oder die API verwenden, um Datenbankersteller zu benennen.
**Anmerkung**
Datenbankersteller verfügen nicht implizit über Berechtigungen für Tabellen, die andere Benutzer in der Datenbank erstellen.
Weitere Informationen finden Sie unter [Erstellen einer Datenbank](creating-database.md).
**Ersteller von Tabellen**
+ Sie verfügen über alle Berechtigungen für Tabellen, die sie erstellen.
+ Kann Prinzipalen im selben AWS Konto Berechtigungen für alle von ihnen erstellten Tabellen gewähren.
+ Kann anderen AWS Konten oder Organisationen Berechtigungen für alle von ihnen erstellten Tabellen gewähren, wenn diese über die `AWSLakeFormationCrossAccountManager` AWS verwaltete Richtlinie verfügen.
+ Kann die Datenbanken anzeigen, die die von ihnen erstellten Tabellen enthalten.
# Referenz zu den Genehmigungen von Lake Formation
Zur Ausführung von AWS Lake Formation Vorgängen benötigen Principals sowohl Lake Formation Formation-Berechtigungen als auch AWS Identity and Access Management (IAM) -Berechtigungen. In der Regel gewähren Sie IAM-Berechtigungen mithilfe von *groben Zugriffskontrollrichtlinien, wie unter beschrieben*. [Überblick über die Genehmigungen für Lake Formation](lf-permissions-overview.md) Sie können Lake Formation Formation-Berechtigungen mithilfe der Konsole, der API oder der AWS Command Line Interface (AWS CLI) gewähren.
Informationen zum Erteilen oder Widerrufen Lake Formation Formation-Berechtigungen finden Sie unter [Erteilen von Berechtigungen für Datenkatalogressourcen](granting-catalog-permissions.md) und[Erteilung von Berechtigungen zum Speicherort von Daten](granting-location-permissions.md).
**Anmerkung**
Die Beispiele in diesem Abschnitt zeigen, wie Prinzipalen im selben AWS Konto Berechtigungen erteilt werden. Beispiele für kontenübergreifende Zuschüsse finden Sie unter. [Kontoübergreifender Datenaustausch in Lake Formation](cross-account-permissions.md)
## Lake Formation Formation-Berechtigungen pro Ressourcentyp
Im Folgenden sind die gültigen Lake Formation Formation-Berechtigungen aufgeführt, die für jeden Ressourcentyp verfügbar sind:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/lf-permissions-reference.html)
**Topics**
+ [Lake Formation Formation-Berechtigungen pro Ressourcentyp](#lf-resource-permissions-summary)
+ [Lake Formation erteilt und widerruft AWS CLI Befehle](#perm-command-format)
+ [Lake-Formation-Berechtigungen](#lf-permissions)
## Lake Formation erteilt und widerruft AWS CLI Befehle
Jede Berechtigungsbeschreibung in diesem Abschnitt enthält Beispiele für die Erteilung der Berechtigung mithilfe eines AWS CLI Befehls. Im Folgenden finden Sie die Zusammenfassungen der Lake Formation **grant-permissions** und **revoke-permissions** AWS CLI der Befehle.
```
grant-permissions
[--catalog-id ]
--principal
--resource
--permissions
[--permissions-with-grant-option ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
```
revoke-permissions
[--catalog-id ]
--principal
--resource
--permissions
[--permissions-with-grant-option ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
*Eine ausführliche Beschreibung dieser Befehle finden Sie unter [grant-permissions und [revoke-permissions](https://docs.aws.amazon.com/cli/latest/reference/lakeformation/revoke-permissions.html)](https://docs.aws.amazon.com/cli/latest/reference/lakeformation/grant-permissions.html) in der Befehlsreferenz.AWS CLI * Dieser Abschnitt enthält zusätzliche Informationen zu dieser Option. `--principal`
Der Wert der `--principal` Option ist einer der folgenden:
+ Amazon-Ressourcenname (ARN) für einen AWS Identity and Access Management (IAM) -Benutzer oder eine Rolle
+ ARN für einen Benutzer oder eine Gruppe, die sich über einen SAML-Anbieter wie Microsoft Active Directory Federation Service (AD FS) authentifiziert
+ ARN für einen Amazon Quick-Benutzer oder eine Gruppe
+ Für kontoübergreifende Berechtigungen eine AWS Konto-ID, eine Organisations-ID oder eine Organisationseinheits-ID
+ Für IAM Identity Center-Benutzer oder -Gruppe, ARN für IAM Identity Center-Benutzer oder -Gruppe.
Im Folgenden finden Sie Syntax und Beispiele für alle `--principal` Typen.
**Principal ist ein IAM-Benutzer**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::user/
```
Beispiel:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1
```
**Principal ist eine IAM-Rolle**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::role/
```
Beispiel:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:role/workflowrole
```
**Principal ist ein Benutzer, der sich über einen SAML-Anbieter authentifiziert**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::saml-provider/:user/
```
Beispiele:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/idp1:user/datalake_user1
```
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/AthenaLakeFormationOkta:user/athena-user@example.com
```
**Principal ist eine Gruppe, die sich über einen SAML-Anbieter authentifiziert**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam:::saml-provider/:group/
```
Beispiele:
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/idp1:group/data-scientists
```
```
--principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:saml-provider/AthenaLakeFormationOkta:group/my-group
```
**Principal ist ein Benutzer der Amazon Quick Enterprise Edition**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:::user//
```
Für ** müssen Sie `default` angeben.
Beispiel:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:us-east-1:111122223333:user/default/bi_user1
```
**Principal ist eine Amazon Quick Enterprise Edition-Gruppe**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:::group//
```
Für ** müssen Sie `default` angeben.
Beispiel:
```
--principal DataLakePrincipalIdentifier=arn:aws:quicksight:us-east-1:111122223333:group/default/data_scientists
```
**Principal ist ein AWS Konto**
Syntax:
```
--principal DataLakePrincipalIdentifier=
```
Beispiel:
```
--principal DataLakePrincipalIdentifier=111122223333
```
**Principal ist eine Organisation**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations:::organization/
```
Beispiel:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations::111122223333:organization/o-abcdefghijkl
```
**Principal ist eine Organisationseinheit**
Syntax:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations:::ou//
```
Beispiel:
```
--principal DataLakePrincipalIdentifier=arn:aws:organizations::111122223333:ou/o-abcdefghijkl/ou-ab00-cdefghij
```
**Principal ist ein IAM Identity Center-Identitätsbenutzer oder eine Identitätsgruppe**
Beispiel: Benutzer
```
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::user/
```
Beispiel: Gruppe:
```
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::group/
```
**Principal ist eine IAM-Gruppe - `IAMAllowedPrincipals`**
Lake Formation legt einer Gruppe, die `IAMAllowedPrincipals` standardmäßig aufgerufen wird, `Super` Berechtigungen für alle Datenbanken und Tabellen im Datenkatalog fest. Wenn diese Gruppenberechtigung für eine Datenbank oder eine Tabelle existiert, haben alle Prinzipale in Ihrem Konto über die IAM-Prinzipalrichtlinien für Zugriff auf die Ressource. AWS Glue Es bietet Abwärtskompatibilität, wenn Sie beginnen, Lake Formation Formation-Berechtigungen zu verwenden, um die Datenkatalogressourcen zu sichern, für die zuvor durch IAM-Richtlinien geschützt waren. AWS Glue
Wenn Sie Lake Formation verwenden, um Berechtigungen für Ihre Data Catalog-Ressourcen zu verwalten, müssen Sie zuerst die `IAMAllowedPrincipals` Berechtigungen für die Ressourcen widerrufen oder die Principals und die Ressourcen für den Hybridzugriffsmodus aktivieren, damit die Lake Formation Formation-Berechtigungen funktionieren.
Beispiel:
```
--principal DataLakePrincipalIdentifier=IAM_Allowed_Principals
```
**Principal ist eine IAM-Gruppe - `ALLIAMPrincipals`**
Wenn Sie `ALLIAMPrincipals` Gruppenberechtigungen für eine Datenkatalogressource gewähren, erhält jeder Prinzipal im Konto mithilfe von Lake Formation Formation-Berechtigungen und IAM-Berechtigungen Zugriff auf die Datenkatalogressource.
Beispiel:
```
--principal DataLakePrincipalIdentifier=123456789012:IAMPrincipals
```
## Lake-Formation-Berechtigungen
Dieser Abschnitt enthält die verfügbaren Lake Formation Formation-Berechtigungen, die Sie Principals gewähren können.
### `ALTER`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| ALTER | DATABASE | glue:UpdateDatabase |
| ALTER | TABLE | glue:UpdateTable |
| ALTER | LF-Tag | lakeformation:UpdateLFTag |
Ein Principal mit dieser Berechtigung kann Metadaten für eine Datenbank oder Tabelle im Datenkatalog ändern. Bei Tabellen können Sie das Spaltenschema ändern und Spaltenparameter hinzufügen. Sie können keine Spalten in den zugrunde liegenden Daten ändern, auf die eine Metadatentabelle verweist.
Wenn es sich bei der Eigenschaft, die geändert wird, um einen registrierten Amazon Simple Storage Service (Amazon S3) -Standort handelt, muss der Principal über Datenstandortberechtigungen für den neuen Standort verfügen.
**Example**
Im folgenden Beispiel wird dem Benutzer die `ALTER` Berechtigung für die Datenbank `datalake_user1` `retail` im AWS Konto 1111-2222-3333 erteilt.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ALTER" --resource '{ "Database": {"Name":"retail"}}'
```
**Example**
Das folgende Beispiel erteilt einem Benutzer Zugriff `datalake_user1` auf `ALTER` die Tabelle in der Datenbank. `inventory` `retail`
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ALTER" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
### `CREATE_DATABASE`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| CREATE\$1DATABASE | Data Catalog | glue:CreateDatabase |
Ein Principal mit dieser Berechtigung kann eine Metadatendatenbank oder einen Ressourcenlink im Datenkatalog erstellen. Der Principal kann auch Tabellen in der Datenbank erstellen.
**Example**
Das folgende Beispiel gewährt dem Benutzer `CREATE_DATABASE` das AWS Konto `datalake_user1` 1111-2222-3333.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "CREATE_DATABASE" --resource '{ "Catalog": {}}'
```
Wenn ein Principal eine Datenbank im Datenkatalog erstellt, werden keine Berechtigungen für die zugrunde liegenden Daten gewährt. Die folgenden zusätzlichen Metadatenberechtigungen werden gewährt (zusammen mit der Möglichkeit, diese Berechtigungen anderen zu gewähren):
+ `CREATE_TABLE`in der Datenbank
+ `ALTER`-Datenbank
+ `DROP`-Datenbank
Beim Erstellen einer Datenbank kann der Principal optional einen Amazon S3 S3-Standort angeben. Je nachdem, ob der Prinzipal über Datenspeicherberechtigungen verfügt, reicht die `CREATE_DATABASE` Berechtigung möglicherweise nicht in allen Fällen aus, um Datenbanken zu erstellen. Es ist wichtig, die folgenden drei Fälle zu berücksichtigen.
| Erstellen Sie einen Datenbank-Anwendungsfall | Berechtigungen erforderlich |
| --- | --- |
| Die Standorteigenschaft ist nicht spezifiziert. | CREATE\$1DATABASEist ausreichend. |
| Die Standorteigenschaft ist angegeben, und der Standort wird nicht von Lake Formation verwaltet (ist nicht registriert). | CREATE\$1DATABASEist ausreichend. |
| Die Standorteigenschaft ist angegeben, und der Standort wird von Lake Formation verwaltet (ist registriert). | CREATE\$1DATABASEist erforderlich, zuzüglich der Berechtigungen für den Datenspeicherort für den angegebenen Standort. |
### `CREATE_TABLE`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| CREATE\$1TABLE | DATABASE | glue:CreateTable |
Ein Principal mit dieser Berechtigung kann eine Metadatentabelle oder einen Ressourcenlink im Datenkatalog innerhalb der angegebenen Datenbank erstellen.
**Example**
Im folgenden Beispiel wird dem Benutzer die `datalake_user1` Berechtigung erteilt, Tabellen in der `retail` Datenbank im AWS Konto 1111-2222-3333 zu erstellen.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1
--permissions "CREATE_TABLE" --resource '{ "Database": {"Name":"retail"}}'
```
Wenn ein Principal eine Tabelle im Datenkatalog erstellt, werden dem Prinzipal alle Lake Formation Formation-Berechtigungen für die Tabelle gewährt, mit der Möglichkeit, diese Berechtigungen anderen zu gewähren.
**Kontoübergreifende Zuschüsse**
Wenn ein Datenbankeigentümerkonto einem Empfängerkonto Zuschüsse gewährt `CREATE_TABLE` und ein Benutzer des Empfängerkontos erfolgreich eine Tabelle in der Datenbank des Besitzerkontos erstellt, gelten die folgenden Regeln:
+ Der Benutzer und die Data Lake-Administratoren im Empfängerkonto verfügen über alle Lake Formation Formation-Berechtigungen für die Tabelle. Sie können anderen Principals in ihrem Konto Berechtigungen für die Tabelle gewähren. Sie können Prinzipalen im Besitzerkonto oder in anderen Konten keine Berechtigungen erteilen.
+ Data Lake-Administratoren im Besitzerkonto können anderen Prinzipalen in ihrem Konto Berechtigungen für die Tabelle gewähren.
**Berechtigungen zum Speicherort von Daten**
Wenn Sie versuchen, eine Tabelle zu erstellen, die auf einen Amazon S3 S3-Standort verweist, reicht die `CREATE_TABLE` Berechtigung möglicherweise nicht aus, um eine Tabelle zu erstellen, je nachdem, ob Sie über Datenstandortberechtigungen verfügen. Es ist wichtig, die folgenden drei Fälle zu berücksichtigen.
| Erstellen Sie einen Anwendungsfall für Tabellen | Berechtigungen erforderlich |
| --- | --- |
| Der angegebene Standort wird nicht von Lake Formation verwaltet (ist nicht registriert). | CREATE\$1TABLEist ausreichend. |
| Der angegebene Standort wird von Lake Formation verwaltet (ist registriert), und die enthaltende Datenbank hat keine Standorteigenschaft oder eine Standorteigenschaft, die kein Amazon S3 S3-Präfix des Tabellenstandorts ist. | CREATE\$1TABLEist erforderlich plus Datenspeicherberechtigungen für den angegebenen Standort. |
| Der angegebene Standort wird von Lake Formation verwaltet (ist registriert), und die enthaltende Datenbank hat eine Standorteigenschaft, die auf einen registrierten Standort verweist und ein Amazon S3 S3-Präfix des Tabellenstandorts ist. | CREATE\$1TABLEist ausreichend. |
### `DATA_LOCATION_ACCESS`
| Berechtigung | Auf dieser Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| DATA\$1LOCATION\$1ACCESS | Amazon-S3-Speicherort | (Amazon S3 S3-Berechtigungen für den Standort, die durch die Rolle angegeben werden müssen, die für die Registrierung des Standorts verwendet wurde.) |
Dies ist die einzige Berechtigung zum Speicherort von Daten. Ein Principal mit dieser Berechtigung kann eine Metadaten-Datenbank oder -Tabelle erstellen, die auf den angegebenen Amazon S3 S3-Speicherort verweist. Der Standort muss registriert sein. Ein Principal, der über Datenspeicherberechtigungen für einen Standort verfügt, verfügt auch über Standortberechtigungen für untergeordnete Standorte.
**Example**
Im folgenden Beispiel werden dem Benutzer `datalake_user1` im AWS Konto 1111-2222-3333 Berechtigungen `s3://products/retail` zum Speicherort von Daten erteilt.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DATA_LOCATION_ACCESS" --resource '{ "DataLocation": {"ResourceArn":"arn:aws:s3:::products/retail"}}'
```
`DATA_LOCATION_ACCESS`ist nicht erforderlich, um die zugrunde liegenden Daten abzufragen oder zu aktualisieren. Diese Berechtigung gilt nur für das Erstellen von Datenkatalogressourcen.
Weitere Informationen zu Berechtigungen zum Speicherort von Daten finden Sie unter[Underlying data access control](access-control-underlying-data.md#data-location-permissions).
### `DELETE`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| DELETE | TABLE | (Wenn der Standort registriert ist, sind keine zusätzlichen IAM-Berechtigungen erforderlich.) |
Ein Principal mit dieser Berechtigung kann die zugrunde liegenden Daten an dem in der Tabelle angegebenen Amazon S3 S3-Standort einfügen, aktualisieren und lesen. Der Principal kann die Tabelle auch in der Lake Formation Formation-Konsole anzeigen und Informationen über die Tabelle mit der AWS Glue API abrufen.
**Example**
Im folgenden Beispiel wird dem Benutzer die `DELETE` Berechtigung für die Tabelle `inventory` in `datalake_user1` der Datenbank `retail` im AWS Konto 1111-2222-3333 erteilt.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DELETE" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Diese Berechtigung gilt nur für Daten in Amazon S3 und nicht für Daten in anderen Datenspeichern wie Amazon Relational Database Service (Amazon RDS).
### `DESCRIBE`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| DESCRIBE | Link zur Tabellenressource Link zur Datenbankressource | `glue:GetTable` `glue:GetDatabase` |
| DESCRIBE | DATABASE | glue:GetDatabase |
| DESCRIBE | TABLE | glue:GetTable |
| DESCRIBE | LF-Tag | `glue:GetTable` `glue:GetDatabase` `lakeformation:GetResourceLFTags` `lakeformation:ListLFTags` `lakeformation:GetLFTag` `lakeformation:SearchTablesByLFTags` `lakeformation:SearchDatabasesByLFTags` |
Ein Principal mit dieser Berechtigung kann die angegebene Datenbank, Tabelle oder den angegebenen Ressourcenlink anzeigen. Es werden keine anderen Datenkatalogberechtigungen implizit gewährt, und es werden keine Datenzugriffsberechtigungen implizit gewährt. Datenbanken und Tabellen werden in den Abfrage-Editoren integrierter Services angezeigt, aber es können keine Abfragen an sie gestellt werden, sofern nicht andere Lake Formation Formation-Berechtigungen (z. B.`SELECT`) erteilt wurden.
Beispielsweise kann ein Benutzer, der `DESCRIBE` über eine Datenbank verfügt, die Datenbank und alle Datenbankmetadaten (Beschreibung, Speicherort usw.) sehen. Der Benutzer kann jedoch nicht herausfinden, welche Tabellen die Datenbank enthält, und er kann keine Tabellen in der Datenbank löschen, ändern oder erstellen. Ebenso kann ein Benutzer, der `DESCRIBE` über eine Tabelle verfügt, die Tabelle und die Tabellenmetadaten (Beschreibung, Schema, Speicherort usw.) sehen, aber keine Abfragen für die Tabelle löschen, ändern oder ausführen.
Im Folgenden finden Sie einige zusätzliche Regeln für`DESCRIBE`:
+ Wenn ein Benutzer andere Lake Formation Formation-Berechtigungen für eine Datenbank, Tabelle oder einen Ressourcenlink hat, `DESCRIBE` wird dies implizit gewährt.
+ Wenn ein Benutzer nur `SELECT` über eine Teilmenge von Spalten für eine Tabelle verfügt (teilweise`SELECT`), kann der Benutzer nur diese Spalten sehen.
+ Einem Benutzer`DESCRIBE`, der in einer Tabelle nur teilweise eine Auswahl getroffen hat, können Sie keine Zugriffsrechte gewähren. Umgekehrt können Sie für Tabellen, für die eine Erteilung gewährt wurde, keine Liste mit Aufnahme- oder Ausschlusslisten für Spalten angeben. `DESCRIBE`
**Example**
Im folgenden Beispiel wird dem Benutzer `datalake_user1` die `DESCRIBE` Berechtigung für den Link zur Tabellenressource `inventory-link` in der Datenbank `retail` im AWS Konto 1111-2222-3333 erteilt.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DESCRIBE" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory-link"}}'
```
### `DROP`
| Berechtigung | Für diese Ressource erteilt | Der Stipendiat braucht auch |
| --- | --- | --- |
| DROP | DATABASE | glue:DeleteDatabase |
| DROP | TABLE | glue:DeleteTable |
| DROP | LF-Tag | lakeformation:DeleteLFTag |
| DROP | Link zur Datenbankressource Link zur Tabellenressource | `glue:DeleteDatabase` `glue:DeleteTable` |
Ein Principal mit dieser Berechtigung kann einen Datenbank-, Tabellen- oder Ressourcenlink im Datenkatalog löschen. Sie können DROP für eine Datenbank nicht einem externen Konto oder einer externen Organisation gewähren.
**Warnung**
Beim Löschen einer Datenbank werden alle Tabellen in der Datenbank gelöscht.
**Example**
Im folgenden Beispiel wird dem Benutzer die `DROP` Berechtigung für die Datenbank `datalake_user1` `retail` im AWS Konto 1111-2222-3333 erteilt.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Database": {"Name":"retail"}}'
```
**Example**
Das folgende Beispiel erteilt dem Benutzer `DROP` Zugriff `datalake_user1` auf die Tabelle in der Datenbank. `inventory` `retail`
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
**Example**
Im folgenden Beispiel wird `DROP` dem Benutzer für `datalake_user1` die Tabelle ein Ressourcenlink `inventory-link` in der Datenbank gewährt`retail`.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "DROP" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory-link"}}'
```
### `INSERT`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| INSERT | TABLE | (Wenn der Standort registriert ist, sind keine zusätzlichen IAM-Berechtigungen erforderlich.) |
Ein Principal mit dieser Berechtigung kann die zugrunde liegenden Daten an dem in der Tabelle angegebenen Amazon S3 S3-Standort einfügen, aktualisieren und lesen. Der Principal kann die Tabelle auch in der Lake Formation Formation-Konsole anzeigen und Informationen über die Tabelle mit der AWS Glue API abrufen.
**Example**
Im folgenden Beispiel wird dem Benutzer die `INSERT` Berechtigung für die Tabelle `inventory` in `datalake_user1` der Datenbank `retail` im AWS Konto 1111-2222-3333 erteilt.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "INSERT" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Diese Berechtigung gilt nur für Daten in Amazon S3 und nicht für Daten in anderen Datenspeichern wie Amazon RDS.
### `SELECT`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| SELECT | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/lf-permissions-reference.html) | (Wenn der Standort registriert ist, sind keine zusätzlichen IAM-Berechtigungen erforderlich.) |
Ein Principal mit dieser Berechtigung kann eine Tabelle im Datenkatalog anzeigen und die zugrunde liegenden Daten in Amazon S3 an dem in der Tabelle angegebenen Speicherort abfragen. Der Principal kann die Tabelle in der Lake Formation Formation-Konsole anzeigen und Informationen über die Tabelle mit der AWS Glue API abrufen. Wenn bei der Erteilung dieser Berechtigung eine Spaltenfilterung angewendet wurde, kann der Principal die Metadaten nur für die enthaltenen Spalten anzeigen und nur Daten aus den enthaltenen Spalten abfragen.
**Anmerkung**
Es liegt in der Verantwortung des integrierten Analysedienstes, die Spaltenfilterung bei der Verarbeitung einer Abfrage anzuwenden.
**Example**
Im folgenden Beispiel wird dem Benutzer die `SELECT` Berechtigung für die Tabelle `inventory` in `datalake_user1` der Datenbank `retail` im AWS Konto 1111-2222-3333 erteilt.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "Table": {"DatabaseName":"retail", "Name":"inventory"}}'
```
Diese Berechtigung gilt nur für Daten in Amazon S3 und nicht für Daten in anderen Datenspeichern wie Amazon RDS.
Sie können bestimmte Spalten mit einer optionalen Aufnahme- oder Ausschlussliste filtern (den Zugriff darauf einschränken). Eine Aufnahmeliste gibt die Spalten an, auf die zugegriffen werden kann. Eine Ausschlussliste gibt die Spalten an, auf die nicht zugegriffen werden kann. In Ermangelung einer Aufnahme- oder Ausschlussliste sind alle Tabellenspalten zugänglich.
Die Ergebnisse von `glue:GetTable` geben nur die Spalten zurück, zu deren Anzeige der Aufrufer berechtigt ist. Integrierte Dienste wie Amazon Athena und Amazon Redshift berücksichtigen Spalten mit Ein- und Ausschlusslisten.
**Example**
Das folgende Beispiel gewährt `SELECT` dem Benutzer `datalake_user1` in der Tabelle `inventory` mithilfe einer Aufnahmeliste Zuteilungen.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "TableWithColumns": {"DatabaseName":"retail", "Name":"inventory", "ColumnNames": ["prodcode","location","period","withdrawals"]}}'
```
**Example**
Im nächsten Beispiel wird mithilfe einer Ausschlussliste für die `inventory` Tabelle gewährt`SELECT`.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "SELECT" --resource '{ "TableWithColumns": {"DatabaseName":"retail", "Name":"inventory", "ColumnWildcard": {"ExcludedColumnNames": ["intkey", "prodcode"]}}}'
```
Für die `SELECT` Genehmigung gelten die folgenden Einschränkungen:
+ Bei der Erteilung `SELECT` können Sie die Option „Gewährung“ nicht angeben, wenn die Spaltenfilterung angewendet wird.
+ Sie können die Zugriffskontrolle nicht auf Spalten einschränken, bei denen es sich um Partitionsschlüssel handelt.
+ Einem Prinzipal mit der `SELECT` Berechtigung für eine Teilmenge von Spalten in einer Tabelle kann die`ALTER`, `DROP``DELETE`, oder `INSERT` -Berechtigung für diese Tabelle nicht erteilt werden. Ebenso kann einem Prinzipal mit der `INSERT` Berechtigung `ALTER` `DROP``DELETE`,, oder für eine Tabelle die `SELECT` Berechtigung zur Spaltenfilterung nicht erteilt werden.
Die `SELECT` Berechtigung wird auf der Seite **Datenberechtigungen** der Lake Formation Formation-Konsole immer als separate Zeile angezeigt. Die folgende Abbildung zeigt, `SELECT` dass sie den Benutzern `datalake_user2` und in `datalake_user3` allen Spalten der `inventory` Tabelle gewährt wird.
![\[Die Seite mit den Datenberechtigungen zeigt vier Zeilen. In der ersten und dritten Zeile sind die Berechtigungen Löschen und Einfügen mit dem Ressourcentyp Tabelle aufgeführt, wobei die Ressource als Inventar angezeigt wird, und in der zweiten und vierten Zeile die Auswahlberechtigung mit dem Ressourcentyp Spalte und mit der Ressource retail.inventory.*.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/data-permissions-dialog-select-cross.png)
### `Super`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| Super | DATABASE | glue:\$1Database\$1 |
| Super | TABLE | glue:\$1Table\$1, glue:\$1Partition\$1 |
Diese Berechtigung ermöglicht es einem Principal, jeden unterstützten Lake Formation Formation-Vorgang in der Datenbank oder Tabelle auszuführen. Sie können einem externen Konto keinen Zugriff `Super` auf eine Datenbank gewähren.
Diese Genehmigung kann mit den anderen Lake Formation Formation-Berechtigungen koexistieren. Sie können beispielsweise die `INSERT` Berechtigungen `Super``SELECT`, und für eine Metadatentabelle gewähren. Der Principal kann dann alle unterstützten Operationen an der Tabelle ausführen. Beim Widerrufen `Super` bleiben die `INSERT` Berechtigungen `SELECT` und erhalten, und der Prinzipal kann nur Auswahl- und Einfügevorgänge ausführen.
Anstatt es einem einzelnen Prinzipal `Super` zu gewähren, können Sie es der Gruppe gewähren`IAMAllowedPrincipals`. Die `IAMAllowedPrincipals` Gruppe wird automatisch erstellt und umfasst alle IAM-Benutzer und -Rollen, denen gemäß Ihren IAM-Richtlinien Zugriff auf Ihre Datenkatalogressourcen gewährt wird. Wenn `IAMAllowedPrincipals` für eine Datenkatalogressource ein Zugriff gewährt `Super` wird, wird der Zugriff auf die Ressource effektiv ausschließlich durch IAM-Richtlinien gesteuert.
Sie können die automatische `Super` Genehmigung `IAMAllowedPrincipals` für neue Katalogressourcen erhalten, indem Sie die Optionen auf der **Einstellungsseite** der Lake Formation Formation-Konsole nutzen.
![\[Das Dialogfeld mit den Datenkatalogeinstellungen hat den Untertitel „Standardberechtigungen für neu erstellte Datenbanken und Tabellen“ und verfügt über zwei Kontrollkästchen, die im Text beschrieben werden.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/settings-page.png)
+ Um allen neuen Datenbanken Zugriff `Super` `IAMAllowedPrincipals` zu gewähren, wählen Sie **Nur IAM-Zugriffskontrolle für neue Datenbanken verwenden** aus.
+ Um allen neuen Tabellen in neuen Datenbanken Zugriff `Super` zu `IAMAllowedPrincipals` gewähren, wählen Sie **Nur IAM-Zugriffskontrolle für neue Tabellen in neuen Datenbanken verwenden** aus.
**Anmerkung**
Diese Option bewirkt, dass das Kontrollkästchen **Nur IAM-Zugriffskontrolle für neue Tabellen in dieser Datenbank verwenden** im Dialogfeld **Datenbank erstellen** standardmäßig aktiviert ist. Mehr tut es nicht. Es ist das Kontrollkästchen im Dialogfeld **Datenbank erstellen**, das die Erteilung von `Super` an aktiviert`IAMAllowedPrincipals`.
Diese Optionen auf der **Einstellungsseite** sind standardmäßig aktiviert. Weitere Informationen finden Sie hier:
+ [Ändern der Standardeinstellungen für Ihren Data Lake](change-settings.md)
+ [AWS GlueDatenberechtigungen für das AWS Lake Formation Modell aktualisieren](upgrade-glue-lake-formation.md)
### `SUPER_USER`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| Super user | Catalog | glue:GetCatalog |
Sie können die `Super user` Berechtigung nur bestimmten Hauptbenutzern für Kataloge innerhalb des Standarddatenkatalogs gewähren. Sie können keine `Super user` Berechtigungen für den Standardkatalog oder für andere Ressourcentypen wie Datenbanken und Tabellen oder für Prinzipale in externen Konten gewähren. Die `Super user` Berechtigungsberechtigung ermöglicht es einem Prinzipal, jeden unterstützten Lake Formation Formation-Vorgang für die Datenbanken und Tabellen innerhalb des erteilten Katalogs auszuführen.
Mit der `Super user` Berechtigung kann der Hauptbenutzer (Empfänger) die folgenden Aktionen mit den Ressourcen (Kataloge, Datenbanken und Tabellen) innerhalb des Katalogs ausführen:
+ `CREATE_DATABASE`, `DESCRIBE` Berechtigungen für den Katalog.
+ `DROP`, `ALTER``CREATE_TABLE`, `DESCRIBE` (effektiv`SUPER`) Berechtigungen für alle Datenbanken innerhalb des Katalogs.
+ `DROP`,`ALTER`,`DESCRIBE`, `SELECT``INSERT`, `DELETE` (effektiv`SUPER`) Berechtigungen für alle Tabellen in allen Datenbanken innerhalb des Katalogs.
+ `All`(effektiv SUPER-) Berechtigungen für Kataloge innerhalb des Katalogs.
+ Erteilbare Berechtigungen (die Möglichkeit, diese Berechtigungen anderen Hauptbenutzern zu gewähren) für alle Kataloge, Datenbanken und Tabellen innerhalb des Katalogs.
Mit der `Super user` Berechtigung für eine Katalogressource darf der Empfänger keine Aktionen im Katalog ausführen oder `ALTER` delegieren`DROP`.
### `ASSOCIATE`
| Berechtigung | Für diese Ressource gewährt | Der Stipendiat braucht auch |
| --- | --- | --- |
| ASSOCIATE | LF-Tag | `glue:GetDatabase` `glue:GetTable` `lakeformation:AddLFTagsToResource"` `lakeformation:RemoveLFTagsFromResource"` `lakeformation:GetResourceLFTags` `lakeformation:ListLFTags` `lakeformation:GetLFTag` `lakeformation:SearchTablesByLFTags` `lakeformation:SearchDatabasesByLFTags` |
Ein Principal mit dieser Berechtigung für ein LF-Tag kann das LF-Tag einer Datenkatalogressource zuweisen. Implizite Gewährung von Zuschüssen. `ASSOCIATE` `DESCRIBE`
**Example**
In diesem Beispiel wird dem Benutzer `datalake_user1` die `ASSOCIATE` Erlaubnis für das LF-Tag mit dem Schlüssel erteilt. `module` Es gewährt Berechtigungen zum Anzeigen und Zuweisen aller Werte für diesen Schlüssel, wie durch das Sternchen (\$1) gekennzeichnet.
```
aws lakeformation grant-permissions --principal DataLakePrincipalIdentifier=arn:aws:iam::111122223333:user/datalake_user1 --permissions "ASSOCIATE" --resource '{ "LFTag": {"CatalogId":"111122223333","TagKey":"module","TagValues":["*"]}}'
```
# Integration von IAM Identity Center
Mit AWS IAM Identity Center können Sie eine Verbindung zu Identitätsanbietern (IdPs) herstellen und den Zugriff für Benutzer und Gruppen über AWS Analysedienste hinweg zentral verwalten. Sie können Identitätsanbieter wie Okta, Ping und Microsoft Entra ID (früher Azure Active Directory) in IAM Identity Center integrieren, damit Benutzer in Ihrer Organisation über eine Single-Sign-On-Erfahrung auf Daten zugreifen können. IAM Identity Center unterstützt auch die Verbindung weiterer externer Identitätsanbieter.
Weitere Informationen finden Sie unter [Unterstützte Identitätsanbieter](https://docs.aws.amazon.com/singlesignon/latest/userguide/supported-idps.html) im AWS IAM Identity Center Benutzerhandbuch.
Sie können die Anwendung in IAM Identity Center AWS Lake Formation als aktivierte Anwendung konfigurieren, und Data Lake-Administratoren können autorisierten Benutzern und Gruppen detaillierte Berechtigungen für Ressourcen gewähren. AWS Glue Data Catalog
Benutzer aus Ihrer Organisation können sich mit dem Identitätsanbieter Ihrer Organisation bei jeder Identity Center-fähigen Anwendung anmelden und Datensätze mit Lake Formation Formation-Berechtigungen abfragen. Mit dieser Integration können Sie den Zugriff auf AWS Dienste verwalten, ohne mehrere IAM-Rollen erstellen zu müssen.
[Die Weitergabe vertrauenswürdiger Identitäten](https://docs.aws.amazon.com//singlesignon/latest/userguide/trustedidentitypropagation-overview.html) ist eine AWS IAM Identity Center Funktion, mit der Administratoren von Connected den Zugriff auf Servicedaten gewähren und prüfen AWS-Services können. Der Zugriff auf diese Daten basiert auf Benutzerattributen wie Gruppenzuordnungen. Die Einrichtung der Verbreitung vertrauenswürdiger Identitäten erfordert die Zusammenarbeit zwischen den Administratoren von Connected AWS-Services und den IAM Identity Center-Administratoren. Weitere Informationen finden Sie unter [Voraussetzungen und Überlegungen](https://docs.aws.amazon.com//singlesignon/latest/userguide/trustedidentitypropagation-overall-prerequisites.html).
Einschränkungen finden Sie unter [Einschränkungen bei der IAM Identity Center-Integration](identity-center-lf-notes.md).
**Topics**
+ [Voraussetzungen für die Integration von IAM Identity Center mit Lake Formation](prerequisites-identity-center.md)
+ [Lake Formation mit dem IAM Identity Center verbinden](connect-lf-identity-center.md)
+ [Aktualisierung der IAM Identity Center-Integration](update-lf-identity-center-connection.md)
+ [Löschen einer Lake Formation Formation-Verbindung mit IAM Identity Center](delete-lf-identity-center-connection.md)
+ [Benutzern und Gruppen Berechtigungen gewähren](grant-permissions-sso.md)
+ [Einbeziehen des IAM Identity Center-Benutzerkontextes in die Protokolle CloudTrail](identity-center-ct-logs.md)
# Voraussetzungen für die Integration von IAM Identity Center mit Lake Formation
Im Folgenden sind die Voraussetzungen für die Integration von IAM Identity Center in Lake Formation aufgeführt.
1. IAM Identity Center aktivieren — Die Aktivierung von IAM Identity Center ist eine Voraussetzung für die Unterstützung von Authentifizierung und Identitätsweitergabe.
1. Wählen Sie Ihre Identitätsquelle — Nachdem Sie IAM Identity Center aktiviert haben, benötigen Sie einen Identitätsanbieter für die Verwaltung von Benutzern und Gruppen. Sie können entweder das integrierte Identity Center-Verzeichnis als Identitätsquelle verwenden oder einen externen IdP wie Microsoft Entra ID oder Okta verwenden.
Weitere Informationen finden Sie unter [Ihre Identitätsquelle verwalten](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source.html) und [Connect zu einem externen Identitätsanbieter](https://docs.aws.amazon.com/singlesignon/latest/userguide/manage-your-identity-source-idp.html) herstellen im AWS IAM Identity Center Benutzerhandbuch.
1. Eine IAM-Rolle erstellen — Für die Rolle, die eine IAM Identity Center-Verbindung herstellt, sind Berechtigungen zum Erstellen und Ändern der Anwendungskonfiguration in Lake Formation und IAM Identity Center erforderlich, wie in der folgenden Inline-Richtlinie beschrieben.
Sie müssen Berechtigungen gemäß den Best Practices für IAM hinzufügen. Die spezifischen Berechtigungen werden in den folgenden Verfahren beschrieben. Weitere Informationen finden Sie unter [Erste Schritte mit IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/get-started-enable-identity-center.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:CreateLakeFormationIdentityCenterConfiguration",
"sso:CreateApplication",
"sso:PutApplicationAssignmentConfiguration",
"sso:PutApplicationAuthenticationMethod",
"sso:PutApplicationGrant",
"sso:PutApplicationAccessScope"
],
"Resource": [
"*"
]
}
]
}
```
------
Wenn Sie Datenkatalogressourcen für externe Benutzer AWS-Konten oder Organisationen gemeinsam nutzen, benötigen Sie die AWS Resource Access Manager (AWS RAM) -Berechtigungen zum Erstellen von gemeinsamen Ressourcen. Weitere Informationen zu den Berechtigungen, die für die gemeinsame Nutzung von Ressourcen erforderlich sind, finden Sie unter [Voraussetzungen für die kontoübergreifende gemeinsame Nutzung von Daten](cross-account-prereqs.md).
Die folgenden Inline-Richtlinien enthalten spezifische Berechtigungen, die zum Anzeigen, Aktualisieren und Löschen von Eigenschaften der Lake Formation Formation-Integration mit IAM Identity Center erforderlich sind.
+ Verwenden Sie die folgende Inline-Richtlinie, damit eine IAM-Rolle eine Lake Formation Formation-Integration mit IAM Identity Center anzeigen kann.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:DescribeLakeFormationIdentityCenterConfiguration",
"sso:DescribeApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Verwenden Sie die folgende Inline-Richtlinie, damit eine IAM-Rolle eine Lake Formation Formation-Integration mit IAM Identity Center aktualisieren kann. Die Richtlinie umfasst auch optionale Berechtigungen, die für die gemeinsame Nutzung von Ressourcen mit externen Konten erforderlich sind.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:UpdateLakeFormationIdentityCenterConfiguration",
"lakeformation:DescribeLakeFormationIdentityCenterConfiguration",
"sso:DescribeApplication",
"sso:UpdateApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Verwenden Sie die folgende Inline-Richtlinie, um einer IAM-Rolle das Löschen einer Lake Formation Formation-Integration mit IAM Identity Center zu ermöglichen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lakeformation:DeleteLakeFormationIdentityCenterConfiguration",
"sso:DeleteApplication"
],
"Resource": [
"*"
]
}
]
}
```
------
+ Informationen zu IAM-Berechtigungen, die erforderlich sind, um Data Lake-Berechtigungen für IAM Identity Center-Benutzer und -Gruppen zu gewähren oder zu widerrufen, finden Sie unter. [IAM-Berechtigungen sind erforderlich, um Lake Formation Formation-Berechtigungen zu gewähren oder zu widerrufen](required-permissions-for-grant.md)
*Beschreibung der Berechtigungen*
+ `lakeformation:CreateLakeFormationIdentityCenterConfiguration`— Erzeugt die Lake Formation iDC-Konfiguration.
+ `lakeformation:DescribeLakeFormationIdentityCenterConfiguration`— Beschreibt eine bestehende iDC-Konfiguration.
+ `lakeformation:DeleteLakeFormationIdentityCenterConfiguration`— Ermöglicht das Löschen einer vorhandenen Lake Formation iDC-Konfiguration.
+ `lakeformation:UpdateLakeFormationIdentityCenterConfiguration`— Wird verwendet, um eine bestehende Lake Formation Formation-Konfiguration zu ändern.
+ `sso:CreateApplication` – Zur Erstellung einer IAM-Identity-Center-Anwendung verwendet.
+ `sso:DeleteApplication` – Zum Löschen einer IAM-Identity-Center-Anwendung verwendet.
+ `sso:UpdateApplication` – Zur Aktualisierung einer IAM-Identity-Center-Anwendung verwendet.
+ `sso:PutApplicationGrant` – Zur Änderung der Informationen zu vertrauenswürdigen Token-Ausstellern verwendet.
+ `sso:PutApplicationAuthenticationMethod`— Gewährt Lake Formation Formation-Authentifizierungszugriff.
+ `sso:GetApplicationGrant` – Zum Auflisten der Informationen zu vertrauenswürdigen Token-Ausstellern verwendet.
+ `sso:DeleteApplicationGrant` – Löscht die Informationen zum vertrauenswürdigen Token-Aussteller.
+ `sso:PutApplicationAccessScope`— Fügt die Liste der autorisierten Ziele für einen IAM Identity Center-Zugriffsbereich für eine Anwendung hinzu oder aktualisiert sie.
+ `sso:PutApplicationAssignmentConfiguration`— Wird verwendet, um zu konfigurieren, wie Benutzer Zugriff auf eine Anwendung erhalten.
# Lake Formation mit dem IAM Identity Center verbinden
Bevor Sie IAM Identity Center zur Verwaltung von Identitäten verwenden können, um mithilfe von Lake Formation Zugriff auf Datenkatalogressourcen zu gewähren, müssen Sie die folgenden Schritte ausführen. Sie können die IAM Identity Center-Integration mithilfe der Lake Formation Formation-Konsole oder AWS CLI erstellen.
------
#### [ AWS-Managementkonsole ]
**Um Lake Formation mit IAM Identity Center zu verbinden**
1. Melden Sie sich bei an AWS-Managementkonsole und öffnen Sie die Lake Formation Formation-Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie im linken Navigationsbereich die Option **IAM Identity Center-Integration** aus.
![\[IAM Identity Center-Integrationsbildschirm mit Identity Center ARN.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/identity-center-integ.png)
1. (Optional) Geben Sie eine oder mehrere gültige AWS-Konto IDs Organisationen oder and/or Organisationseinheiten ein IDs, IDs um externen Konten den Zugriff auf die Datenkatalogressourcen zu ermöglichen. Wenn Benutzer oder Gruppen von IAM Identity Center versuchen, auf von Lake Formation verwaltete Datenkatalogressourcen zuzugreifen, nimmt Lake Formation eine IAM-Rolle an, um den Metadatenzugriff zu autorisieren. Wenn die IAM-Rolle zu einem externen Konto gehört, das keine AWS Glue Ressourcenrichtlinie und keine AWS RAM Ressourcenfreigabe hat, können die Benutzer und Gruppen von IAM Identity Center nicht auf die Ressource zugreifen, selbst wenn sie über Lake Formation Formation-Berechtigungen verfügen.
Lake Formation verwendet den Dienst AWS Resource Access Manager (AWS RAM), um die Ressource mit externen Konten und Organisationen zu teilen. AWS RAM sendet eine Einladung an das Konto des Empfängers, die gemeinsame Nutzung der Ressource anzunehmen oder abzulehnen.
Weitere Informationen finden Sie unter [Annahme einer Einladung zur gemeinsamen Nutzung von Ressourcen AWS RAM](accepting-ram-invite.md).
**Anmerkung**
Lake Formation ermöglicht es IAM-Rollen von externen Konten, im Namen von IAM Identity Center-Benutzern und -Gruppen als Trägerrollen für den Zugriff auf Datenkatalogressourcen zu fungieren. Berechtigungen können jedoch nur für Datenkatalogressourcen innerhalb des Eigentümerkontos erteilt werden. Wenn Sie versuchen, Benutzern und Gruppen von IAM Identity Center Berechtigungen für Datenkatalogressourcen in einem externen Konto zu gewähren, gibt Lake Formation die folgende Fehlermeldung aus: „Kontoübergreifende Zuweisungen werden für den Prinzipal nicht unterstützt“.
1. (Optional) Geben Sie auf dem **Integrationsbildschirm Create Lake Formation** die Anwendungen ARNs von Drittanbietern an, die auf Daten an Amazon S3 S3-Standorten zugreifen können, die bei Lake Formation registriert sind. Lake Formation verkauft begrenzte temporäre Anmeldeinformationen in Form von AWS STS Token an registrierte Amazon S3 S3-Standorte auf der Grundlage der effektiven Berechtigungen, sodass autorisierte Anwendungen im Namen von Benutzern auf Daten zugreifen können.
1. (Optional) Markieren Sie auf dem **Integrationsbildschirm Create Lake Formation** das Kontrollkästchen Amazon Redshift Connect unter Trusted Identity Propagation, um die Erkennung von Amazon Redshift Federated Permissions über IDC zu aktivieren. Lake Formation gibt die Identität auf der Grundlage der effektiven Berechtigungen an Downstream weiter, sodass autorisierte Anwendungen im Namen von Benutzern auf Daten zugreifen können.
1. Wählen Sie **Absenden** aus.
Nachdem der Lake Formation-Administrator die Schritte abgeschlossen und die Integration erstellt hat, werden die IAM Identity Center-Eigenschaften in der Lake Formation Formation-Konsole angezeigt. Durch das Erledigen dieser Aufgaben wird Lake Formation zu einer IAM Identity Center-fähigen Anwendung. Die Eigenschaften in der Konsole umfassen auch den Integrationsstatus. Der Integrationsstatus gibt an, `Success` wann der Vorgang abgeschlossen ist. Dieser Status gibt an, ob die IAM Identity Center-Konfiguration abgeschlossen ist.
------
#### [ AWS CLI ]
+ Das folgende Beispiel zeigt, wie die Lake Formation Formation-Integration mit IAM Identity Center erstellt wird. Sie können auch die `Status` (`ENABLED`,`DISABLED`) der Anwendungen angeben.
```
aws lakeformation create-lake-formation-identity-center-configuration \
--catalog-id <123456789012> \
--instance-arn \
--share-recipients '[{"DataLakePrincipalIdentifier": "<123456789012>"},
{"DataLakePrincipalIdentifier": "<555555555555>"}]' \
--external-filtering '{"AuthorizedTargets": ["", ""], "Status": "ENABLED"}'
```
+ Das folgende Beispiel zeigt, wie eine Lake Formation Formation-Integration mit IAM Identity Center angezeigt wird.
```
aws lakeformation describe-lake-formation-identity-center-configuration
--catalog-id <123456789012>
```
+ Das folgende Beispiel zeigt, wie die `Redshift:Connect` Autorisierung aktiviert wird. Die Autorisierung kann AKTIVIERT oder DEAKTIVIERT sein.
```
aws lakeformation create-lake-formation-identity-center-configuration \
--instance-arn \
--service-integrations '[{
"Redshift": [{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}]
}]'
```
+ Verwenden Sie den `describe-lake-formation-identity-center-configuration` Befehl, um die Lake Formation Identity Center-Anwendung zu beschreiben. `Redshift:Connect`Die Dienstintegration ist für die dienst- und clusterübergreifende IdC-Identitätsverbreitung unerlässlich:
```
aws lakeformation describe-lake-formation-identity-center-configuration --catalog-id <123456789012>
```
Antwort:
```
{
"CatalogId": "CATALOG ID",
"InstanceArn": "INSTANCE ARN",
"ApplicationArn": "APPLICATION ARN",
"ShareRecipients": [],
"ServiceIntegrations": [
{
"Redshift": [
{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}
]
}
]
}
```
------
## Verwendung von IAM Identity Center für mehrere AWS-Regionen
Lake Formation unterstützt IAM Identity Center in mehreren AWS-Regionen Bereichen. Sie können IAM Identity Center von Ihren primären AWS-Region auf weitere Regionen ausdehnen, um die Leistung durch Benutzernähe und Zuverlässigkeit zu verbessern. Wenn eine neue Region in IAM Identity Center hinzugefügt wird, können Sie Lake Formation Identity Center-Anwendungen in der neuen Region erstellen, ohne Identitäten aus der primären Region zu replizieren. *Weitere Informationen zu den ersten Schritten mit IAM Identity Center in mehreren Regionen finden Sie unter [Multi-Region IAM Identity Center im IAM Identity Center-Benutzerhandbuch](https://docs.aws.amazon.com/singlesignon/latest/userguide/multi-region-iam-identity-center.html).*
# Aktualisierung der IAM Identity Center-Integration
Nachdem Sie die Verbindung hergestellt haben, können Sie Drittanbieteranwendungen für die IAM Identity Center-Integration hinzufügen, um sie in Lake Formation zu integrieren und im Namen der Benutzer Zugriff auf Amazon S3 S3-Daten zu erhalten. Sie können auch vorhandene Anwendungen aus der IAM Identity Center-Integration entfernen. Sie können Anwendungen mithilfe der Lake Formation Formation-Konsole und mithilfe von [UpdateLakeFormationIdentityCenterConfiguration](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_UpdateLakeFormationIdentityCenterConfiguration.html)Operation hinzufügen oder entfernen. AWS CLI
**Anmerkung**
Nachdem Sie die IAM Identity Center-Integration erstellt haben, können Sie die Instanz `ARN` nicht aktualisieren.
------
#### [ AWS-Managementkonsole ]
**So aktualisieren Sie eine bestehende IAM Identity Center-Verbindung mit Lake Formation**
1. Melden Sie sich bei an AWS-Managementkonsole und öffnen Sie die Lake Formation Formation-Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie im linken Navigationsbereich die Option **IAM Identity Center-Integration** aus.
1. Wählen Sie auf der **IAM Identity Center-Integrationsseite** **Hinzufügen** aus.
1. Geben Sie eine oder mehrere gültige AWS-Konto IDs Organisationen oder and/or Organisationseinheiten ein IDs, IDs um externen Konten den Zugriff auf die Datenkatalogressourcen zu ermöglichen.
1. Geben Sie auf dem Bildschirm **Anwendungen hinzufügen** die Anwendung IDs der Drittanbieteranwendungen ein, die Sie in Lake Formation integrieren möchten.
1. Wählen Sie **Hinzufügen** aus.
1. (Optional) Auf der **IAM Identity Center-Integrationsseite können Sie entweder Trusted Identity** Propagation für Amazon Redshift Connect aktivieren oder deaktivieren. Lake Formation gibt die Identität auf der Grundlage der effektiven Berechtigungen an Downstream weiter, sodass autorisierte Anwendungen im Namen von Benutzern auf Daten zugreifen können.
------
#### [ AWS CLI ]
Sie können Drittanbieteranwendungen für die IAM Identity Center-Integration hinzufügen oder entfernen, indem Sie den folgenden AWS CLI Befehl ausführen. Wenn Sie den externen Filterstatus auf festlegen`ENABLED`, ermöglicht dies dem IAM Identity Center, Identitätsmanagement für Drittanbieteranwendungen bereitzustellen, um auf von Lake Formation verwaltete Daten zuzugreifen. Sie können die IAM Identity Center-Integration auch aktivieren oder deaktivieren, indem Sie den Anwendungsstatus festlegen.
```
aws lakeformation update-lake-formation-identity-center-configuration \
--external-filtering '{"AuthorizedTargets": ["", ""], "Status": "ENABLED"}'\
--share-recipients '[{"DataLakePrincipalIdentifier": "<444455556666>"}
{"DataLakePrincipalIdentifier": "<777788889999>"}]' \
--application-status ENABLED
```
Wenn Sie bereits über eine LF IDC-Anwendung verfügen, aber die `Redshift:Connect` Autorisierung hinzufügen möchten, können Sie Ihre Lake Formation IDC-Anwendung wie folgt aktualisieren. Die Autorisierung kann AKTIVIERT oder DEAKTIVIERT werden.
```
aws lakeformation update-lake-formation-identity-center-configuration \
--service-integrations '[{
"Redshift": [{
"RedshiftConnect": {
"Authorization": "ENABLED"
}
}]
}]'
```
------
# Löschen einer Lake Formation Formation-Verbindung mit IAM Identity Center
Wenn Sie eine bestehende IAM Identity Center-Integration löschen möchten, können Sie dies mithilfe der Lake Formation Formation-Konsole oder [DeleteLakeFormationIdentityCenterConfiguration](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_DeleteLakeFormationIdentityCenterConfiguration.html)-Operation tun. AWS CLI
------
#### [ AWS-Managementkonsole ]
**So löschen Sie eine bestehende IAM Identity Center-Verbindung mit Lake Formation**
1. Melden Sie sich bei an AWS-Managementkonsole und öffnen Sie die Lake Formation Formation-Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie im linken Navigationsbereich die Option **IAM Identity Center-Integration** aus.
1. Wählen Sie auf der **IAM Identity Center-Integrationsseite** **Löschen** aus.
1. **Bestätigen Sie auf dem Bildschirm „Integration** bestätigen“ die Aktion und wählen Sie **Löschen** aus.
------
#### [ AWS CLI ]
Sie können die IAM Identity Center-Integration löschen, indem Sie den folgenden AWS CLI Befehl ausführen.
```
aws lakeformation delete-lake-formation-identity-center-configuration \
--catalog-id <123456789012>
```
------
# Benutzern und Gruppen Berechtigungen gewähren
Ihr Data Lake-Administrator kann Benutzern und Gruppen von IAM Identity Center Berechtigungen für Datenkatalogressourcen (Datenbanken, Tabellen und Ansichten) gewähren, um einen einfachen Datenzugriff zu ermöglichen. Um Data Lake-Berechtigungen zu gewähren oder zu widerrufen, benötigt der Erteilende Berechtigungen für die folgenden IAM Identity Center-Aktionen.
+ [DescribeUser](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_DescribeUser.html)
+ [DescribeGroup](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_DescribeGroup.html)
+ [DescribeInstance](https://docs.aws.amazon.com/singlesignon/latest/APIReference/API_DescribeInstance.html)
Sie können Berechtigungen gewähren, indem Sie die Lake Formation Formation-Konsole, die API oder die verwenden AWS CLI.
Weitere Informationen zur Erteilung von Berechtigungen finden Sie unter[Erteilen von Berechtigungen für Datenkatalogressourcen](granting-catalog-permissions.md).
**Anmerkung**
Sie können nur Berechtigungen für Ressourcen in Ihrem Konto gewähren. Um Benutzern und Gruppen Berechtigungen für Ressourcen, die mit Ihnen gemeinsam genutzt werden, zu kaskadieren, müssen Sie AWS RAM Ressourcenfreigaben verwenden.
------
#### [ AWS-Managementkonsole ]
**Um Benutzern und Gruppen Berechtigungen zu gewähren**
1. Melden Sie sich bei an AWS-Managementkonsole und ö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 **Lake Formation-Konsole unter **Berechtigungen** die Option Data** Lake-Berechtigungen aus.
1. Wählen Sie **Grant** aus.
1. Wählen Sie auf der Seite **Data Lake-Berechtigungen gewähren** die Option **IAM Identity Center-Benutzer** und -Gruppen aus.
1. Wählen Sie **Hinzufügen** aus, um die Benutzer und Gruppen auszuwählen, denen Berechtigungen erteilt werden sollen.
![\[Bildschirm „Data Lake-Berechtigungen gewähren“ mit ausgewählten IAM Identity Center-Benutzern und -Gruppen.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/identity-center-grant-perm.png)
1. Wählen Sie auf dem Bildschirm **„Benutzer und Gruppen zuweisen**“ die and/or Benutzergruppen aus, denen Berechtigungen erteilt werden sollen.
Wählen Sie **Zuweisen** aus.
![\[Bildschirm „Data Lake-Berechtigungen gewähren“ mit ausgewählten IAM Identity Center-Benutzern und -Gruppen.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/identity-center-assign-users-groups.png)
1. Wählen Sie als Nächstes die Methode zum Erteilen von Berechtigungen aus.
Anweisungen zum Erteilen von Berechtigungen mithilfe der Methode „Benannte Ressourcen“ finden Sie unter[Erteilen von Datenberechtigungen mithilfe der benannten Ressourcenmethode](granting-cat-perms-named-resource.md).
Anweisungen zur Erteilung von Berechtigungen mithilfe von LF-Tags finden Sie unter. [Erteilen von Data Lake-Berechtigungen mithilfe der LF-TBAC-Methode](granting-catalog-perms-TBAC.md)
1. Wählen Sie die Datenkatalogressourcen aus, für die Sie Berechtigungen erteilen möchten.
1. Wählen Sie die Datenkatalogberechtigungen aus, die Sie gewähren möchten.
1. Wählen Sie **Gewähren** aus.
------
#### [ AWS CLI ]
Das folgende Beispiel zeigt, wie IAM Identity `SELECT` Center-Benutzerberechtigungen für eine Tabelle erteilt werden.
```
aws lakeformation grant-permissions \
--principal DataLakePrincipalIdentifier=arn:aws:identitystore:::user/ \
--permissions "SELECT" \
--resource '{ "Table": { "DatabaseName": "retail", "TableWildcard": {} } }'
```
Informationen zum Abrufen `UserId` aus dem IAM Identity Center finden Sie unter [GetUserId](https://docs.aws.amazon.com/singlesignon/latest/IdentityStoreAPIReference/API_GetUserId.html)Vorgang in der IAM Identity Center API-Referenz.
------
# Einbeziehen des IAM Identity Center-Benutzerkontextes in die Protokolle CloudTrail
Lake Formation verwendet die [Verkaufsfunktion für Anmeldeinformationen](using-cred-vending.md), um temporären Zugriff auf Amazon S3 S3-Daten zu ermöglichen. Wenn ein IAM Identity Center-Benutzer eine Anfrage an einen integrierten Analysedienst sendet, enthalten die CloudTrail Protokolle standardmäßig nur die IAM-Rolle, die der Service für den kurzfristigen Zugriff annimmt. Wenn Sie eine benutzerdefinierte Rolle verwenden, um den Amazon S3 S3-Datenstandort bei Lake Formation zu registrieren, können Sie sich dafür entscheiden, den Kontext des IAM Identity Center-Benutzers in die CloudTrail Ereignisse einzubeziehen und dann die Benutzer zu verfolgen, die auf Ihre Ressourcen zugreifen.
**Wichtig**
Um Amazon S3 S3-API-Anfragen auf Objektebene in die aufzunehmen CloudTrail, müssen Sie die CloudTrail Ereignisprotokollierung für den Amazon S3 S3-Bucket und die Objekte aktivieren. Weitere Informationen finden Sie unter [Aktivieren der CloudTrail Ereignisprotokollierung für Amazon S3 S3-Buckets und -Objekte](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-cloudtrail-logging-for-s3.html) im Amazon S3 S3-Benutzerhandbuch.
**So aktivieren Sie die Prüfung von Anmeldedaten an Data Lake-Standorten, die mit benutzerdefinierten Rollen registriert sind**
1. Melden Sie sich bei der Lake Formation Formation-Konsole unter an [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Erweitern Sie in der linken Navigationsleiste die Option **Administration** und wählen Sie **Datenkatalogeinstellungen** aus.
1. Wählen Sie unter **Erweitertes Auditing** die Option **Bereitgestellten Kontext weitergeben** aus.
1. Wählen Sie **Speichern**.
Sie können die erweiterte Überwachungsoption auch aktivieren, indem Sie das `Parameters` Attribut im [PutDataLakeSettings](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_PutDataLakeSettings.html)Vorgang festlegen. Standardmäßig ist der `SET_CONTEXT"` Parameterwert auf „true“ gesetzt.
```
{
"DataLakeSettings": {
"Parameters": {"SET_CONTEXT": "true"},
}
}
```
Im Folgenden finden Sie einen Auszug aus einem CloudTrail Ereignis mit der erweiterten Überwachungsoption. Dieses Protokoll enthält sowohl den Sitzungskontext des IAM Identity Center-Benutzers als auch die benutzerdefinierte IAM-Rolle, die Lake Formation für den Zugriff auf den Amazon S3 S3-Datenstandort übernommen hat. Sehen Sie sich den `onBehalfOf` Parameter im folgenden Auszug an.
```
{
"eventVersion":"1.09",
"userIdentity":{
"type":"AssumedRole",
"principalId":"AROAW7F7MOX4OYE6FLIFN:access-grants-e653760c-4e8b-44fd-94d9-309e035b75ab",
"arn":"arn:aws:sts::123456789012:assumed-role/accessGrantsTestRole/access-grants-e653760c-4e8b-44fd-94d9-309e035b75ab",
"accountId":"123456789012",
"accessKeyId":"ASIAW7F7MOX4CQLD4JIZN",
"sessionContext":{
"sessionIssuer":{
"type":"Role",
"principalId":"AROAW7F7MOX4OYE6FLIFN",
"arn":"arn:aws:iam::123456789012:role/accessGrantsTestRole",
"accountId":"123456789012",
"userName":"accessGrantsTestRole"
},
"attributes":{
"creationDate":"2023-08-09T17:24:02Z",
"mfaAuthenticated":"false"
}
},
"onBehalfOf":{
"userId": "",
"identityStoreArn": "arn:aws:identitystore::"
}
},
"eventTime":"2023-08-09T17:25:43Z",
"eventSource":"s3.amazonaws.com",
"eventName":"GetObject",
....
```
# Hinzufügen eines Amazon S3 S3-Standorts zu Ihrem Data Lake
Um einen Datenstandort als Speicher in Ihrem Data Lake hinzuzufügen, *registrieren* Sie den Standort (**Data Lake-Standort**) bei AWS Lake Formation. Anschließend können Sie Lake Formation Formation-Berechtigungen für eine detaillierte Zugriffskontrolle auf AWS Glue Data Catalog Objekte verwenden, die auf diese Position und auf die zugrunde liegenden Daten in der Position verweisen.
Lake Formation ermöglicht auch die Registrierung eines Datenstandorts im Hybridzugriffsmodus und bietet Ihnen die Flexibilität, Lake Formation Formation-Berechtigungen für Datenbanken und Tabellen in Ihrem Datenkatalog selektiv zu aktivieren. Im Hybridzugriffsmodus verfügen Sie über einen inkrementellen Pfad, mit dem Sie Lake Formation Formation-Berechtigungen für eine bestimmte Gruppe von Benutzern festlegen können, ohne die Berechtigungsrichtlinien anderer vorhandener Benutzer oder Workloads zu unterbrechen.
Weitere Informationen zur Einrichtung des hybriden Zugriffsmodus finden Sie unter [Hybrider Zugriffsmodus](hybrid-access-mode.md)
Wenn Sie einen Standort registrieren, werden dieser Amazon S3 S3-Pfad und alle Ordner unter diesem Pfad registriert.
Nehmen wir zum Beispiel an, Sie haben eine Amazon S3 S3-Pfadorganisation wie die folgende:
`/mybucket/accounting/sales/`
Wenn Sie sich registrieren`S3://mybucket/accounting`, ist der `sales` Ordner ebenfalls registriert und wird von Lake Formation verwaltet.
Weitere Informationen zur Registrierung von Standorten finden Sie unter[Underlying data access control](access-control-underlying-data.md#underlying-data-access-control).
**Anmerkung**
Lake Formation Formation-Berechtigungen werden für strukturierte Daten (angeordnet in Tabellen mit Zeilen und Spalten) empfohlen. Wenn Ihre Daten objektbasierte unstrukturierte Daten enthalten, sollten Sie erwägen, Amazon S3-Zugriffsberechtigungen zur Verwaltung des Datenzugriffs zu verwenden.
**Topics**
+ [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md)
+ [Registrierung eines Amazon S3 S3-Standorts](register-location.md)
+ [Registrierung eines verschlüsselten Amazon S3 S3-Standorts](register-encrypted.md)
+ [Registrierung eines Amazon S3 S3-Standorts in einem anderen AWS Konto](register-cross-account.md)
+ [AWS Kontoübergreifende Registrierung eines verschlüsselten Amazon S3 S3-Standorts](register-cross-encrypted.md)
+ [Abmeldung eines Amazon S3 S3-Standorts](unregister-location.md)
# Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden
Sie müssen eine AWS Identity and Access Management (IAM) -Rolle angeben, wenn Sie einen Amazon Simple Storage Service (Amazon S3) -Standort registrieren. AWS Lake Formation nimmt diese Rolle beim Zugriff auf die Daten an diesem Standort an.
Sie können einen der folgenden Rollentypen verwenden, um einen Standort zu registrieren:
+ Die dienstleistungsbezogene Rolle von Lake Formation. Diese Rolle gewährt die erforderlichen Berechtigungen für den Standort. Die Verwendung dieser Rolle ist die einfachste Methode, den Standort zu registrieren. Weitere Informationen erhalten Sie unter [Verwenden von serviceverknüpften Rollen für Lake Formation](service-linked-roles.md) und [Einschränkungen für dienstbezogene Rollen](service-linked-role-limitations.md).
+ Eine benutzerdefinierte Rolle. Verwenden Sie eine benutzerdefinierte Rolle, wenn Sie mehr Berechtigungen gewähren müssen, als die dienstverknüpfte Rolle bietet.
In den folgenden Fällen müssen Sie eine benutzerdefinierte Rolle verwenden:
+ Bei der Registrierung eines Standorts in einem anderen Konto.
Weitere Informationen erhalten Sie unter [Registrierung eines Amazon S3 S3-Standorts in einem anderen AWS Konto](register-cross-account.md) und [AWS Kontoübergreifende Registrierung eines verschlüsselten Amazon S3 S3-Standorts](register-cross-encrypted.md).
+ Wenn Sie ein AWS verwaltetes CMK (`aws/s3`) verwendet haben, um den Amazon S3 S3-Standort zu verschlüsseln.
Weitere Informationen finden Sie unter [Registrierung eines verschlüsselten Amazon S3 S3-Standorts](register-encrypted.md).
+ Wenn Sie mit Amazon EMR auf den Standort zugreifen möchten.
Wenn Sie bereits einen Standort mit der serviceverknüpften Rolle registriert haben und mit Amazon EMR auf den Standort zugreifen möchten, müssen Sie den Standort abmelden und ihn mit einer benutzerdefinierten Rolle erneut registrieren. Weitere Informationen finden Sie unter [Abmeldung eines Amazon S3 S3-Standorts](unregister-location.md).
# Verwenden von serviceverknüpften Rollen für Lake Formation
AWS Lake Formation verwendet eine *dienstbezogene AWS Identity and Access Management (IAM-*) Rolle. Eine serviceverknüpfte Rolle ist eine einzigartige Art von IAM-Rolle, die direkt mit Lake Formation verknüpft ist. Die dienstverknüpfte Rolle ist von Lake Formation vordefiniert und umfasst alle Berechtigungen, die der Dienst benötigt, um andere AWS Dienste in Ihrem Namen aufzurufen.
Eine serviceverknüpfte Rolle erleichtert die Einrichtung von Lake Formation, da Sie keine Rolle erstellen und die erforderlichen Berechtigungen manuell hinzufügen müssen. Lake Formation definiert die Berechtigungen seiner dienstbezogenen Rolle, und sofern nicht anders definiert, kann nur Lake Formation seine Rollen übernehmen. Die definierten Berechtigungen umfassen die Vertrauens- und Berechtigungsrichtlinie. Diese Berechtigungsrichtlinie kann keinen anderen IAM-Entitäten zugewiesen werden.
Diese dienstbezogene Rolle vertraut darauf, dass die folgenden Dienste die Rolle übernehmen:
+ `lakeformation.amazonaws.com`
Wenn Sie eine serviceverknüpfte Rolle in Konto A verwenden, um einen Amazon S3 S3-Standort zu registrieren, der Konto B gehört, muss die Amazon S3 S3-Bucket-Richtlinie (eine ressourcenbasierte Richtlinie) in Konto B Zugriffsberechtigungen für die serviceverknüpfte Rolle in Konto A gewähren.
Informationen zur Verwendung einer serviceverknüpften Rolle zur Registrierung eines Datenstandorts finden Sie unter. [Einschränkungen für dienstbezogene Rollen](service-linked-role-limitations.md)
**Anmerkung**
Richtlinien zur Dienststeuerung (SCPs) wirken sich nicht auf dienstverknüpfte Rollen aus.
Weitere Informationen finden Sie im *AWS Organizations Benutzerhandbuch* unter [Richtlinien zur Servicesteuerung (SCPs)](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html).
## Dienstbezogene Rollenberechtigungen für Lake Formation
Lake Formation verwendet die angegebene dienstbezogene Rolle. `AWSServiceRoleForLakeFormationDataAccess` Diese Rolle bietet eine Reihe von Amazon Simple Storage Service (Amazon S3) -Berechtigungen, die es dem integrierten Service von Lake Formation (z. B. Amazon Athena) ermöglichen, auf registrierte Standorte zuzugreifen. Wenn Sie einen Data Lake-Standort registrieren, müssen Sie eine Rolle angeben, die über die erforderlichen Amazon S3 read/write S3-Berechtigungen für diesen Standort verfügt. Anstatt eine Rolle mit den erforderlichen Amazon S3 S3-Berechtigungen zu erstellen, können Sie diese serviceverknüpfte Rolle verwenden.
Wenn Sie die serviceverknüpfte Rolle zum ersten Mal als Rolle angeben, mit der ein Pfad registriert werden soll, werden die serviceverknüpfte Rolle und eine neue IAM-Richtlinie in Ihrem Namen erstellt. Lake Formation fügt den Pfad zur Inline-Richtlinie hinzu und fügt ihn der dienstbezogenen Rolle hinzu. Wenn Sie nachfolgende Pfade mit der serviceverknüpften Rolle registrieren, fügt Lake Formation den Pfad der vorhandenen Richtlinie hinzu.
Registrieren Sie einen Data Lake-Standort, während Sie als Data Lake-Administrator angemeldet sind. Suchen Sie dann in der IAM-Konsole nach der Rolle `AWSServiceRoleForLakeFormationDataAccess` und sehen Sie sich die zugehörigen Richtlinien an.
Nachdem Sie den Standort registriert haben`s3://my-kinesis-test/logs`, erstellt Lake Formation beispielsweise die folgende Inline-Richtlinie und hängt sie an an. `AWSServiceRoleForLakeFormationDataAccess`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LakeFormationDataAccessPermissionsForS3",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:s3:::my-kinesis-test/logs/*"
]
},
{
"Sid": "LakeFormationDataAccessPermissionsForS3ListBucket",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:ListBucketMultipartUploads"
],
"Resource": [
"arn:aws:s3:::my-kinesis-test"
]
}
]
}
```
------
## Schaffung einer dienstbezogenen Rolle für Lake Formation
Sie müssen eine serviceverknüpfte Rolle nicht manuell erstellen. Wenn Sie einen Amazon S3 S3-Standort bei Lake Formation in der AWS-Managementkonsole, der AWS CLI oder der AWS API registrieren, erstellt Lake Formation die serviceverknüpfte Rolle für Sie.
**Wichtig**
Diese serviceverknüpfte Rolle kann in Ihrem Konto erscheinen, wenn Sie eine Aktion in einem anderen Service abgeschlossen haben, der die von dieser Rolle unterstützten Features verwendet. Weitere Informationen finden Sie unter [In meinem IAM-Konto wird eine neue Rolle angezeigt](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_roles.html#troubleshoot_roles_new-role-appeared).
Wenn Sie diese serviceverknüpfte Rolle löschen und sie dann erneut erstellen müssen, können Sie dasselbe Verfahren anwenden, um die Rolle in Ihrem Konto neu anzulegen. Wenn Sie einen Amazon S3 S3-Standort bei Lake Formation registrieren, erstellt Lake Formation die serviceverknüpfte Rolle erneut für Sie.
Sie können die IAM-Konsole auch verwenden, um eine serviceverknüpfte Rolle mit dem **Lake Formation Formation-Anwendungsfall** zu erstellen. Erstellen Sie in der AWS CLI oder der AWS API eine dienstverknüpfte Rolle mit dem `lakeformation.amazonaws.com` Dienstnamen. Weitere Informationen finden Sie unter [Erstellen einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#create-service-linked-role) im *IAM-Benutzerhandbuch*. Wenn Sie diese serviceverknüpfte Rolle löschen, können Sie mit demselben Verfahren die Rolle erneut erstellen.
## Bearbeiten einer serviceverknüpften Rolle für Lake Formation
In Lake Formation können Sie die `AWSServiceRoleForLakeFormationDataAccess` serviceverknüpfte Rolle nicht bearbeiten. Da möglicherweise verschiedene Entitäten auf die Rolle verweisen, kann der Rollenname nach dem Erstellen einer serviceverknüpften Rolle nicht mehr geändert werden. Sie können jedoch die Beschreibung der Rolle mit IAM bearbeiten. Weitere Informationen finden Sie unter [Bearbeiten einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#edit-service-linked-role) im *IAM-Benutzerhandbuch*.
## Löschen einer serviceverknüpften Rolle für Lake Formation
Wenn Sie ein Feature oder einen Dienst, die bzw. der eine serviceverknüpften Rolle erfordert, nicht mehr benötigen, sollten Sie diese Rolle löschen. Auf diese Weise haben Sie keine ungenutzte juristische Stelle, die nicht aktiv überwacht oder verwaltet wird. Sie müssen jedoch die Ressourcen für Ihre serviceverknüpften Rolle zunächst bereinigen, bevor Sie sie manuell löschen können.
**Anmerkung**
Wenn der Lake Formation Formation-Dienst die Rolle verwendet, wenn Sie versuchen, die Ressourcen zu löschen, schlägt das Löschen möglicherweise fehl. Wenn dies passiert, warten Sie einige Minuten und versuchen Sie es erneut.
**Um Lake Formation-Ressourcen zu löschen, die von der Lake Formation verwendet werden**
+ Wenn Sie die serviceverknüpfte Rolle verwendet haben, um Amazon S3 S3-Standorte bei Lake Formation zu registrieren, müssen Sie vor dem Löschen der serviceverknüpften Rolle den Standort abmelden und ihn mit einer benutzerdefinierten Rolle erneut registrieren.
**So löschen Sie die serviceverknüpfte Rolle mit IAM**
Verwenden Sie die IAM-Konsole, die oder die API, um die serviceverknüpfte AWS CLI Rolle zu löschen. AWS `AWSServiceRoleForLakeFormationDataAccess` Weitere Informationen finden Sie unter [Löschen einer serviceverknüpften Rolle](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html#delete-service-linked-role) im *IAM-Leitfaden*.
Im Folgenden sind die Anforderungen für eine benutzerdefinierte Rolle aufgeführt:
+ Wählen Sie beim Erstellen der neuen Rolle auf der Seite **Rolle erstellen** der IAM-Konsole **AWS Service** und dann unter **Anwendungsfall auswählen** die Option **Lake Formation** aus.
Wenn Sie die Rolle unter Verwendung eines anderen Pfads erstellen, stellen Sie sicher, dass für die Rolle eine Vertrauensstellung besteht. `lakeformation.amazonaws.com` Weitere Informationen finden Sie unter [Ändern einer Vertrauensrichtlinie für Rollen (Konsole)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-trust-policy.html).
+ Die Rolle muss über eine Inline-Richtlinie verfügen, die Amazon S3 read/write S3-Berechtigungen für den Standort gewährt. Im Folgenden finden Sie eine typische Richtlinie.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::awsexamplebucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::awsexamplebucket"
]
}
]
}
```
------
+ Fügen Sie der IAM-Rolle die folgende Vertrauensrichtlinie hinzu, damit der Lake Formation Formation-Dienst die Rolle übernehmen und temporäre Anmeldeinformationen an die integrierten Analyse-Engines weitergeben kann.
Um den IAM Identity Center-Benutzerkontext in die CloudTrail Protokolle aufzunehmen, muss die Vertrauensrichtlinie über die entsprechende Berechtigung für die Aktion verfügen. `sts:SetContext`
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"lakeformation.amazonaws.com"
]
},
"Action": [
"sts:AssumeRole",
"sts:SetContext"
]
}
]
}
```
------
+ Der Data Lake-Administrator, der den Standort registriert, muss über die entsprechenden `iam:PassRole` Berechtigungen für die Rolle verfügen.
Im Folgenden finden Sie eine Inline-Richtlinie, die diese Berechtigung gewährt. **Ersetzen Sie es durch eine gültige AWS Kontonummer und ** ersetzen Sie es durch den Namen der Rolle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "PassRolePermissions",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/"
]
}
]
}
```
------
+ Damit Lake Formation Logs zu Logs hinzufügen und Metriken veröffentlichen kann, fügen Sie die folgende Inline-Richtlinie hinzu. CloudWatch
**Anmerkung**
Das Schreiben in CloudWatch Logs ist kostenpflichtig.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Sid1",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-lakeformation-acceleration/*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-lakeformation-acceleration/*:log-stream:*"
]
}
]
}
```
------
# Registrierung eines Amazon S3 S3-Standorts
Sie müssen eine AWS Identity and Access Management (IAM) -Rolle angeben, wenn Sie einen Amazon Simple Storage Service (Amazon S3) -Standort registrieren. Lake Formation übernimmt diese Rolle, wenn es integrierten AWS Diensten, die auf die Daten an diesem Standort zugreifen, temporäre Anmeldeinformationen gewährt.
**Wichtig**
Vermeiden Sie es, einen Amazon S3 S3-Bucket zu registrieren, für den Zahlungen durch den **Antragsteller aktiviert** ist. Bei Buckets, die bei Lake Formation registriert sind, wird die Rolle, mit der der Bucket registriert wurde, immer als der Anforderer angesehen. Wenn ein anderes AWS Konto auf den Bucket zugreift, wird dem Bucket-Besitzer der Datenzugriff in Rechnung gestellt, sofern die Rolle zu demselben Konto gehört wie der Bucket-Besitzer.
Sie können die AWS Lake Formation Konsole, die Lake Formation API oder AWS Command Line Interface (AWS CLI) verwenden, um einen Amazon S3 S3-Standort zu registrieren.
**Bevor Sie beginnen**
Überprüfen Sie die [Anforderungen für die Rolle, die zur Registrierung des Standorts verwendet](registration-role.md) wurde.
**Um einen Standort zu registrieren (Konsole)**
**Wichtig**
Bei den folgenden Verfahren wird davon ausgegangen, dass sich der Amazon S3 S3-Standort in demselben AWS Konto wie der Datenkatalog befindet und dass die Daten am Standort nicht verschlüsselt sind. Andere Abschnitte in diesem Kapitel behandeln die kontoübergreifende Registrierung und die Registrierung verschlüsselter Standorte.
1. Öffnen Sie die AWS Lake Formation Konsole unter. [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) Melden Sie sich als Data Lake-Administrator oder als Benutzer mit der `lakeformation:RegisterResource` IAM-Berechtigung an.
1. Wählen Sie im Navigationsbereich unter **Verwaltung** die Option **Data Lake-Standorte** aus.
1. Wählen Sie **Speicherort registrieren** und anschließend **Durchsuchen**, um einen Amazon Simple Storage Service (Amazon S3) -Pfad auszuwählen.
1. (Optional, aber dringend empfohlen) Wählen Sie **Standortberechtigungen überprüfen** aus, um eine Liste aller vorhandenen Ressourcen am ausgewählten Amazon S3 S3-Standort und deren Berechtigungen anzuzeigen.
Die Registrierung des ausgewählten Standorts kann dazu führen, dass Ihre Lake Formation Formation-Benutzer Zugriff auf Daten erhalten, die sich bereits an diesem Standort befinden. Durch das Anzeigen dieser Liste können Sie sicherstellen, dass die vorhandenen Daten sicher bleiben.
1. Wählen Sie für die **IAM-Rolle** entweder die `AWSServiceRoleForLakeFormationDataAccess` serviceverknüpfte Rolle (Standard) oder eine benutzerdefinierte IAM-Rolle, die die Anforderungen in erfüllt. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md)
Sie können einen registrierten Standort oder andere Details nur aktualisieren, wenn Sie ihn mit einer benutzerdefinierten IAM-Rolle registrieren. Um einen Standort zu bearbeiten, der mit einer serviceverknüpften Rolle registriert wurde, sollten Sie den Standort abmelden und ihn erneut registrieren.
1. Wählen Sie die Option **Datenkatalogverbund aktivieren**, damit Lake Formation eine Rolle übernehmen und temporäre Anmeldeinformationen an integrierte AWS Dienste weitergeben kann, um auf Tabellen in Verbunddatenbanken zuzugreifen. Wenn ein Standort bei Lake Formation registriert ist und Sie denselben Speicherort für eine Tabelle in einer Verbunddatenbank verwenden möchten, müssen Sie denselben Standort mit der Option **Datenkatalogverbund aktivieren** registrieren.
1. Wählen Sie **den Hybrid-Zugriffsmodus**, um Lake Formation Formation-Berechtigungen standardmäßig nicht zu aktivieren. Wenn Sie den Amazon S3 S3-Standort im Hybridzugriffsmodus registrieren, können Sie Lake Formation Formation-Berechtigungen aktivieren, indem Sie Prinzipale für Datenbanken und Tabellen unter diesem Standort auswählen.
Weitere Informationen zur Einrichtung des hybriden Zugriffsmodus finden Sie unter. [Hybrider Zugriffsmodus](hybrid-access-mode.md)
1. Wählen Sie **Standort registrieren** aus.
**Um einen Standort zu registrieren (AWS CLI)**
1.
**Registrieren Sie einen neuen Standort bei Lake Formation**
In diesem Beispiel wird eine dienstbezogene Rolle verwendet, um den Standort zu registrieren. Sie können das `--role-arn` Argument stattdessen verwenden, um Ihre eigene Rolle anzugeben.
**Ersetzen Sie es durch einen gültigen Amazon S3 S3-Pfad, die Kontonummer durch ein gültiges AWS Konto und ** durch eine IAM-Rolle, die über Berechtigungen zur Registrierung eines Datenstandorts verfügt.
**Anmerkung**
Sie können die Eigenschaften eines registrierten Standorts nicht bearbeiten, wenn er mit einer serviceverknüpften Rolle registriert ist.
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--use-service-linked-role
```
Im folgenden Beispiel wird eine benutzerdefinierte Rolle verwendet, um den Standort zu registrieren.
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/
```
1.
**Um einen bei Lake Formation registrierten Standort zu aktualisieren**
Sie können einen registrierten Standort nur bearbeiten, wenn er mit einer benutzerdefinierten IAM-Rolle registriert ist. Bei einem Standort, der mit einer serviceverknüpften Rolle registriert ist, sollten Sie die Registrierung des Standorts aufheben und ihn erneut registrieren. Weitere Informationen finden Sie unter [Abmeldung eines Amazon S3 S3-Standorts](unregister-location.md).
```
aws lakeformation update-resource \
--role-arn arn:aws:iam::<123456789012>:role/\
--resource-arn arn:aws:s3:::
```
```
aws lakeformation update-resource \
--resource-arn arn:aws:s3::: \
--use-service-linked-role
```
1.
**Registrieren Sie einen Datenstandort im Hybridzugriffsmodus mit Verbund**
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--hybrid-access-enabled
```
```
aws lakeformation register-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--with-federation
```
```
aws lakeformation update-resource \
--resource-arn arn:aws:s3::: \
--role-arn arn:aws:iam::<123456789012>:role/ \
--hybrid-access-enabled
```
Weitere Informationen finden Sie unter [RegisterResource](https://docs.aws.amazon.com/lake-formation/latest/APIReference/API_RegisterResource.html)API-Betrieb.
**Anmerkung**
Sobald Sie einen Amazon S3 S3-Standort registriert haben, gibt jede AWS Glue Tabelle, die auf den Standort (oder einen seiner untergeordneten Standorte) verweist, den Wert für den `IsRegisteredWithLakeFormation` Parameter wie `true` im `GetTable` Aufruf zurück. Es gibt eine bekannte Einschränkung, dass Datenkatalog-API-Operationen, wie z. B. `GetTables` und `SearchTables` nicht, den Wert für den `IsRegisteredWithLakeFormation` Parameter aktualisieren und den Standardwert zurückgeben, der falsch ist. Es wird empfohlen, die `GetTable` API zu verwenden, um den richtigen Wert für den `IsRegisteredWithLakeFormation` Parameter anzuzeigen.
# Registrierung eines verschlüsselten Amazon S3 S3-Standorts
Lake Formation ist in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)(AWS KMS) integriert, sodass Sie andere integrierte Dienste zum Verschlüsseln und Entschlüsseln von Daten an Amazon Simple Storage Service (Amazon S3) -Standorten einfacher einrichten können.
Beide werden vom Kunden verwaltet AWS KMS keys und Von AWS verwaltete Schlüssel werden unterstützt. Derzeit encryption/decryption wird die Client-Seite nur mit Athena unterstützt.
Sie müssen eine AWS Identity and Access Management (IAM-) Rolle angeben, wenn Sie einen Amazon S3 S3-Standort registrieren. Für verschlüsselte Amazon S3 S3-Standorte muss entweder die Rolle über die Berechtigung zum Verschlüsseln und Entschlüsseln von Daten mit dem verfügen AWS KMS key, oder die KMS-Schlüsselrichtlinie muss Berechtigungen für den Schlüssel der Rolle gewähren.
**Wichtig**
Vermeiden Sie es, einen Amazon S3 S3-Bucket zu registrieren, für den Zahlungen durch den **Antragsteller aktiviert** ist. Bei Buckets, die bei Lake Formation registriert sind, wird die Rolle, mit der der Bucket registriert wurde, immer als der Anforderer angesehen. Wenn ein anderes AWS Konto auf den Bucket zugreift, wird dem Bucket-Besitzer der Datenzugriff in Rechnung gestellt, sofern die Rolle zu demselben Konto gehört wie der Bucket-Besitzer.
Lake Formation verwendet eine serviceverknüpfte Rolle, um Ihre Datenstandorte zu registrieren. Diese Rolle hat jedoch mehrere [Einschränkungen](service-linked-role-limitations.md). Aufgrund dieser Einschränkungen empfehlen wir, stattdessen eine benutzerdefinierte IAM-Rolle zu erstellen und zu verwenden, um mehr Flexibilität und Kontrolle zu gewährleisten. Die benutzerdefinierte Rolle, die Sie für die Registrierung des Standorts erstellen, muss die unter angegebenen Anforderungen erfüllen. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md)
**Wichtig**
Wenn Sie eine verwendet haben Von AWS verwalteter Schlüssel , um den Amazon S3 S3-Standort zu verschlüsseln, können Sie die serviceverknüpfte Rolle Lake Formation nicht verwenden. Sie müssen eine benutzerdefinierte Rolle verwenden und der Rolle IAM-Berechtigungen für den Schlüssel hinzufügen. Einzelheiten finden Sie weiter unten in diesem Abschnitt.
In den folgenden Verfahren wird erklärt, wie Sie einen Amazon S3 S3-Standort registrieren, der entweder mit einem vom Kunden verwalteten Schlüssel oder einem verschlüsselt ist Von AWS verwalteter Schlüssel.
+ [Registrierung eines mit einem vom Kunden verwalteten Schlüssel verschlüsselten Standorts](#proc-register-cust-cmk)
+ [Registrierung eines mit einem verschlüsselten Standort Von AWS verwalteter Schlüssel](#proc-register-aws-cmk)
**Bevor Sie beginnen**
Prüfen Sie die [Anforderungen für die Rolle, die zur Registrierung des Standorts verwendet](registration-role.md) wurde.
**Um einen Amazon S3 S3-Standort zu registrieren, der mit einem vom Kunden verwalteten Schlüssel verschlüsselt ist**
**Anmerkung**
Wenn sich der KMS-Schlüssel oder der Amazon S3 S3-Standort nicht in demselben AWS Konto wie der Datenkatalog befinden, folgen Sie [AWS Kontoübergreifende Registrierung eines verschlüsselten Amazon S3 S3-Standorts](register-cross-encrypted.md) stattdessen den Anweisungen unter.
1. Öffnen Sie die AWS KMS Konsole unter [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms) und melden Sie sich als AWS Identity and Access Management (IAM-) Administratorbenutzer oder als Benutzer an, der die Schlüsselrichtlinie des KMS-Schlüssels ändern kann, der zur Verschlüsselung des Standorts verwendet wird.
1. Wählen Sie im Navigationsbereich die Option Vom **Kunden verwaltete Schlüssel** und dann den Namen des gewünschten KMS-Schlüssels aus.
1. Wählen Sie auf der Seite mit den KMS-Schlüsseldetails die Registerkarte **Schlüsselrichtlinie** aus, und führen Sie dann einen der folgenden Schritte aus, um Ihre benutzerdefinierte Rolle oder die mit dem Lake Formation Service verknüpfte Rolle als KMS-Schlüsselbenutzer hinzuzufügen:
+ **Wenn die Standardansicht angezeigt wird** (mit den Abschnitten **Schlüsseladministratoren**, **Schlüssellöschung**, **Schlüsselbenutzer** und **Andere AWS Konten**), fügen Sie im Abschnitt **Schlüsselbenutzer** Ihre benutzerdefinierte Rolle oder die mit dem Lake Formation Service verknüpfte Rolle `AWSServiceRoleForLakeFormationDataAccess` hinzu.
+ **Wenn die Schlüsselrichtlinie (JSON) angezeigt wird** — Bearbeiten Sie die Richtlinie, um Ihre benutzerdefinierte Rolle oder die mit dem Lake Formation Service verknüpfte Rolle `AWSServiceRoleForLakeFormationDataAccess` zum Objekt „Verwendung des Schlüssels zulassen“ hinzuzufügen, wie im folgenden Beispiel gezeigt.
**Anmerkung**
Wenn das Objekt fehlt, fügen Sie es mit den im Beispiel gezeigten Berechtigungen hinzu. In dem Beispiel wird die serviceverknüpfte Rolle verwendet.
```
...
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/aws-service-role/lakeformation.amazonaws.com/AWSServiceRoleForLakeFormationDataAccess",
"arn:aws:iam::111122223333:user/keyuser"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
...
```
1. Öffnen Sie die AWS Lake Formation Konsole unter. [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) Melden Sie sich als Data Lake-Administrator oder als Benutzer mit der `lakeformation:RegisterResource` IAM-Berechtigung an.
1. Wählen Sie im Navigationsbereich unter **Verwaltung** die Option **Data Lake-Standorte** aus.
1. Wählen Sie **Speicherort registrieren** und anschließend **Durchsuchen**, um einen Amazon Simple Storage Service (Amazon S3) -Pfad auszuwählen.
1. (Optional, aber dringend empfohlen) Wählen Sie **Standortberechtigungen überprüfen**, um eine Liste aller vorhandenen Ressourcen am ausgewählten Amazon S3 S3-Standort und deren Berechtigungen anzuzeigen.
Die Registrierung des ausgewählten Standorts kann dazu führen, dass Ihre Lake Formation Formation-Benutzer Zugriff auf Daten erhalten, die sich bereits an diesem Standort befinden. Durch das Anzeigen dieser Liste können Sie sicherstellen, dass die vorhandenen Daten sicher bleiben.
1. Wählen Sie für die **IAM-Rolle** entweder die `AWSServiceRoleForLakeFormationDataAccess` serviceverknüpfte Rolle (Standard) oder Ihre benutzerdefinierte Rolle, die dem entspricht. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md)
1. Wählen Sie „Standort **registrieren“.**
Weitere Informationen zur serviceverknüpften Rolle finden Sie unter [Dienstbezogene Rollenberechtigungen für Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Um einen Amazon S3 S3-Standort zu registrieren, der verschlüsselt ist mit einem Von AWS verwalteter Schlüssel**
**Wichtig**
Wenn sich der Amazon S3 S3-Standort nicht in demselben AWS Konto wie der Datenkatalog befindet, folgen Sie [AWS Kontoübergreifende Registrierung eines verschlüsselten Amazon S3 S3-Standorts](register-cross-encrypted.md) stattdessen den Anweisungen unter.
1. Erstellen Sie eine IAM-Rolle, die zur Registrierung des Standorts verwendet werden soll. Stellen Sie sicher, dass es die unter aufgeführten Anforderungen erfüllt. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md)
1. Fügen Sie der Rolle die folgende Inline-Richtlinie hinzu. Sie gewährt Berechtigungen für den Schlüssel zur Rolle. In der `Resource` Spezifikation muss der Amazon-Ressourcenname (ARN) des Von AWS verwalteter Schlüssel angegeben werden. Sie können den ARN von der AWS KMS Konsole abrufen. Um den richtigen ARN zu erhalten, stellen Sie sicher, dass Sie sich bei der AWS KMS Konsole mit demselben AWS Konto und derselben Region anmelden Von AWS verwalteter Schlüssel , mit der der Standort verschlüsselt wurde.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
}
]
}
```
------
Sie können KMS-Schlüsselaliase anstelle der Schlüssel-ID verwenden - `arn:aws:kms:region:account-id:key/alias/your-key-alias`
Weitere Informationen finden Sie [im AWS KMS Abschnitt Aliase im](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html) AWS Key Management Service Entwicklerhandbuch.
1. Öffnen Sie die AWS Lake Formation Konsole unter. [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) Melden Sie sich als Data Lake-Administrator oder als Benutzer mit der `lakeformation:RegisterResource` IAM-Berechtigung an.
1. Wählen Sie im Navigationsbereich unter **Verwaltung** die Option **Data Lake-Standorte** aus.
1. Wählen Sie **Standort registrieren** und anschließend **Durchsuchen**, um einen Amazon S3 S3-Pfad auszuwählen.
1. (Optional, aber dringend empfohlen) Wählen Sie **Standortberechtigungen überprüfen**, um eine Liste aller vorhandenen Ressourcen am ausgewählten Amazon S3 S3-Standort und deren Berechtigungen anzuzeigen.
Die Registrierung des ausgewählten Standorts kann dazu führen, dass Ihre Lake Formation Formation-Benutzer Zugriff auf Daten erhalten, die sich bereits an diesem Standort befinden. Durch das Anzeigen dieser Liste können Sie sicherstellen, dass die vorhandenen Daten sicher bleiben.
1. Wählen Sie für die **IAM-Rolle** die Rolle aus, die Sie in Schritt 1 erstellt haben.
1. Wählen Sie **Standort registrieren**.
# Registrierung eines Amazon S3 S3-Standorts in einem anderen AWS Konto
AWS Lake Formation ermöglicht es Ihnen, Amazon Simple Storage Service (Amazon S3) -Standorte AWS kontenübergreifend zu registrieren. Wenn sich der beispielsweise in Konto A AWS Glue Data Catalog befindet, kann ein Benutzer in Konto A einen Amazon S3 S3-Bucket in Konto B registrieren.
Die Registrierung eines Amazon S3 S3-Buckets in AWS Konto B mithilfe einer AWS Identity and Access Management (IAM-) Rolle in AWS Konto A erfordert die folgenden Berechtigungen:
+ Die Rolle in Konto A muss Berechtigungen für den Bucket in Konto B gewähren.
+ Die Bucket-Richtlinie in Konto B muss der Rolle in Konto A Zugriffsberechtigungen gewähren.
**Wichtig**
Vermeiden Sie es, einen Amazon S3 S3-Bucket zu registrieren, für den Zahlungen durch den **Antragsteller aktiviert** ist. Bei Buckets, die bei Lake Formation registriert sind, wird die Rolle, mit der der Bucket registriert wurde, immer als der Anforderer angesehen. Wenn ein anderes AWS Konto auf den Bucket zugreift, wird dem Bucket-Besitzer der Datenzugriff in Rechnung gestellt, sofern die Rolle zu demselben Konto gehört wie der Bucket-Besitzer.
Sie können die dienstverknüpfte Rolle Lake Formation nicht verwenden, um einen Standort in einem anderen Konto zu registrieren. Sie müssen stattdessen eine benutzerdefinierte Rolle verwenden. Die Rolle muss die Anforderungen von erfüllen. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md) Weitere Informationen zur serviceverknüpften Rolle finden Sie unter [Dienstbezogene Rollenberechtigungen für Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Bevor Sie beginnen**
Überprüfen Sie die [Anforderungen für die Rolle, mit der der Standort registriert](registration-role.md) wurde.
**Um einen Standort in einem anderen AWS Konto zu registrieren**
**Anmerkung**
Wenn der Standort verschlüsselt ist, folgen Sie [AWS Kontoübergreifende Registrierung eines verschlüsselten Amazon S3 S3-Standorts](register-cross-encrypted.md) stattdessen den Anweisungen unter.
Das folgende Verfahren geht davon aus, dass ein Principal im Konto 1111-2222-3333, das den Datenkatalog enthält, den Amazon S3 S3-Bucket registrieren möchte, der sich im Konto `awsexamplebucket1` 1234-5678-9012 befindet.
1. Melden Sie sich im Konto 1111-2222-3333 bei der an und öffnen Sie die IAM-Konsole unter. AWS-Managementkonsole [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Erstellen Sie eine neue Rolle oder zeigen Sie eine vorhandene Rolle an, die die Anforderungen in erfüllt. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md) Stellen Sie sicher, dass die Rolle Amazon S3 S3-Berechtigungen gewährt`awsexamplebucket1`.
1. Öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). Melden Sie sich mit dem Konto 1234-5678-9012 an.
1. Wählen Sie in der Liste mit den **Bucket-Namen den Bucket-Namen** aus. `awsexamplebucket1`
1. Wählen Sie **Berechtigungen**.
1. Wählen Sie auf der Seite „**Berechtigungen**“ die Option **Bucket Policy** aus.
1. Fügen Sie im **Bucket-Policy-Editor** die folgende Richtlinie ein. Ersetzen Sie ** durch den Namen Ihrer Rolle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action":"s3:ListBucket",
"Resource":"arn:aws:s3:::awsexamplebucket1"
},
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:PutObject"
],
"Resource":"arn:aws:s3:::awsexamplebucket1/*"
}
]
}
```
------
1. Wählen Sie **Speichern**.
1. Öffnen Sie die AWS Lake Formation Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Melden Sie sich als Data Lake-Administrator oder als Benutzer mit ausreichenden Berechtigungen zum Registrieren von Standorten beim Konto 1111-2222-3333 an.
1. **Wählen Sie im Navigationsbereich unter **Verwaltung** die Option Data Lake-Standorte aus.**
1. Wählen Sie auf der Seite **Data Lake-Standorte** die Option **Standort registrieren** aus.
1. Geben Sie auf der **Seite Speicherort registrieren** für den **Amazon S3 S3-Pfad** den Bucket-Namen ein`s3://awsexamplebucket1`.
**Anmerkung**
**Sie müssen den Bucket-Namen eingeben, da kontoübergreifende Buckets nicht in der Liste erscheinen, wenn Sie Durchsuchen wählen.**
1. Wählen Sie für die **IAM-Rolle Ihre Rolle** aus.
1. Wählen Sie **Standort registrieren**.
# AWS Kontoübergreifende Registrierung eines verschlüsselten Amazon S3 S3-Standorts
AWS Lake Formation integriert in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)(AWS KMS), damit Sie andere integrierte Dienste zum Verschlüsseln und Entschlüsseln von Daten an Amazon Simple Storage Service (Amazon S3) -Standorten einfacher einrichten können.
Beide vom Kunden verwalteten Schlüssel und Von AWS verwaltete Schlüssel werden unterstützt. Clientseitig encryption/decryption wird nicht unterstützt.
**Wichtig**
Vermeiden Sie es, einen Amazon S3 S3-Bucket zu registrieren, für den Zahlungen durch den **Antragsteller aktiviert** ist. Bei Buckets, die bei Lake Formation registriert sind, wird die Rolle, mit der der Bucket registriert wurde, immer als der Anforderer angesehen. Wenn ein anderes AWS Konto auf den Bucket zugreift, wird dem Bucket-Besitzer der Datenzugriff in Rechnung gestellt, sofern die Rolle zu demselben Konto gehört wie der Bucket-Besitzer.
In diesem Abschnitt wird erklärt, wie Sie einen Amazon S3 S3-Standort unter den folgenden Umständen registrieren:
+ Die Daten am Amazon S3 S3-Standort werden mit einem KMS-Schlüssel verschlüsselt, der in erstellt wurde AWS KMS.
+ Der Amazon S3 S3-Standort befindet sich nicht in demselben AWS Konto wie der AWS Glue Data Catalog.
+ Der KMS-Schlüssel befindet sich entweder in demselben AWS Konto wie der Datenkatalog oder nicht.
Die Registrierung eines AWS KMS—verschlüsselten Amazon S3 S3-Buckets in AWS Konto B mithilfe einer AWS Identity and Access Management (IAM-) Rolle in AWS Konto A erfordert die folgenden Berechtigungen:
+ Die Rolle in Konto A muss Berechtigungen für den Bucket in Konto B gewähren.
+ Die Bucket-Richtlinie in Konto B muss der Rolle in Konto A Zugriffsberechtigungen gewähren.
+ Wenn sich der KMS-Schlüssel in Konto B befindet, muss die Schlüsselrichtlinie Zugriff auf die Rolle in Konto A gewähren, und die Rolle in Konto A muss Berechtigungen für den KMS-Schlüssel gewähren.
Im folgenden Verfahren erstellen Sie eine Rolle in dem AWS Konto, das den Datenkatalog enthält (Konto A in der vorherigen Diskussion). Anschließend verwenden Sie diese Rolle, um den Standort zu registrieren. Lake Formation übernimmt diese Rolle beim Zugriff auf zugrunde liegende Daten in Amazon S3. Die übernommene Rolle verfügt über die erforderlichen Berechtigungen für den KMS-Schlüssel. Daher müssen Sie Prinzipalen, die mit ETL-Aufträgen oder integrierten Diensten wie z. B. auf die zugrunde liegenden Daten zugreifen, keine Berechtigungen für den KMS-Schlüssel gewähren. Amazon Athena
**Wichtig**
Sie können die dienstverknüpfte Rolle Lake Formation nicht verwenden, um einen Standort in einem anderen Konto zu registrieren. Sie müssen stattdessen eine benutzerdefinierte Rolle verwenden. Die Rolle muss die Anforderungen von erfüllen. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md) Weitere Informationen zur serviceverknüpften Rolle finden Sie unter [Dienstbezogene Rollenberechtigungen für Lake Formation](service-linked-roles.md#service-linked-role-permissions).
**Bevor Sie beginnen**
Überprüfen Sie die [Anforderungen für die Rolle, mit der der Standort registriert](registration-role.md) wurde.
**Um einen verschlüsselten Amazon S3 S3-Standort AWS kontenübergreifend zu registrieren**
1. Melden Sie sich mit demselben AWS Konto wie der Datenkatalog an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Erstellen Sie eine neue Rolle oder zeigen Sie eine vorhandene Rolle an, die die Anforderungen in [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md) erfüllt. Stellen Sie sicher, dass die Rolle eine Richtlinie enthält, die Amazon S3 S3-Berechtigungen für den Standort gewährt.
1. Wenn sich der KMS-Schlüssel nicht in demselben Konto wie der Datenkatalog befindet, fügen Sie der Rolle eine Inline-Richtlinie hinzu, die die erforderlichen Berechtigungen für den KMS-Schlüssel gewährt. Es folgt eine Beispielrichtlinie . Ersetzen Sie Region und Konto-ID durch die Region und Kontonummer des KMS-Schlüssels. **Ersetzen Sie durch die Schlüssel-ID.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/"
}
]
}
```
------
1. Fügen Sie in der Amazon S3 S3-Konsole eine Bucket-Richtlinie hinzu, die der Rolle die erforderlichen Amazon S3 S3-Berechtigungen gewährt. Hier finden Sie ein Beispiel für eine Bucket-Richtlinie. Ersetzen Sie die Konto-ID durch die AWS Kontonummer des Datenkatalogs, ** durch den Namen Ihrer Rolle und ** durch den Namen des Buckets.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action":"s3:ListBucket",
"Resource":"arn:aws:s3:::"
},
{
"Effect":"Allow",
"Principal": {
"AWS":"arn:aws:iam::111122223333:role/"
},
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:PutObject"
],
"Resource":"arn:aws:s3:::/*"
}
]
}
```
------
1. Fügen Sie AWS KMS unter die Rolle als Benutzer des KMS-Schlüssels hinzu.
1. Öffnen Sie die AWS KMS Konsole unter [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms). Melden Sie sich dann als Administratorbenutzer oder als Benutzer an, der die Schlüsselrichtlinie des KMS-Schlüssels ändern kann, der zur Verschlüsselung des Speicherorts verwendet wird.
1. Wählen Sie im Navigationsbereich die Option Vom **Kunden verwaltete Schlüssel** und dann den Namen des KMS-Schlüssels aus.
1. Wenn auf der Seite mit den **KMS-Schlüsseldetails auf der Registerkarte Schlüsselrichtlinie** die JSON-Ansicht der Schlüsselrichtlinie nicht angezeigt wird, wählen Sie **Zur Richtlinienansicht wechseln** aus.
1. Wählen Sie im Abschnitt **Schlüsselrichtlinie** die Option **Bearbeiten** und fügen Sie dem `Allow use of the key` Objekt den Amazon-Ressourcennamen (ARN) der Rolle hinzu, wie im folgenden Beispiel gezeigt.
**Anmerkung**
Wenn das Objekt fehlt, fügen Sie es mit den im Beispiel gezeigten Berechtigungen hinzu.
```
...
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam:::role/"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
...
```
Weitere Informationen finden Sie unter [Zulassen, dass Benutzer mit anderen Konten einen KMS-Schlüssel verwenden](https://docs.amazonaws.cn/en_us/kms/latest/developerguide/key-policy-modifying-external-accounts.html) können im *AWS Key Management Service Entwicklerhandbuch*.
1. Öffnen Sie die AWS Lake Formation Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Melden Sie sich als Data Lake-Administrator beim Data AWS Catalog-Konto an.
1. Wählen Sie im Navigationsbereich unter **Verwaltung** die Option **Data Lake-Standorte** aus.
1. Wählen Sie **Standort registrieren** aus.
1. Geben Sie auf der **Seite Standort registrieren** für **Amazon S3 S3-Pfad** den Standortpfad als ein**s3://**/****. **Ersetzen Sie ihn durch den Namen des Buckets und ** durch den Rest des Pfads für den Standort.
**Anmerkung**
**Sie müssen den Pfad eingeben, da kontoübergreifende Buckets nicht in der Liste angezeigt werden, wenn Sie Durchsuchen wählen.**
1. Wählen Sie für die **IAM-Rolle** die Rolle aus Schritt 2 aus.
1. Wählen Sie **Standort registrieren** aus.
# Abmeldung eines Amazon S3 S3-Standorts
Sie können einen Amazon Simple Storage Service (Amazon S3) -Standort abmelden, wenn Sie nicht mehr möchten, dass er von Lake Formation verwaltet wird. Die Abmeldung eines Standorts hat keine Auswirkungen auf die Datenstandortberechtigungen von Lake Formation, die für diesen Standort erteilt wurden. Sie können einen Standort, für den Sie die Registrierung aufgehoben haben, erneut registrieren, und die Berechtigungen für den Datenspeicherort bleiben in Kraft. Sie können eine andere Rolle verwenden, um den Standort erneut zu registrieren.
**Um einen Standort abzumelden (Konsole)**
1. Öffnen Sie die AWS Lake Formation Konsole unter. [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) Melden Sie sich als Data Lake-Administrator oder als Benutzer mit der `lakeformation:RegisterResource` IAM-Berechtigung an.
1. Wählen Sie im Navigationsbereich unter **Verwaltung** die Option **Data Lake-Standorte** aus.
1. Wählen Sie einen Speicherort aus, und klicken Sie im Menü **Aktionen** auf **Entfernen**.
1. Wenn Sie zur Bestätigung aufgefordert werden, wählen Sie **Entfernen**.
# Hybrider Zugriffsmodus
AWS Lake Formation *Der hybride Zugriffsmodus* unterstützt zwei Berechtigungspfade für dieselben Objekte. AWS Glue Data Catalog
Im ersten Schritt können Sie mit Lake Formation bestimmte Principals auswählen und ihnen Lake Formation Formation-Berechtigungen für den Zugriff auf Kataloge, Datenbanken, Tabellen und Ansichten gewähren, indem Sie sich dafür anmelden. Der zweite Weg ermöglicht allen anderen Prinzipalen den Zugriff auf diese Ressourcen über die standardmäßigen IAM-Prinzipalrichtlinien für Amazon S3 und AWS Glue Aktionen.
Wenn Sie einen Amazon S3 S3-Standort bei Lake Formation registrieren, haben Sie die Möglichkeit, entweder Lake Formation Formation-Berechtigungen für alle Ressourcen an diesem Standort durchzusetzen oder den hybriden Zugriffsmodus zu verwenden. Der hybride Zugriffsmodus erzwingt standardmäßig nur `CREATE_TABLE` `UPDATE_TABLE` Berechtigungen. `CREATE_PARTITION` Wenn sich ein Amazon S3 S3-Standort im Hybridmodus befindet, können Sie Lake Formation Formation-Berechtigungen aktivieren, indem Sie Prinzipale für die Datenkatalogobjekte unter diesem Standort auswählen. Das bedeutet, dass sowohl Lake Formation Formation-Berechtigungen als auch IAM-Berechtigungen den Zugriff auf diese Daten kontrollieren können. Das bedeutet, dass für registrierte Principals sowohl Lake Formation Formation-Berechtigungen als auch IAM-Berechtigungen für den Zugriff auf die Daten erforderlich sind, während non-opted-in Principals weiterhin ausschließlich mit IAM-Berechtigungen auf Daten zugreifen.
Somit bietet der hybride Zugriffsmodus die Flexibilität, Lake Formation selektiv für Kataloge, Datenbanken und Tabellen in Ihrem Datenkatalog für eine bestimmte Gruppe von Benutzern zu aktivieren, ohne den Zugriff für andere bestehende Benutzer oder Workloads zu unterbrechen.
![\[AWS-Konto architecture showing data flow between S3, Glue, Lake Formation, Athena, and IAM roles.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/hybrid-access-mode-concept.png)
Überlegungen und Einschränkungen finden Sie unter [Überlegungen und Einschränkungen des hybriden Zugriffsmodus](notes-hybrid.md).Begriffe und Definitionen
Im Folgenden finden Sie die Definitionen von Datenkatalogressourcen, die darauf basieren, wie Sie Zugriffsberechtigungen einrichten:
Ressource Lake Formation
Eine Ressource, die bei Lake Formation registriert ist. Benutzer benötigen Lake Formation Formation-Berechtigungen, um auf die Ressource zugreifen zu können.
AWS Glue Ressource
Eine Ressource, die nicht bei Lake Formation registriert ist. Benutzer benötigen nur IAM-Berechtigungen, um auf die Ressource zuzugreifen, da sie über `IAMAllowedPrincipals` Gruppenberechtigungen verfügt. Die Genehmigungen für Lake Formation werden nicht durchgesetzt.
Weitere Informationen zu `IAMAllowedPrincipals` Gruppenberechtigungen finden Sie unter[Berechtigungen für Metadaten](metadata-permissions.md).
Hybride Ressource
Eine Ressource, die im Hybridzugriffsmodus registriert ist. Je nachdem, welche Benutzer auf die Ressource zugreifen, wechselt die Ressource dynamisch zwischen einer Lake Formation Formation-Ressource und einer AWS Glue Ressource.
## Allgemeine Anwendungsfälle im hybriden Zugriffsmodus
Sie können den hybriden Zugriffsmodus verwenden, um den Zugriff in Szenarien für die gemeinsame Nutzung von Daten mit einem Konto und zwischen Konten bereitzustellen:
**Szenarien mit einem einzigen Konto**
+ **Eine AWS Glue Ressource in eine Hybridressource konvertieren** — In diesem Szenario verwenden Sie Lake Formation derzeit nicht, möchten aber Lake Formation Formation-Berechtigungen für Datenkatalogobjekte übernehmen. Wenn Sie den Amazon S3 S3-Standort im Hybridzugriffsmodus registrieren, können Sie Benutzern, die sich für bestimmte Datenbanken und Tabellen entscheiden, die auf diesen Standort verweisen, Lake Formation Formation-Berechtigungen gewähren.
+ **Eine Lake Formation Formation-Ressource in eine Hybridressource konvertieren** — Derzeit verwenden Sie Lake Formation Formation-Berechtigungen, um den Zugriff auf eine Data Catalog-Datenbank zu steuern, möchten aber neuen Principals mithilfe von IAM-Berechtigungen für Amazon S3 Zugriff gewähren, AWS Glue ohne die bestehenden Lake Formation Formation-Berechtigungen zu unterbrechen.
Wenn Sie eine Datenstandortregistrierung auf den Hybridzugriffsmodus aktualisieren, können neue Principals mithilfe von IAM-Berechtigungsrichtlinien auf die Data Catalog-Datenbank zugreifen, die auf den Amazon S3 S3-Standort verweist, ohne die Lake Formation Formation-Berechtigungen der bestehenden Benutzer zu unterbrechen.
Bevor Sie die Datenstandortregistrierung aktualisieren, um den Hybridzugriffsmodus zu aktivieren, müssen Sie zunächst Prinzipale aktivieren, die derzeit mit Lake Formation Formation-Berechtigungen auf die Ressource zugreifen.
Dadurch soll eine mögliche Unterbrechung des aktuellen Workflows verhindert werden.
Sie müssen der `IAMAllowedPrincipal` Gruppe auch `Super` Berechtigungen für die Tabellen in der Datenbank erteilen.
**Szenarien für den kontenübergreifenden Datenaustausch**
+ ** AWS Glue Ressourcen im hybriden Zugriffsmodus gemeinsam nutzen** — In diesem Szenario verfügt das Produzentenkonto über Tabellen in einer Datenbank, die derzeit mit einem Verbraucherkonto gemeinsam genutzt werden, das IAM-Berechtigungsrichtlinien für Amazon S3 und AWS Glue Aktionen verwendet. Der Datenstandort der Datenbank ist nicht bei Lake Formation registriert.
Bevor Sie den Datenstandort im Hybridzugriffsmodus registrieren, müssen Sie die **Einstellungen der kontoübergreifenden Version** auf Version 4 aktualisieren. Version 4 enthält die neuen AWS RAM Berechtigungsrichtlinien, die für die kontoübergreifende gemeinsame Nutzung erforderlich sind, wenn die `IAMAllowedPrincipal` Gruppe über die erforderlichen `Super` Berechtigungen für die Ressource verfügt. Für Ressourcen mit `IAMAllowedPrincipal` Gruppenberechtigungen können Sie externen Konten Lake Formation Formation-Berechtigungen gewähren und sie für die Verwendung von Lake Formation Formation-Berechtigungen aktivieren. Der Data Lake-Administrator im Empfängerkonto kann den Prinzipalen im Konto Lake Formation Formation-Berechtigungen gewähren und sie aktivieren, um die Lake Formation Formation-Berechtigungen durchzusetzen.
+ **Lake Formation Formation-Ressourcen im hybriden Zugriffsmodus gemeinsam nutzen** — Derzeit enthält das Produzentenkonto Tabellen in einer Datenbank, die mit einem Verbraucherkonto gemeinsam genutzt werden, wodurch Lake Formation Formation-Berechtigungen durchgesetzt werden. Der Datenstandort der Datenbank ist bei Lake Formation registriert.
In diesem Fall können Sie die Amazon S3-Standortregistrierung auf den Hybridzugriffsmodus aktualisieren und die Daten aus Amazon S3 und Metadaten aus dem Datenkatalog mithilfe von Amazon S3 S3-Bucket-Richtlinien und Datenkatalog-Ressourcenrichtlinien an Prinzipale im Kundenkonto weitergeben. Sie müssen die bestehenden Lake Formation Formation-Berechtigungen erneut gewähren und die Principals aktivieren, bevor Sie die Amazon S3 S3-Standortregistrierung aktualisieren. Außerdem müssen Sie der Gruppe `Super` Berechtigungen für die Tabellen in der Datenbank erteilen. `IAMAllowedPrincipals`
**Topics**
+ [Allgemeine Anwendungsfälle im hybriden Zugriffsmodus](#hybrid-access-mode-use-cases)
+ [So funktioniert der hybride Zugriffsmodus](hybrid-access-workflow.md)
+ [Einrichtung des hybriden Zugriffsmodus — häufig vorkommende Szenarien](hybrid-access-setup.md)
+ [Prinzipale und Ressourcen aus dem Hybridzugriffsmodus entfernen](delete-hybrid-access.md)
+ [Prinzipale und Ressourcen im Hybridzugriffsmodus anzeigen](view-hybrid-access.md)
+ [Weitere Ressourcen](additional-resources-hybrid.md)
# So funktioniert der hybride Zugriffsmodus
Das folgende Diagramm zeigt, wie die Lake Formation Formation-Autorisierung im Hybridzugriffsmodus funktioniert, wenn Sie die Datenkatalogressourcen abfragen.
![\[AWS Lake Formation authorization process flowchart for hybrid access mode queries.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/hybrid-workflow.png)
Vor dem Zugriff auf Daten in Ihrem Data Lake richtet ein Data Lake-Administrator oder ein Benutzer mit Administratorberechtigungen individuelle Benutzerrichtlinien für Datenkatalogtabellen ein, um den Zugriff auf Tabellen in Ihrem Datenkatalog zuzulassen oder zu verweigern. Anschließend registriert ein Principal, der über die erforderlichen Berechtigungen zur Ausführung des `RegisterResource` Vorgangs verfügt, den Amazon S3 S3-Standort der Tabelle bei Lake Formation im Hybridzugriffsmodus. Wenn ein Datenstandort nicht bei Lake Formation registriert ist, erteilt der Administrator bestimmten Benutzern Lake Formation Formation-Berechtigungen für die Data Catalog-Datenbanken und -Tabellen und stimmt ihnen zu, Lake Formation Formation-Berechtigungen für diese Datenbanken und Tabellen im Hybridzugriffsmodus zu verwenden.
1. **Sendet eine Abfrage** — Ein Principal übermittelt eine Abfrage oder ein ETL-Skript mithilfe eines integrierten Services wie Amazon Athena AWS Glue, Amazon EMR oder Amazon Redshift Spectrum.
1. **Fordert Daten** an — Die integrierte Analyse-Engine identifiziert die angeforderte Tabelle und sendet die Metadatenanforderung an den Datenkatalog (,). `GetTable` `GetDatabase`
1. **Prüft die Berechtigungen** — Der Datenkatalog überprüft die Zugriffsberechtigungen des abfragenden Prinzipals mit Lake Formation.
1. Wenn der Tabelle keine `IAMAllowedPrincipals` Gruppenberechtigungen zugewiesen sind, werden Lake Formation Formation-Berechtigungen erzwungen.
1. Wenn sich der Principal für die Verwendung Lake Formation Formation-Berechtigungen im Hybridzugriffsmodus entschieden hat und der Tabelle `IAMAllowedPrincipals` Gruppenberechtigungen zugewiesen sind, werden Lake Formation Formation-Berechtigungen durchgesetzt. Die Abfrage-Engine wendet die Filter an, die sie von Lake Formation erhalten hat, und gibt die Daten an den Benutzer zurück.
1. Wenn der Tabellenstandort nicht bei Lake Formation registriert ist und der Principal sich nicht für die Verwendung von Lake Formation Formation-Berechtigungen im Hybridzugriffsmodus entschieden hat, prüft der Datenkatalog, ob der Tabelle `IAMAllowedPrincipals` Gruppenberechtigungen zugewiesen sind. Wenn diese Berechtigung für die Tabelle vorhanden ist, erhalten alle Prinzipale im Konto `Super` oder `All` Berechtigungen für die Tabelle.
Der Verkauf von Anmeldeinformationen für Lake Formation ist nicht verfügbar, auch wenn diese Option aktiviert ist, es sei denn, der Datenstandort ist bei Lake Formation registriert.
1. **Anmeldeinformationen abrufen** — Der Datenkatalog überprüft und teilt der Engine mit, ob der Tabellenstandort bei Lake Formation registriert ist oder nicht. Wenn die zugrunde liegenden Daten bei Lake Formation registriert sind, fordert die Analyse-Engine Lake Formation nach temporären Anmeldeinformationen für den Zugriff auf Daten im Amazon S3 S3-Bucket an.
1. **Daten abrufen** — Wenn der Principal berechtigt ist, auf die Tabellendaten zuzugreifen, bietet Lake Formation temporären Zugriff auf die integrierte Analyse-Engine. Mithilfe des temporären Zugriffs ruft die Analyse-Engine die Daten von Amazon S3 ab und führt die erforderlichen Filter wie Spalten-, Zeilen- oder Zellenfilterung durch. Wenn die Engine die Ausführung des Jobs beendet hat, gibt sie die Ergebnisse an den Benutzer zurück. Dieser Prozess wird als Anmeldeinformationsvergabe bezeichnet. Für weitere Informationen siehe[Integration von Diensten von Drittanbietern mit Lake Formation](Integrating-with-LakeFormation.md).
1.
Wenn der Datenstandort der Tabelle nicht bei Lake Formation registriert ist, erfolgt der zweite Aufruf von der Analyse-Engine direkt an Amazon S3. Die betreffende Amazon S3 S3-Bucket-Richtlinie und die IAM-Benutzerrichtlinie werden im Hinblick auf den Datenzugriff bewertet. Wenn Sie IAM-Richtlinien verwenden, stellen Sie sicher, dass Sie die bewährten IAM-Methoden befolgen. Weitere Informationen finden Sie unter [Bewährte Sicherheitsmethoden in IAM im IAM-Benutzerhandbuch](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html).
# Einrichtung des hybriden Zugriffsmodus — häufig vorkommende Szenarien
Wie bei Lake Formation Formation-Berechtigungen gibt es im Allgemeinen zwei Arten von Szenarien, in denen Sie den Hybridzugriffsmodus verwenden können, um den Datenzugriff zu verwalten: Gewähren Sie Zugriff auf Prinzipale innerhalb eines Systems AWS-Konto und gewähren Sie Zugriff auf einen externen AWS-Konto oder Prinzipal.
Dieser Abschnitt enthält Anweisungen zur Einrichtung des hybriden Zugriffsmodus in den folgenden Szenarien:
**Verwalten Sie Berechtigungen im hybriden Zugriffsmodus innerhalb eines AWS-Konto**
+ [Eine AWS Glue Ressource in eine Hybridressource konvertieren](hybrid-access-mode-new.md)— Sie gewähren derzeit Zugriff auf Tabellen in einer Datenbank für alle Principals in Ihrem Konto mithilfe von IAM-Berechtigungen für Amazon S3 und AWS Glue möchten Lake Formation verwenden, um Berechtigungen schrittweise zu verwalten.
+ [Umwandlung einer Lake Formation Formation-Ressource in eine Hybridressource](hybrid-access-mode-update.md)— Sie verwenden derzeit Lake Formation, um den Zugriff auf Tabellen in einer Datenbank für alle Prinzipale in Ihrem Konto zu verwalten, möchten Lake Formation jedoch nur für bestimmte Prinzipale verwenden. Sie möchten Zugriff auf neue Principals gewähren, indem Sie IAM-Berechtigungen für AWS Glue und Amazon S3 für dieselbe Datenbank und dieselben Tabellen verwenden.
**Verwalten Sie Berechtigungen im hybriden Zugriffsmodus für mehrere AWS-Konto**
+ [Gemeinsame Nutzung einer AWS Glue Ressource im hybriden Zugriffsmodus](hybrid-access-mode-cross-account.md)— Sie verwenden Lake Formation derzeit nicht, um Berechtigungen für eine Tabelle zu verwalten, möchten aber Lake Formation Formation-Berechtigungen anwenden, um Prinzipalen in einem anderen Konto Zugriff zu gewähren.
+ [Gemeinsame Nutzung einer Lake Formation Formation-Ressource im hybriden Zugriffsmodus](hybrid-access-mode-cross-account-IAM.md)— Sie verwenden Lake Formation, um den Zugriff auf eine Tabelle zu verwalten, möchten aber Zugriff für Principals in einem anderen Konto gewähren, indem Sie IAM-Berechtigungen für AWS Glue und Amazon S3 für dieselbe Datenbank und dieselben Tabellen verwenden.
**Einrichtung des hybriden Zugriffsmodus — Allgemeine Schritte**
1. Registrieren Sie den Amazon S3 S3-Datenstandort bei Lake Formation, indem Sie **den Hybrid-Zugriffsmodus** auswählen.
1. Principals müssen über die `DATA_LOCATION` Berechtigung für einen Data Lake-Standort verfügen, um Datenkatalogtabellen oder Datenbanken zu erstellen, die auf diesen Speicherort verweisen.
1. Stellen Sie die **Einstellung für kontoübergreifende Version** auf Version 4 ein.
1. Gewähren Sie bestimmten IAM-Benutzern oder -Rollen detaillierte Berechtigungen für Datenbanken und Tabellen. Stellen Sie gleichzeitig sicher, dass Sie der `IAMAllowedPrincipals` Gruppe in der Datenbank und allen oder ausgewählten Tabellen in der Datenbank `All` Berechtigungen zuweisen. `Super`
1. Wählen Sie die Prinzipale und Ressourcen aus. Andere Principals im Konto können weiterhin auf die Datenbanken und Tabellen zugreifen, indem sie IAM-Berechtigungsrichtlinien für AWS Glue und Amazon S3 S3-Aktionen verwenden.
1. Bereinigen Sie optional die IAM-Berechtigungsrichtlinien für Amazon S3 für die Principals, die sich für die Verwendung von Lake Formation Formation-Berechtigungen angemeldet haben.
# Voraussetzungen für die Einrichtung des hybriden Zugriffsmodus
Im Folgenden sind die Voraussetzungen für die Einrichtung des hybriden Zugriffsmodus aufgeführt:
**Anmerkung**
Wir empfehlen, dass ein Lake Formation-Administrator den Amazon S3 S3-Standort im Hybridzugriffsmodus registriert und Prinzipale und Ressourcen aktiviert.
1. Erteilen Sie die Datenstandortberechtigung (`DATA_LOCATION_ACCESS`), um Datenkatalogressourcen zu erstellen, die auf die Amazon S3 S3-Standorte verweisen. Datenstandortberechtigungen steuern die Fähigkeit, Datenkatalogkataloge, Datenbanken und Tabellen zu erstellen, die auf bestimmte Amazon S3 S3-Standorte verweisen.
1. Um Data Catalog-Ressourcen mit einem anderen Konto im Hybridzugriffsmodus gemeinsam zu nutzen (ohne die `IAMAllowedPrincipals` Gruppenberechtigungen für die Ressource zu entfernen), müssen Sie die **Einstellungen der kontoübergreifenden Version** auf Version 4 oder höher aktualisieren. Um die Version mit der Lake Formation Console zu aktualisieren, wählen Sie **Version 4** oder **Version 5** unter **Einstellungen für kontoübergreifende Versionen** auf der Seite mit den **Datenkatalogeinstellungen** aus.
Sie können den `put-data-lake-settings` AWS CLI Befehl auch verwenden, um den `CROSS_ACCOUNT_VERSION` Parameter auf Version 4 oder 5 zu setzen:
```
aws lakeformation put-data-lake-settings --region us-east-1 --data-lake-settings file://settings
{
"DataLakeAdmins": [
{
"DataLakePrincipalIdentifier": "arn:aws:iam::<111122223333>:user/"
}
],
"CreateDatabaseDefaultPermissions": [],
"CreateTableDefaultPermissions": [],
"Parameters": {
"CROSS_ACCOUNT_VERSION": "5"
}
}
```
1.
Um kontenübergreifende Berechtigungen im Hybridzugriffsmodus zu gewähren, muss der Gewährer über die erforderlichen IAM-Berechtigungen für AWS Glue Dienste und Dienste verfügen. AWS RAM Die AWS verwaltete Richtlinie `AWSLakeFormationCrossAccountManager` gewährt die erforderlichen Berechtigungen.
Um die kontoübergreifende gemeinsame Nutzung von Daten im Hybridzugriffsmodus zu ermöglichen, haben wir die `AWSLakeFormationCrossAccountManager` verwaltete Richtlinie aktualisiert und zwei neue IAM-Berechtigungen hinzugefügt:
+ RAM: ListResourceSharePermissions
+ RAM: AssociateResourceSharePermission
**Anmerkung**
Wenn Sie die AWS verwaltete Richtlinie nicht für die Rolle des Antragstellers verwenden, fügen Sie die oben genannten Richtlinien zu Ihren benutzerdefinierten Richtlinien hinzu.
## Amazon S3 S3-Bucket-Standort und Benutzerzugriff
Wenn Sie einen Katalog, eine Datenbank oder eine Tabelle in der erstellen AWS Glue Data Catalog, können Sie den Amazon S3 S3-Bucket-Speicherort der zugrunde liegenden Daten angeben und ihn bei Lake Formation registrieren. In den folgenden Tabellen wird beschrieben, wie Berechtigungen für AWS Glue und Lake Formation Formation-Benutzer (Principals) funktionieren, basierend auf dem Amazon S3 S3-Datenspeicherort der Tabelle oder Datenbank.
**Amazon S3 S3-Standort ist bei Lake Formation registriert**
| Amazon S3 S3-Speicherort einer Datenbank | AWS Glue Benutzer | Lake Formation Formation-Benutzer |
| --- | --- | --- |
| Registriert bei Lake Formation (im Hybrid-Zugriffsmodus oder im Lake Formation Formation-Modus) | Haben Sie read/write Zugriff auf den Amazon S3 S3-Datenstandort, indem Sie die Berechtigungen der IAMAllowed Principals-Gruppe (Superzugriff) erben. | Erben Sie die Berechtigungen zum Erstellen von Tabellen von der ihnen erteilten CREATE TABLE-Berechtigung. |
| Kein zugeordneter Amazon S3 S3-Standort | Für die Ausführung der Anweisungen CREATE TABLE und INSERT TABLE ist die ausdrückliche DATA LOCATION-Berechtigung erforderlich. | Für die Ausführung der Anweisungen CREATE TABLE und INSERT TABLE ist die ausdrückliche DATA LOCATION-Berechtigung erforderlich. |
****IsRegisteredWithLakeFormation**Tabelleneigenschaft**
Die `IsRegisteredWithLakeFormation` Eigenschaft einer Tabelle gibt an, ob die Datenposition der Tabelle bei Lake Formation für den Anforderer registriert ist. Wenn der Berechtigungsmodus des Standorts als Lake Formation registriert ist, gilt die `IsRegisteredWithLakeFormation` Eigenschaft `true` für alle Benutzer, die auf den Datenstandort zugreifen, da alle Benutzer als für diese Tabelle angemeldet gelten. Wenn der Standort im Hybridzugriffsmodus registriert ist, wird der Wert `true` nur für Benutzer festgelegt, die sich für diese Tabelle angemeldet haben.
**Funktionsweise von `IsRegisteredWithLakeFormation`**
| Berechtigungsmodus | Benutzer/Rollen | `IsRegisteredWithLakeFormation` | Description |
| --- | --- | --- | --- |
| Lake Formation | Alle | Wahr | Wenn ein Standort bei Lake Formation registriert ist, wird die `IsRegisteredWithLakeFormation` Eigenschaft für alle Benutzer auf true gesetzt. Das bedeutet, dass die in Lake Formation definierten Berechtigungen für den registrierten Standort gelten. Der Verkauf von Anmeldeinformationen wird von Lake Formation durchgeführt. |
| Hybrider Zugriffsmodus | Hat sich angemeldet | Wahr | Für Benutzer, die sich für die Verwendung von Lake Formation für den Datenzugriff und die Verwaltung einer Tabelle entschieden haben, wird die `IsRegisteredWithLakeFormation` Eigenschaft `true` für diese Tabelle auf gesetzt. Sie unterliegen den in Lake Formation für den registrierten Standort definierten Genehmigungsrichtlinien. |
| Hybrider Zugriffsmodus | Nicht angemeldet | Falsch | Für Benutzer, die sich nicht für die Verwendung von Lake Formation Formation-Berechtigungen entschieden haben, ist die `IsRegisteredWithLakeFormation` Eigenschaft auf gesetzt`false`. Sie unterliegen nicht den in Lake Formation für den registrierten Standort definierten Genehmigungsrichtlinien. Stattdessen befolgen die Benutzer die Amazon S3 S3-Berechtigungsrichtlinien. |
# Eine AWS Glue Ressource in eine Hybridressource konvertieren
Gehen Sie wie folgt vor, um einen Amazon S3 S3-Standort im Hybridzugriffsmodus zu registrieren und neue Lake Formation-Benutzer einzubinden, ohne den Datenzugriff der bestehenden Data Catalog-Benutzer zu unterbrechen.
Beschreibung des Szenarios — Der Datenstandort ist nicht bei Lake Formation registriert, und der Benutzerzugriff auf die Data Catalog-Datenbank und die Tabellen wird durch IAM-Berechtigungsrichtlinien für Amazon S3 und AWS Glue Aktionen bestimmt.
Die `IAMAllowedPrincipals` Gruppe hat standardmäßig `Super` Berechtigungen für alle Tabellen in der Datenbank.
**Um den Hybridzugriffsmodus für einen Datenstandort zu aktivieren, der nicht bei Lake Formation registriert ist**
1.
**Registrieren Sie einen Amazon S3 S3-Standort, um den Hybrid-Zugriffsmodus zu aktivieren.**
------
#### [ Console ]
1. Melden Sie sich als Data Lake-Administrator bei der [Lake Formation Formation-Konsole](https://console.aws.amazon.com/lakeformation/) an.
1. Wählen Sie im Navigationsbereich unter **Administration** die Option **Data Lake-Standorte** aus.
1. Wählen Sie **Standort registrieren** aus.
![\[Register location form for Amazon S3 data lake with path input, IAM role selection, and permission mode options.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/hybrid-access-register-s3.png)
1. Wählen Sie im Fenster **Standort registrieren** den **Amazon S3-Pfad** aus, den Sie bei Lake Formation registrieren möchten.
1. Wählen Sie für die **IAM-Rolle** entweder die `AWSServiceRoleForLakeFormationDataAccess` serviceverknüpfte Rolle (Standard) oder eine benutzerdefinierte IAM-Rolle Rolle, die die Anforderungen von erfüllt. [Anforderungen für Rollen, die zur Registrierung von Standorten verwendet werden](registration-role.md)
1. Wählen Sie **den Hybrid-Zugriffsmodus**, um detaillierte Lake Formation Formation-Zugriffskontrollrichtlinien auf Opt-in-Prinzipale und Data Catalog-Datenbanken und -Tabellen anzuwenden, die auf den registrierten Standort verweisen.
Wählen Sie Lake Formation, damit Lake Formation Zugriffsanfragen für den registrierten Standort autorisieren kann.
1. Wählen Sie **Standort registrieren**.
------
#### [ AWS CLI ]
Im Folgenden finden Sie ein Beispiel für die Registrierung eines Datenstandorts bei Lake Formation HybridAccessEnabled mit:true/false. Der Standardwert für den Parameter ist falsch. `HybridAccessEnabled` Ersetzen Sie den Amazon S3 S3-Pfad, den Rollennamen und die AWS Konto-ID durch gültige Werte.
```
aws lakeformation register-resource --cli-input-json file:file path
json:
{
"ResourceArn": "arn:aws:s3:::s3-path",
"UseServiceLinkedRole": false,
"RoleArn": "arn:aws:iam::<123456789012>:role/",
"HybridAccessEnabled": true
}
```
------
1.
**Gewähren Sie Berechtigungen und stimmen Sie Principals zu, um Lake Formation Formation-Berechtigungen für Ressourcen im Hybridzugriffsmodus zu verwenden**
Bevor Sie sich für Prinzipale und Ressourcen im Hybridzugriffsmodus entscheiden, stellen Sie sicher, dass für die Datenbanken und Tabellen, deren Standort bei Lake Formation im Hybridzugriffsmodus registriert ist, `Super` oder `All` Berechtigungen zum `IAMAllowedPrincipals` Gruppieren vorhanden sind.
**Anmerkung**
Sie können der `IAMAllowedPrincipals` Gruppe `All tables` innerhalb einer Datenbank keine Zugriffsrechte gewähren. Sie müssen jede Tabelle separat aus dem Drop-down-Menü auswählen und Berechtigungen erteilen. Wenn Sie neue Tabellen in der Datenbank erstellen, können Sie auch die `Use only IAM access control for new tables in new databases` in den **Datenkatalogeinstellungen** verwenden. Diese Option erteilt der `IAMAllowedPrincipals` Gruppe automatisch die `Super` Berechtigung, wenn Sie neue Tabellen in der Datenbank erstellen.
------
#### [ Console ]
1. Wählen Sie in der Lake Formation Formation-Konsole unter **Datenkatalog** die Option **Kataloge**, **Datenbanken** oder **Tabellen** aus.
1. Wählen Sie einen Katalog, eine Datenbank oder eine Tabelle aus der Liste aus und wählen Sie im Menü **Aktionen** die Option **Grant** aus.
1. Wählen Sie Principals aus, um mithilfe von benannten Ressourcenmethoden oder LF-Tags Berechtigungen für die Datenbank, Tabellen und Spalten zu gewähren.
**Wählen Sie alternativ **Datenberechtigungen** aus, wählen Sie aus der Liste die Prinzipale aus, denen Berechtigungen erteilt werden sollen, und wählen Sie dann Grant aus.**
Weitere Informationen zum Erteilen von Datenberechtigungen finden Sie unter[Erteilen von Berechtigungen für Datenkatalogressourcen](granting-catalog-permissions.md).
**Anmerkung**
Wenn Sie einem Prinzipal die Berechtigung „Tabelle erstellen“ erteilen, müssen Sie dem Prinzipal auch Datenspeicherberechtigungen (`DATA_LOCATION_ACCESS`) erteilen. Diese Berechtigung ist nicht erforderlich, um Tabellen zu aktualisieren.
Weitere Informationen finden Sie unter [Erteilung von Berechtigungen zum Speicherort von Daten](granting-location-permissions.md).
1. Wenn Sie die **Methode „Benannte Ressource“** verwenden, um Berechtigungen zu erteilen, ist die Option, Prinzipale und Ressourcen zu aktivieren, im unteren Bereich der Seite **Datenberechtigungen gewähren** verfügbar.
Wählen Sie **Lake Formation Formation-Berechtigungen sofort wirksam machen**, um Lake Formation Formation-Berechtigungen für die Prinzipale und Ressourcen zu aktivieren.
![\[Die Option zur Auswahl des hybriden Zugriffsmodus für die Datenkatalogressource.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/hybrid-access-grant-option.png)
1. Wählen Sie **Grant (Erteilen)**.
Wenn Sie Principal A für Tabelle A auswählen, die auf einen Datenstandort verweist, ermöglicht es Principal A, mithilfe von Lake Formation Formation-Berechtigungen auf den Speicherort dieser Tabelle zuzugreifen, wenn der Datenstandort im Hybridmodus registriert ist.
------
#### [ AWS CLI ]
Im Folgenden finden Sie ein Beispiel für die Auswahl eines Prinzipals und einer Tabelle im Hybridzugriffsmodus. Ersetzen Sie den Rollennamen, die AWS Konto-ID, den Datenbanknamen und den Tabellennamen durch gültige Werte.
```
aws lakeformation create-lake-formation-opt-in --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam::<123456789012>:role/"
},
"Resource": {
"Table": {
"CatalogId": "<123456789012>",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
1. Wenn Sie LF-Tags zur Erteilung von Berechtigungen wählen, können Sie in einem separaten Schritt festlegen, dass Prinzipale Lake Formation Formation-Berechtigungen verwenden. Sie können dies tun, indem Sie in der linken Navigationsleiste unter **Berechtigungen** den **Hybrid-Zugriffsmodus** auswählen.
1. Wählen Sie im unteren Bereich der Seite **Hybrid-Zugriffsmodus** die Option **Hinzufügen** aus, um Ressourcen und Prinzipale zum Hybridzugriffsmodus hinzuzufügen.
1. Wählen Sie auf der Seite **Ressourcen und Prinzipale hinzufügen** die Kataloge, Datenbanken und Tabellen aus, die im Hybridzugriffsmodus registriert sind.
Sie können `All tables` unter einer Datenbank auswählen, ob Sie Zugriff gewähren möchten.
![\[Die Schnittstelle zum Hinzufügen von Katalogen, Datenbanken und Tabellen im Hybridzugriffsmodus.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/hybrid-access-opt-in.png)
1. Wählen Sie Principals aus, um Lake Formation Formation-Berechtigungen im hybriden Zugriffsmodus zu verwenden.
+ **Principals** — Sie können IAM-Benutzer und -Rollen für dasselbe Konto oder für ein anderes Konto auswählen. Sie können auch SAML-Benutzer und -Gruppen auswählen.
+ **Attribute** — Wählen Sie Attribute aus, um Berechtigungen auf der Grundlage von Attributen zu gewähren.
![\[Die Schnittstelle zum Hinzufügen von Prinzipalen und Ressourcen mit einem Attributausdruck.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/abac-hybrid-access.png)
+ Geben Sie das Schlüssel-Wert-Paar ein, um einen Grant auf der Grundlage von Attributen zu erstellen. Überprüfen Sie den Cedar-Richtlinienausdruck auf der Konsole. Weitere Informationen zu Cedar finden Sie unter [Was ist Cedar? \$1 Sprachreferenz für Cedar Policy GuideLink](https://docs.cedarpolicy.com/).
+ Wählen Sie **Hinzufügen** aus.
Allen IAMs roles/users mit passenden Attributen wird Zugriff gewährt.
1. Wählen Sie **Hinzufügen** aus.
# Umwandlung einer Lake Formation Formation-Ressource in eine Hybridressource
In Fällen, in denen Sie derzeit Lake Formation Formation-Berechtigungen für Ihre Datenkatalog-Datenbanken und -Tabellen verwenden, können Sie die Eigenschaften der Standortregistrierung bearbeiten, um den Hybridzugriffsmodus zu aktivieren. Auf diese Weise können Sie neuen Principals mithilfe von IAM-Berechtigungsrichtlinien für Amazon S3 und AWS Glue Aktionen Zugriff auf dieselben Ressourcen gewähren, ohne bestehende Lake Formation Formation-Berechtigungen zu unterbrechen.
Beschreibung des Szenarios — Bei den folgenden Schritten wird davon ausgegangen, dass Sie einen Datenstandort bei Lake Formation registriert haben und dass Sie Berechtigungen für Prinzipale für Datenbanken, Tabellen oder Spalten eingerichtet haben, die auf diesen Speicherort verweisen. Wenn der Standort mit einer dienstverknüpften Rolle registriert wurde, können Sie die Standortparameter nicht aktualisieren und den Hybridzugriffsmodus nicht aktivieren. Die `IAMAllowedPrincipals` Gruppe verfügt standardmäßig über Superberechtigungen für die Datenbank und all ihre Tabellen.
**Wichtig**
Aktualisieren Sie eine Standortregistrierung nicht auf den Hybridzugriffsmodus, ohne die Prinzipale zu aktivieren, die auf Daten an diesem Standort zugreifen.
**Aktivierung des hybriden Zugriffsmodus für einen bei Lake Formation registrierten Datenstandort**
1.
**Warnung**
Wir empfehlen nicht, einen von Lake Formation verwalteten Datenstandort in den hybriden Zugriffsmodus zu konvertieren, um zu vermeiden, dass die Berechtigungsrichtlinien anderer vorhandener Benutzer oder Workloads unterbrochen werden.
Entscheiden Sie sich für die bestehenden Principals, die über Lake Formation Formation-Berechtigungen verfügen.
1. Führen Sie die Berechtigungen auf, die Sie Principals für Kataloge, Datenbanken und Tabellen erteilt haben, und überprüfen Sie sie. Weitere Informationen finden Sie unter [Datenbank- und Tabellenberechtigungen in Lake Formation anzeigen](viewing-permissions.md).
1. **Wählen Sie in der linken Navigationsleiste unter **Berechtigungen** den **Hybrid-Zugriffsmodus** und dann Hinzufügen aus.**
1. Wählen Sie auf der Seite **Prinzipale und Ressourcen hinzufügen** die Kataloge, Datenbanken und Tabellen aus dem Amazon S3 S3-Datenspeicherort aus, die Sie im Hybridzugriffsmodus verwenden möchten. Wählen Sie die Principals aus, die bereits über Lake Formation Formation-Berechtigungen verfügen.
1. Wählen Sie **Hinzufügen**, um die Prinzipale für die Verwendung von Lake Formation Formation-Berechtigungen im Hybridzugriffsmodus zu aktivieren.
1. Aktualisieren Sie die Amazon S3 bucket/prefix S3-Registrierung, indem Sie die Option **Hybrid-Zugriffsmodus** wählen.
------
#### [ Console ]
1. Melden Sie sich als Data Lake-Administrator bei der Lake Formation Formation-Konsole an.
1. Wählen Sie im Navigationsbereich unter **Registrieren und Ingest** die Option **Data Lake-Standorte** aus.
1. Wählen Sie einen Standort aus, und klicken Sie im Menü **Aktionen** auf **Bearbeiten**.
1. Wählen Sie **den Hybrid-Zugriffsmodus**.
1. Wählen Sie **Speichern**.
1. Wählen Sie unter Datenkatalog die Datenbank oder Tabelle aus und gewähren Sie der aufgerufenen virtuellen Gruppe `Super` oder `All` Berechtigungen`IAMAllowedPrincipals`.
1. Stellen Sie sicher, dass der Zugriff Ihrer bestehenden Lake Formation Formation-Benutzer nicht unterbrochen wird, wenn Sie die Eigenschaften der Standortregistrierung aktualisiert haben. Melden Sie sich als Lake Formation-Principal bei der Athena-Konsole an und führen Sie eine Beispielabfrage für eine Tabelle aus, die auf den aktualisierten Speicherort verweist.
Überprüfen Sie auf ähnliche Weise den Zugriff von AWS Glue Benutzern, die IAM-Berechtigungsrichtlinien für den Zugriff auf die Datenbank und die Tabellen verwenden.
------
#### [ AWS CLI ]
Im Folgenden finden Sie ein Beispiel für die Registrierung eines Datenstandorts bei Lake Formation HybridAccessEnabled mit:true/false. Der Standardwert für den Parameter ist falsch. `HybridAccessEnabled` Ersetzen Sie den Amazon S3 S3-Pfad, den Rollennamen und die AWS Konto-ID durch gültige Werte.
```
aws lakeformation update-resource --cli-input-json file://file path
json:
{
"ResourceArn": "arn:aws:s3:::",
"RoleArn": "arn:aws:iam::<123456789012>:role/",
"HybridAccessEnabled": true
}
```
------
# Gemeinsame Nutzung einer AWS Glue Ressource im hybriden Zugriffsmodus
Teilen Sie Daten mit einem anderen AWS-Konto oder einem Principal in einem anderen, indem Sie Lake Formation AWS-Konto Formation-Berechtigungen durchsetzen, ohne den IAM-basierten Zugriff vorhandener Data Catalog-Benutzer zu unterbrechen.
Beschreibung des Szenarios — Das Produzentenkonto verfügt über eine Datenkatalog-Datenbank, deren Zugriff mithilfe von IAM-Prinzipalrichtlinien für Amazon S3 und AWS Glue Aktionen gesteuert wird. Der Datenstandort der Datenbank ist nicht bei Lake Formation registriert. Die `IAMAllowedPrincipals` Gruppe hat standardmäßig `Super` Berechtigungen für die Datenbank und all ihre Tabellen.
**Erteilung kontenübergreifender Lake Formation Formation-Berechtigungen im Hybridzugriffsmodus**
1.
**Produzentenkonto eingerichtet**
1. Melden Sie sich mit einer Rolle, die über `lakeformation:PutDataLakeSettings` IAM-Berechtigungen verfügt, bei der Lake Formation Formation-Konsole an.
1. Gehen Sie zu den **Datenkatalogeinstellungen** und wählen Sie die **Einstellungen `Version 4` für die kontoübergreifende Version** aus.
Wenn Sie derzeit Version 1 oder 2 verwenden, lesen Sie die [Aktualisierung der Versionseinstellungen für die kontenübergreifende gemeinsame Nutzung von Daten](optimize-ram.md) Anweisungen zur Aktualisierung auf Version 3.
Beim Upgrade von Version 3 auf 4 sind keine Änderungen der Berechtigungsrichtlinien erforderlich.
1. Registrieren Sie den Amazon S3 S3-Speicherort der Datenbank oder Tabelle, die Sie im Hybridzugriffsmodus teilen möchten.
1. Vergewissern Sie sich, dass für die Datenbanken und Tabellen, deren Datenspeicherort Sie im obigen Schritt im Hybridzugriffsmodus registriert haben, `Super` Berechtigungen für die `IAMAllowedPrincipals` Gruppe vorhanden sind.
1. Erteilen Sie Lake Formation Formation-Berechtigungen für AWS Organisationen, Organisationseinheiten (OUs) oder direkt mit einem IAM-Prinzipal in einem anderen Konto.
1. Wenn Sie einem IAM-Prinzipal direkt Berechtigungen gewähren, wählen Sie den Prinzipal aus dem Verbraucherkonto aus, um Lake Formation Formation-Berechtigungen im Hybridzugriffsmodus durchzusetzen, indem Sie die Option **Lake Formation Formation-Berechtigungen sofort wirksam machen** aktivieren aktivieren.
Wenn Sie einem anderen AWS Konto kontoübergreifende Berechtigungen gewähren, werden die Lake Formation Formation-Berechtigungen bei der Aktivierung des Kontos nur für die Administratoren dieses Kontos durchgesetzt. Der Data Lake-Administrator des Empfängerkontos muss die Berechtigungen kaskadieren und die Principals im Konto aktivieren, um Lake Formation Formation-Berechtigungen für die gemeinsam genutzten Ressourcen durchzusetzen, die sich im Hybridzugriffsmodus befinden.
Wenn Sie die Option **Mit LF-Tags abgeglichene Ressourcen** auswählen, um kontoübergreifende Berechtigungen zu gewähren, müssen Sie zuerst den Schritt „Berechtigungen erteilen“ abschließen. Sie können Principals und Ressourcen in einem separaten Schritt für den Hybridzugriffsmodus aktivieren, indem Sie in der linken Navigationsleiste der Lake Formation Formation-Konsole unter Berechtigungen den **Hybridzugriffsmodus** auswählen. Wählen Sie dann **Hinzufügen**, um die Ressourcen und Principals hinzuzufügen, für die Sie Lake Formation Formation-Berechtigungen erzwingen möchten.
1.
**Kundenkonto eingerichtet**
1. Melden Sie sich [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)als Data Lake-Administrator bei der Lake Formation Formation-Konsole an.
1. Gehen Sie zur [https://console.aws.amazon.com/ram/Startseite](https://console.aws.amazon.com/ram/home) und nehmen Sie die Einladung zur gemeinsamen Nutzung von Ressourcen an. Auf der Registerkarte **Für mich freigegeben** in der AWS RAM Konsole werden die Datenbank und die Tabellen angezeigt, die für Ihr Konto freigegeben sind.
1. Erstellen Sie einen Ressourcenlink zur gemeinsam genutzten and/or Datenbanktabelle in Lake Formation.
1. `Describe`Erteilen Sie den IAM-Prinzipalen in Ihrem (Verbraucher-) Konto `Grant on target` Berechtigungen für den Ressourcenlink und Berechtigungen (für die ursprünglich gemeinsam genutzte Ressource).
1. Erteilen Sie den Prinzipalen in Ihrem Konto Lake Formation Formation-Berechtigungen für die Datenbank oder Tabelle, die mit Ihnen geteilt wurde. Entscheiden Sie sich für die Prinzipale und Ressourcen, um Lake Formation Formation-Berechtigungen im hybriden Zugriffsmodus durchzusetzen, indem Sie die Option **Lake Formation Formation-Berechtigungen sofort wirksam machen** aktivieren aktivieren.
1. Testen Sie die Lake Formation Formation-Berechtigungen des Prinzipals, indem Sie Athena-Beispielabfragen ausführen. Testen Sie den bestehenden Zugriff Ihrer AWS Glue Benutzer mit IAM-Prinzipalrichtlinien für Amazon S3 und AWS Glue Aktionen.
(Optional) Entfernen Sie die Amazon S3 S3-Bucket-Richtlinie für den Datenzugriff und die IAM-Prinzipalrichtlinien für AWS Glue und den Amazon S3 S3-Datenzugriff für die Prinzipale, die Sie für die Verwendung von Lake Formation Formation-Berechtigungen konfiguriert haben.
# Gemeinsame Nutzung einer Lake Formation Formation-Ressource im hybriden Zugriffsmodus
Erlauben Sie neuen Data Catalog-Benutzern in einem externen Konto den Zugriff auf Data Catalog-Datenbanken und -Tabellen mithilfe von IAM-basierten Richtlinien, ohne die bestehenden Kontofreigabeberechtigungen von Lake Formation zu unterbrechen.
Beschreibung des Szenarios: Das Produzentenkonto verfügt über eine von Lake Formation verwaltete Datenbank und Tabellen, die mit einem externen (Verbraucher-) Konto auf Konto- oder IAM-Prinzipalebene gemeinsam genutzt werden. Der Datenstandort der Datenbank ist bei Lake Formation registriert. Die `IAMAllowedPrincipals` Gruppe hat keine `Super` Berechtigungen für die Datenbank und ihre Tabellen.
**Neuen Data Catalog-Benutzern kontenübergreifenden Zugriff über IAM-basierte Richtlinien gewähren, ohne bestehende Lake Formation Formation-Berechtigungen zu unterbrechen**
1.
**Produzentenkonto eingerichtet**
1. Melden Sie sich mit einer Rolle bei der Lake Formation Formation-Konsole an`lakeformation:PutDataLakeSettings`.
1. Wählen Sie unter **Einstellungen für den Datenkatalog** die **Einstellungen `Version 4` für die kontoübergreifende Version** aus.
Wenn Sie derzeit Version 1 oder 2 verwenden, lesen Sie die [Aktualisierung der Versionseinstellungen für die kontenübergreifende gemeinsame Nutzung von Daten](optimize-ram.md) Anweisungen zur Aktualisierung auf Version 3.
Für ein Upgrade von Version 3 auf 4 sind keine Änderungen der Berechtigungsrichtlinien erforderlich.
1. Führen Sie die Berechtigungen auf, die Sie Prinzipalen für Datenbanken und Tabellen erteilt haben. Weitere Informationen finden Sie unter [Datenbank- und Tabellenberechtigungen in Lake Formation anzeigen](viewing-permissions.md).
1. Gewähren Sie bestehende kontoübergreifende Berechtigungen von Lake Formation erneut, indem Sie sich für Prinzipale und Ressourcen entscheiden.
**Anmerkung**
Bevor Sie eine Datenstandortregistrierung auf den Hybridzugriffsmodus aktualisieren, um kontenübergreifende Berechtigungen zu gewähren, müssen Sie mindestens eine kontenübergreifende Datenfreigabe pro Konto erneut gewähren. Dieser Schritt ist erforderlich, um die AWS RAM verwalteten Berechtigungen zu aktualisieren, die der Ressourcenfreigabe zugeordnet sind. AWS RAM
Im Juli 2023 hat Lake Formation die AWS RAM verwalteten Berechtigungen aktualisiert, die für die gemeinsame Nutzung von Datenbanken und Tabellen verwendet werden:
`arn:aws:ram::aws:permission/AWSRAMLFEnabledGlueAllTablesReadWriteForDatabase`(Richtlinie zur gemeinsamen Nutzung auf Datenbankebene)
`arn:aws:ram::aws:permission/AWSRAMLFEnabledGlueTableReadWrite`(Freigaberichtlinie auf Tabellenebene)
Für kontoübergreifende Genehmigungen, die vor Juli 2023 erteilt wurden, gelten diese aktualisierten Berechtigungen nicht. AWS RAM
Wenn Sie Prinzipalen direkt kontoübergreifende Berechtigungen erteilt haben, müssen Sie diese Berechtigungen den Prinzipalen einzeln erneut gewähren. Wenn Sie diesen Schritt überspringen, wird bei den Prinzipalen, die auf die gemeinsam genutzte Ressource zugreifen, möglicherweise ein unzulässiger Kombinationsfehler angezeigt.
1. Geh nach [https://console.aws.amazon.com/ram/Hause](https://console.aws.amazon.com/ram/home).
1. Auf der Registerkarte **Von mir gemeinsam genutzt** in der AWS RAM Konsole werden die Datenbank- und Tabellennamen angezeigt, die Sie mit einem externen Konto oder Prinzipal geteilt haben.
Stellen Sie sicher, dass die mit der gemeinsam genutzten Ressource verknüpften Berechtigungen den richtigen ARN haben.
1. Stellen Sie sicher, dass die Ressourcen in der AWS RAM Freigabe `Associated` den Status haben. Wenn der Status als angezeigt wird`Associating`, warten Sie, bis sie in den `Associated` Status wechseln. Wenn der Status lautet`Failed`, halten Sie an und wenden Sie sich an das Lake Formation-Serviceteam.
1. Wählen Sie in der linken Navigationsleiste unter **Berechtigungen** den **Hybrid-Zugriffsmodus** und dann **Hinzufügen** aus.
1. Auf der Seite „**Prinzipale und Ressourcen hinzufügen**“ werden die Datenbanken, and/or Tabellen und Prinzipale angezeigt, die Zugriff haben. Sie können die erforderlichen Aktualisierungen vornehmen, indem Sie Prinzipale und Ressourcen hinzufügen oder entfernen.
1. Wählen Sie die Principals mit Lake Formation Formation-Berechtigungen für die Datenbank und die Tabellen aus, die Sie in den Hybridzugriffsmodus ändern möchten. Wählen Sie die Datenbanken und Tabellen aus.
1. Wählen Sie **Hinzufügen**, um die Principals zu aktivieren, um Lake Formation Formation-Berechtigungen im Hybridzugriffsmodus durchzusetzen.
1. Erteilen Sie der virtuellen Gruppe `Super` `IAMAllowedPrincipals` Berechtigungen für Ihre Datenbank und ausgewählte Tabellen.
1. Bearbeiten Sie die Registrierung des Amazon S3 S3-Standorts Lake Formation in den Hybridzugriffsmodus.
1. Erteilen Sie den AWS Glue Benutzern im externen (Verbraucher-) Konto mithilfe von IAM-Berechtigungsrichtlinien für Amazon S3 AWS Glue S3-Aktionen Berechtigungen.
1.
**Kundenkonto eingerichtet**
1. Melden Sie sich [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)als Data Lake-Administrator bei der Lake Formation Formation-Konsole an.
1. Gehen Sie zur [https://console.aws.amazon.com/ram/Startseite](https://console.aws.amazon.com/ram/home) und nehmen Sie die Einladung zur gemeinsamen Nutzung von Ressourcen an. Auf der Registerkarte **Mit mir geteilte Ressourcen** auf der AWS RAM Seite werden die Datenbank- und Tabellennamen angezeigt, die mit Ihrem Konto geteilt wurden.
Stellen Sie für das AWS RAM Teilen sicher, dass die angehängte Berechtigung den richtigen ARN der geteilten AWS RAM Einladung enthält. Prüfen Sie, ob sich die Ressourcen in der AWS RAM Freigabe im `Associated` Status befinden. Wenn der Status als angezeigt wird`Associating`, warten Sie, bis sie in den `Associated` Status wechseln. Wenn der Status lautet`Failed`, halten Sie an und wenden Sie sich an das Lake Formation-Serviceteam.
1. Erstellen Sie einen Ressourcenlink zur gemeinsam genutzten and/or Datenbanktabelle in Lake Formation.
1. `Describe`Erteilen Sie den IAM-Prinzipalen in Ihrem (Verbraucher-) Konto `Grant on target` Berechtigungen für den Ressourcenlink und Berechtigungen (für die ursprünglich gemeinsam genutzte Ressource).
1. Als Nächstes richten Sie Lake Formation Formation-Berechtigungen für Principals in Ihrem Konto in der gemeinsam genutzten Datenbank oder Tabelle ein.
Wählen Sie in der linken Navigationsleiste unter **Berechtigungen** den **Hybridzugriffsmodus** aus.
1. Wählen Sie im unteren Bereich der Seite für den **hybriden Zugriffsmodus** die Option **Hinzufügen** aus, um die Prinzipale und die Datenbank oder Tabelle zu aktivieren, die über das Produzentenkonto für Sie freigegeben wurde.
1. Erteilen Sie den AWS Glue Benutzern in Ihrem Konto mithilfe von IAM-Berechtigungsrichtlinien für Amazon S3 AWS Glue S3-Aktionen Berechtigungen.
1. Testen Sie die Lake Formation Formation-Berechtigungen und AWS Glue -Berechtigungen der Benutzer, indem Sie mit Athena separate Beispielabfragen für die Tabelle ausführen
(Optional) Bereinigen Sie die IAM-Berechtigungsrichtlinien für Amazon S3 für die Principals, die sich im Hybridzugriffsmodus befinden.
# Prinzipale und Ressourcen aus dem Hybridzugriffsmodus entfernen
Gehen Sie wie folgt vor, um Datenbanken, Tabellen und Prinzipale aus dem Hybridzugriffsmodus zu entfernen.
------
#### [ Console ]
1. Melden Sie sich bei der Lake Formation Formation-Konsole unter an [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie unter **Berechtigungen** die Option **Hybrid-Zugriffsmodus** aus.
1. Aktivieren Sie auf der Seite **Hybrid-Zugriffsmodus** das Kontrollkästchen neben dem Datenbank- oder Tabellennamen und wählen Sie`Remove`.
1. In einer Warnmeldung werden Sie aufgefordert, die Aktion zu bestätigen. Wählen Sie **Remove (Entfernen)** aus.
Lake Formation erzwingt keine Berechtigungen mehr für diese Ressourcen, und der Zugriff auf diese Ressource wird mithilfe von IAM und AWS Glue Berechtigungen gesteuert. Dies kann dazu führen, dass der Benutzer keinen Zugriff mehr auf diese Ressource hat, wenn er nicht über die entsprechenden IAM-Berechtigungen verfügt.
------
#### [ AWS CLI ]
Das folgende Beispiel zeigt, wie Ressourcen aus dem Hybridzugriffsmodus entfernt werden.
```
aws lakeformation delete-lake-formation-opt-in --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam::<123456789012>:role/role name"
},
"Resource": {
"Table": {
"CatalogId": "<123456789012>",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
# Prinzipale und Ressourcen im Hybridzugriffsmodus anzeigen
Gehen Sie wie folgt vor, um Datenbanken, Tabellen und Prinzipale im Hybridzugriffsmodus anzuzeigen.
------
#### [ Console ]
1. Melden Sie sich bei der Lake Formation Formation-Konsole unter an [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie unter **Berechtigungen** die Option **Hybrid-Zugriffsmodus** aus.
1. Auf der Seite **Hybridzugriffsmodus** werden die Ressourcen und Prinzipale angezeigt, die sich derzeit im Hybridzugriffsmodus befinden.
------
#### [ AWS CLI ]
Das folgende Beispiel zeigt, wie alle Opt-in-Prinzipale und Ressourcen aufgelistet werden, die sich im Hybridzugriffsmodus befinden.
```
aws lakeformation list-lake-formation-opt-ins
```
Das folgende Beispiel zeigt, wie Opt-In für ein bestimmtes Principal-Resource-Paar aufgelistet wird.
```
aws lakeformation list-lake-formation-opt-ins --cli-input-json file://file path
json:
{
"Principal": {
"DataLakePrincipalIdentifier": "arn:aws:iam:::role/"
},
"Resource": {
"Table": {
"CatalogId": "",
"DatabaseName": "",
"Name": ""
}
}
}
```
------
# Weitere Ressourcen
Im folgenden Blogbeitrag führen wir Sie durch die Anweisungen zur Integration von Lake Formation Formation-Berechtigungen im Hybrid-Zugriffsmodus für ausgewählte Benutzer, während die Datenbank bereits für andere Benutzer über IAM- und Amazon S3 S3-Berechtigungen zugänglich ist. Wir werden uns die Anweisungen zur Einrichtung des hybriden Zugriffsmodus innerhalb eines AWS Kontos und zwischen zwei Konten ansehen.
+ [Einführung des hybriden Zugriffsmodus für AWS Glue Data Catalog den sicheren Zugriff mithilfe von Lake Formation und IAM- und Amazon S3 S3-Richtlinien.](https://aws.amazon.com/blogs/big-data/introducing-hybrid-access-mode-for-aws-glue-data-catalog-to-secure-access-using-aws-lake-formation-and-iam-and-amazon-s3-policies/)
# Objekte erstellen in AWS Glue Data Catalog
AWS Lake Formation verwendet den AWS Glue Data Catalog (Datenkatalog), um Metadaten zu Data Lakes, Datenquellen, Transformationen und Zielen zu speichern. Metadaten sind Daten zu den Daten im Datensatz. Jedes AWS Konto hat einen Datenkatalog pro AWS Region.
Die Metadaten im Datenkatalog sind in einer dreistufigen Datenhierarchie organisiert, die Kataloge, Datenbanken und Tabellen umfasst. Es organisiert Daten aus verschiedenen Quellen in logischen Containern, den sogenannten Katalogen. Jeder Katalog stellt Daten aus Quellen wie Amazon Redshift Data Warehouses, Amazon DynamoDB Datenbanken und Datenquellen von Drittanbietern wie Snowflake, MySQL und über 30 externen Datenquellen dar, die über föderierte Konnektoren integriert sind. Sie können auch neue Kataloge im Datenkatalog erstellen, um Daten in S3 Table Buckets oder Redshift Managed Storage (RMS) zu speichern.
In Tabellen werden Informationen über die zugrunde liegenden Daten gespeichert, einschließlich Schemainformationen, Partitionsinformationen und Datenspeicherort. Datenbanken sind Sammlungen von Tabellen. Der Datenkatalog enthält auch Ressourcenlinks, d. h. Links zu gemeinsam genutzten Katalogen, Datenbanken und Tabellen in externen Konten, die für den kontenübergreifenden Zugriff auf Daten im Data Lake verwendet werden.
Der Datenkatalog ist ein verschachteltes Katalogobjekt, das Kataloge, Datenbanken und Tabellen enthält. Er wird durch die AWS-Konto ID referenziert und ist der Standardkatalog in einem Konto und einem. AWS-Region Der Datenkatalog verwendet eine dreistufige Hierarchie (catalog.database.table), um Tabellen zu organisieren.
+ Katalog — Die oberste Ebene der dreistufigen Metadatenhierarchie des Datenkatalogs. Sie können einem Datenkatalog über einen Verbund mehrere Kataloge hinzufügen.
+ Datenbank — Die zweite Ebene der Metadatenhierarchie, die aus Tabellen und Ansichten besteht. Eine Datenbank wird in vielen Datensystemen wie Amazon Redshift und Trino auch als Schema bezeichnet.
+ Tabelle und Ansicht — Die dritte Ebene der dreistufigen Datenhierarchie des Datenkatalogs.
Alle Iceberg-Tabellen in Amazon S3 werden im Standard-Datenkatalog mit der Katalog-ID = AWS-Konto ID gespeichert. Sie können Verbundkataloge erstellen AWS Glue Data Catalog , in denen Definitionen von Tabellen in Amazon Redshift, Amazon S3 Table Storage oder anderen Datenquellen von Drittanbietern über den Verbund gespeichert werden.
**Topics**
+ [Einen Katalog erstellen](creating-catalog.md)
+ [Erstellen einer Datenbank](creating-database.md)
+ [Erstellen von Tabellen](creating-tables.md)
+ [AWS Glue Data Catalog Ansichten von Gebäuden](working-with-views.md)
# Einen Katalog erstellen
Kataloge stellen die höchste oder oberste Ebene in der dreistufigen Metadatenhierarchie von dar. AWS Glue Data Catalog Sie können mehrere Methoden verwenden, um Daten in den Datenkatalog aufzunehmen und Kataloge mit mehreren Ebenen zu erstellen.
Weitere Informationen zum Erstellen von Katalogen aus externen Datenquellen finden Sie unter. [Bringen Sie Ihre Daten in die AWS Glue Data Catalog](bring-your-data-overview.md)
Um einen Katalog mit der Lake Formation Formation-Konsole zu erstellen, müssen Sie als Data Lake-Administrator oder *Katalogersteller* angemeldet sein. Ein Katalogersteller ist ein Principal, dem die `CREATE_CATALOG` Genehmigung für Lake Formation erteilt wurde. Eine Liste der Katalogersteller finden Sie auf der Seite **Administrative Rollen und Aufgaben** der Lake Formation Formation-Konsole. Um diese Liste anzeigen zu können, müssen Sie über die `lakeformation:ListPermissions` IAM-Berechtigung verfügen und als Data Lake-Administrator oder als Katalogersteller mit der Option „Gewähren“ für die `CREATE_CATALOG` Berechtigung angemeldet sein.
# Erstellen einer Datenbank
Metadatentabellen im Datenkatalog werden in Datenbanken gespeichert. Sie können so viele Datenbanken erstellen, wie Sie benötigen, und Sie können für jede Datenbank unterschiedliche Lake Formation Formation-Berechtigungen gewähren.
Datenbanken können über eine optionale Standorteigenschaft verfügen. Dieser Standort befindet sich normalerweise innerhalb eines Amazon Simple Storage Service (Amazon S3) -Standorts, der bei Lake Formation registriert ist. Wenn Sie einen Speicherort angeben, benötigen Principals keine Datenspeicherortberechtigungen, um Datenkatalogtabellen zu erstellen, die auf Speicherorte innerhalb des Datenbankspeicherorts verweisen. Weitere Informationen finden Sie unter [Underlying data access control](access-control-underlying-data.md#data-location-permissions).
Um eine Datenbank mit der Lake Formation Formation-Konsole zu erstellen, müssen Sie als Data Lake-Administrator oder *Datenbankersteller* angemeldet sein. Ein Datenbankersteller ist ein Principal, dem die Lake Formation `CREATE_DATABASE` Formation-Genehmigung erteilt wurde. Eine Liste der Datenbankersteller finden Sie auf der Seite **Administrative Rollen und Aufgaben** der Lake Formation Formation-Konsole. Um diese Liste anzeigen zu können, müssen Sie über die `lakeformation:ListPermissions` IAM-Berechtigung verfügen und als Data Lake-Administrator oder als Datenbankersteller mit der Grant-Option für die `CREATE_DATABASE` Berechtigung angemeldet sein.
**So erstellen Sie eine Datenbank**
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 oder Datenbankersteller an.
1. Wählen Sie im Navigationsbereich unter **Datenkatalog** die Option **Datenbanken** aus.
1. Wählen Sie **Datenbank erstellen** aus.
1. Geben **Sie im Dialogfeld Datenbank erstellen** einen Datenbanknamen, einen optionalen Speicherort und eine optionale Beschreibung ein.
1. Wählen Sie optional **Nur IAM-Zugriffskontrolle für neue Tabellen in dieser Datenbank verwenden** aus.
Weitere Informationen zu dieser Option finden Sie unter [Ändern der Standardeinstellungen für Ihren Data Lake](change-settings.md).
1. Wählen Sie **Datenbank erstellen** aus.
# Erstellen von Tabellen
AWS Lake Formation Metadatentabellen enthalten Informationen über Daten im Data Lake, einschließlich Schemainformationen, Partitionsinformationen und Datenspeicherort. Diese Tabellen werden im AWS Glue Datenkatalog gespeichert. Sie verwenden sie, um auf die zugrunde liegenden Daten im Data Lake zuzugreifen und diese Daten mit Lake Formation Formation-Berechtigungen zu verwalten. Tabellen werden in Datenbanken im Datenkatalog gespeichert.
Es gibt mehrere Möglichkeiten, Datenkatalogtabellen zu erstellen:
+ Führen Sie einen Crawler in AWS Glue aus. Weitere Informationen finden Sie unter [Definieren von Crawlern](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) im *AWS Glue Entwicklerhandbuch*.
+ Erstellen Sie einen Workflow und führen Sie ihn aus. Siehe [Daten mithilfe von Workflows in Lake Formation importieren](workflows.md).
+ Erstellen Sie manuell eine Tabelle mit der Lake Formation Formation-Konsole, der AWS Glue API oder AWS Command Line Interface (AWS CLI).
+ Erstellen Sie eine Tabelle mit Amazon Athena.
+ Erstellen Sie einen Ressourcenlink zu einer Tabelle in einem externen Konto. Siehe [Ressourcenlinks erstellen](creating-resource-links.md).
# Erstellen von Apache-Iceberg-Tabellen
AWS Lake Formation unterstützt die Erstellung von Apache Iceberg-Tabellen, die das Apache Parquet-Datenformat verwenden, AWS Glue Data Catalog wobei sich die Daten in Amazon S3 befinden. Eine Tabelle im Data Catalog ist die Metadatendefinition, die die Daten in einem Datenspeicher repräsentiert. Standardmäßig erstellt Lake Formation Iceberg v2-Tabellen. Den Unterschied zwischen v1- und v2-Tabellen finden Sie unter [Formatversionsänderungen](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) in der Apache-Iceberg-Dokumentation.
[Apache Iceberg](https://iceberg.apache.org/) ist ein offenes Tabellenformat für sehr große analytische Datensätze. Iceberg ermöglicht einfache Änderungen an Ihrem Schema, auch bekannt als Schemaentwicklung. Das bedeutet, dass Benutzer Spalten zu einer Datentabelle hinzufügen, umbenennen oder daraus entfernen können, ohne die zugrunde liegenden Daten zu stören. Iceberg unterstützt auch die Datenversionierung, sodass Benutzer Änderungen an Daten im Laufe der Zeit nachverfolgen können. Dadurch wird die Zeitreisefeature aktiviert, mit der Benutzer auf die bisherigen Versionen von Daten zugreifen und diese abfragen und Datenänderungen zwischen Aktualisierungen und Löschungen analysieren können.
Sie können die Lake Formation Formation-Konsole oder den `CreateTable` Vorgang in der AWS Glue API verwenden, um eine Iceberg-Tabelle im Datenkatalog zu erstellen. Weitere Informationen finden Sie unter [CreateTable action (Python: create\$1table](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-CreateTable)).
Wenn Sie eine Iceberg-Tabelle im Data Catalog erstellen, müssen Sie das Tabellenformat und den Metadaten-Dateipfad in Amazon S3 angeben, um Lese- und Schreibvorgänge durchführen zu können.
Sie können Lake Formation verwenden, um Ihre Iceberg-Tabelle mithilfe detaillierter Zugriffskontrollberechtigungen zu sichern, wenn Sie den Amazon S3 S3-Datenstandort bei registrieren. AWS Lake Formation Für Quelldaten in Amazon S3 und Metadaten, die nicht bei Lake Formation registriert sind, wird der Zugriff durch IAM-Berechtigungsrichtlinien für Amazon S3 und AWS Glue Aktionen bestimmt. Weitere Informationen finden Sie unter [Verwaltung von Lake Formation Formation-Berechtigungen](managing-permissions.md).
**Anmerkung**
Data Catalog unterstützt nicht das Erstellen von Partitionen und das Hinzufügen von Iceberg-Tabelleneigenschaften.
**Topics**
+ [Voraussetzungen](#iceberg-prerequisites)
+ [Erstellen einer Iceberg-Tabelle](#create-iceberg-table)
## Voraussetzungen
Um Iceberg-Tabellen im Data Catalog zu erstellen und Lake-Formation-Datenzugriffsberechtigungen einzurichten, müssen Sie die folgenden Anforderungen erfüllen:
1.
**Berechtigungen, die zum Erstellen von Iceberg-Tabellen ohne die bei Lake Formation registrierten Daten erforderlich sind.**
Zusätzlich zu den Berechtigungen, die zum Erstellen der Tabelle im Data Catalog erforderlich sind, benötigt der Tabellenersteller folgende Berechtigungen:
+ `s3:PutObject` in Ressource arn:aws:s3:::\$1bucketName\$1
+ `s3:GetObject` in Ressource arn:aws:s3:::\$1bucketName\$1
+ `s3:DeleteObject` in Ressource arn:aws:s3:::\$1bucketName\$1
1.
**Berechtigungen, die zum Erstellen von Iceberg-Tabellen mit den bei Lake Formation registrierten Daten erforderlich sind.**
Um Lake Formation zur Verwaltung und Sicherung der Daten in Ihrem Data Lake zu verwenden, registrieren Sie Ihren Amazon-S3-Speicherort, der die Daten für Tabellen enthält, bei Lake Formation. Auf diese Weise kann Lake Formation Anmeldeinformationen an AWS Analysedienste wie Athena, Redshift Spectrum und Amazon EMR weitergeben, um auf Daten zuzugreifen. Weitere Informationen zur Registrierung eines Amazon S3 S3-Standorts finden Sie unter[Hinzufügen eines Amazon S3 S3-Standorts zu Ihrem Data Lake](register-data-lake.md).
Ein Principal, der die zugrunde liegenden Daten liest und schreibt, die bei Lake Formation registriert sind, benötigt folgende Berechtigungen:
+ `lakeformation:GetDataAccess`
+ `DATA_LOCATION_ACCESS`
Ein Principal, der über Berechtigungen zum Speichern von Daten für einen Standort verfügt, hat auch Standortberechtigungen für alle untergeordneten Standorte.
Weitere Informationen zu Berechtigungen für den Datenspeicherort finden Sie unter[Zugrundeliegende Datenzugriffskontrolle](access-control-underlying-data.md).
Um die Komprimierung zu aktivieren, muss der Service eine IAM-Rolle übernehmen, die über Berechtigungen zum Aktualisieren von Tabellen im Data Catalog verfügt. Einzelheiten finden Sie unter [Voraussetzungen für die Tabellenoptimierung](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html).
## Erstellen einer Iceberg-Tabelle
Sie können Iceberg v1- und v2-Tabellen mit der Lake Formation Formation-Konsole oder AWS Command Line Interface wie auf dieser Seite dokumentiert erstellen. Sie können Iceberg-Tabellen auch mit der AWS Glue Konsole oder erstellen. AWS-Glue-Crawler Weitere Informationen finden Sie unter [Data Catalog und Crawler](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) im AWS Glue -Entwicklerhandbuch.
**So erstellen Sie eine Iceberg-Tabelle**
------
#### [ Console ]
1. Melden Sie sich bei an AWS-Managementkonsole und öffnen Sie die Lake Formation Formation-Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie unter „Data Catalog“ die Option **Tabellen** aus, und verwenden Sie die Schaltfläche **Tabelle erstellen**, um die folgenden Attribute anzugeben:
+ **Tabellenname**: Geben Sie einen Namen für die Tabelle ein. Wenn Sie Athena verwenden, um auf Tabellen zuzugreifen, verwenden Sie diese [Benennungstipps](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html) im Amazon-Athena-Benutzerhandbuch.
+ **Datenbank**: Wählen Sie eine bestehende Datenbank oder erstellen Sie eine neue.
+ **Beschreibung: Die** Beschreibung der Tabelle. Sie können eine Beschreibung zum besseren Verständnis der Inhalte der Tabelle schreiben.
+ **Tabellenformat**: Wählen Sie als **Tabellenformat** Apache Iceberg.
![\[Die Tabellenoption Apache Iceberg wurde mit den Optionen zur Tabellenoptimierung ausgewählt.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/table-optimization.png)
+ **Tabellenoptimierung**
+ **Compaction** – Datendateien werden zusammengeführt und neu geschrieben, um veraltete Daten zu entfernen und fragmentierte Daten in größeren, effizienteren Dateien zu konsolidieren.
+ **Aufbewahrung von Snapshots**: Snapshots sind Versionen einer Iceberg-Tabelle mit Zeitstempel. Mit Konfigurationen zur Beibehaltung von Snapshots können Kunden festlegen, wie lange und wie viele Snapshots beibehalten werden sollen. Die Konfiguration eines Optimierer zur Aufbewahrung von Snapshots kann helfen, den Speicheraufwand zu minimieren, indem ältere, unnötige Snapshots und die zugehörigen zugrunde liegenden Dateien entfernt werden.
+ **Löschen verwaister Dateien**: Verwaiste Dateien sind Dateien, auf die in den Metadaten der Iceberg-Tabelle nicht mehr verwiesen wird. Diese Dateien können sich im Laufe der Zeit ansammeln, insbesondere nach Vorgängen wie dem Löschen von Tabellen oder fehlgeschlagenen ETL-Aufträgen. Wenn Sie das Löschen verwaister Dateien aktivieren AWS Glue , können Sie diese unnötigen Dateien regelmäßig identifizieren und entfernen, wodurch Speicherplatz frei wird.
Weitere Informationen finden Sie unter [Optimieren von Iceberg-Tabellen](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html).
+ **IAM-Rolle**: Um die Komprimierung auszuführen, übernimmt der Dienst in Ihrem Namen eine IAM-Rolle. Sie können über das Dropdown-Menü eine IAM-Rolle auswählen. Die Rolle sollte die erforderlichen Berechtigungen für die Verdichtung haben.
Weitere Informationen zu den erforderlichen Berechtigungen finden Sie unter Voraussetzungen für die [Tabellenoptimierung](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html).
+ **Speicherort**: Geben Sie den Pfad zu dem Ordner in Amazon S3 an, in dem die Metadatentabelle gespeichert ist. Iceberg benötigt eine Metadatendatei und einen Speicherort im Data Catalog, um Lese- und Schreibvorgänge durchführen zu können.
+ **Schema**: Wählen **Sie Spalten** hinzufügen, um Spalten und Datentypen der Spalten hinzuzufügen. Sie haben die Möglichkeit, eine leere Tabelle zu erstellen und das Schema später zu aktualisieren. Data Catalog unterstützt Hive-Datentypen. Weitere Informationen finden Sie unter [Datentypen](https://cwiki.apache.org/confluence/plugins/servlet/mobile?contentId=27838462#content/view/27838462).
Mit Iceberg können Sie Schema und Partition weiterentwickeln, nachdem Sie die Tabelle erstellt haben. Sie können [Athena-Abfragen](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-evolving-table-schema.html) verwenden, um das Tabellenschema zu aktualisieren, und [Spark-Abfragen](https://iceberg.apache.org/docs/latest/spark-ddl/#alter-table-sql-extensions), um Partitionen zu aktualisieren.
------
#### [ AWS CLI ]
```
aws glue create-table \
--database-name iceberg-db \
--region us-west-2 \
--open-table-format-input '{
"IcebergInput": {
"MetadataOperation": "CREATE",
"Version": "2"
}
}' \
--table-input '{"Name":"test-iceberg-input-demo",
"TableType": "EXTERNAL_TABLE",
"StorageDescriptor":{
"Columns":[
{"Name":"col1", "Type":"int"},
{"Name":"col2", "Type":"int"},
{"Name":"col3", "Type":"string"}
],
"Location":"s3://DOC_EXAMPLE_BUCKET_ICEBERG/"
}
}'
```
------
# Optimieren von Iceberg-Tabellen
Lake Formation unterstützt mehrere Optionen zur Tabellenoptimierung, um die Verwaltung und Leistung von Apache Iceberg-Tabellen zu verbessern, die von den AWS Analyse-Engines und ETL-Jobs verwendet werden. Diese Optimierer sorgen für eine effiziente Speichernutzung, eine verbesserte Abfrageleistung und ein effektives Datenmanagement. In Lake Formation sind drei Arten von Tabellenoptimierern verfügbar:
+ **Komprimierung**: Bei der Datenkomprimierung werden kleine Datendateien komprimiert, um den Speicherverbrauch zu reduzieren und die Leseleistung zu verbessern. Datendateien werden zusammengeführt und neu geschrieben, um veraltete Daten zu entfernen und fragmentierte Daten in größeren, effizienteren Dateien zu konsolidieren. Die Komprimierung kann so konfiguriert werden, dass sie bei Bedarf automatisch oder manuell ausgelöst wird.
+ **Aufbewahrung von Snapshots**: Snapshots sind Versionen einer Iceberg-Tabelle mit Zeitstempel. Mit Konfigurationen zur Beibehaltung von Snapshots können Kunden festlegen, wie lange und wie viele Snapshots beibehalten werden sollen. Die Konfiguration eines Optimierer zur Aufbewahrung von Snapshots kann helfen, den Speicheraufwand zu minimieren, indem ältere, unnötige Snapshots und die zugehörigen zugrunde liegenden Dateien entfernt werden.
+ **Löschen verwaister Dateien**: Verwaiste Dateien sind Dateien, auf die in den Metadaten der Iceberg-Tabelle nicht mehr verwiesen wird. Diese Dateien können sich im Laufe der Zeit ansammeln, insbesondere nach Vorgängen wie dem Löschen von Tabellen oder fehlgeschlagenen ETL-Aufträgen. Wenn Sie das Löschen verwaister Dateien aktivieren AWS Glue , können Sie diese überflüssigen Dateien regelmäßig identifizieren und entfernen, wodurch Speicherplatz frei wird.
Sie können die Optimierer für die Komprimierung, die Aufbewahrung von Snapshots und das Löschen verwaister Dateien für einzelne Iceberg-Tabellen im Datenkatalog mithilfe der AWS Glue Konsole oder API-Operationen aktivieren oder deaktivieren. AWS CLI AWS Glue
Weitere Informationen finden Sie unter [Optimieren von Iceberg-Tabellen](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html) im Entwicklerhandbuch. AWS Glue
# Nach Tabellen suchen
Sie können die AWS Lake Formation Konsole verwenden, um nach Datenkatalogtabellen nach Namen, Speicherort, enthaltender Datenbank und mehr zu suchen. In den Suchergebnissen werden nur die Tabellen angezeigt, für die Sie Lake Formation Formation-Berechtigungen haben.
**Um nach Tabellen zu suchen (Konsole)**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Lake Formation Formation-Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Wählen Sie im Navigationsbereich **Tables** (Tabellen) aus.
1. Positionieren Sie den Cursor im Suchfeld oben auf der Seite. Das Feld hat den Platzhaltertext *Tabelle anhand von Eigenschaften suchen*.
Das **Eigenschaftenmenü** mit den verschiedenen Tabelleneigenschaften, nach denen gesucht werden kann, wird angezeigt.
![\[Das Eigenschaftenmenü wird aus dem Suchfeld entfernt und enthält die folgenden Einträge: Name, Klassifizierung, Datenbank, Standort, Katalog-ID\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/search-for-tables.png)
1. Führen Sie eine der folgenden Aktionen aus:
+ Suchen Sie nach der enthaltenen Datenbank.
1. Wählen Sie im Menü **Eigenschaften** die Option **Datenbank** und wählen Sie dann entweder eine Datenbank aus dem angezeigten Menü **Datenbanken** aus, oder geben Sie einen Datenbanknamen ein und drücken **Sie die Eingabetaste**.
Die Tabellen, für die Sie in der Datenbank berechtigt sind, werden aufgelistet.
1. (Optional) Um die Liste auf eine einzige Tabelle in der Datenbank einzuschränken, positionieren Sie den Cursor erneut im Suchfeld, wählen Sie **Name** aus dem **Eigenschaftenmenü** und wählen entweder einen Tabellennamen aus dem angezeigten Menü **Tabellen** aus, oder geben Sie einen Tabellennamen ein und drücken **Sie die Eingabetaste**.
Die einzelne Tabelle wird aufgelistet, und sowohl der Datenbankname als auch der Tabellenname werden als Kacheln unter dem Suchfeld angezeigt.
![\[Unter dem Suchfeld befinden sich zwei Kacheln: eine mit der Bezeichnung Datenbank, die den ausgewählten Datenbanknamen enthält, und eine mit der Bezeichnung Tabelle, die den ausgewählten Tabellennamen enthält. Rechts neben den Kacheln befindet sich die Schaltfläche Filter löschen.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/search-for-tables-with-filter.png)
Um den Filter anzupassen, schließen Sie eine der Kacheln oder wählen Sie **Filter löschen**.
+ Suchen Sie nach anderen Eigenschaften.
1. Wählen Sie im Eigenschaften-Menü eine **Sucheigenschaft** aus.
**Um nach der AWS Konto-ID zu suchen, wählen Sie im Menü „**Eigenschaften**“ die Option „**Katalog-ID**“, geben Sie eine gültige AWS Konto-ID ein (z. B. 111122223333) und drücken Sie die Eingabetaste.**
Um nach Standort zu suchen, wählen Sie im Menü „**Eigenschaften**“ die Option „**Standort**“ und anschließend im daraufhin angezeigten Menü „**Standorte**“ einen Standort aus. Alle Tabellen im Stammverzeichnis des ausgewählten Speicherorts (z. B. Amazon S3) werden zurückgegeben.
**Suchen nach Tabellen mit AWS CLI**
+ Das folgende Beispiel zeigt, wie eine Teilsuche ausgeführt wird. Mit dem `--search-text` Parameter können Sie nach Tabellen suchen, die den angegebenen Text in ihren Metadaten enthalten. In diesem Fall werden alle Tabellen zurückgegeben, deren Name, Beschreibung oder andere Metadatenfelder das Wort „Kunde“ enthalten.
```
aws glue search-tables
--search-text "customer"
--region AWS-Region
--max-results 10
--sort-criteria "FieldName=Name,Sort=ASC"
```
# Gemeinsame Nutzung von Datenkatalogtabellen und Datenbanken für mehrere AWS Konten
Sie können Datenkatalogressourcen (Datenbanken und Tabellen) mit externen AWS Konten gemeinsam nutzen, indem Sie den externen Konten Lake Formation Formation-Berechtigungen für die Ressourcen gewähren. Benutzer können dann Abfragen und Jobs ausführen, die Tabellen mehrerer Konten verknüpfen und abfragen. Wenn Sie eine Datenkatalogressource mit einem anderen Konto gemeinsam nutzen, können Prinzipale in diesem Konto mit dieser Ressource arbeiten, als ob sich die Ressource in ihrem Datenkatalog befände.
Sie teilen Ressourcen nicht mit bestimmten Prinzipalen in externen AWS Konten — Sie teilen die Ressourcen mit einem Konto oder einer Organisation. AWS Wenn Sie eine Ressource mit einer AWS Organisation teilen, teilen Sie die Ressource mit allen Konten auf allen Ebenen in dieser Organisation. Der Data Lake-Administrator in jedem externen Konto muss dann den Prinzipalen in ihrem Konto Berechtigungen für die gemeinsam genutzten Ressourcen gewähren.
Weitere Informationen erhalten Sie unter [Kontoübergreifender Datenaustausch in Lake Formation](cross-account-permissions.md) und [Erteilen von Berechtigungen für Datenkatalogressourcen](granting-catalog-permissions.md).
**Weitere Informationen finden Sie auch unter:**
[Zugreifen auf und Anzeigen von gemeinsam genutzten Datenkatalogtabellen und Datenbanken](viewing-shared-resources.md)
[Voraussetzungen](cross-account-prereqs.md)
# AWS Glue Data Catalog Ansichten von Gebäuden
In der ist eine *Ansicht* eine virtuelle Tabelle AWS Glue Data Catalog, deren Inhalt durch eine SQL-Abfrage definiert wird, die auf eine oder mehrere Tabellen verweist. Sie können mithilfe von SQL-Editoren für Amazon Athena, Amazon Redshift oder Apache Spark mit EMR Serverless oder Version 5.0 eine Datenkatalogsicht erstellen, die auf bis zu 10 Tabellen verweist. AWS Glue Die einer Ansicht zugrunde liegenden Referenztabellen können zu derselben Datenbank oder zu verschiedenen Datenbanken innerhalb desselben AWS-Konto Datenkatalogs gehören.
Sie können auf AWS Glue Standardtabellen und Tabellen in offenen Tabellenformaten (OTF) wie [Apache Hudi](https://hudi.incubator.apache.org/), Linux Foundation [Delta Lake](https://delta.io/) und [Apache Iceberg](https://iceberg.apache.org/) verweisen, wobei die zugrunde liegenden Daten an Amazon S3 S3-Speicherorten gespeichert sind, bei denen Sie registriert sind. AWS Lake Formation Darüber hinaus können Sie Ansichten aus Verbundtabellen aus Amazon Redshift-Datenfreigaben erstellen, die mit Lake Formation gemeinsam genutzt werden.
## Differenzierung von Datenkatalogansichten von anderen Ansichtstypen
Datenkatalogansichten unterscheiden sich von Apache Hive-, Apache Spark- und Amazon Athena Athena-Ansichten. Die Datenkatalogansicht ist eine systemeigene Funktion von und ist eine vom AWS Glue Data Catalog Definierer erstellte Ansicht mit mehreren Dialekten. Sie können eine Datenkatalogansicht mit einem der unterstützten Analysedienste wie Athena oder Amazon Redshift Spectrum erstellen und mit anderen unterstützten Analysediensten auf dieselbe Ansicht zugreifen. Andererseits werden die Ansichten Apache Hive, Apache Spark und Athena unabhängig voneinander in jedem Analytics-Service wie Athena und Amazon Redshift erstellt und sind nur innerhalb dieses Dienstes sichtbar und zugänglich.
## Was ist eine definere Ansicht?
Eine Definer-Ansicht ist eine SQL-Ansicht, die auf den Berechtigungen des Prinzipals basiert, der sie erstellt hat. Die Definiererrolle verfügt über die erforderlichen Berechtigungen für den Zugriff auf die referenzierten Tabellen und führt die SQL-Anweisung aus, die die Ansicht definiert. Der Definierer erstellt die Ansicht und gibt sie mithilfe AWS Lake Formation seiner detaillierten Zugriffskontrolle für andere Benutzer frei.
Wenn ein Benutzer die Definer-Ansicht abfragt, verwendet die Abfrage-Engine die Berechtigungen der Definer-Rolle, um auf die zugrunde liegenden Referenztabellen zuzugreifen. Dieser Ansatz ermöglicht es Benutzern, mit der Ansicht zu interagieren, ohne direkten Zugriff auf die Quelltabellen zu benötigen, wodurch die Sicherheit erhöht und die Datenzugriffsverwaltung vereinfacht wird.
Um eine Definer-Ansicht einzurichten, kann sich die Definer-IAM-Rolle innerhalb desselben AWS Kontos wie die Basistabellen oder in einem anderen Konto befinden, wobei kontoübergreifende Definerrollen verwendet werden. Weitere Informationen zu den für die Definerrolle erforderlichen Berechtigungen finden Sie unter. [Voraussetzungen für das Erstellen von Ansichten](views-prereqs.md)
## Ein Framework für Ansichten mit mehreren Dialekten
Der Datenkatalog unterstützt die Erstellung von Ansichten mit mehreren SQL-Dialekten (Structured Query Language). SQL ist eine Sprache, die zum Speichern und Verarbeiten von Informationen in einer relationalen Datenbank verwendet wird, und jede AWS Analyse-Engine verwendet ihre eigene Variante von SQL oder ihren eigenen SQL-Dialekt.
Sie erstellen eine Datenkatalogsicht in einem SQL-Dialekt mit einer der unterstützten Analytics-Abfrage-Engines. Anschließend können Sie die Ansicht aktualisieren, indem Sie die `ALTER VIEW` Anweisung in einem anderen SQL-Dialekt in jeder anderen unterstützten Analyse-Engine verwenden. Jeder Dialekt muss jedoch auf denselben Satz von Tabellen, Spalten und Datentypen verweisen.
Sie können über die `GetTable` API und die Konsole auf die verschiedenen Dialekte zugreifen, AWS CLI die für die Ansicht verfügbar sind. AWS Somit ist die Datenkatalogansicht sichtbar und kann über verschiedene unterstützte Analyse-Engines abgefragt werden.
Durch die Definition eines gemeinsamen Ansichtsschemas und eines Metadatenobjekts, das Sie von mehreren Engines abfragen können, ermöglichen Ihnen Datenkatalogansichten die Verwendung einheitlicher Ansichten für Ihren gesamten Data Lake.
Weitere Informationen darüber, wie das Schema für jeden Dialekt aufgelöst wird, finden Sie unter [dem Link zur API-Referenz.]() Weitere Informationen zu den Abgleichsregeln für verschiedene Typen finden Sie unter [dem Link zum entsprechenden Abschnitt im API-Dokument]().
## Integration mit Lake Formation Formation-Berechtigungen
Sie können AWS Lake Formation es verwenden, um die Berechtigungsverwaltung für AWS Glue Data Catalog Benutzeransichten zu zentralisieren. Sie können mithilfe der Methode für benannte Ressourcen oder mithilfe von LF-Tags detaillierte Berechtigungen für die Datenkatalogansichten gewähren und diese für AWS Organisationen und Organisationseinheiten AWS-Konten gemeinsam nutzen. Sie können die AWS-Regionen Datenkatalogansichten auch mithilfe von Ressourcenlinks gemeinsam nutzen und darauf zugreifen. Auf diese Weise können Benutzer auf Daten zugreifen, ohne die Datenquelle duplizieren und die zugrunde liegenden Tabellen gemeinsam nutzen zu müssen.
Die `CREATE VIEW` DDL-Anweisung einer Datenkatalogsicht kann auf die AWS Glue Standardtabellen und Tabellen in offenen Tabellenformaten (OTF) wie Hudi, Delta Lake und Iceberg verweisen, wobei die zugrunde liegenden Daten in Amazon S3 S3-Standorten gespeichert sind, die bei Lake Formation registriert sind, sowie auf die Verbundtabellen aus Amazon Redshift Datashare, die mit Lake Formation gemeinsam genutzt werden, gespeichert sind. Die Tabellen können ein beliebiges Dateiformat haben, sofern die Engine, mit der die Ansicht abgefragt wurde, dieses Format unterstützt. Sie können auch auf integrierte Funktionen der Engine verweisen, auf der sie ausgeführt wird. Andere modulspezifische Ressourcen sind jedoch möglicherweise nicht zulässig. Weitere Details finden Sie unter [Überlegungen und Einschränkungen im Datenkatalog](views-notes.md).
## Anwendungsfälle
Im Folgenden sind die wichtigen Anwendungsfälle für Datenkatalog-Ansichten aufgeführt:
+ Erstellen und verwalten Sie Berechtigungen für ein einzelnes Ansichtsschema. Auf diese Weise können Sie das Risiko inkonsistenter Berechtigungen für doppelte Ansichten vermeiden, die in mehreren Engines erstellt wurden.
+ Erteilen Sie Benutzern Berechtigungen für eine Ansicht, die auf mehrere Tabellen verweist, ohne Berechtigungen direkt für die zugrunde liegenden Referenztabellen zu gewähren.
+ Filtern Sie Tabellen auf Zeilenebene mithilfe von LF-Tags (wobei LF-Tags nur bis zur Spaltenebene kaskadiert werden), indem Sie LF-Tags auf Ansichten anwenden und Benutzern auf LF-Tags basierende Berechtigungen gewähren.
## Unterstützte Analysedienste für Ansichten AWS
Die folgenden AWS Analysedienste unterstützen die Erstellung von Datenkatalogansichten:
+ Amazon Redshift
+ Amazon Athena versie 3
+ Apache Spark auf EMR Serverless
+ Apache Spark auf Version 5.0 AWS Glue
## Weitere Ressourcen
In diesem Handbuch erfahren Sie mehr über den Datenkatalog und nutzen die folgenden Ressourcen:
Das folgende Video zeigt, wie Ansichten von Athena und Amazon Redshift erstellt und abgefragt werden.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/rFO2OoxVYxE?si=Z0qsyuvTp2ZJg-PL)
**Topics**
+ [Differenzierung von Datenkatalogansichten von anderen Ansichtstypen](#diff-views)
+ [Was ist eine definere Ansicht?](#definer-view)
+ [Ein Framework für Ansichten mit mehreren Dialekten](#multi-dialect)
+ [Integration mit Lake Formation Formation-Berechtigungen](#lf-view-integ)
+ [Anwendungsfälle](#views-use-cases)
+ [Unterstützte Analysedienste für Ansichten AWS](#views-supported-engines)
+ [Weitere Ressourcen](#views-addtional-resources)
+ [Voraussetzungen für das Erstellen von Ansichten](views-prereqs.md)
+ [Datenkatalogsichten mithilfe von DDL-Anweisungen erstellen](create-views.md)
+ [Datenkatalogsichten erstellen mit AWS Glue APIs](views-api-usage.md)
+ [Erteilen von Berechtigungen für Datenkatalog-Ansichten](grant-perms-views.md)
+ [Materialisierte Ansichten](materialized-views.md)
# Voraussetzungen für das Erstellen von Ansichten
+ Um Ansichten in Data Catalog zu erstellen, müssen Sie die zugrunde liegenden Amazon S3 S3-Datenspeicherorte der Referenztabellen bei Lake Formation registrieren. Einzelheiten zur Registrierung von Daten bei Lake Formation finden Sie unter[Hinzufügen eines Amazon S3 S3-Standorts zu Ihrem Data Lake](register-data-lake.md).
+ Nur IAM-Rollen können Datenkatalogansichten erstellen. Andere IAM-Identitäten können keine Datenkatalogsichten erstellen.
+ Die IAM-Rolle, die die Ansicht definiert, muss über die folgenden Berechtigungen verfügen:
+ Lake Formation `SELECT` Formation-Genehmigung mit der `Grantable` Option für alle Referenztabellen, einschließlich aller Spalten.
+ Lake Formation `CREATE_TABLE` Formation-Berechtigung für die Zieldatenbank, in der Ansichten erstellt werden.
+ Eine Vertrauenspolitik, damit die Lake Formation und ihre AWS Glue Dienste die Rolle übernehmen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
+ Das Ziel: PassRole Genehmigung für AWS Glue und Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerPassRole1",
"Action": [
"iam:PassRole"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
}
}
}
]
}
```
------
+ AWS Glue und Genehmigungen für Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"Glue:GetDatabase",
"Glue:GetDatabases",
"Glue:CreateTable",
"Glue:GetTable",
"Glue:GetTables",
"Glue:BatchGetPartition",
"Glue:GetPartitions",
"Glue:GetPartition",
"Glue:GetTableVersion",
"Glue:GetTableVersions",
"Glue:PassConnection",
"lakeFormation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
------
+ Sie können keine Ansichten in einer Datenbank erstellen, für die der `IAMAllowedPrincipals` Gruppe `ALL` Berechtigungen erteilt wurden. `Super` Sie können entweder der `IAMAllowedPrincipals` Gruppe die `Super` Berechtigung für eine Datenbank entziehen, sie einsehen oder eine neue Datenbank erstellen[Schritt 4: Stellen Sie Ihre Datenspeicher auf das Lake Formation Formation-Berechtigungsmodell um](upgrade-glue-lake-formation.md#upgrade-glue-lake-formation-step4), wobei das Kontrollkästchen **Nur IAM-Zugriffssteuerung für neue Tabellen in dieser Datenbank verwenden** unter **Standardberechtigungen für neu erstellte** Tabellen deaktiviert ist.
# Datenkatalogsichten mithilfe von DDL-Anweisungen erstellen
Sie können AWS Glue Data Catalog Ansichten mit SQL-Editoren für Athena, Amazon Redshift und mit dem AWS Glue APIs/erstellen.AWS CLI
Um eine Datenkatalogsicht mit SQL-Editoren zu erstellen, wählen Sie Athena oder Redshift Spectrum und erstellen Sie die Ansicht mit einer DDL-Anweisung (`CREATE VIEW`Data Definition Language). Nachdem Sie eine Ansicht im Dialekt der ersten Engine erstellt haben, können Sie eine `ALTER VIEW` DDL-Anweisung der zweiten Engine verwenden, um die zusätzlichen Dialekte hinzuzufügen.
Bei der Definition von Ansichten ist es wichtig, Folgendes zu berücksichtigen:
+ **Definition von Ansichten mit mehreren Dialekten** — Wenn Sie eine Ansicht mit mehreren Dialekten definieren, müssen die Schemas der verschiedenen Dialekte übereinstimmen. Jeder SQL-Dialekt hat eine etwas andere Syntaxspezifikation. Die Abfragesyntax, die die Datenkatalogansicht definiert, sollte in allen Dialekten exakt dieselbe Spaltenliste, einschließlich Typen und Namen, ergeben. Diese Informationen werden in `StorageDescriptor` der Ansicht gespeichert. Die Dialekte müssen auch auf dieselben zugrunde liegenden Tabellenobjekte aus dem Datenkatalog verweisen.
Um einer Ansicht mithilfe von DDL einen weiteren Dialekt hinzuzufügen, können Sie die Anweisung verwenden. `ALTER VIEW` Wenn eine `ALTER VIEW` Anweisung versucht, die Sichtdefinition zu aktualisieren, z. B. den Speicherdeskriptor oder die zugrunde liegenden Tabellen der Ansicht zu ändern, gibt die Anweisung einen Fehler mit der Meldung „Eingabe und vorhandener Speicherdeskriptor stimmen nicht überein“. Sie können SQL-Cast-Operationen verwenden, um sicherzustellen, dass die Typen der View-Spalten übereinstimmen.
+ **Eine Ansicht aktualisieren** — Um die Ansicht zu aktualisieren, können Sie die `UpdateTable` API verwenden. Wenn Sie die Ansicht aktualisieren, ohne dass die Speicherdeskriptoren oder die Referenztabellen übereinstimmen, können Sie das `FORCE` Flag angeben (die Syntax finden Sie in der Engine-SQL-Dokumentation). Nach einer erzwungenen Aktualisierung übernimmt die Ansicht die erzwungenen Tabellen `StorageDescriptor` und die Referenztabellen. Jede weitere `ALTER VIEW` DDL sollte den geänderten Werten entsprechen. Eine Ansicht, die aktualisiert wurde, sodass sie inkompatible Dialekte enthält, erhält den Status „Veraltet“. Der Status der Ansicht ist in der Lake Formation Formation-Konsole und bei Verwendung der `GetTable` Operation sichtbar.
+ Auf **einen Varchar-Spaltentyp als Zeichenfolge verweisen — Es ist nicht möglich, einen** Varchar-Spaltentyp von Redshift Spectrum in eine Zeichenfolge umzuwandeln. Wenn in Redshift Spectrum eine Ansicht mit einem Varchar-Spaltentyp erstellt wird und ein nachfolgender Dialekt versucht, auf dieses Feld als Zeichenfolge zu verweisen, behandelt der Datenkatalog es als Zeichenfolge, ohne dass das Flag erforderlich ist. `FORCE`
+ **Behandlung komplexer Typfelder** — Amazon Redshift behandelt alle komplexen Typen als [SUPER-Typen](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html), während Athena den komplexen Typ spezifiziert. Wenn eine Ansicht über ein `SUPER` Typfeld verfügt und eine andere Engine diese Spalte als einen bestimmten komplexen Typ referenziert, z. B. struct (`>`), geht der Datenkatalog davon aus, dass es sich bei dem Feld um einen spezifischen komplexen Typ handelt, und verwendet diesen im Speicherdeskriptor, ohne dass das Flag erforderlich ist. `Force`
Weitere Informationen zur Syntax für die Erstellung und Verwaltung von Datenkatalogsichten finden Sie unter:
+ [Verwenden von AWS Glue Data Catalog Ansichten](https://docs.aws.amazon.com/athena/latest/ug/views-glue.html) im Amazon Athena Athena-Benutzerhandbuch.
+ Die [Abfragesyntax für die Glue-Datenkatalogansicht](https://docs.aws.amazon.com/athena/latest/ug/views-glue-ddl.html) finden Sie im Amazon Athena Athena-Benutzerhandbuch.
+ [Erstellen von Ansichten AWS Glue Data Catalog im](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html) Amazon Redshift Database Developer Guide.
Weitere Informationen zu den SQL-Befehlen für Ansichten im Datenkatalog finden Sie unter [CREATE EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_VIEW.html), [ALTER EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_EXTERNAL_VIEW.html) und [DROP EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_EXTERNAL_VIEW.html).
Nachdem Sie eine Datenkatalog-Ansicht erstellt haben, sind die Details der Ansicht in der Lake Formation Formation-Konsole verfügbar.
1. Wählen Sie in der Lake Formation Formation-Konsole unter Datenkatalog die Option **Ansichten** aus.
1. Eine Liste der verfügbaren Ansichten wird auf der Seite „Ansichten“ angezeigt.
1. Wählen Sie eine Ansicht aus der Liste aus und auf der Detailseite werden die Attribute der Ansicht angezeigt.
![\[Der untere Bereich enthält fünf horizontal angeordnete Registerkarten, wobei jede Registerkarte die entsprechenden Informationen enthält.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/view-definition.png)
Schema
Wählen Sie eine `Column` Zeile aus und wählen Sie **LF-Tags bearbeiten**, um Tag-Werte zu aktualisieren oder neue LF-Tags zuzuweisen.
SQL-Definitionen
Sie können eine Liste der verfügbaren SQL-Definitionen sehen. Wählen Sie **SQL-Definition hinzufügen** und wählen Sie eine Abfrage-Engine aus, um eine SQL-Definition hinzuzufügen. Wählen Sie unter der `Edit definition` Spalte eine Abfrage-Engine (Athena oder Amazon Redshift) aus, um eine SQL-Definition zu aktualisieren.
LF-Tags
Wählen Sie **LF-Tags bearbeiten**, um Werte für ein Tag zu bearbeiten oder neue Tags zuzuweisen. Sie können LF-Tags verwenden, um Berechtigungen für Ansichten zu erteilen.
Kontoübergreifender Zugriff
Sie können eine Liste der Organisationen und Organisationseinheiten (OUs) sehen AWS-Konten, für die Sie die Datenkatalogansicht freigegeben haben.
Zugrundeliegende Tabellen
Die zugrunde liegenden Tabellen, auf die in der SQL-Definition verwiesen wird, die zur Erstellung der Ansicht verwendet wurde, werden auf dieser Registerkarte angezeigt.
# Datenkatalogsichten erstellen mit AWS Glue APIs
Sie können und verwenden AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html), [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html) APIs um Ansichten im Datenkatalog zu erstellen und zu aktualisieren. Die `UpdateTable` Operationen `CreateTable` und haben eine neue `TableInput` Struktur für`ViewDefinition`,,`SearchTables`,`GetTable`, `GetTables``GetTableVersion`, `GetTableVersions` Operationen stellen die `ViewDefinition` Ausgabesyntax für Ansichten bereit. Darüber hinaus gibt es ein neues `Status` Feld in der `GetTable` API-Ausgabe.
Zwei neue AWS Glue Verbindungen sind für die Validierung des SQL-Dialekts für jede unterstützte Abfrage-Engine Amazon Athena und Amazon Redshift verfügbar.
Die `CreateTable` und `UpdateTable` APIs sind asynchron, wenn sie mit Ansichten verwendet werden. Wenn diese mit mehreren SQL-Dialekten aufgerufen APIs werden, wird der Aufruf mit jeder Engine überprüft, um festzustellen, ob der Dialekt auf dieser Engine ausgeführt werden kann und ob das resultierende Schema der Ansicht aus jedem Dialekt übereinstimmt. Der AWS Glue Dienst verwendet diese Verbindungen, um interne Aufrufe an die Analyse-Engines zu tätigen. Diese Aufrufe simulieren, was die Engine tut, um zu überprüfen, ob eine `CREATE VIEW` oder eine `ALTER VIEW` SQL-DDL auf der Engine ausgeführt wurde.
Wenn das bereitgestellte SQL gültig ist und die Schemas in den verschiedenen View-Dialekten übereinstimmen, schreibt die AWS Glue API das Ergebnis atomar fest. Atomicity ermöglicht das Erstellen oder Ändern von Ansichten mit mehreren Dialekten ohne Ausfallzeiten.
**Topics**
+ [AWS Glue Verbindungen werden hergestellt, um den Status zu überprüfen](views-api-usage-connection.md)
+ [Der Status der View-Generierung wird validiert](views-api-usage-get-table.md)
+ [Asynchrone Zustände und Operationen](views-api-usage-async-states.md)
+ [Sehen Sie sich Szenarien mit Fehlern bei der Erstellung bei asynchronen Vorgängen an](views-api-usage-errors.md)
# AWS Glue Verbindungen werden hergestellt, um den Status zu überprüfen
Um eine AWS Glue Data Catalog Ansicht mithilfe der `UpdateTable` Operationen `CreateTable` oder zu erstellen oder zu aktualisieren, müssen Sie einen neuen AWS Glue Verbindungstyp für die Validierung erstellen und ihn der unterstützten Analytics-Engine zur Verfügung stellen. Diese Verbindungen sind erforderlich, um Datenkatalogansichten mit Athena oder Amazon Redshift zu verwenden. Sie können diese Verbindungen nur mit AWS CLI AWS SDKs, oder erstellen. AWS Glue APIs Sie können das nicht verwenden AWS-Managementkonsole , um die AWS Glue Verbindung herzustellen.
**Anmerkung**
Wenn die View Definer-Rolle und die Rolle, die `CreateTable` Or aufruft, unterschiedlich `UpdateTable` sind, benötigen beide in ihrer IAM-Richtlinienerklärung eine `glue:PassConnection` entsprechende Genehmigung.
Weitere Informationen finden Sie in der Dokumentation zum [Erstellen](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-connection.html) AWS CLI einer Verbindung.
**AWS CLI Befehl zum Erstellen einer Verbindung**
Im Folgenden finden AWS CLI Sie einen Befehl zum Erstellen einer Verbindung:
```
aws glue create-connection --region us-east-1
--endpoint-url https://glue.us-east-1.amazonaws.com
--cli-input-json file:///root/path/to/create-connection.json
```
**AWS CLI Eingabe JSON**
Für Amazon Redshift:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_REDSHIFT",
"Name": "views-preview-cluster-connection-2",
"Description": "My first Amazon Redshift validation connection",
"ConnectionProperties": {
"DATABASE": "dev",
"CLUSTER_IDENTIFIER": "glue-data-catalog-views-preview-cluster"
}
}
}
```
Für Amazon Athena:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_ATHENA",
"Name": "views-preview-cluster-connection-3",
"Description": "My first Amazon Athena validation connection",
"ConnectionProperties": {
"WORKGROUP_NAME": "workgroup-name"
}
}
}
```
# Der Status der View-Generierung wird validiert
Wenn Sie die `UpdateTable` Operationen `CreateTable` oder ausführen, zeigt das `Status` Feld für die `GetTable` API-Ausgabe die Details zum Status der Ansichtserstellung an. Für `create` Anfragen, bei denen die Tabelle noch nicht existiert, AWS Glue wird für die Dauer des asynchronen Prozesses eine leere Tabelle erstellt. Beim Aufrufen `GetTable` können Sie ein optionales boolesches Flag übergeben`IncludeStatusDetails`, das Diagnoseinformationen zur Anfrage anzeigt. Im Falle eines Fehlers zeigt dieses Flag eine Fehlermeldung mit individuellen Status für jeden Dialekt an.
Fehler bei Vorgängen zum Erstellen, Lesen, Aktualisieren und Löschen von Ansichten (CRUD) können entweder während der Verarbeitung im AWS Glue/Lake Formation Service oder während der View-SQL-Validierung in Amazon Redshift oder Athena auftreten. Wenn bei der Validierung in einer Engine ein Fehler auftritt, gibt der AWS Glue Service die Fehlermeldung aus, die die Engine zurückgibt.
**Statusfelder**
Im Folgenden sind die Statusfelder aufgeführt:
+ Status: ein allgemeiner Status, der unabhängig von verschiedenen Arten von Jobs ist:
+ IN WARTESCHLANGE
+ IN\$1PROGRESS
+ ERFOLG
+ FEHLGESCHLAGEN
+ Aktion — Gibt an, welche Aktion für die Tabelle aufgerufen wurde. Derzeit sind nur `CREATE` `UPDATE` Operationen verfügbar.
Bei der Arbeit mit Ansichten ist es wichtig, zwischen `CREATE` Operationen `UPDATE` und zu unterscheiden. Der Operationstyp bestimmt, wie Sie beim Abfragen der Tabellen vorgehen sollten.
Eine `UPDATE` Operation bedeutet, dass die Tabelle bereits im Datenkatalog vorhanden ist. In diesem Fall können Sie die zuvor erstellte Tabelle problemlos weiter abfragen. Andererseits zeigt eine `CREATE ` Operation an, dass die Tabelle noch nie erfolgreich erstellt wurde. Wenn eine Tabelle als markiert ist`CREATE`, schlägt der Versuch, sie abzufragen, fehl, da die Tabelle noch nicht im System vorhanden ist. Daher ist es wichtig, den Operationstyp (UPDATE oder CREATE) zu identifizieren, bevor Sie versuchen, eine Tabelle abzufragen.
+ RequestedBy — Der ARN des Benutzers, der die asynchrone Änderung angefordert hat.
+ UpdatedBy — Der ARN des Benutzers, der den asynchronen Änderungsprozess zuletzt manuell geändert hat, z. B. eine Stornierung oder Änderung beantragt hat.
+ Fehler — Dieses Feld wird nur angezeigt, wenn der Status **FAILED** lautet. Dies ist eine Ausnahmemeldung auf übergeordneter Ebene. Für jeden Dialekt können unterschiedliche Fehler auftreten.
+ ErrorCode — Die Art der Ausnahme.
+ ErrorMessage — eine kurze Beschreibung der Ausnahme.
+ RequestTime — eine nach ISO 8601 formatierte Datumszeichenfolge, die den Zeitpunkt angibt, zu dem die Änderung initiiert wurde.
+ UpdateTime — eine nach ISO 8601 formatierte Datumszeichenfolge, die den Zeitpunkt angibt, zu dem der Status zuletzt aktualisiert wurde.
# Asynchrone Zustände und Operationen
Wenn Sie eine `glue:CreateTable` Anforderung ausführen, beginnt die asynchrone Erstellung der Datenkatalogansicht. In den folgenden Abschnitten beschreibt dieses Dokument die `Status` AWS Glue Ansicht, die in einer `glue:GetTable` Antwort verfügbar ist. Der Kürze halber wird in diesem Abschnitt die vollständige Antwort weggelassen.
```
{
"Table": {
...
"Status": {
...
"Action": "CREATE",
"State": "QUEUED",
}
}
}
```
Beide oben genannten Attribute stellen wichtige Diagnoseinformationen dar, die den Status des asynchronen Vorgangs sowie die Aktionen angeben, die in dieser Ansicht ausgeführt werden können. Im Folgenden sind die möglichen Werte aufgeführt, die diese Attribute annehmen können.
1. `Status.Action`
1. CREATE
1. UPDATE
1. `Status.State`
1. IN WARTESCHLANGE
1. IN\$1PROGRESS
1. ERFOLG
1. FEHLGESCHLAGEN
Es ist auch wichtig zu beachten, dass einige Aktualisierungen in einer Datenkatalogansicht keinen asynchronen Vorgang erfordern. Beispielsweise möchte man vielleicht das `Description` Attribut der Tabelle aktualisieren. Da hierfür keine asynchronen Operationen erforderlich sind, werden die resultierenden Tabellenmetadaten keine haben`Status`, und das Attribut schon. `NULL`
```
{
"Table": {
...,
"Description": "I changed this attribute!"
}
}
```
Als Nächstes wird in diesem Thema untersucht, wie sich die obigen Statusinformationen auf Vorgänge auswirken können, die in einer AWS Glue Ansicht ausgeführt werden können.
**Klebstoff: CreateTable**
Für diese API gibt es keine Änderungen im Vergleich zu den `glue:CreateTable` Funktionen für jede Glue-Tabelle. `CreateTable`kann für jeden Tabellennamen aufgerufen werden, der noch nicht existiert.
**kleben: UpdateTable**
Dieser Vorgang kann nicht für eine AWS Glue Ansicht ausgeführt werden, die die folgenden Statusinformationen enthält:
1. Aktion == CREATE und Status == QUEUED
1. Aktion == CREATE und Status == IN\$1PROGRESS
1. Aktion == CREATE und Status == FAILED
1. Aktion == UPDATE und Status == QUEUED
1. Aktion == UPDATE und Status == IN\$1PROGRESS
Zusammenfassend lässt sich sagen, dass Sie eine Datenkatalogansicht nur aktualisieren können, wenn sie die folgenden Anforderungen erfüllt.
1. Sie wurde erfolgreich zum ersten Mal erstellt.
1. Aktion == CREATE und State == SUCCESS
1. Es hat nach einem asynchronen Aktualisierungsvorgang einen Terminalstatus erreicht.
1. Aktion == UPDATE und Status == ERFOLG
1. Aktion == UPDATE und Status == FEHLGESCHLAGEN
1. Es hat ein `NULL` State-Attribut als Ergebnis einer synchronen Aktualisierung.
**kleben: DeleteTable**
Bei dieser Operation gibt es keine Änderungen im Vergleich zu den `glue:DeleteTable` Funktionen für jede AWS Glue Tabelle. Sie können eine Datenkatalogansicht unabhängig von ihrem Status löschen.
**kleben: GetTable**
Bei dieser Operation gibt es keine Änderungen im Vergleich zu den `glue:GetTable` Funktionen für jede AWS Glue Tabelle. Sie können eine Datenkatalogsicht jedoch erst dann von den Analytical Engines abfragen, wenn sie erfolgreich zum ersten Mal erstellt wurde. `Action == CREATE and State == SUCCESS`. Nachdem Sie eine Datenkatalogsicht zum ersten Mal erfolgreich erstellt haben, können Sie die Ansicht unabhängig von ihrem Status abfragen.
**Anmerkung**
Alle Informationen in diesem Abschnitt gelten für alle gelesenen Tabellen APIs wie `GetTable``GetTables`, und`SearchTables`.
# Sehen Sie sich Szenarien mit Fehlern bei der Erstellung bei asynchronen Vorgängen an
Die folgenden Beispiele sind repräsentativ für die Arten von Fehlern, die aus API-Aufrufen `CreateTable` oder `UpdateTable` Anzeigen von API-Aufrufen resultieren können. Sie erheben keinen Anspruch auf Vollständigkeit, da die Fehleroberfläche von SQL-Abfragefehlern ziemlich groß ist.
## Szenario 1: Fehler bei der Amazon Redshift Redshift-Abfrage
Die für Amazon Redshift bereitgestellte Abfrage enthält einen falsch geschriebenen Tabellennamen, der während der Überprüfung nicht im Datenkatalog gefunden wurde. Der daraus resultierende Fehler wird in dem `Status` Feld in der `GetTable` Antwort für die Ansicht angezeigt.
`GetTable`Anfrage:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-72",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`Antwort:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"UpdateTime": "2024-07-11T11:39:37-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu
Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
}
}
]
}
}
}
}
```
## Szenario 2: Ungültige Amazon Redshift Redshift-Verbindung
Die Amazon Redshift Redshift-Verbindung im folgenden Beispiel ist fehlerhaft, da sie auf eine Amazon Redshift Redshift-Datenbank verweist, die auf dem angegebenen Endpunkt nicht vorhanden ist. cluster/serverless Amazon Redshift kann die Ansicht nicht validieren und das `Status` Feld in der `GetTable` Antwort zeigt den Fehler an (`"State": "FAILED"`von Amazon Redshift).
`GetTable`Anfrage:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-73",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection-malformed"
}
]
}
}
}
```
`GetTable`Antwort:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Timestamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:43:38-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Time
stamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
}
}
]
}
}
}
}
```
## Szenario 3: Fehler bei der Athena-Abfrage
Die SQL für Athena hier ist ungültig, weil die Abfrage den Datenbanknamen falsch buchstabiert. Die Athena-Abfragevalidierung fängt dies ab und der daraus resultierende Fehler wird durch das `Status` Objekt in einem Aufruf angezeigt. `GetTable`
`GetTable`Anfrage:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-70",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`Antwort:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu Jul 11 18:10:
41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu J
ul 11 18:10:41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "SUCCESS"
}
]
}
}
}
}
```
## Szenario 4: Die Speicherdeskriptoren stimmen nicht überein
Das für den Athena-Dialekt bereitgestellte SQL wählt `col1` und, `col2` während das SQL für Redshift nur selektiert. `col1` Dies führt zu einem Fehler bei der Nichtübereinstimmung des Speicherdeskriptors.
`GetTable`Anfrage:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-71",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`Antwort:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:22:49-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
}
]
}
}
}
}
```
# Erteilen von Berechtigungen für Datenkatalog-Ansichten
Nachdem Sie Ansichten in der erstellt haben AWS Glue Data Catalog, können Sie Prinzipalen in allen AWS-Konten Organisationen und Organisationseinheiten Data Lake-Berechtigungen für Ansichten gewähren. Sie können Berechtigungen mithilfe von LF-Tags oder der Methode mit der benannten Ressource erteilen. Weitere Informationen zum Markieren von Ressourcen finden Sie unter. [Tag-basierte Zugangskontrolle von Lake Formation](tag-based-access-control.md) Weitere Informationen zum direkten Erteilen von Berechtigungen für Ansichten finden Sie unter[Erteilen von Berechtigungen für Ansichten mithilfe der benannten Ressourcenmethode](granting-view-permissions.md).
# Materialisierte Ansichten
**Topics**
+ [Differenzierung materialisierter Ansichten von anderen Ansichtstypen](#materialized-views-differentiating)
+ [Anwendungsfälle](#materialized-views-use-cases)
+ [Die wichtigsten Konzepte](#materialized-views-key-concepts)
+ [Berechtigungen für materialisierte Ansichten](#materialized-views-permissions)
+ [Materialisierte Ansichten erstellen und verwalten](#materialized-views-creating-managing)
+ [Speicher und Datenzugriff](#materialized-views-storage-access)
+ [AWS Lake Formation Integration mit Berechtigungen](#materialized-views-lake-formation)
+ [Überwachung und Debugging](#materialized-views-monitoring-debugging)
+ [Verwaltung von Aktualisierungsaufträgen](#materialized-views-managing-refresh-jobs)
+ [Überwachung und Problembehebung](#materialized-views-monitoring-troubleshooting)
+ [Überlegungen und Einschränkungen](#materialized-views-considerations-limitations)
Im AWS Glue Datenkatalog ist eine materialisierte Ansicht eine verwaltete Tabelle, in der das vorberechnete Ergebnis einer SQL-Abfrage im Apache Iceberg-Format gespeichert wird. Im Gegensatz zu Standard-Datenkatalogsichten, die die Abfrage bei jedem Zugriff ausführen, speichern materialisierte Ansichten die Abfrageergebnisse physisch und aktualisieren sie, wenn sich die zugrunde liegenden Quelltabellen ändern. Sie können materialisierte Ansichten mit Apache Spark Version 3.5.6\$1 in Amazon Athena, Amazon EMR oder erstellen. AWS Glue
Materialisierte Ansichten verweisen auf Apache Iceberg-Tabellen, die im AWS Glue Datenkatalog registriert sind, wobei vorberechnete Daten als Apache Iceberg-Tabellen in Amazon S3 S3-Tabellen oder Amazon S3 S3-Allzweck-Buckets gespeichert sind, sodass sie von mehreren Abfrage-Engines wie Amazon Athena, Amazon Redshift und Iceberg-kompatiblen Engines von Drittanbietern aus zugänglich sind.
## Differenzierung materialisierter Ansichten von anderen Ansichtstypen
Materialisierte Ansichten unterscheiden sich grundlegend von AWS Glue Datenkatalogansichten, Apache Spark-Ansichten und Amazon Athena Athena-Ansichten. Während es sich bei Datenkatalogsichten um virtuelle Tabellen handelt, die die SQL-Abfragedefinition bei jedem Zugriff ausführen, speichern materialisierte Ansichten die vorberechneten Abfrageergebnisse physisch. Dadurch werden redundante Berechnungen vermieden und die Abfrageleistung für komplexe Transformationen, auf die häufig zugegriffen wird, erheblich verbessert.
Materialisierte Ansichten unterscheiden sich auch von herkömmlichen Datentransformationspipelines, die mit AWS Glue ETL- oder benutzerdefinierten Spark-Jobs erstellt wurden. Anstatt benutzerdefinierten Code für die Änderungserkennung, inkrementelle Aktualisierungen und Workflow-Orchestrierung zu schreiben, definieren Sie materialisierte Ansichten mithilfe der Standard-SQL-Syntax. Der AWS Glue Datenkatalog überwacht automatisch Quelltabellen, erkennt Änderungen und aktualisiert materialisierte Ansichten mithilfe einer vollständig verwalteten Recheninfrastruktur.
## Anwendungsfälle
Im Folgenden sind wichtige Anwendungsfälle für materialisierte Ansichten aufgeführt:
+ **Beschleunigen Sie komplexe analytische Abfragen** — Erstellen Sie materialisierte Ansichten, die teure Verknüpfungen, Aggregationen und Fensterfunktionen vorab berechnen. Spark-Engines schreiben nachfolgende Abfragen automatisch neu, um die im Voraus berechneten Ergebnisse zu verwenden, wodurch die Latenz von Abfragen und die Rechenkosten reduziert werden.
+ **Vereinfachen Sie Datenumwandlungs-Pipelines** — Ersetzen Sie komplexe ETL-Jobs, die sich um die Änderungserkennung, inkrementelle Updates und Workflow-Orchestrierung kümmern, durch einfache SQL-basierte Definitionen für materialisierte Ansichten. Der AWS Glue Datenkatalog verwaltet die gesamte betriebliche Komplexität automatisch.
+ **Ermöglichen Sie Self-Service-Analysen mit geregeltem Datenzugriff** — Erstellen Sie kuratierte materialisierte Ansichten, die Rohdaten in einsatzbereite Datensätze umwandeln. Gewähren Sie Benutzern Zugriff auf materialisierte Ansichten, ohne die zugrunde liegenden Quelltabellen offenzulegen. Dies vereinfacht das Sicherheitsmanagement und ermöglicht gleichzeitig Self-Service-Analysen.
+ **Optimieren Sie das Feature-Engineering für maschinelles Lernen** — Definieren Sie materialisierte Ansichten, die Feature-Transformationen für ML-Modelle implementieren. Die automatische Aktualisierungsfunktion stellt sicher, dass die Feature-Speicher bei der Weiterentwicklung der Quelldaten aktuell bleiben, während die inkrementelle Aktualisierung die Rechenkosten minimiert.
+ **Implementieren Sie eine effiziente gemeinsame Nutzung von Daten** — Erstellen Sie materialisierte Ansichten, die Daten für bestimmte Nutzer filtern und transformieren. Teilen Sie materialisierte Ansichten über Konten und Regionen hinweg AWS Lake Formation, indem Sie die Notwendigkeit von Datenduplikationen vermeiden und gleichzeitig eine zentralisierte Verwaltung aufrechterhalten.
## Die wichtigsten Konzepte
### Automatische Aktualisierung
Die automatische Aktualisierung ist eine Funktion, die Ihre Quelltabellen kontinuierlich überwacht und materialisierte Ansichten gemäß einem von Ihnen definierten Zeitplan aktualisiert. Wenn Sie eine materialisierte Ansicht erstellen, können Sie mithilfe einer zeitbasierten Planung mit Intervallen von bis zu einer Stunde eine Aktualisierungshäufigkeit angeben. Der AWS Glue Datenkatalog verwendet eine verwaltete Spark-Recheninfrastruktur, um Aktualisierungsvorgänge im Hintergrund auszuführen und alle Aspekte der Änderungserkennung und der inkrementellen Aktualisierungen transparent zu handhaben.
Wenn sich die Quelldaten zwischen den Aktualisierungsintervallen ändern, ist die materialisierte Ansicht vorübergehend veraltet. Abfragen, die direkt auf die materialisierte Ansicht zugreifen, geben möglicherweise veraltete Ergebnisse zurück, bis die nächste geplante Aktualisierung abgeschlossen ist. In Szenarien, die sofortigen Zugriff auf die aktuellsten Daten erfordern, können Sie mit dem `REFRESH MATERIALIZED VIEW` SQL-Befehl eine manuelle Aktualisierung ausführen.
### Inkrementelle Aktualisierung
Die inkrementelle Aktualisierung ist eine Optimierungstechnik, bei der nur die Daten verarbeitet werden, die sich in den Quelltabellen seit der letzten Aktualisierung geändert haben, anstatt die gesamte materialisierte Ansicht neu zu berechnen. Der AWS Glue Datenkatalog nutzt die Metadatenebene von Apache Iceberg, um Änderungen in Quelltabellen effizient nachzuverfolgen und festzustellen, welche Teile der materialisierten Ansicht aktualisiert werden müssen.
Dieser Ansatz reduziert die Rechenkosten und die Aktualisierungsdauer im Vergleich zu vollständigen Aktualisierungsvorgängen erheblich, insbesondere bei großen Datensätzen, bei denen sich nur ein kleiner Prozentsatz der Daten zwischen den Aktualisierungszyklen ändert. Der inkrementelle Aktualisierungsmechanismus funktioniert automatisch. Sie müssen keine benutzerdefinierte Logik schreiben, um geänderte Daten zu erkennen oder zu verarbeiten.
### Automatisches Umschreiben von Abfragen
Automatisches Umschreiben von Abfragen ist eine Funktion zur Abfrageoptimierung, die in Spark-Engines von Amazon Athena, Amazon EMR und verfügbar ist. AWS Glue Wenn Sie eine Abfrage anhand von Basistabellen ausführen, analysiert der Spark-Optimierer Ihren Abfrageplan und ermittelt automatisch, ob verfügbare materialisierte Ansichten die Abfrage effizienter erfüllen können. Wenn eine geeignete materialisierte Ansicht vorhanden ist, schreibt der Optimierer die Abfrage transparent neu, sodass die vorberechneten Ergebnisse verwendet werden, anstatt die Basistabellen zu verarbeiten.
Diese Optimierung erfolgt, ohne dass Änderungen am Anwendungscode oder an den Abfrageanweisungen erforderlich sind. Der Spark-Optimierer stellt sicher, dass das automatische Umschreiben von Abfragen nur angewendet wird, wenn die materialisierte Ansicht aktuell ist und zu genauen Ergebnissen führen kann. Wenn eine materialisierte Ansicht veraltet ist oder die Abfrageanforderungen nicht vollständig erfüllt, führt der Optimierer den ursprünglichen Abfrageplan anhand der Basistabellen aus, wobei der Korrektheit Vorrang vor der Leistung eingeräumt wird.
### Rolle des View-Definers
Eine materialisierte Ansicht funktioniert auf der Grundlage der Berechtigungen der IAM-Rolle, mit der sie erstellt wurde. Sie wird als View Definer-Rolle bezeichnet. Die Definerrolle muss Lesezugriff auf alle Basistabellen haben, auf die in der Definition der materialisierten Ansicht verwiesen wird, und muss über Berechtigungen zum Erstellen von Tabellen in der Zieldatenbank verfügen. Wenn der AWS Glue Datenkatalog eine materialisierte Ansicht aktualisiert, übernimmt er die Rolle des Definierers, um auf Quelltabellen zuzugreifen und aktualisierte Ergebnisse zu schreiben.
Dieses Sicherheitsmodell ermöglicht es Ihnen, Benutzern Zugriff auf materialisierte Ansichten zu gewähren, ohne ihnen direkte Berechtigungen für die zugrunde liegenden Quelltabellen zu gewähren. Wenn die Rolle des View Definers den Zugriff auf eine Basistabelle verliert, schlagen nachfolgende Aktualisierungsvorgänge fehl, bis die Berechtigungen wiederhergestellt sind.
## Berechtigungen für materialisierte Ansichten
Um materialisierte Ansichten zu erstellen und zu verwalten, müssen Sie Berechtigungen konfigurieren AWS Lake Formation . Die IAM-Rolle, die die materialisierte Ansicht erstellt (die Definer-Rolle), erfordert spezielle Berechtigungen für Quelltabellen und Zieldatenbanken.
### Erforderliche Berechtigungen für die Definer-Rolle
Die Definiererrolle muss über die folgenden Lake Formation Formation-Berechtigungen verfügen:
+ Für Quelltabellen — SELECT- oder ALL-Berechtigungen ohne Zeilen-, Spalten- oder Zellenfilter
+ In der Zieldatenbank — CREATE\$1TABLE-Berechtigung
+ Über den AWS Glue Datenkatalog — GetTable und API-Berechtigungen CreateTable
Wenn Sie eine materialisierte Ansicht erstellen, wird der ARN der Definiererrolle in der Ansichtsdefinition gespeichert. Der AWS Glue Datenkatalog übernimmt diese Rolle, wenn automatische Aktualisierungsvorgänge ausgeführt werden. Wenn die Definiererrolle den Zugriff auf Quelltabellen verliert, schlagen Aktualisierungsvorgänge fehl, bis die Berechtigungen wiederhergestellt sind.
### IAM-Berechtigungen für Jobs AWS Glue
Für die IAM-Rolle Ihres AWS Glue Jobs sind die folgenden Berechtigungen erforderlich:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetCatalogs",
"glue:GetTable",
"glue:GetTables",
"glue:CreateTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetDatabase",
"glue:GetDatabases",
"cloudwatch:PutMetricData"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:*:/aws-glue/*"
]
},
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
Die Rolle, die Sie für die automatische Aktualisierung von Materialized View verwenden, muss über die iam: PassRole -Berechtigung für die Rolle verfügen.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Damit Glue die materialisierte Ansicht automatisch für Sie aktualisiert, muss die Rolle außerdem über die folgende Vertrauensrichtlinie verfügen, die es dem Dienst ermöglicht, die Rolle zu übernehmen.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Wenn die Materialized View in S3 Tables Buckets gespeichert ist, müssen Sie der Rolle außerdem die folgende Berechtigung hinzufügen.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3tables:PutTableMaintenanceConfiguration"
],
"Resource": "arn:aws:s3tables:*:123456789012:*"
}
]
}
```
### Zugriff auf materialisierte Ansichten gewähren
Um anderen Benutzern Zugriff auf die Abfrage einer materialisierten Ansicht zu gewähren, verwenden Sie, AWS Lake Formation um die SELECT-Berechtigung für die Materialized View-Tabelle zu gewähren. Benutzer können die Materialized View abfragen, ohne direkten Zugriff auf die zugrunde liegenden Quelltabellen zu benötigen.
Ausführliche Informationen zur Konfiguration von Lake Formation Formation-Berechtigungen finden Sie unter Erteilen und Widerrufen von Berechtigungen für Datenkatalogressourcen im AWS Lake Formation Entwicklerhandbuch.
## Materialisierte Ansichten erstellen und verwalten
Sie erstellen materialisierte Ansichten mithilfe der `CREATE MATERIALIZED VIEW` SQL-Anweisung in Spark-Engines. Die View-Definition spezifiziert die SQL-Abfrage, die die Transformationslogik, den Zieldatenbank- und Tabellennamen sowie die optionale Aktualisierungskonfiguration definiert. Sie können komplexe Transformationen definieren, einschließlich Aggregationen, Verknüpfungen über mehrere Tabellen hinweg, Filter und Fensterfunktionen.
```
CREATE MATERIALIZED VIEW sales_summary
AS
SELECT
region,
product_category,
SUM(sales_amount) as total_sales,
COUNT(DISTINCT customer_id) as unique_customers
FROM sales_transactions
WHERE transaction_date >= current_date - interval '90' day
GROUP BY region, product_category;
```
Um die automatische Aktualisierung zu konfigurieren, nehmen Sie den Aktualisierungszeitplan in Ihre View-Definition auf:
```
CREATE MATERIALIZED VIEW sales_summary
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT region, product_category, SUM(sales_amount) as total_sales
FROM sales_transactions
GROUP BY region, product_category;
```
Sie können eine materialisierte Ansicht jederzeit manuell aktualisieren, indem Sie den `REFRESH MATERIALIZED VIEW` folgenden Befehl verwenden:
```
REFRESH MATERIALIZED VIEW sales_summary;
```
Um den Aktualisierungszeitplan einer vorhandenen materialisierten Ansicht zu ändern, verwenden Sie die `ALTER MATERIALIZED VIEW` folgende Anweisung:
```
ALTER MATERIALIZED VIEW sales_summary
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```
### Verschachtelte materialisierte Ansichten
Sie können materialisierte Ansichten erstellen, die auf andere materialisierte Ansichten als Basistabellen verweisen, wodurch mehrstufige Datentransformationen ermöglicht werden. Wenn Sie verschachtelte Materialized Views erstellen, verfolgt der AWS Glue Datenkatalog Abhängigkeiten und verteilt Aktualisierungen automatisch über die Materialized View-Hierarchie. Wenn eine materialisierte Basisansicht aktualisiert wird, werden alle von ihr abhängigen Downstream-Materialized Views entsprechend aktualisiert.
Diese Funktion ermöglicht es Ihnen, komplexe Transformationen in logische Phasen zu zerlegen, was die Wartbarkeit verbessert und eine selektive Aktualisierung der Transformationsebenen auf der Grundlage Ihrer Datenaktualisierungsanforderungen ermöglicht.
## Speicher und Datenzugriff
Materialisierte Ansichten speichern vorberechnete Ergebnisse als Apache Iceberg-Tabellen in S3-Tabellen-Buckets oder S3-Buckets für allgemeine Zwecke in Ihrem Konto. AWS Der AWS Glue Datenkatalog verwaltet alle Aspekte der Wartung von Iceberg-Tabellen, einschließlich der Komprimierung und Aufbewahrung von Snapshots, mithilfe der automatisierten Optimierungsfunktionen von S3 Tables.
Da materialisierte Ansichten als Iceberg-Tabellen gespeichert werden, können Sie sie direkt von jeder Iceberg-kompatiblen Engine lesen, einschließlich Amazon Athena, Amazon Redshift und Analyseplattformen von Drittanbietern. Dieser Zugriff auf mehrere Engines stellt sicher, dass Ihre vorberechneten Daten in Ihrem gesamten Analytics-Ökosystem ohne Datenduplizierung oder Formatkonvertierung zugänglich bleiben.
## AWS Lake Formation Integration mit Berechtigungen
Sie können es verwenden AWS Lake Formation , um detaillierte Berechtigungen für materialisierte Ansichten zu verwalten. Der Ersteller der Ansicht wird automatisch Eigentümer der materialisierten Ansicht und kann anderen Benutzern oder Rollen mithilfe der benannten Ressourcenmethode oder AWS Lake Formation LF-Tags Berechtigungen gewähren.
Wenn Sie einem Benutzer die `SELECT` Berechtigung für eine materialisierte Ansicht gewähren, kann er die vorberechneten Ergebnisse abfragen, ohne Zugriff auf die zugrunde liegenden Quelltabellen zu benötigen. Dieses Sicherheitsmodell vereinfacht die Datenzugriffsverwaltung und ermöglicht es Ihnen, das Prinzip der geringsten Rechte zu implementieren, sodass Benutzer nur auf die spezifischen Datentransformationen zugreifen können, die sie benötigen.
Mithilfe der Funktionen zur AWS kontenübergreifenden gemeinsamen Nutzung können Sie materialisierte Ansichten für Konten, AWS Organisationen und Organisationseinheiten gemeinsam nutzen AWS Lake Formation. Mithilfe von Ressourcenlinks können Sie auch AWS regionsübergreifend auf materialisierte Ansichten zugreifen und so eine zentrale Datenverwaltung mit verteiltem Datenzugriff ermöglichen.
## Überwachung und Debugging
Der AWS Glue Datenkatalog veröffentlicht alle Aktualisierungsvorgänge von materialisierten Ansichten und die zugehörigen Metriken auf Amazon CloudWatch. Sie können die Startzeit, die Endzeit, die Dauer, das verarbeitete Datenvolumen und den Aktualisierungsstatus von Aktualisierungen anhand von CloudWatch Metriken überwachen. Wenn Aktualisierungsvorgänge fehlschlagen, werden Fehlermeldungen und Diagnoseinformationen in CloudWatch Protokollen erfasst.
Sie können CloudWatch Alarme einrichten, um Benachrichtigungen zu erhalten, wenn Aktualisierungsaufträge die erwartete Dauer überschreiten oder wiederholt fehlschlagen. Der AWS Glue Datenkatalog veröffentlicht auch Änderungsereignisse sowohl für erfolgreiche als auch für fehlgeschlagene Aktualisierungsläufe, sodass Sie Materialized View-Operationen in eine umfassendere Workflow-Automatisierung integrieren können.
Um den aktuellen Status einer materialisierten Ansicht zu überprüfen, verwenden Sie den `DESCRIBE MATERIALIZED VIEW` SQL-Befehl, der Metadaten zurückgibt, darunter den Verfallsstatus, den Zeitstempel der letzten Aktualisierung und die Konfiguration des Aktualisierungszeitplans.
## Verwaltung von Aktualisierungsaufträgen
### Starten einer manuellen Aktualisierung
Löst eine sofortige Aktualisierung außerhalb des geplanten Intervalls aus.
Erforderliche Berechtigung: Die für den API-Aufruf verwendeten AWS Anmeldeinformationen müssen über eine `glue:GetTable` Berechtigung für die materialisierte Ansicht verfügen.
Für den S3-Tabellenkatalog:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id :s3tablescatalog/ \
--database-name \
--table-name
```
Für Root Catalog:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
### Aktualisierungsstatus wird überprüft
Rufen Sie den Status eines bestimmten Aktualisierungsauftrags ab:
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id
```
### Aktualisierungsverlauf auflisten
Alle Aktualisierungsaufträge für eine materialisierte Ansicht anzeigen:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name
```
**Anmerkung**
Wird `:s3tablescatalog/` für S3-Tabellen oder `` für den Stammkatalog verwendet.
### Eine laufende Aktualisierung wird gestoppt
Brechen Sie einen laufenden Aktualisierungsauftrag ab:
```
aws glue stop-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
## Überwachung und Problembehebung
Es gibt drei Möglichkeiten, Aktualisierungsaufträge für Materialized Views zu überwachen:
### CloudWatch Metriken
Sehen Sie sich aggregierte Metriken für all Ihre Materialized View Refresh-Jobs an unter: CloudWatch
Verfügbare Metriken:
+ AWS/Glue-Namespace mit Abmessungen:
+ CatalogId: Ihre Katalog-ID
+ DatabaseName: Datenbank, die die materialisierte Ansicht enthält
+ TableName: Name der materialisierten Ansicht
+ TaskType: Auf "“ MaterializedViewRefresh gesetzt
In der Konsole anzeigen:
1. Navigieren Sie zu CloudWatch Konsole → Metriken
1. Wählen Sie den AWS/Glue-Namespace
1. Nach Dimensionen filtern: CatalogId,,, DatabaseName TableName TaskType
1. Sehen Sie sich Kennzahlen für Erfolg, Misserfolg und Dauer von Aufträgen an
Beispiel für eine CloudWatch Metrik-Abfrage:
```
{AWS/Glue,CatalogId,DatabaseName,TableName,TaskType} MaterializedViewRefresh
```
Verwenden von AWS CLI:
```
aws cloudwatch get-metric-statistics \
--namespace AWS/Glue \
--metric-name \
--dimensions Name=CatalogId,Value= \
Name=DatabaseName,Value= \
Name=TableName,Value= \
Name=TaskType,Value=MaterializedViewRefresh \
--start-time \
--end-time \
--period 3600 \
--statistics Sum \
--region
```
### CloudWatch Logs
Detaillierte Ausführungsprotokolle für einzelne Ausführungen von Aktualisierungsaufgaben anzeigen:
Protokollgruppe: `/aws-glue/materialized-views/`
Wo `` ist eine UUID (z. B. abc12345-def6-7890-ghij-klmnopqrstuv).
Protokolle anzeigen:
```
# List log streams for a task run
aws logs describe-log-streams \
--log-group-name /aws-glue/materialized-views/ \
--region
# Get log events
aws logs get-log-events \
--log-group-name /aws-glue/materialized-views/ \
--log-stream-name \
--region
```
In der CloudWatch Konsole:
1. Navigieren Sie zu CloudWatch → Protokollgruppen
1. Suchen Sie nach /aws-glue/materialized-views/
1. Wählen Sie die Protokollgruppe mit Ihrer Aufgabenausführungs-ID aus
1. Sehen Sie sich detaillierte Ausführungsprotokolle, Fehler und die Spark-Jobausgabe an
### Benachrichtigungen
Abonnieren Sie Ereignisse für Benachrichtigungen in Echtzeit über Statusänderungen bei der Aktualisierung von Jobs:
Verfügbare Ereignistypen:
+ Die Aufgabe zur Aktualisierung von Glue Materialized View wurde gestartet
+ Die Aktualisierungsaufgabe von Glue Materialized View war erfolgreich
+ Die Aktualisierungsaufgabe für Glue Materialized View ist fehlgeschlagen
+ Fehler beim Aufrufen der automatischen Aktualisierung von Glue Materialized View
Eine Regel erstellen:
```
aws events put-rule \
--name materialized-view-refresh-notifications \
--event-pattern '{
"source": ["aws.glue"],
"detail-type": [
"Glue Materialized View Refresh Task Started",
"Glue Materialized View Refresh Task Succeeded",
"Glue Materialized View Refresh Task Failed",
"Glue Materialized View Auto-Refresh Invocation Failure"
]
}' \
--region
```
Ein Ziel hinzufügen (z. B. ein SNS-Thema):
```
aws events put-targets \
--rule materialized-view-refresh-notifications \
--targets "Id"="1","Arn"="arn:aws:sns:::" \
--region
```
### Aktualisierungsstatus anzeigen
Überprüfen Sie den Status Ihrer Materialized View-Aktualisierungsaufträge mithilfe der AWS Glue API:
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id \
--region
```
Oder listen Sie alle letzten Aktualisierungsläufe auf:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name \
--region
```
Das zeigt:
+ Uhrzeit der letzten Aktualisierung
+ Aktualisierungsstatus (ERFOLGREICH, FEHLGESCHLAGEN, LÄUFT, GESTOPPT)
+ ID der Aufgabenausführung
+ Fehlermeldungen (falls fehlgeschlagen)
Allgemeine Aktualisierungsstatus:
+ WIRD AUSGEFÜHRT: Der Aktualisierungsjob wird gerade ausgeführt
+ ERFOLGREICH: Die Aktualisierung wurde erfolgreich abgeschlossen
+ FEHLGESCHLAGEN: Bei der Aktualisierung ist ein Fehler aufgetreten
+ GESTOPPT: Die Aktualisierung wurde manuell abgebrochen
Fehlerbehebung bei fehlgeschlagenen Aktualisierungen:
Wenn eine Aktualisierung fehlschlägt, überprüfen Sie:
1. IAM-Berechtigungen: Stellen Sie sicher, dass die Definiererrolle Zugriff auf alle Basistabellen und den Speicherort der materialisierten Ansicht hat
1. Verfügbarkeit von Basistabellen: Stellen Sie sicher, dass alle referenzierten Tabellen existieren und zugänglich sind
1. Gültigkeit der Abfrage: Stellen Sie sicher, dass die SQL-Abfrage für den Spark-SQL-Dialekt gültig ist
1. Ressourcenlimits: Prüfen Sie, ob Sie die Limits für gleichzeitige Aktualisierungen für Ihr Konto erreicht haben
Verwenden Sie die GetMaterializedViewRefreshTaskRun API, um detaillierte Fehlermeldungen abzurufen.
## Überlegungen und Einschränkungen
+ Materialisierte Ansichten können nur auf Apache Iceberg-Tabellen verweisen, die im AWS Glue Datenkatalog als Basistabellen registriert sind.
+ Die Erstellung von Ansichten und das automatische Umschreiben von Abfragen sind nur über Spark-Engines in Apache Spark Version 3.5.6 und höher in Amazon Athena, Amazon EMR und AWS Glue (Version 5.1) verfügbar.
+ Materialisierte Ansichten stimmen letztendlich mit Basistabellen überein. Während des Aktualisierungsfensters können Abfragen, die direkt auf die materialisierte Ansicht zugreifen, veraltete Daten zurückgeben. Führen Sie eine manuelle Aktualisierung durch, um sofort auf aktuelle Daten zugreifen zu können.
+ Das minimale automatische Aktualisierungsintervall beträgt eine Stunde. In Anwendungsfällen, die häufigere Updates erfordern, führen Sie manuelle Aktualisierungen programmgesteuert mit dem Befehl aus. `REFRESH MATERIALIZED VIEW`
+ Beim Umschreiben von Abfragen wird der Korrektheit Vorrang vor der Leistung eingeräumt. Wenn eine materialisierte Ansicht veraltet ist oder die Abfrageanforderungen nicht genau erfüllen kann, führen Spark-Engines die ursprüngliche Abfrage anhand der Basistabellen aus.
# Daten mithilfe von Workflows in Lake Formation importieren
Mit AWS Lake Formation können Sie Ihre Daten mithilfe von *Workflows* importieren. Ein Workflow definiert die Datenquelle und den Zeitplan für den Import von Daten in Ihren Data Lake. Es ist ein Container für AWS Glue Crawler, Jobs und Trigger, die verwendet werden, um die Prozesse zum Laden und Aktualisieren des Data Lakes zu orchestrieren.
**Topics**
+ [Baupläne und Arbeitsabläufe in Lake Formation](workflows-about.md)
+ [Einen Workflow erstellen](workflows-creating.md)
+ [Einen Workflow ausführen](workflows-running.md)
# Baupläne und Arbeitsabläufe in Lake Formation
Ein Workflow umfasst eine komplexe ETL-Aktivität (Extrahieren, Transformieren und Laden) mit mehreren Aufträgen. Workflows generieren AWS Glue Crawler, Jobs und Trigger, um das Laden und Aktualisieren von Daten zu orchestrieren. Lake Formation führt einen Workflow als eine Einheit aus und verfolgt ihn. Sie können einen Workflow so konfigurieren, dass er bei Bedarf oder nach einem Zeitplan ausgeführt wird.
**Anmerkung**
Spark Parquet Writer unterstützt keine Sonderzeichen in Spaltennamen. Dies ist eine technische Einschränkung des Writers selbst, kein Konfigurationsproblem.
Workflows, die Sie in Lake Formation erstellen, sind in der AWS Glue Konsole als gerichteter azyklischer Graph (DAG) sichtbar. Jeder DAG-Knoten ist ein Job, Crawler oder Trigger. Um den Fortschritt zu überwachen und Fehler zu beheben, können Sie den Status jedes Knotens im Workflow verfolgen.
Wenn ein Lake Formation Formation-Workflow abgeschlossen ist, erhält der Benutzer, der den Workflow ausgeführt hat, die Lake Formation `SELECT` Formation-Berechtigung für die Datenkatalogtabellen, die der Workflow erstellt.
Sie können Workflows auch in erstellenAWS Glue. Da Sie mit Lake Formation jedoch einen Workflow anhand eines Blueprints erstellen können, ist die Erstellung von Workflows in Lake Formation viel einfacher und automatisierter. Lake Formation bietet die folgenden Arten von Bauplänen:
+ **Datenbank-Snapshot** — Lädt Daten aus allen Tabellen aus einer JDBC-Quelle in den Data Lake oder lädt sie neu. Sie können einige Daten anhand eines Ausschlussmusters aus der Quelle ausschließen.
+ **Inkrementelle Datenbank** — Lädt nur neue Daten aus einer JDBC-Quelle in den Data Lake, die auf zuvor gesetzten Lesezeichen basieren. Sie geben die einzelnen Tabellen in der JDBC-Quelldatenbank an, die eingeschlossen werden sollen. Für jede Tabelle wählen Sie die Lesezeichenspalten und die Lesezeichen-Sortierreihenfolge aus, um den Überblick über die Daten zu behalten, die zuvor geladen wurden. Wenn Sie zum ersten Mal einen inkrementellen Datenbank-Blueprint für eine Gruppe von Tabellen ausführen, lädt der Workflow alle Daten aus den Tabellen und legt Lesezeichen für den nächsten inkrementellen Datenbank-Blueprint-Lauf fest. Sie können daher einen inkrementellen Datenbank-Blueprint anstelle des Datenbanksnapshot-Blueprints verwenden, um alle Daten zu laden, vorausgesetzt, Sie geben jede Tabelle in der Datenquelle als Parameter an.
+ **Protokolldatei** — Daten werden massenweise aus Protokolldateiquellen geladen AWS CloudTrail, darunter Elastic Load Balancing-Logs und Application Load Balancer Balancer-Logs.
Anhand der folgenden Tabelle können Sie entscheiden, ob Sie einen Datenbank-Snapshot oder einen inkrementellen Datenbank-Blueprint verwenden möchten.
| Verwenden Sie einen Datenbank-Snapshot, wenn... | Verwenden Sie eine inkrementelle Datenbank, wenn... |
| --- | --- |
| [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/workflows-about.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/workflows-about.html) |
**Anmerkung**
Benutzer können von Lake Formation erstellte Blueprints und Workflows nicht bearbeiten.
# Einen Workflow erstellen
Bevor Sie beginnen, stellen Sie sicher, dass Sie der Rolle die erforderlichen Datenberechtigungen und Datenspeicherberechtigungen erteilt haben`LakeFormationWorkflowRole`. Auf diese Weise kann der Workflow Metadatentabellen im Datenkatalog erstellen und Daten an Zielorte in Amazon S3 schreiben. Weitere Informationen erhalten Sie unter [(Optional) Erstellen Sie eine IAM-Rolle für Workflows](initial-lf-config.md#iam-create-blueprint-role) und [Überblick über die Genehmigungen für Lake Formation](lf-permissions-overview.md).
**Anmerkung**
Lake Formation verwendet `GetTemplateInstance``GetTemplateInstances`, und `InstantiateTemplate` Operationen, um Workflows aus Blueprints zu erstellen. Diese Operationen sind nicht öffentlich verfügbar und werden nur intern zur Erstellung von Ressourcen in Ihrem Namen verwendet. Sie erhalten CloudTrail Ereignisse für die Erstellung von Workflows.
**Um einen Workflow aus einem Blueprint zu erstellen**
1. Öffnen Sie die AWS Lake Formation Konsole unter. [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) Melden Sie sich als Data Lake-Administrator oder als Benutzer mit Data Engineer-Rechten an. Weitere Informationen finden Sie unter [Referenz zu Personas und IAM-Berechtigungen in Lake Formation](permissions-reference.md).
1. Wählen Sie im Navigationsbereich **Blueprints** und dann **Blueprint verwenden** aus.
1. Wählen Sie auf der Seite **Blueprint verwenden eine** Kachel aus, um den Blueprint-Typ auszuwählen.
1. Geben **Sie unter Importquelle** die Datenquelle an.
Wenn Sie aus einer JDBC-Quelle importieren, geben Sie Folgendes an:
+ ****Datenbankverbindung**** — Wählen Sie eine Verbindung aus der Liste aus. Erstellen Sie zusätzliche Verbindungen mithilfe der AWS Glue Konsole. Der JDBC-Benutzername und das JDBC-Kennwort in der Verbindung bestimmen, auf welche Datenbankobjekte der Workflow Zugriff hat.
+ ****Quelldatenpfad**** — Geben Sie ** je nach ** ** Datenbankprodukt**//oder/**ein. Oracle Database und MySQL unterstützen kein Schema im Pfad. Sie können das Prozentzeichen (%) durch ** oder ** ersetzen. Geben Sie beispielsweise für eine Oracle-Datenbank mit einem Systembezeichner (SID) von ein`orcl`, `orcl/%` um alle Tabellen zu importieren, auf die der in der Verbindung angegebene Benutzer Zugriff hat.
**Wichtig**
In diesem Feld wird zwischen Groß- und Kleinschreibung unterschieden. Der Workflow schlägt fehl, wenn die Groß- und Kleinschreibung für eine der Komponenten nicht übereinstimmt.
Wenn Sie eine MySQL-Datenbank angeben, verwendet AWS Glue ETL standardmäßig den Mysql5-JDBC-Treiber, sodass My nicht nativ unterstützt SQL8 wird. Sie können das ETL-Jobskript bearbeiten, um einen `customJdbcDriverS3Path` Parameter zu verwenden, wie in [JDBC connectionType Values](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-jdbc) im *AWS Glue Developer Guide* beschrieben, um einen anderen JDBC-Treiber zu verwenden, der My unterstützt. SQL8
Wenn Sie aus einer Protokolldatei importieren, stellen Sie sicher, dass die Rolle, die Sie für den Workflow angeben (die „Workflow-Rolle“), über die erforderlichen IAM-Berechtigungen für den Zugriff auf die Datenquelle verfügt. Um beispielsweise AWS CloudTrail Protokolle zu importieren, muss der Benutzer über die `cloudtrail:LookupEvents` Berechtigungen `cloudtrail:DescribeTrails` und verfügen, um die Liste der CloudTrail Protokolle bei der Erstellung des Workflows zu sehen, und die Workflow-Rolle muss über Berechtigungen für den CloudTrail Standort in Amazon S3 verfügen.
1. Führen Sie eine der folgenden Aktionen aus:
+ Identifizieren Sie für den **Blueprint-Typ Datenbank-Snapshot** optional eine Teilmenge der zu importierenden Daten, indem Sie ein oder mehrere Ausschlussmuster angeben. Bei diesen Ausschlussmustern handelt es sich um Muster im UNIX-Stil`glob`. Sie werden als Eigenschaft der Tabellen gespeichert, die durch den Workflow erstellt werden.
Einzelheiten zu den verfügbaren Ausschlussmustern finden Sie unter [Einschluss- und Ausschlussmuster](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) im *AWS Glue Entwicklerhandbuch*.
+ Geben Sie für den Blueprint-Typ **Inkrementelle Datenbank** die folgenden Felder an. Fügen Sie für jede zu importierende Tabelle eine Zeile hinzu.
**Tabellenname**
Zu importierende Tabelle. Muss ausschließlich in Kleinbuchstaben geschrieben werden.
**Schlüssel als Lesezeichen speichern**
Durch Kommas getrennte Liste von Spaltennamen, die die Lesezeichenschlüssel definieren. Wenn das Feld leer ist, wird der Primärschlüssel verwendet, um neue Daten zu ermitteln. Die Groß- und Kleinschreibung für jede Spalte muss mit der in der Datenquelle definierten Groß- und Kleinschreibung übereinstimmen.
Der Primärschlüssel gilt nur dann als Standardlesezeichenschlüssel, wenn er sequenziell erhöht oder verringert wird (ohne Lücken). Wenn Sie den Primärschlüssel als Lesezeichenschlüssel verwenden möchten und dieser Lücken aufweist, müssen Sie die Primärschlüsselspalte als Lesezeichenschlüssel benennen.
**Reihenfolge der Lesezeichen**
Wenn Sie **Aufsteigend** wählen, werden Zeilen mit Werten, die größer sind als die mit den Lesezeichen markierten Werte, als neue Zeilen identifiziert. Wenn Sie **Absteigend** wählen, werden Zeilen, deren Werte kleiner als die mit der Textmarke markierten Werte sind, als neue Zeilen identifiziert.
**Partitionierungsschema**
(Optional) Liste der Partitionierungsschlüsselspalten, getrennt durch Schrägstriche (/). ` year/month/day`Beispiel:.
![\[Der Bereich Inkrementelle Daten der Konsole umfasst die folgenden Felder: Tabellenname, Lesezeichenschlüssel, Lesezeichenreihenfolge, Partitionsschema. Sie können Zeilen hinzufügen oder entfernen, wobei jede Zeile für eine andere Tabelle bestimmt ist.\]](http://docs.aws.amazon.com/de_de/lake-formation/latest/dg/images/incremental-data.png)
Weitere Informationen finden Sie unter [Verfolgen verarbeiteter Daten mithilfe von Job-Lesezeichen](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) im *AWS Glue Entwicklerhandbuch*.
1. Geben Sie unter **Importziel** die Zieldatenbank, den Amazon S3 S3-Zielort und das Datenformat an.
Stellen Sie sicher, dass die Workflow-Rolle über die erforderlichen Lake Formation Formation-Berechtigungen für die Datenbank und den Amazon S3 S3-Zielstandort verfügt.
**Anmerkung**
Derzeit unterstützen Blueprints die Verschlüsselung von Daten am Ziel nicht.
1. Wählen Sie eine Importhäufigkeit.
Sie können einen `cron` Ausdruck mit der Option **Benutzerdefiniert** angeben.
1. Unter **Importoptionen**:
1. Geben Sie einen Workflow-Namen ein.
1. Wählen Sie unter Rolle die Rolle aus`LakeFormationWorkflowRole`, in der Sie sie erstellt haben[(Optional) Erstellen Sie eine IAM-Rolle für Workflows](initial-lf-config.md#iam-create-blueprint-role).
1. Geben Sie optional ein Tabellenpräfix an. Das Präfix wird den Namen der Datenkatalogtabellen vorangestellt, die der Workflow erstellt.
1. Wählen Sie **Erstellen** und warten Sie, bis die Konsole meldet, dass der Workflow erfolgreich erstellt wurde.
**Tipp**
Haben Sie die folgende Fehlermeldung erhalten?
`User: arn:aws:iam:::user/ is not authorized to perform: iam:PassRole on resource:arn:aws:iam:::role/...`
Falls ja, überprüfen Sie, ob Sie in allen Policen die AWS Kontonummer durch eine gültige ersetzt ** haben.
**Weitere Informationen finden Sie auch unter:**
[Baupläne und Arbeitsabläufe in Lake Formation](workflows-about.md)
# Einen Workflow ausführen
Sie können einen Workflow mit der Lake Formation Formation-Konsole, der AWS Glue Konsole, der AWS Glue Befehlszeilenschnittstelle (AWS CLI) oder der API ausführen.
**So führen Sie einen Workflow aus (Lake Formation Formation-Konsole)**
1. Öffnen Sie die AWS Lake Formation Konsole unter [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/). Melden Sie sich als Data Lake-Administrator oder als Benutzer mit Data Engineer-Rechten an. Weitere Informationen finden Sie unter [Referenz zu Personas und IAM-Berechtigungen in Lake Formation](permissions-reference.md).
1. Wählen Sie im Navigationsbereich die Option **Blueprints** aus.
1. Wählen Sie auf der Seite **Blueprints** den Workflow aus. Wählen Sie dann im Menü **Aktionen** die Option **Start** aus.
1. Während der Ausführung des Workflows können Sie seinen Fortschritt in der Spalte **Status der letzten Ausführung** anzeigen. Wählen Sie gelegentlich die Schaltfläche „Aktualisieren“.
Der Status wechselt von **LÄUFT** zu **Wird** erkannt, **importiert** und ist **ABGESCHLOSSEN**.
Wenn der Workflow abgeschlossen ist:
+ Der Datenkatalog enthält neue Metadatentabellen.
+ Ihre Daten werden in den Data Lake aufgenommen.
Wenn der Workflow fehlschlägt, gehen Sie wie folgt vor:
1. Wählen Sie den Workflow aus. Wählen Sie **Aktionen** und dann **Diagramm anzeigen** aus.
Der Workflow wird in der AWS Glue Konsole geöffnet.
1. Wählen Sie den Workflow aus und gehen Sie auf die Registerkarte **History (Verlauf)**.
1. Wählen Sie unter **Verlauf** den letzten Lauf aus und klicken Sie **auf Laufdetails anzeigen**.
1. Wählen Sie im dynamischen (Laufzeit-) Diagramm einen fehlgeschlagenen Job oder Crawler aus und überprüfen Sie die Fehlermeldung. Fehlgeschlagene Knoten sind entweder rot oder gelb.
**Weitere Informationen finden Sie auch unter:**
[Baupläne und Arbeitsabläufe in Lake Formation](workflows-about.md)