Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # AWS Lake Formation Modelle für die Zugriffskontrolle AWS Glue 5.0 und höher unterstützen zwei Modelle für den Datenzugriff über AWS Lake Formation: **Topics** + [Verwenden von AWS Glue with AWS Lake Formation für den vollständigen Tabellenzugriff](security-access-control-fta.md) + [Verwendung von AWS Glue mit AWS Lake Formation für eine feinkörnige Zugriffskontrolle](security-lf-enable.md) # Verwenden von AWS Glue with AWS Lake Formation für den vollständigen Tabellenzugriff ## Einführung in Full Table Access AWS Glue 5.0 und höher unterstützt die Steuerung des vollständigen Tabellenzugriffs (FTA) in Apache Spark auf der Grundlage Ihrer in AWS Lake Formation definierten Richtlinien. Diese Funktion ermöglicht Lese- und Schreiboperationen von Ihren AWS Glue Spark-Jobs aus auf AWS Lake Formation registrierten Tabellen, wenn die Jobrolle vollen Tabellenzugriff hat. FTA ist ideal für Anwendungsfälle, bei denen Sicherheitsvorschriften auf Tabellenebene eingehalten werden müssen, und unterstützt Spark-Funktionen wie Resilient Distributed Datasets (RDDs), benutzerdefinierte Bibliotheken und benutzerdefinierte Funktionen (UDFs) mit AWS Lake Formation Tabellen. Wenn ein AWS Glue Spark-Job für Full Table Access (FTA) konfiguriert ist, werden AWS Lake Formation Anmeldeinformationen für read/write Amazon S3 S3-Daten für AWS Lake Formation registrierte Tabellen verwendet, während die Runtime-Rollen-Anmeldeinformationen des Jobs für read/write Tabellen verwendet werden, bei AWS Lake Formation denen nicht registriert ist. Diese Funktion ermöglicht DML-Operationen (Data Manipulation Language) wie CREATE-, ALTER-, DELETE-, UPDATE- und MERGE INTO-Anweisungen in Apache-Hive- und Iceberg-Tabellen. **Anmerkung** Überprüfen Sie Ihre Anforderungen und stellen Sie fest, ob Fine-Grained Access Control (FGAC) oder Full Table Access (FTA) Ihren Anforderungen entspricht. Für einen bestimmten AWS Glue Job kann nur eine AWS Lake Formation Berechtigungsmethode aktiviert werden. Ein Auftrag kann nicht gleichzeitig Full Table Access (FTA) und Fine-Grained Access Control (FGAC) ausführen. ## So funktioniert Full-Table Access (FTA) auf AWS Glue AWS Lake Formation bietet zwei Ansätze für die Datenzugriffskontrolle: Fine-Grained Access Control (FGAC) und Full Table Access (FTA). FGAC bietet verbesserte Sicherheit durch Filterung auf Spalten-, Zeilen- und Zellenebene, ideal für Szenarien, die präzise Berechtigungen erfordern. FTA ist ideal für einfache Zugriffskontrollszenarien, in denen Sie Berechtigungen auf Tabellenebene benötigen. Es vereinfacht die Implementierung, da kein differenzierter Zugriffsmodus erforderlich ist, verbessert die Leistung und senkt die Kosten, da Systemtreiber und Systemausführungen vermieden werden, und unterstützt sowohl Lese- als auch Schreibvorgänge (einschließlich der Befehle CREATE, ALTER, DELETE, UPDATE und MERGE INTO). In AWS Glue 4.0 funktionierte der AWS Lake Formation basierte Datenzugriff über die Klasse, die von zur Verfügung GlueContext gestellte Dienstprogrammklasse. AWS Glue In AWS Glue 5.0 ist der AWS Lake Formation basierte Datenzugriff über systemeigenes Spark-SQL, Spark DataFrames, verfügbar und wird weiterhin über GlueContext Klassen unterstützt. ## Implementierung von Full Table Access ### Schritt 1: Aktivieren Sie den vollständigen Tabellenzugriff in AWS Lake Formation Um den Modus Full Table Access (FTA) zu verwenden, müssen Sie Abfrage-Engines von Drittanbietern den Zugriff auf Daten ermöglichen, ohne dass die IAM-Sitzungstag-Validierung in AWS Lake Formation aktiviert ist. Folgen Sie zur Aktivierung den Schritten unter [Application integration for full table access](https://docs.aws.amazon.com/lake-formation/latest/dg/full-table-credential-vending.html). ### Schritt 2: Einrichten der IAM-Berechtigungen für die Auftrag-Laufzeitrolle Für den Lese- oder Schreibzugriff auf zugrunde liegende Daten benötigt eine Job-Runtime-Rolle zusätzlich zu den AWS Lake Formation Berechtigungen die `lakeformation:GetDataAccess` IAM-Berechtigung. Mit dieser Berechtigung wird der Anforderung temporärer Anmeldeinformationen für den Zugriff auf die Daten stattgegeben. AWS Lake Formation Die folgende Beispielrichtlinie beschreibt, wie Sie IAM-Berechtigungen für den Zugriff auf ein Skript in Amazon S3, das Hochladen von Protokollen in Amazon S3, API-Berechtigungen für AWS Glue und die Berechtigung für den Zugriff auf AWS Lake Formation erteilen. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ScriptAccess", "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/scripts/*" ] }, { "Sid": "LoggingAccess", "Effect": "Allow", "Action": [ "s3:PutObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/logs/*" ] }, { "Sid": "GlueCatalogAccess", "Effect": "Allow", "Action": [ "glue:GetDatabase", "glue:GetDatabases", "glue:GetTable", "glue:GetTables", "glue:GetPartition", "glue:GetPartitions", "glue:CreateTable", "glue:UpdateTable" ], "Resource": [ "arn:aws:glue:us-east-1:111122223333:catalog", "arn:aws:glue:us-east-1:111122223333:database/default", "arn:aws:glue:us-east-1:111122223333:table/default/*" ] }, { "Sid": "LakeFormationAccess", "Effect": "Allow", "Action": [ "lakeformation:GetDataAccess" ], "Resource": "*" } ] } ``` ------ #### Schritt 2.1 AWS Lake Formation Berechtigungen konfigurieren AWS Glue Spark-Jobs, die Daten aus Amazon S3 lesen, benötigen die AWS Lake Formation SELECT-Berechtigung. AWS Glue Spark-Jobs, für die write/delete Daten in Amazon S3 ist eine AWS Lake Formation ALL-Genehmigung erforderlich. AWS Glue Spark-Jobs, die mit dem AWS Glue Datenkatalog interagieren, benötigen die entsprechenden DESCRIBE-, ALTER- und DROP-Berechtigungen. ### Schritt 3: Initialisieren Sie eine Spark-Sitzung für den vollständigen Tabellenzugriff mit AWS Lake Formation Um auf Tabellen zuzugreifen AWS Lake Formation, bei denen registriert ist, müssen bei der Spark-Initialisierung die folgenden Konfigurationen festgelegt werden, um Spark für die Verwendung AWS Lake Formation von Anmeldeinformationen zu konfigurieren. Um auf Tabellen zuzugreifen AWS Lake Formation, mit denen Sie registriert sind, müssen Sie Ihre Spark-Sitzung explizit für die Verwendung von AWS Lake Formation Anmeldeinformationen konfigurieren. Fügen Sie bei der Initialisierung Ihrer Spark-Sitzung die folgenden Konfigurationen hinzu: ``` from pyspark.sql import SparkSession # Initialize Spark session with Lake Formation configurations spark = SparkSession.builder \ .appName("Lake Formation Full Table Access") \ .config("spark.sql.catalog.glue_catalog", "org.apache.spark.sql.catalog.hive.GlueCatalog") \ .config("spark.sql.catalog.glue_catalog.glue.lakeformation-enabled", "true") \ .config("spark.sql.defaultCatalog", "glue_catalog") \ .getOrCreate() ``` Wichtige Konfigurationen: + `spark.sql.catalog.glue_catalog`: Registriert einen Katalog mit dem Namen „glue\$1catalog“, der die Implementierung verwendet GlueCatalog + `spark.sql.catalog.glue_catalog.glue.lakeformation-enabled`: Aktiviert explizit die AWS Lake Formation Integration für diesen Katalog + Der Katalogname (in diesem Beispiel „glue\$1catalog“) kann angepasst werden, muss aber in beiden Konfigurationseinstellungen konsistent sein. #### Hive ``` ‐‐conf spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.AWS Glue.accesscontrol.AWSLakeFormationCredentialResolver --conf spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true --conf spark.hadoop.fs.s3.folderObject.autoAction.disabled=true --conf spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true --conf spark.sql.catalog.createDirectoryAfterTable.enabled=true --conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true ``` #### Iceberg ``` --conf spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.AWS Glue.accesscontrol.AWSLakeFormationCredentialResolver --conf spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true --conf spark.hadoop.fs.s3.folderObject.autoAction.disabled=true --conf spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true --conf spark.sql.catalog.createDirectoryAfterTable.enabled=true --conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true --conf spark.sql.catalog..AWS Glue.lakeformation-enabled=true ``` + `spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.AWS Glue.accesscontrol.AWSLakeFormationCredentialResolver`: Konfigurieren Sie das EMR-Dateisystem (EMRFS) so, dass AWS Lake Formation S3-Anmeldeinformationen für registrierte Tabellen verwendet werden. AWS Lake Formation Wenn die Tabelle nicht registriert ist, verwenden Sie die Anmeldeinformationen für die Auftrag-Laufzeitrolle. + `spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true` und `spark.hadoop.fs.s3.folderObject.autoAction.disabled=true`: Konfigurieren Sie EMRFS so, dass beim Erstellen von S3-Ordnern der Content-Type-Header „application/x-directory“ anstelle des Suffixes „\$1folder\$1“ verwendet wird. Dies ist beim Lesen von AWS Lake Formation Tabellen erforderlich, da AWS Lake Formation Anmeldeinformationen das Lesen von Tabellenordnern mit dem Suffix \$1folder\$1 nicht zulassen. + `spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true`: Konfigurieren Sie Spark so, dass die Überprüfung, ob der Tabellenspeicherort leer ist, vor der Erstellung übersprungen wird. Dies ist für AWS Lake Formation registrierte Tabellen erforderlich, da AWS Lake Formation Anmeldeinformationen zur Überprüfung des leeren Speicherorts erst nach der Erstellung der AWS Glue Datenkatalogtabelle verfügbar sind. Ohne diese Konfiguration validieren die Anmeldeinformationen für die Auftrag-Laufzeitrolle den Speicherort der leeren Tabelle. + `spark.sql.catalog.createDirectoryAfterTable.enabled=true`: Konfigurieren Sie Spark so, dass der Amazon-S3-Ordner nach der Tabellenerstellung im Hive-Metastore erstellt wird. Dies ist für AWS Lake Formation registrierte Tabellen erforderlich, da AWS Lake Formation Anmeldeinformationen für die Erstellung des Amazon S3 S3-Ordners erst nach der Erstellung der AWS Glue Datenkatalogtabelle verfügbar sind. + `spark.sql.catalog.dropDirectoryBeforeTable.enabled=true`: Konfigurieren Sie Spark so, dass der Amazon-S3-Ordner vor dem Löschen von Tabellen im Hive-Metastore entfernt wird. Dies ist für AWS Lake Formation registrierte Tabellen erforderlich, da die AWS Lake Formation Anmeldeinformationen zum Löschen des S3-Ordners nach dem Löschen der Tabelle aus dem AWS Glue Datenkatalog nicht verfügbar sind. + `spark.sql.catalog..AWS Glue.lakeformation-enabled=true`: Konfigurieren Sie den Iceberg-Katalog so, dass er AWS Lake Formation Amazon S3 S3-Anmeldeinformationen für AWS Lake Formation registrierte Tabellen verwendet. Wenn die Tabelle nicht registriert ist, verwenden Sie die Standardanmeldeinformationen für die Umgebung. ## Nutzungsmuster ### Verwenden von FTA mit DataFrames Für Benutzer, die mit Spark vertraut sind, DataFrames kann es mit AWS Lake Formation Full Table Access verwendet werden. AWS Glue 5.0 bietet native Spark-Unterstützung für Lake Formation Full Table Access und vereinfacht so die Arbeit mit geschützten Tabellen. Diese Funktion ermöglicht es AWS Glue AWS Glue 5.0-Spark-Jobs, Daten direkt zu lesen und zu schreiben, wenn vollständiger Tabellenzugriff gewährt wird, wodurch Einschränkungen aufgehoben werden, die zuvor bestimmte ETL-Operationen (Extrahieren, Transformieren und Laden) einschränkten. Sie können jetzt erweiterte Spark-Funktionen wie Resilient Distributed Datasets (RDDs), benutzerdefinierte Bibliotheken und benutzerdefinierte Funktionen (UDFs) mit AWS Lake Formation Tabellen nutzen. #### Natives Spark-FTA in 5.0 AWS Glue AWS Glue 5.0 unterstützt die Steuerung des vollständigen Tabellenzugriffs (FTA) in Apache Spark auf der Grundlage Ihrer in definierten Richtlinien. AWS Lake Formation Diese Kontrollebene ist ideal für Anwendungsfälle, bei denen Sicherheitsvorschriften auf Tabellenebene eingehalten werden müssen. #### Beispiel für Apache-Iceberg-Tabellen ``` from pyspark.sql import SparkSession catalog_name = "spark_catalog" aws_region = "us-east-1" aws_account_id = "123456789012" warehouse_path = "s3://amzn-s3-demo-bucket/warehouse/" spark = SparkSession.builder \ .config("spark.sql.extensions","org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions") \ .config(f"spark.sql.catalog.{catalog_name}", "org.apache.iceberg.spark.SparkSessionCatalog") \ .config(f"spark.sql.catalog.{catalog_name}.warehouse", f"{warehouse_path}") \ .config(f"spark.sql.catalog.{catalog_name}.client.region",f"{aws_region}") \ .config(f"spark.sql.catalog.{catalog_name}.glue.account-id",f"{aws_account_id}") \ .config(f"spark.sql.catalog.{catalog_name}.glue.lakeformation-enabled","true") \ .config(f"spark.sql.catalog.dropDirectoryBeforeTable.enabled", "true") \ .config(f"spark.sql.catalog.{catalog_name}.catalog-impl", "org.apache.iceberg.aws.glue.GlueCatalog") \ .config(f"spark.sql.catalog.{catalog_name}.io-impl", "org.apache.iceberg.aws.s3.S3FileIO") \ .config("spark.sql.defaultCatalog", catalog_name) \ # Add this line .getOrCreate() database_name = "your_database" table_name = "your_table" df = spark.sql(f"select * from {database_name}.{table_name}") df.show() ``` #### Erforderliche IAM-Berechtigungen Ihre Rolle bei der Ausführung von AWS Glue Aufgaben muss über Folgendes verfügen: ``` { "Action": "lakeformation:GetDataAccess", "Resource": "*", "Effect": "Allow" } ``` Außerdem die entsprechenden S3-Zugriffsberechtigungen für Ihre Datenspeicherorte. #### Lake-Formation-Konfiguration Vor der Verwendung von nativem Spark FTA in AWS Glue 5.0: 1. Erlauben Sie Abfrage-Engines von Drittanbietern den Zugriff auf Daten ohne Überprüfung des IAM-Sitzungs-Tags in AWS Lake Formation 1. Erteilen Sie Ihrer AWS Glue Jobausführungsrolle über AWS Lake Formation die Konsole die entsprechenden Tabellenberechtigungen 1. Konfigurieren Sie Ihre Spark-Sitzung mit den erforderlichen Parametern, die im obigen Beispiel gezeigt werden. ### Verwenden von FTA mit DynamicFrames AWS Glue Die native Version DynamicFrames kann mit AWS Lake Formation vollständigem Tabellenzugriff für optimierte ETL-Operationen verwendet werden. Full Table Access (FTA) bietet ein Sicherheitsmodell, das Berechtigungen auf Tabellenebene gewährt. Das ermöglicht im Vergleich zu Fine-Grained Access Control (FGAC) eine schnellere Datenverarbeitung, da der Aufwand für Berechtigungsprüfungen auf Zeilen- und Spaltenebene umgangen wird. Dieser Ansatz ist nützlich, wenn Sie ganze Tabellen verarbeiten müssen und Berechtigungen auf Tabellenebene Ihren Sicherheitsanforderungen entsprechen. In AWS Glue 4.0 war DynamicFrames mit FTA eine spezifische GlueContext Konfiguration erforderlich. Bestehender AWS Glue DynamicFrame 4.0-Code mit FTA wird in AWS Glue 5.0 weiterhin funktionieren, aber die neuere Version bietet auch native Spark FTA-Unterstützung mit größerer Flexibilität. Für neue Entwicklungen sollten Sie den in DataFrames diesem Abschnitt beschriebenen systemeigenen Spark-Ansatz in Betracht ziehen, insbesondere wenn Sie zusätzliche Funktionen wie Resilient Distributed Datasets (RDDs), benutzerdefinierte Bibliotheken und benutzerdefinierte Funktionen (UDFs) mit Tabellen benötigen. AWS Lake Formation #### Erforderliche Berechtigungen Die IAM-Rolle, die Ihren Glue-Auftrag ausführt, muss Folgendes haben: + `lakeformation:GetDataAccess`-Berechtigung + Entsprechende Lake-Formation-Tabellenberechtigungen, die über die Lake-Formation-Konsole erteilt wurden #### Beispiel für eine DynamicFrame Implementierung in 5.0 AWS Glue ``` from awsglue.context import GlueContext from pyspark.context import SparkContext # Initialize Glue context sc = SparkContext() glueContext = GlueContext(sc) # Configure catalog for Iceberg tables catalog_name = "glue_catalog" aws_region = "us-east-1" aws_account_id = "123456789012" warehouse_path = "s3://amzn-s3-demo-bucket/warehouse/" spark = glueContext.spark_session spark.conf.set(f"spark.sql.catalog.{catalog_name}", "org.apache.iceberg.spark.SparkCatalog") spark.conf.set(f"spark.sql.catalog.{catalog_name}.warehouse", f"{warehouse_path}") spark.conf.set(f"spark.sql.catalog.{catalog_name}.catalog-impl", "org.apache.iceberg.aws.glue.GlueCatalog") spark.conf.set(f"spark.sql.catalog.{catalog_name}.io-impl", "org.apache.iceberg.aws.s3.S3FileIO") spark.conf.set(f"spark.sql.catalog.{catalog_name}.glue.lakeformation-enabled","true") spark.conf.set(f"spark.sql.catalog.{catalog_name}.client.region",f"{aws_region}") spark.conf.set(f"spark.sql.catalog.{catalog_name}.glue.id", f"{aws_account_id}") # Read Lake Formation-protected table with DynamicFrame df = glueContext.create_data_frame.from_catalog( database="your_database", table_name="your_table" ) ``` ## Zusätzliche Konfiguration ### Konfigurieren Sie den vollständigen Tabellenzugriffsmodus in AWS Glue Studio Notebooks Um über interaktive Spark-Sitzungen in AWS Glue Studio Notebooks auf AWS Lake Formation registrierte Tabellen zuzugreifen, müssen Sie den Kompatibilitätsberechtigungsmodus verwenden. Verwenden Sie den `%%configure`-Magic-Befehl, um Ihre Spark-Konfiguration einzurichten, bevor Sie Ihre interaktive Sitzung starten. Diese Konfiguration muss der erste Befehl in Ihrem Notebook sein, da sie nach dem Start der Sitzung nicht mehr angewendet werden kann. Wählen Sie die Konfiguration basierend auf Ihrem Tabellentyp aus: #### Für Hive-Tabellen ``` %%configure --conf spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver --conf spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true --conf spark.hadoop.fs.s3.folderObject.autoAction.disabled=true --conf spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true --conf spark.sql.catalog.createDirectoryAfterTable.enabled=true --conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true ``` #### Für Iceberg-Tabellen ``` %%configure --conf spark.hadoop.fs.s3.credentialsResolverClass=com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver --conf spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true --conf spark.hadoop.fs.s3.folderObject.autoAction.disabled=true --conf spark.sql.catalog.skipLocationValidationOnCreateTable.enabled=true --conf spark.sql.catalog.createDirectoryAfterTable.enabled=true --conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true --conf spark.sql.catalog.glue_catalog.warehouse=s3://example-s3-bucket_DATA_LOCATION --conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog --conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO --conf spark.sql.catalog.glue_catalog.glue.account-id=ACCOUNT_ID --conf spark.sql.catalog.glue_catalog.glue.region=REGION ``` Ersetzen Sie die Platzhalter: + S3\$1DATA\$1LOCATION: *s3://amzn-s3-demo-bucket* + REGION: *AWS Region (e.g., us-east-1)* + KONTO-ID: *Your AWS Account ID* **Anmerkung** Sie müssen diese Konfigurationen festlegen, bevor Sie Spark-Operationen in Ihrem Notebook ausführen. ### Unterstützte Vorgänge Bei diesen Vorgängen werden AWS Lake Formation Anmeldeinformationen für den Zugriff auf die Tabellendaten verwendet. **Anmerkung** Bei der Aktivierung AWS Lake Formation: Für FTA: Aktivieren der Spark-Konfiguration `spark.sql.catalog.{catalog_name}.glue.lakeformation-enabled` + CREATE TABLE + ALTER TABLE + INSERT INTO + INSERT OVERWRITE + SELECT + UPDATE + MERGE INTO + DELETE FROM + ANALYZE TABLE + REPAIR TABLE + DROP TABLE + Spark-Datenquellenabfragen + Spark-Datenquellenschreibvorgänge **Anmerkung** Operationen, die oben nicht aufgeführt sind, verwenden weiterhin IAM-Berechtigungen für den Zugriff auf Tabellendaten. ## Migration von AWS Glue 4.0 auf AWS Glue 5.0 FTA Bei der Migration von AWS Glue 4.0 GlueContext FTA auf AWS Glue 5.0 native Spark FTA: 1. Erlauben Sie Abfrage-Engines von Drittanbietern den Zugriff auf Daten ohne Überprüfung des IAM-Sitzungstags in AWS Lake Formation. Befolgen Sie [Schritt 1: Aktivieren Sie den vollständigen Tabellenzugriff in AWS Lake Formation](#security-access-control-fta-step-1). 1. Sie müssen die Auftrag-Laufzeitrolle nicht ändern. Stellen Sie jedoch sicher, dass die Rolle „ AWS Glue Job Execution“ über die Berechtigung Lakeformation: IAM verfügt. GetDataAccess 1. Ändern Sie die Spark-Sitzungskonfigurationen im Skript. Stellen Sie sicher, dass die folgenden Spark-Konfigurationen vorhanden sind: ``` --conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog --conf spark.sql.catalog.spark_catalog.warehouse=s3:///warehouse/ --conf spark.sql.catalog.spark_catalog.client.region= --conf spark.sql.catalog.spark_catalog.glue.account-id=ACCOUNT_ID --conf spark.sql.catalog.spark_catalog.glue.lakeformation-enabled=true --conf spark.sql.catalog.dropDirectoryBeforeTable.enabled=true ``` 1. Aktualisieren Sie das Skript so, dass es auf native GlueContext DataFrames Spark-Version umgestellt wurde. DataFrames 1. Aktualisieren Sie Ihren AWS Glue Job, um AWS Glue 5.0 zu verwenden ## Überlegungen und Einschränkungen + Wenn eine Hive-Tabelle mit einem Auftrag erstellt wird, für den der vollständige Tabellenzugriff nicht aktiviert ist, und keine Datensätze eingefügt werden, schlagen nachfolgende Lese- oder Schreibvorgänge aus einem Auftrag mit vollständigem Tabellenzugriff fehl. Das liegt daran, dass AWS Glue Spark ohne vollständigen Tabellenzugriff dem Namen des Tabellenordners das Suffix \$1folder\$1 hinzufügt. Um dieses Problem zu lösen, haben Sie folgende Möglichkeiten: + Fügen Sie mindestens eine Zeile aus einem Auftrag in die Tabelle ein, für den FTA nicht aktiviert ist. + Konfigurieren Sie den Auftrag, für den FTA nicht aktiviert ist, so, dass er das Suffix „\$1folder\$1“ im Ordnernamen in S3 nicht verwendet. Dies kann durch Einstellen der Spark-Konfiguration `spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject=true` erreicht werden. + Erstellen eines Amazon-S3-Ordners am Tabellenspeicherort `s3://path/to/table/table_name` mit der Amazon-S3-Konsole oder Amazon-S3-CLI. + Full Table Access funktioniert ausschließlich mit dem EMR-Dateisystem (EMRFS). Das S3A-Dateisystem ist nicht kompatibel. + Full Table Access wird für Hive- und Iceberg-Tabellen unterstützt. Support für Hudi- und Delta-Tabellen wurde noch nicht hinzugefügt. + Jobs, die auf Tabellen mit FGAC-Regeln ( AWS Lake Formation Fine-Grained Access Control) oder Datenkatalogsichten verweisen, schlagen fehl. AWS Glue Um eine Tabelle mit FGAC-Regeln oder einer AWS Glue Datenkatalogsicht abzufragen, müssen Sie den FGAC-Modus verwenden. Sie können den FGAC-Modus aktivieren, indem Sie die in der AWS Dokumentation beschriebenen Schritte ausführen: Verwenden AWS Glue von with für eine detaillierte Zugriffskontrolle. AWS Lake Formation + Der vollständige Tabellenzugriff unterstützt Spark Streaming nicht. + Kann nicht gleichzeitig mit FGAC verwendet werden. # Verwendung von AWS Glue mit AWS Lake Formation für eine feinkörnige Zugriffskontrolle ## -Übersicht Mit AWS Glue Version 5.0 und höher können Sie detaillierte Zugriffskontrollen auf Datenkatalogtabellen anwenden, die von S3 unterstützt werden. AWS Lake Formation Mit dieser Funktion können Sie Zugriffskontrollen auf Tabellen-, Zeilen-, Spalten- und Zellenebene für read-Abfragen innerhalb Ihrer AWS Glue für Apache-Spark-Aufträge konfigurieren. In den folgenden Abschnitten erfahren Sie mehr über Lake Formation und wie Sie es mit AWS Glue verwenden können. `GlueContext`Eine basierte Zugriffskontrolle auf Tabellenebene mit AWS Lake Formation Berechtigungen, die in Glue 4.0 oder früher unterstützt wurden, wird in Glue 5.0 nicht unterstützt. Verwenden Sie die neue native differenzierte Zugriffskontrolle (FGAC) von Spark in Glue 5.0. Beachten Sie folgende Details: + Wenn Sie Fine Grained Access Control (FGAC) für die row/column/cell Zugriffskontrolle benötigen, müssen Sie in Glue 4.0 von `GlueContext` /Glue und DynamicFrame in Glue 5.0 vor Spark-Dataframe migrieren. Beispiele finden Sie unter [Migration von GlueContext/Glue DynamicFrame zu Spark DataFrame](security-lf-migration-spark-dataframes.md) + Wenn Sie Full Table Access Control (FTA) benötigen, können Sie FTA DynamicFrames in AWS Glue 5.0 nutzen. Sie können auch zum nativen Spark-Ansatz migrieren, um zusätzliche Funktionen wie Resilient Distributed Datasets (RDDs), benutzerdefinierte Bibliotheken und benutzerdefinierte Funktionen (UDFs) mit Tabellen zu nutzen. AWS Lake Formation Beispiele finden Sie unter [Migration von AWS Glue 4.0 zu AWS Glue 5.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html). + Wenn Sie FGAC nicht benötigen, ist keine Migration zu Spark DataFrame erforderlich und `GlueContext`-Features wie Auftragslesezeichen und Push-Down-Prädikate funktionieren weiterhin. + Aufträge mit FGAC erfordern mindestens 4 Worker: einen Benutzertreiber, einen Systemtreiber, einen System-Executor und einen Standby-Benutzer-Executor. Für die Verwendung von AWS AWS Lake Formation Glue mit fallen zusätzliche Gebühren an. ## So funktioniert AWS Glue mit AWS Lake Formation Wenn Sie AWS Glue mit Lake Formation verwenden, können Sie für jeden Spark-Job eine Berechtigungsebene erzwingen, um die Lake Formation Formation-Berechtigungssteuerung anzuwenden, wenn AWS Glue Jobs ausführt. AWS Glue verwendet [Spark-Ressourcenprofile](https://spark.apache.org/docs/latest/api/java/org/apache/spark/resource/ResourceProfile.html), um zwei Profile für die effektive Ausführung von Jobs zu erstellen. Das Benutzerprofil führt vom Benutzer bereitgestellten Code aus, während das Systemprofil die Lake-Formation-Richtlinien durchsetzt. Weitere Informationen finden Sie unter [Was ist AWS Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html) und [Überlegungen und Einschränkungen](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable-considerations.html). Im Folgenden finden Sie einen allgemeinen Überblick darüber, wie AWS Glue Zugriff auf Daten erhält, die durch die Sicherheitsrichtlinien von Lake Formation geschützt sind. ![\[Das Diagramm zeigt, wie eine detaillierte Zugriffskontrolle mit der AWS StartJobRun Glue-API funktioniert.\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/images/glue-50-fgac-start-job-run-api-diagram.png) 1. Ein Benutzer ruft die `StartJobRun` API für einen AWS Lake Formation-fähigen AWS Glue-Job auf. 1. AWS Glue sendet den Job an einen Benutzertreiber und führt den Job im Benutzerprofil aus. Der Benutzertreiber führt eine schlanke Version von Spark aus, die nicht in der Lage ist, Aufgaben zu starten, Executors anzufordern, auf S3 oder den Glue-Katalog zuzugreifen. Er erstellt einen Auftragsplan. 1. AWS Glue richtet einen zweiten Treiber ein, den Systemtreiber, und führt ihn im Systemprofil aus (mit einer privilegierten Identität). AWS Glue richtet einen verschlüsselten TLS-Kanal zwischen den beiden Treibern für die Kommunikation ein. Der Benutzertreiber verwendet den Kanal, um die Auftragspläne an den Systemtreiber zu senden. Der Systemtreiber führt keinen vom Benutzer übermittelten Code aus. Er führt Spark vollständig aus und kommuniziert mit S3 und dem Datenkatalog für den Datenzugriff. Er fordert Executors an und stellt den Auftragsplan in eine Abfolge von Ausführungsphasen zusammen. 1. AWS Glue führt dann die Stufen auf Executoren mit dem Benutzertreiber oder Systemtreiber aus. Benutzercode wird in jeder Phase ausschließlich auf Benutzerprofil-Executors ausgeführt. 1. Stufen, die Daten aus Datenkatalogtabellen lesen, die durch Sicherheitsfilter geschützt sind AWS Lake Formation oder solche, die Sicherheitsfilter anwenden, werden an System-Executoren delegiert. ## Mindestanforderung an Worker Ein Lake Formation-fähiger Job in AWS Glue erfordert mindestens 4 Worker: einen Benutzertreiber, einen Systemtreiber, einen System-Executor und einen Standby-User Executor. Dies ist ein Anstieg der Mindestanzahl von 2 Arbeitern, die für AWS Standardklebearbeiten erforderlich sind. Ein Lake Formation-fähiger Job in AWS Glue verwendet zwei Spark-Treiber — einen für das Systemprofil und einen weiteren für das Benutzerprofil. Ebenso sind die Executors in zwei Profile unterteilt: + System-Executors: Bearbeiten Aufgaben, bei denen Lake-Formation-Datenfilter angewendet werden. + Benutzer-Executoren: Werden bei Bedarf vom Systemtreiber angefordert. Da Spark-Jobs von Natur aus faul sind, reserviert AWS Glue 10% der gesamten Arbeiter (mindestens 1), nach Abzug der beiden Treiber, für Benutzerausführungen. Für alle Lake-Formation-fähigen Aufträge ist Auto Scaling aktiviert. Das bedeutet, dass die Benutzer-Executors nur bei Bedarf gestartet werden. Eine Beispielkonfiguration finden Sie unter [Überlegungen und Einschränkungen](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable-considerations.html). ## IAM-Berechtigungen für die Auftrag-Laufzeitrolle Lake Formation Formation-Berechtigungen kontrollieren den Zugriff auf AWS Glue Data Catalog-Ressourcen, Amazon S3 S3-Standorte und die zugrunde liegenden Daten an diesen Standorten. IAM-Berechtigungen kontrollieren den Zugriff auf Lake Formation und AWS Glue APIs sowie auf Ressourcen. Obwohl Sie möglicherweise über die Lake-Formation-Berechtigung verfügen, auf eine Tabelle im Datenkatalog (SELECT) zuzugreifen, schlägt Ihr Vorgang fehl, wenn Sie nicht über die IAM-Berechtigung für den `glue:Get*`-API-Vorgang verfügen. Die folgende Beispielrichtlinie beschreibt, wie Sie IAM-Berechtigungen für den Zugriff auf ein Skript in S3, das Hochladen von Protokollen in S3, API-Berechtigungen für AWS  Glue und die Berechtigung für den Zugriff auf Lake Formation erteilen. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ScriptAccess", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::*.amzn-s3-demo-bucket/scripts", "arn:aws:s3:::*.amzn-s3-demo-bucket/*" ] }, { "Sid": "LoggingAccess", "Effect": "Allow", "Action": [ "s3:PutObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/logs/*" ] }, { "Sid": "GlueCatalogAccess", "Effect": "Allow", "Action": [ "glue:Get*", "glue:Create*", "glue:Update*" ], "Resource": [ "*" ] }, { "Sid": "LakeFormationAccess", "Effect": "Allow", "Action": [ "lakeformation:GetDataAccess" ], "Resource": [ "*" ] } ] } ``` ------ ## Lake-Formation-Berechtigungen für die Auftrag-Laufzeitrolle einrichten Registrieren Sie zunächst den Speicherort Ihrer Hive-Tabelle bei Lake Formation. Erstellen Sie anschließend Berechtigungen für Ihre Auftrag-Laufzeitrolle für die gewünschte Tabelle. Weitere Informationen zu Lake Formation finden Sie unter [Was ist AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html) im *AWS Lake Formation Entwicklerhandbuch*. Nachdem Sie die Lake-Formation-Berechtigungen eingerichtet haben, können Sie Spark-Aufträge auf AWS  Glue senden. ## Senden einer Auftragsausführung Nachdem Sie die Lake Formation Grants eingerichtet haben, können Sie Spark-Jobs auf AWS Glue einreichen. Um Iceberg-Aufträge auszuführen, müssen Sie die folgenden Spark-Konfigurationen angeben. Geben Sie den folgenden Parameter ein, um die Konfiguration über Glue-Auftragsparameter vorzunehmen: + Schlüssel: ``` --conf ``` + Wert: ``` spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog --conf spark.sql.catalog.spark_catalog.warehouse= --conf spark.sql.catalog.spark_catalog.glue.account-id= --conf spark.sql.catalog.spark_catalog.client.region= --conf spark.sql.catalog.spark_catalog.glue.endpoint=https://glue..amazonaws.com ``` ## Verwenden einer interaktiven Sitzung Nachdem Sie die AWS Lake Formation Grants eingerichtet haben, können Sie interaktive Sessions auf AWS Glue verwenden. Sie müssen die folgenden Spark-Konfigurationen über die `%%configure`-Magic angeben, bevor Sie Code ausführen. ``` %%configure { "--enable-lakeformation-fine-grained-access": "true", "--conf": "spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog --conf spark.sql.catalog.spark_catalog.warehouse= --conf spark.sql.catalog.spark_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog --conf spark.sql.catalog.spark_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions --conf spark.sql.catalog.spark_catalog.client.region= --conf spark.sql.catalog.spark_catalog.glue.account-id= --conf spark.sql.catalog.spark_catalog.glue.endpoint=https://glue..amazonaws.com" } ``` ## FGAC für AWS Glue 5.0 Notebook oder interaktive Sitzungen Um Fine-Grained Access Control (FGAC) in AWS Glue zu aktivieren, müssen Sie die für Lake Formation erforderlichen Spark-Konfigurationen als Teil von %%configure Magic angeben, bevor Sie die erste Zelle erstellen. Eine spätere Angabe über die Aufrufe `SparkSession.builder().conf("").get()` oder `SparkSession.builder().conf("").create()` reicht nicht aus. Dies ist eine Änderung gegenüber dem Verhalten von AWS Glue 4.0. ## Unterstützung für das offene Tabellenformat AWS Glue Version 5.0 oder höher bietet Unterstützung für eine feinkörnige Zugriffskontrolle auf Basis von Lake Formation. AWS Glue unterstützt die Tabellentypen Hive und Iceberg. In der folgenden Tabelle werden alle unterstützten Vorgänge beschrieben. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/glue/latest/dg/security-lf-enable.html) # Migration von GlueContext/Glue DynamicFrame zu Spark DataFrame Im Folgenden finden Sie Python- und Scala-Beispiele für die Migration von `GlueContext`/Glue `DynamicFrame` in Glue 4.0 zu Spark `DataFrame` in Glue 5.0. **Python** Vorher: ``` escaped_table_name= '``.``' additional_options = { "query": f'select * from {escaped_table_name} WHERE column1 = 1 AND column7 = 7' } # DynamicFrame example dataset = glueContext.create_data_frame_from_catalog( database="", table_name=escaped_table_name, additional_options=additional_options) ``` Nachher: ``` table_identifier= '``.``.``"' #catalogname is optional # DataFrame example dataset = spark.sql(f'select * from {table_identifier} WHERE column1 = 1 AND column7 = 7') ``` **Scala** Vorher: ``` val escapedTableName = "``.``" val additionalOptions = JsonOptions(Map( "query" -> s"select * from $escapedTableName WHERE column1 = 1 AND column7 = 7" ) ) # DynamicFrame example val datasource0 = glueContext.getCatalogSource( database="", tableName=escapedTableName, additionalOptions=additionalOptions).getDataFrame() ``` Nachher: ``` val tableIdentifier = "``.``.``" //catalogname is optional # DataFrame example val datasource0 = spark.sql(s"select * from $tableIdentifier WHERE column1 = 1 AND column7 = 7") ``` # Überlegungen und Einschränkungen Berücksichtigen Sie folgende Überlegungen und Einschränkungen, wenn Sie Lake Formation mit AWS  Glue verwenden. AWS Glue with Lake Formation ist in allen unterstützten Regionen außer AWS GovCloud (US-Ost) und AWS GovCloud (US-West) verfügbar. + AWS Glue unterstützt eine feinkörnige Zugriffskontrolle über Lake Formation nur für Apache Hive- und Apache Iceberg-Tabellen. Zu den Apache-Hive-Formaten gehören Parquet, ORC und CSV. + Sie können Lake Formation nur mit Spark-Aufträgen verwenden. + AWS Glue mit Lake Formation unterstützt nur eine einzige Spark-Sitzung während eines Jobs. + Wenn Lake Formation aktiviert ist, benötigt AWS Glue eine größere Anzahl von Workern, da es einen Systemtreiber, Systemausführungen, einen Benutzertreiber und optional Benutzerausführungen benötigt (erforderlich, wenn Ihr Job oder hat). UDFs `spark.createDataFrame` + AWS Glue with Lake Formation unterstützt nur kontenübergreifende Tabellenabfragen, die über Ressourcenlinks gemeinsam genutzt werden. Der Name des Ressourcenlinks muss identisch sein mit dem Namen der Ressource des Quellkontos. + Um eine differenzierte Zugriffskontrolle für AWS Glue-Jobs zu aktivieren, übergeben Sie den `--enable-lakeformation-fine-grained-access` Job-Parameter. + Sie können Ihre AWS Glue-Jobs so konfigurieren, dass sie mit der AWS Glue-Hierarchie mit mehreren Katalogen funktionieren. Informationen zu den Konfigurationsparametern, die mit der AWS `StartJobRun` Glue-API verwendet werden können, finden Sie unter [Arbeiten mit der AWS Glue-Multi-Katalog-Hierarchie auf EMR Serverless](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/external-metastore-glue-multi.html). + Folgendes wird nicht unterstützt: + Resilient Distributed Datasets (RDD) + Spark-Streaming + Schreiben mit von Lake Formation erteilten Berechtigungen + Zugriffskontrolle für verschachtelte Spalten + AWS Glue blockiert Funktionen, die die vollständige Isolierung des Systemtreibers untergraben könnten, darunter die folgenden: + UDTs, Hive und alle benutzerdefinierten FunktionenUDFs, die benutzerdefinierte Klassen beinhalten + Benutzerdefinierte Datenquellen + Bereitstellung zusätzlicher JARs für Spark-Erweiterungen, Connectors oder Metastore + `ANALYZE TABLE` command + Um Zugriffskontrollen, `EXPLAIN PLAN` und DDL-Vorgänge durchzusetzen, z. B. `DESCRIBE TABLE`, sollten eingeschränkte Informationen nicht offengelegt werden. + AWS Glue schränkt den Zugriff auf Systemtreiber-Spark-Logs für Lake Formation-fähige Anwendungen ein. Weil der Systemtreiber mit mehr Zugriffsrechten ausgeführt wird, können Ereignisse und Protokolle, die der Systemtreiber generiert, vertrauliche Informationen enthalten. Um zu verhindern, dass unbefugte Benutzer oder Code auf diese sensiblen Daten zugreifen, hat AWS Glue den Zugriff auf Systemtreiberprotokolle deaktiviert. Wenden Sie sich zur Fehlerbehebung an den AWS Support. + Wenn Sie einen Tabellenspeicherort bei Lake Formation registriert haben, durchläuft der Datenzugriffspfad unabhängig von der IAM-Berechtigung für die AWS -Glue-Auftrag-Laufzeitrolle die gespeicherten Anmeldeinformationen von Lake Formation. Wenn Sie die mit dem Tabellenspeicherort registrierte Rolle falsch konfigurieren, schlagen gesendete Aufträge fehl, die die Rolle mit der S3-IAM-Berechtigung für den Tabellenspeicherort verwenden. + Beim Schreiben in eine Lake-Formation-Tabelle werden IAM-Berechtigungen und nicht die von Lake Formation erteilten Berechtigungen verwendet. Wenn Ihre Auftrag-Laufzeitrolle über die erforderlichen S3-Berechtigungen verfügt, können Sie sie zum Ausführen von Schreibvorgängen verwenden. Im Folgenden werden Einschränkungen und Überlegungen bei der Verwendung von Apache Iceberg aufgeführt: + Sie können Apache Iceberg nur mit Sitzungskatalogen und nicht mit beliebig benannten Katalogen verwenden. + Iceberg-Tabellen, die in Lake Formation registriert sind, unterstützen nur die Metadatentabellen `history``metadata_log_entries`,`snapshots`,`files`,`manifests`, und`refs`. AWS Glue blendet die Spalten aus, die möglicherweise vertrauliche Daten enthalten, wie `partitions``path`, und`summaries`. Diese Einschränkung gilt nicht für Iceberg-Tabellen, die nicht in Lake Formation registriert sind. + Tabellen, die Sie nicht in Lake Formation registrieren, unterstützen alle gespeicherten Iceberg-Prozeduren. Die Prozeduren `register_table` und `migrate` werden für keine Tabellen unterstützt. + Wir empfehlen, Iceberg DataFrameWriter V2 statt V1 zu verwenden. ## Beispiel für Worker-Zuordnung Für einen Auftrag, der mit folgenden Parametern konfiguriert wurde: ``` --enable-lakeformation-fine-grained-access=true --number-of-workers=20 ``` Die Worker-Zuordnung würde so lauten: + Ein Worker für den Benutzertreiber. + Ein Worker für den Systemtreiber. + 10 % der verbleibenden 18 Worker (d. h. 2 Worker) sind für die Ausführung durch Benutzer-Executors reserviert. + Bis zu 16 Worker sind für System-Executors vorgesehen. Wenn Auto Scaling aktiviert ist, können die Benutzer-Executors bei Bedarf jede der nicht zugewiesenen Kapazitäten der System-Executors nutzen. ## Steuern der Benutzer-Executor-Zuordnung Sie können den Reservierungsprozentsatz für Benutzer-Executors mit der folgenden Konfiguration anpassen: ``` --conf spark.dynamicAllocation.maxExecutorsRatio= ``` Mit dieser Konfiguration kann genau gesteuert werden, wie viele Benutzer-Executors im Verhältnis zur verfügbaren Gesamtkapazität reserviert werden. # Fehlerbehebung In den folgenden Abschnitten finden Sie Lösungen zur Fehlerbehebung. ## Protokollierung AWS Glue verwendet Spark-Ressourcenprofile, um die Auftragsausführung aufzuteilen. AWS Glue verwendet das Benutzerprofil, um den von Ihnen bereitgestellten Code auszuführen, während das Systemprofil die Lake Formation-Richtlinien durchsetzt. Sie können auf die Protokolle für die Aufgaben zugreifen, die unter dem Benutzerprofil ausgeführt wurden. ## Live-UI und Spark History Server In der Live-UI und auf dem Spark History Server werden alle Spark-Ereignisse aus dem Benutzerprofil und aus dem Systemtreiber redigierte Ereignisse generiert. Sie können alle Aufgaben sowohl der Benutzer- als auch der Systemtreiber auf der Registerkarte **Executors** sehen. Protokolllinks sind jedoch nur für das Benutzerprofil verfügbar. Außerdem werden einige Informationen aus der Live-UI redigiert, z. B. die Anzahl der Ausgabedatensätze. ## Auftrag schlägt fehl, weil die Lake-Formation-Berechtigungen unzureichend sind Stellen Sie sicher, dass Ihre Auftrag-Laufzeitrolle über die Berechtigungen zum Ausführen von SELECT und DESCRIBE für die Tabelle verfügt, auf die Sie zugreifen. ## Auftrag mit RDD-Ausführung ist fehlgeschlagen AWS Glue unterstützt derzeit keine Resilient Distributed Dataset (RDD) -Operationen für Lake Formation-fähige Jobs. ## Auf Datendateien in Amazon S3 kann nicht zugegriffen werden Stellen Sie sicher, dass Sie den Data-Lake-Standort in Lake Formation registriert haben. ## Sicherheitsvalidierungsausnahme AWS Glue hat einen Fehler bei der Sicherheitsüberprüfung festgestellt. Wenden Sie sich an den AWS Support, um Unterstützung zu erhalten ## Gemeinsame Nutzung des AWS Glue-Datenkatalogs und der Tabellen für mehrere Konten Sie können Datenbanken und Tabellen für mehrere Konten freigeben und trotzdem Lake Formation verwenden. Weitere Informationen finden Sie unter [Kontoübergreifender Datenaustausch in Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/cross-account-permissions.html) und [Wie teile ich den AWS Glue-Datenkatalog und die Tabellen kontoübergreifend](https://repost.aws/knowledge-center/glue-lake-formation-cross-account) mit? . Die folgende Tabelle enthält eine Zusammenfassung der Auswahl zwischen differenzierter Zugriffskontrolle (Fine-grained access control, FGAC) und vollständigem Tabellenzugriff (Full table access, FTA) für Ihre Workload. | Feature | Differenzierte Zugriffskontrolle (FGAC, Fine-Grained Access Control) | Vollständiger Tabellenzugriff (FTA) | | --- |--- |--- | | Zugriffsebene | Spalten-/Zeilenebene | Vollständige Tabelle | | Anwendungsfall | Abfragen und ETL mit eingeschränkten Berechtigungen | ETL | | Auswirkung auf die Leistung | Erfordert system/user Speicherübergänge für die Evaluierung der Zugriffskontrolle, was die Latenz erhöht | Optimierte Leistung |