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.
# EMR File System (EMRFS)
**Anmerkung**
Ab der Version EMR 7.10.0 hat das S3A-Dateisystem EMRFS als Standard-EMR S3-Connector ersetzt.
Das EMR File System (EMRFS) ist eine HDFS-Implementierung, die von allen Amazon-EMR-Clustern verwendet wird, um reguläre Dateien von Amazon EMR direkt zu Amazon S3 zu lesen und zu schreiben. EMRFS bietet die praktische Möglichkeit der Speicherung von persistenten Daten in Amazon S3 zur Nutzung mit Hadoop. Gleichzeitig stehen Features wie die Datenverschlüsselung zur Verfügung.
Die Datenverschlüsselung ermöglicht Ihnen das Verschlüsseln von Objekten, die EMRFS zu Amazon S3 schreibt, und ermöglicht EMRFS das Arbeiten mit verschlüsselten Objekten in Amazon S3. Wenn Sie die Amazon-EMR-Version 4.8.0 oder höher verwenden, können Sie Sicherheitskonfigurationen für die Einrichtung der Verschlüsselung von EMRFS-Objekten in Amazon S3 verwenden, zusammen mit anderen Verschlüsselungseinstellungen. Weitere Informationen finden Sie unter [Verschlüsselungsoptionen](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-data-encryption-options). Wenn Sie eine ältere Version von Amazon EMR verwenden, können Sie Verschlüsselungseinstellungen manuell konfigurieren. Weitere Informationen finden Sie unter [Angeben der Amazon-S3-Verschlüsselung mit EMRFS-Eigenschaften](emr-emrfs-encryption.md).
Amazon S3 bietet eine hohe Konsistenz beim Lesen nach dem Schreiben für alle GET-, PUT- und LIST-Operationen AWS-Regionen. Das bedeutet, dass das, was Sie mit EMRFS schreiben, das ist, was Sie aus Amazon S3 lesen, ohne dass die Leistung beeinträchtigt wird. Weitere Informationen finden Sie unter [Amazon-S3-Datenkonsistenzmodell](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html#ConsistencyModel).
Wenn Sie die Amazon-EMR-Version 5.10.0 oder höher verwenden, können Sie verschiedene IAM-Rollen für EMRFS-Anfragen an Amazon S3 verwenden, basierend auf Cluster-Benutzern oder Gruppen oder auf dem Speicherort von EMRFS-Daten in Amazon S3. Weitere Informationen finden Sie unter [Konfigurieren von IAM-Rollen für EMRFS-Anforderungen an Amazon S3](https://docs.aws.amazon.com//emr/latest/ManagementGuide/emr-emrfs-iam-roles).
**Warnung**
Bevor Sie die spekulative Ausführung für Amazon-EMR-Cluster aktivieren, auf denen Apache-Spark-Aufträge ausgeführt werden, lesen Sie bitte die folgenden Informationen.
EMRFS umfasst den EMRFS S3-optimierten Committer, eine OutputCommitter Implementierung, die für das Schreiben von Dateien in Amazon S3 bei Verwendung von EMRFS optimiert ist. Wenn Sie das spekulative Ausführungsfeature von Apache Spark mit Anwendungen aktivieren, die Daten in Amazon S3 schreiben und den EMRFS-S3-optimierten Committer nicht verwenden, können Probleme mit der Datenkorrektheit auftreten, die in [SPARK-10063](https://issues.apache.org/jira/browse/SPARK-10063) beschrieben sind. Dies kann auftreten, wenn Sie Amazon-EMR-Versionen vor Amazon-EMR-Version 5.19 verwenden oder wenn Sie Dateien mit Formaten wie ORC und CSV auf Amazon S3 schreiben. Diese Formate werden vom EMRFS-S3-optimierten Committer nicht unterstützt. Eine vollständige Liste der Anforderungen für die Verwendung des EMRFS-S3-optimierten Committers finden Sie unter [Anforderungen für den EMRFS-S3-optimierten Committer](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-committer-reqs.html).
EMRFS Direct Write wird in der Regel verwendet, wenn der EMRFS-S3-optimierte Committer nicht unterstützt wird, z. B. wenn Folgendes geschrieben wird:
Ein anderes Ausgabeformat als Parquet, z. B. ORC oder Text.
Hadoop-Dateien, die die Spark-RDD-API verwenden.
Parquet mit Hive. SerDe Sehen Sie unter [Konvertierung der Parquet-Tabelle in Hive Metastore](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#hive-metastore-parquet-table-conversion).
EMRFS-Direct-Write-Verfahren wird in den folgenden Szenarien nicht verwendet:
Wenn der S3-optimierte EMRFS-Committer aktiviert ist. Sehen Sie unter [Anforderungen für den S3-optimierten EMRFS-Committer](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-committer-reqs.html).
Beim Schreiben dynamischer Partitionen, bei denen die partitionOverwriteMode Einstellung auf dynamisch gesetzt ist.
Beim Schreiben in benutzerdefinierte Partitionsspeicherorte, z. B. an Speicherorte, die nicht der Hive-Standardkonvention für Partitionen entsprechen.
Wenn Sie andere Dateisysteme als EMRFS verwenden, z. B. beim Schreiben in HDFS oder beim Verwenden des S3A-Dateisystems.
Um festzustellen, ob Ihre Anwendung Direct Write in Amazon EMR 5.14.0 oder höher verwendet, aktivieren Sie die Spark-INFO-Protokollierung. Wenn eine Protokollzeile mit dem Text „Direct Write: ENABLED“ entweder in den Spark-Treiberprotokollen oder in den Spark-Executor-Container-Protokollen vorhanden ist, dann hat Ihre Spark-Anwendung mit Direct Write geschrieben.
Standardmäßig ist die spekulative Ausführung bei Amazon `OFF` EMRclusters aktiviert. Wir empfehlen dringend, die spekulative Ausführung nicht zu aktivieren, wenn diese beiden Bedingungen zutreffen:
Sie schreiben Daten in Amazon S3.
Daten werden in einem anderen Format als Apache Parquet oder im Apache-Parquet-Format ohne den für EMRFS-S3-optimierten Committer geschrieben.
Wenn Sie die spekulative Ausführung von Spark aktivieren und Daten mithilfe von EMRFS Direct Write auf Amazon S3 schreiben, kann es zu zeitweiligem Datenverlust kommen. Wenn Sie Daten in HDFS schreiben oder Daten mit dem EMRFS-S3-optimierten Committer in Parquet schreiben, verwendet Amazon EMR kein direktes Schreiben und dieses Problem tritt nicht auf.
Wenn Sie Daten in Formaten schreiben müssen, die EMRFS Direct Write von Spark nach Amazon S3 verwenden und spekulative Ausführung verwenden, empfehlen wir, in HDFS zu schreiben und dann die Ausgabedateien mit S3DistCP nach Amazon S3 zu übertragen.
**Topics**
+ [
# Consistent view
](emr-plan-consistent-view.md)
+ [
# Zugriff auf EMRFS-Daten in Amazon S3 genehmigen
](emr-plan-credentialsprovider.md)
+ [
# Verwaltung des Standardendpunkts AWS -Security-Token-Service
](emr-emrfs-sts-endpoint.md)
+ [
# Angeben der Amazon-S3-Verschlüsselung mit EMRFS-Eigenschaften
](emr-emrfs-encryption.md)
# Consistent view
**Warnung**
Am 1. Juni 2023 wird die Standardunterstützung für zukünftige Amazon-EMR-Versionen für EMRFS konsistente Ansicht eingestellt. Die EMRFS-konsistente Ansicht wird auch weiterhin für bestehende Versionen funktionieren.
Mit der Veröffentlichung von Amazon S3 Strong read-after-write Consistency am 1. Dezember 2020 müssen Sie EMRFS Consistent View (EMRFS CV) nicht mehr für Ihre Amazon EMR-Cluster verwenden. EMRFS CV ist eine optionale Funktion, mit der Amazon EMR-Cluster Amazon S3 S3-Objekte auf Liste und read-after-write Konsistenz überprüfen können. Wenn Sie einen Cluster erstellen und EMRFS CV aktiviert ist, erstellt Amazon EMR eine Amazon DynamoDB DynamoDB-Datenbank zum Speichern von Objektmetadaten, die zur Nachverfolgung der Liste und read-after-write Konsistenz von S3-Objekten verwendet werden. Sie können jetzt EMRFS CV deaktivieren und die DynamoDB-Datenbank löschen, sodass Ihnen keine zusätzlichen Kosten entstehen. In den folgenden Verfahren wird erklärt, wie Sie das CV-Feature prüfen, ausschalten und die DynamoDB-Datenbank löschen, die das Feature verwendet.
**Um zu überprüfen, ob Sie das EMRFS-CV-Feature verwenden**
1. Navigieren Sie zur Registerkarte **Konfiguration**. Wenn Ihr Cluster die folgende Konfiguration hat, verwendet er EMRFS CV.
```
Classification=emrfs-site,Property=fs.s3.consistent,Value=true
```
1. [Verwenden Sie alternativ den, um Ihren Cluster AWS CLI mit der API zu beschreiben. `describe-cluster`](https://docs.aws.amazon.com/cli/latest/reference/emr/describe-cluster.html) Wenn die Ausgabe `fs.s3.consistent: true` enthält, verwendet Ihr Cluster EMRFS CV.
**So deaktivieren Sie EMRFS CV auf Ihren Amazon-EMR-Clustern**
Verwenden Sie eine der folgenden drei Optionen, um das EMRFS-CV-Feature zu deaktivieren. Sie sollten diese Optionen in Ihrer Testumgebung testen, bevor Sie sie auf Ihre Produktionsumgebungen anwenden.
1.
**Um Ihren vorhandenen Cluster zu beenden und einen neuen Cluster ohne EMRFS-CV-Optionen zu starten.**
1. Bevor Sie Ihren Cluster beenden, stellen Sie sicher, dass Sie Ihre Daten sichern und Ihre Benutzer benachrichtigen.
1. Befolgen Sie die Anweisungen unter [Einen Cluster beenden](https://docs.aws.amazon.com/emr/latest/ManagementGuide/UsingEMR_TerminateJobFlow.html), um den Cluster zu beenden.
1. Wenn Sie die Amazon-EMR-Konsole verwenden, um einen neuen Cluster zu erstellen, navigieren Sie zu **Erweiterte Optionen**. Deaktivieren Sie im Abschnitt **Softwareeinstellungen bearbeiten** die Option zum Aktivieren von EMRFS CV. Wenn das Kontrollkästchen für die **konsistente EMRFS-Ansicht** verfügbar ist, lassen Sie es deaktiviert.
1. Wenn Sie AWS CLI früher einen neuen Cluster mit der [`create-cluster`API](https://docs.aws.amazon.com/cli/latest/reference/emr/create-cluster.html) erstellen, verwenden Sie nicht die `--emrfs` Option, die EMRFS CV aktiviert.
1. Wenn Sie ein SDK verwenden oder einen neuen Cluster erstellen CloudFormation möchten, verwenden Sie keine der Konfigurationen, die unter [Konsistente Ansicht konfigurieren](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emrfs-configure-consistent-view.html) aufgeführt sind.
1.
**So klonen Sie einen Cluster und entfernen EMRFS CV**
1. Klicken Sie in der Amazon-EMR-Konsole auf den Cluster, der EMRFS-CV verwendet.
1. Wählen Sie oben auf der Seite **Cluster Details (Clusterdetails)** auf **Clone (Klonen)**.
1. Wählen Sie **Zurück** und navigieren Sie zu **Schritt 1: Software und Schritte**.
1. Entfernen Sie **unter Softwareeinstellungen bearbeiten** die Datei EMRFS CV. Löschen Sie unter **Konfiguration bearbeiten** die folgenden Konfigurationen in der `emrfs-site`-Klassifizierung. Wenn Sie JSON aus einem S3-Bucket laden, müssen Sie Ihr S3-Objekt ändern.
```
[
{"classification":
"emrfs-site",
"properties": {
"fs.s3.consistent.retryPeriodSeconds":"10",
"fs.s3.consistent":"true",
"fs.s3.consistent.retryCount":"5",
"fs.s3.consistent.metadata.tableName":"EmrFSMetadata"
}
}
]
```
1.
**Um EMRFS CV aus einem Cluster zu entfernen, der Instance-Gruppen verwendet**
1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob ein einzelner EMR-Cluster die DynamoDB-Tabelle verwendet, die mit EMRFS CV verknüpft ist, oder ob mehrere Cluster die Tabelle gemeinsam nutzen. Der Tabellenname ist in `fs.s3.consistent.metadata.tableName` angegeben, wie unter [Konsistente Ansicht konfigurieren beschrieben.](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emrfs-configure-consistent-view.html) Der von EMRFS CV verwendete Standardtabellenname ist `EmrFSMetadata`.
```
aws emr describe-cluster --cluster-id j-XXXXX | grep fs.s3.consistent.metadata.tableName
```
1. Wenn Ihr Cluster Ihre DynamoDB-Datenbank nicht mit einem anderen Cluster teilt, verwenden Sie den folgenden Befehl, um den Cluster neu zu konfigurieren und EMRFS CV zu deaktivieren. Weitere Informationen finden Sie unter [Neu-Konfiguration für eine Instance-Gruppe in einem aktiven Cluster](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps-running-cluster.html).
```
aws emr modify-instance-groups --cli-input-json file://disable-emrfs-1.json
```
Mit diesem Befehl wird die Datei geöffnet, die Sie ändern möchten. Ändern Sie die Datei mit den folgenden Konfigurationen.
```
{
"ClusterId": "j-xxxx",
"InstanceGroups": [
{
"InstanceGroupId": "ig-xxxx",
"Configurations": [
{
"Classification": "emrfs-site",
"Properties": {
"fs.s3.consistent": "false"
},
"Configurations": []
}
]
}
]
}
```
1. Wenn Ihr Cluster die DynamoDB-Tabelle mit einem anderen Cluster gemeinsam nutzt, deaktivieren Sie EMRFS CV auf allen Clustern zu einem Zeitpunkt, zu dem keine Cluster Objekte am gemeinsam genutzten S3-Standort ändern.
**Löschen Sie Amazon-DynamoDB-Ressourcen, die mit EMRFS CV verknüpft sind, wie folgt**
Nachdem Sie EMRFS CV aus Ihren Amazon-EMR-Clustern entfernt haben, löschen Sie die DynamoDB-Ressourcen, die mit EMRFS CV verknüpft sind. Solange Sie dies nicht tun, fallen für Sie weiterhin DynamoDB-Gebühren im Zusammenhang mit EMRFS CV an.
1. Überprüfen Sie die CloudWatch Metriken für Ihre DynamoDB-Tabelle und stellen Sie sicher, dass die Tabelle von keinem Cluster verwendet wird.
1. Löschen Sie die DynamoDB-Tabelle.
```
aws dynamodb delete-table --table-name
```
**Löschen Sie Amazon-SQS-Ressourcen, die mit EMRFS CV verknüpft sind, wie folgt**
1. Wenn Sie Ihren Cluster so konfiguriert haben, dass Inkonsistenzbenachrichtigungen an Amazon SQS gesendet werden, können Sie alle SQS-Warteschlangen löschen.
1. Suchen Sie den in `fs.s3.consistent.notification.SQS.queueName` angegebenen Amazon-SQS-Warteschlangennamen, wie unter [Konsistente Ansicht konfigurieren](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emrfs-configure-consistent-view.html) beschrieben. Das Standardformat für Warteschlangennamen ist `EMRFS-Inconsistency-`.
```
aws sqs list-queues | grep ‘EMRFS-Inconsistency’
aws sqs delete-queue –queue-url
```
**So beenden Sie die Verwendung der EMRFS-CLI**
+ Die [EMRFS-CLI verwaltet die Metadaten, die EMRFS CV](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emrfs-cli-reference.html) generiert. Da die Standardunterstützung für EMRFS CV in zukünftigen Versionen von Amazon EMR ausläuft, wird auch die Unterstützung für die EMRFS-CLI eingestellt.
**Topics**
+ [
# Die konsistente Ansicht aktivieren
](enable-consistent-view.md)
+ [
# Verstehen, wie mit der konsistenten Ansicht von EMRFS Objekte in Amazon S3 nachverfolgt werden
](emrfs-files-tracked.md)
+ [
# Logik für Wiederholversuche
](emrfs-retry-logic.md)
+ [
# Konsistente Ansicht der Metadaten in EMRFS
](emrfs-metadata.md)
+ [
# Konsistenzbenachrichtigungen für CloudWatch und Amazon SQS konfigurieren
](emrfs-configure-sqs-cw.md)
+ [
# Konfigurieren der konsistenten Ansicht
](emrfs-configure-consistent-view.md)
+ [
# Die EMRFS-CLI-Befehlsreferenz
](emrfs-cli-reference.md)
# Die konsistente Ansicht aktivieren
Sie können die serverseitige Amazon S3 S3-Verschlüsselung oder die konsistente Ansicht für EMRFS mithilfe der AWS-Managementkonsole Konfigurationsklassifizierung AWS CLI, oder aktivieren. `emrfs-site`
**So konfigurieren Sie die konsistente Ansicht mit der Konsole**
1. Navigieren Sie zur neuen Amazon-EMR-Konsole und wählen Sie in der Seitennavigation die Option **Zur alten Konsole wechseln** aus. Weitere Informationen darüber, was Sie erwartet, wenn Sie zur alten Konsole wechseln, finden Sie unter [Verwenden der alten Konsole](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Wählen Sie **Create Cluster (Cluster erstellen)** und **Go to advanced options (Zu erweiterten Optionen)** aus.
1. Wählen Sie in **Step 1: Software and Steps (Schritt 1: Software und Schritte)** und **Step 2: Hardware (Schritt 2: Hardware)** Einstellungen aus.
1. Wählen Sie in **Step 3: General Cluster Settings (Schritt 3: Cluster-Standardeinstellungen)** in **Additional Options (Zusätzliche Optionen)** die Option **EMRFS consistent view (EMRFS-konsistente Ansicht)** aus.
1. Geben Sie in **EMRFS Metadata store (EMRFS-Metadatenspeicher)** den Namen Ihres Metadatenspeichers ein. Der Standardwert ist **EmrFSMetadata**. Wenn die FSMetadata Emr-Tabelle nicht existiert, wird sie in DynamoDB für Sie erstellt.
**Anmerkung**
Amazon EMR entfernt die EMRFS-Metadaten nicht automatisch aus DynamoDB, wenn der Cluster beendet wird.
1. Geben Sie in **Number of retries (Anzahl der Wiederholungen)** einen Ganzzahlwert ein. Wenn eine Inkonsistenz festgestellt wird, versucht EMRFS, Amazon S3 so oft wie möglich aufzurufen. Der Standardwert ist **5**.
1. Geben Sie in **Retry period (in seconds) (Wiederholungszeitraum (in Sekunden))** einen Ganzzahlwert ein. Dies ist die Zeitspanne, die EMRFS zwischen Wiederholungsversuchen wartet. Der Standardwert ist **10**.
**Anmerkung**
Bei nachfolgenden Wiederholversuchen wird ein exponentielles Backoff verwendet.
**Um einen Cluster mit aktivierter konsistenter Ansicht zu starten, verwenden Sie AWS CLI**
Wir empfehlen Ihnen, die aktuelle Version von zu installieren AWS CLI. Informationen zum Herunterladen der neuesten Version finden Sie unter [https://aws.amazon.com/cli/](https://aws.amazon.com/cli/).
+
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
```
1. aws emr create-cluster --instance-type m5.xlarge --instance-count 3 --emrfs Consistent=true \
2. --release-label emr-7.12.0 --ec2-attributes KeyName=myKey
```
**Um zu überprüfen, ob die konsistente Ansicht aktiviert ist, verwenden Sie AWS-Managementkonsole**
+ Um in der Konsole zu überprüfen, ob die konsistente Ansicht aktiviert ist, navigieren Sie zu **Cluster List (Cluster-Liste)** und wählen den Namen Ihres Clusters aus, um die **Cluster Details (Cluster-Details)** anzuzeigen. Das Feld "EMRFS consistent view" hat den Wert `Enabled` oder `Disabled`.
**So prüfen Sie durch Untersuchen der Datei `emrfs-site.xml`, ob die konsistente Ansicht aktiviert ist**
+ Sie können überprüfen, ob die Konsistenz aktiviert ist, indem Sie die Konfigurationsdatei `emrfs-site.xml` auf dem Master-Knoten des Clusters prüfen. Wenn der boolesche Wert für `fs.s3.consistent` auf `true` festgelegt ist, ist die konsistente Ansicht für Dateisystem-Operationen, an denen Amazon S3 beteiligt ist, aktiviert.
# Verstehen, wie mit der konsistenten Ansicht von EMRFS Objekte in Amazon S3 nachverfolgt werden
EMRFS erstellt eine konsistente Ansicht der Objekte in Amazon S3, indem es Informationen über diese Objekte zu den EMRFS-Metadaten hinzufügt. EMRFS fügt diese Listen seinen Metadaten hinzu, wenn Folgendes zutrifft:
+ Ein Objekt wird von EMRFS im Laufe eines Amazon-EMR-Auftrags geschrieben.
+ Ein Objekt wird unter Verwendung der EMRFS-CLI mit EMRFS-Metadaten synchronisiert bzw. in die EMRFS-Metadaten importiert.
Objekte, die von EMRFS gelesen werden, werden nicht automatisch zu den Metadaten hinzugefügt. Wenn EMRFS ein Objekt löscht, verbleibt eine Liste in den Metadaten mit dem Status „Gelöscht“, bis diese Auflistung über die EMRFS-CLI bereinigt wird. Weitere Informationen zur CLI finden Sie unter [Die EMRFS-CLI-Befehlsreferenz](emrfs-cli-reference.md). Weitere Informationen zum Bereinigen von Listen in den EMRFS-Metadaten finden Sie unter [Konsistente Ansicht der Metadaten in EMRFS](emrfs-metadata.md).
Für jede Amazon-S3-Operation überprüft EMRFS die Metadaten auf Informationen über die Objekte in der konsistenten Ansicht. Wenn EMRFS feststellt, dass Amazon S3 während einer dieser Operationen inkonsistent ist, wird die Operation entsprechend den in den `emrfs-site`-Konfigurationseigenschaften definierten Parametern wiederholt. Nachdem EMRFS alle Wiederholversuche ausgeschöpft hat, wirft es entweder eine `ConsistencyException` auf, oder es protokolliert die Ausnahme und setzt den Workflow fort. Weitere Informationen zur Wiederholungslogik finden Sie unter [Logik für Wiederholversuche](emrfs-retry-logic.md). Sie finden die `ConsistencyExceptions` in Ihren Protokollen, zum Beispiel:
+ listStatus: Kein Amazon S3 Objekt für Metadatenelement `/S3_bucket/dir/object`
+ getFileStatus: Der Schlüssel `dir/file` ist in den Metadaten vorhanden, aber nicht in Amazon S3
Wenn Sie ein mit der konsistenten Ansicht von EMRFS nachverfolgtes Objekt direkt in Amazon S3 löschen, behandelt EMRFS dieses Objekt als inkonsistent, da es weiterhin in den Metadaten als in Amazon S3 vorhanden angezeigt wird. Wenn Ihre Metadaten nicht mehr mit den Objekten synchronisiert sind, die EMRFS in Amazon S3 nachverfolgt, können Sie den Unterbefehl **sync** der EMRFS-CLI ausführen, um die Metadaten zurückzusetzen, sodass sie den aktuellen Stand in Amazon S3 reflektieren. Um Abweichungen zwischen Metadaten und Amazon S3 zu entdecken, verwenden Sie den Befehl **diff**. EMRFS verfügt nur über eine konsistente Ansicht der Objekte, auf die in den Metadaten verwiesen wird; im gleichen Amazon-S3-Pfad können andere Objekte vorhanden sein, die nicht verfolgt werden. Wenn EMRFS die Objekte in einem Amazon-S3-Pfad auflistet, wird die Gesamtmenge der Objekte zurückgegeben, die in den Metadaten nachverfolgt werden und im Amazon-S3-Pfad vorhanden sind.
# Logik für Wiederholversuche
EMRFS versucht mit einer bestimmten Anzahl an Wiederholversuchen, die Listenkonsistenz für Objekte zu überprüfen, die in den Metadaten verfolgt werden. Der Standardwert ist 5. Wenn die Anzahl der Wiederholversuche überschritten wird, gibt der ursprüngliche Auftrag einen Fehler zurück, es sei denn, `fs.s3.consistent.throwExceptionOnInconsistency` ist auf `false` festgelegt, sodass die Objekte lediglich protokolliert werden, die als inkonsistent verfolgt wurden. EMRFS verwendet standardmäßig eine Wiederholungsrichtlinie mit exponentiellem Backoff, Sie können jedoch auch eine feste Richtlinie verwenden. Möglicherweise möchten die Benutzer ihre Versuche für einen bestimmten Zeitraum wiederholen, bevor sie den restlichen Auftrag ausführen, ohne dass eine Ausnahme ausgelöst wird. Sie können dies erreichen, indem sie `fs.s3.consistent.throwExceptionOnInconsistency` auf `false`, `fs.s3.consistent.retryPolicyType` auf `fixed` und `fs.s3.consistent.retryPeriodSeconds` auf den gewünschten Wert festlegen. Im folgenden Beispiel wird ein Cluster mit aktivierter Konsistenz erstellt. Dabei werden Inkonsistenzen protokolliert und es wird ein festes Wiederholungsintervall von 10 Sekunden festgelegt:
**Example Festlegen des Wiederholungszeitraums auf einen festen Wert**
```
aws emr create-cluster --release-label emr-7.12.0 \
--instance-type m5.xlarge --instance-count 1 \
--emrfs Consistent=true,Args=[fs.s3.consistent.throwExceptionOnInconsistency=false, fs.s3.consistent.retryPolicyType=fixed,fs.s3.consistent.retryPeriodSeconds=10] --ec2-attributes KeyName=myKey
```
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
Weitere Informationen finden Sie unter [Consistent view](emr-plan-consistent-view.md).
## EMRFS-Konfigurationen für IMDS rufen Regionen ab
EMRFS nutzt den IMDS (Instance-Metadaten-Service), um die Instance-Region und Amazon S3, DynamoDB oder Endpunkte abzurufen. AWS KMS IMDS hat jedoch ein Limit für die Anzahl der Anfragen, die es verarbeiten kann, und Anfragen, die dieses Limit überschreiten, schlagen fehl. Dieses IMDS-Limit kann dazu führen, dass EMRFS-Initialisierungen fehlschlagen und die Abfrage oder der Befehl fehlschlagen. Sie können den folgenden Mechanismus für zufällige exponentielle Backoff-Wiederholungen und die Konfigurationseigenschaften einer Fallback-Region in emrfs-site.xml verwenden, um das Szenario zu beheben, in dem alle Wiederholungsversuche fehlschlagen.
```
fs.s3.region.retryCount
3
Maximum retries that would be attempted to get AWS region.
fs.s3.region.retryPeriodSeconds
3
Base sleep time in second for each get-region retry.
fs.s3.region.fallback
us-east-1
Fallback to this region after maximum retries for getting AWS region have been reached.
```
# Konsistente Ansicht der Metadaten in EMRFS
Die konsistente Ansicht von EMRFS verfolgt die Konsistenz unter Verwendung einer DynamoDB-Tabelle nach, um Objekte in Amazon S3 nachzuverfolgen, die mit EMRFS synchronisiert oder erstellt wurden. Mithilfe dieser Metadaten werden alle Operationen (Lesen, Schreiben, Aktualisieren und Kopieren) verfolgt. Sie enthalten keine tatsächlichen Inhalte. Anhand der Metadaten wird überprüft, ob die Objekte oder Metadaten, die von Amazon S3 eingehen, den erwarteten Werten entsprechen. Diese Bestätigung gibt EMRFS die Möglichkeit, die Listenkonsistenz und read-after-write Konsistenz für neue Objekte, die EMRFS in Amazon S3 schreibt, oder für Objekte, die mit EMRFS synchronisiert wurden, zu überprüfen. Mehrere Cluster können dieselben Metadaten verwenden.
**So fügen Sie Einträge zu den Metadaten hinzu**
Sie können die Unterbefehle `import` oder `sync` verwenden, um Metadaten Einträge hinzuzufügen. `sync` gibt den Status der Amazon-S3-Objekte in einem Pfad an, während `import` ausschließlich zum Hinzufügen neuer Einträge zu den Metadaten verwendet wird. Weitere Informationen finden Sie unter [Die EMRFS-CLI-Befehlsreferenz](emrfs-cli-reference.md).
**So überprüfen Sie Unterschiede zwischen Metadaten und Objekten in Amazon S3**
Um eine Prüfung auf Abweichungen zwischen den Metadaten und Amazon S3 auszuführen, verwenden Sie den Unterbefehl `diff` der EMRFS-CLI. Weitere Informationen finden Sie unter [Die EMRFS-CLI-Befehlsreferenz](emrfs-cli-reference.md).
**So erkennen Sie, ob Metadatenoperationen gedrosselt werden**
EMRFS definiert die maximale Standarddurchsatzkapazität für die Metadaten für Lese- und Schreiboperationen mit jeweils 500 und 100 Einheiten. Eine große Anzahl von Objekten oder Buckets kann dazu führen, dass Vorgänge dieses Limit überschreiten. Sie werden dann von DynamoDB gedrosselt. Zum Beispiel kann es bei einer Anwendung dazu kommen, dass EMRFS eine `ProvisionedThroughputExceededException` auslöst, wenn Sie eine Operation durchführen, die diese Kapazitätsgrenzen überschreitet. Bei der Drosselung versucht das EMRFS-CLI-Tool, mit [exponentiellem Backoff](https://docs.aws.amazon.com/general/latest/gr/api-retries.html) erneut in die DynamoDB-Tabelle zu schreiben, bis die Operation abgeschlossen ist oder wenn der Höchstwert für die Wiederholversuche für das Schreiben von Objekten von Amazon EMR nach Amazon S3 erreicht ist.
Sie können Ihre eigene Durchsatzkapazitätsgrenzen konfigurieren. DynamoDB hat jedoch strenge Partitionsgrenzen von 3000 Lesekapazitätseinheiten (RCUs) und 1000 Schreibkapazitätseinheiten (WCUs) pro Sekunde für Lese- und Schreiboperationen. Um durch Drosselung verursachte `sync` Ausfälle zu vermeiden, empfehlen wir, den Durchsatz für Lesevorgänge auf weniger als 3000 RCUs und für Schreibvorgänge auf weniger als 1000 zu begrenzen. WCUs Anweisungen zur Festlegung benutzerdefinierter Durchsatzkapazitätsgrenzen finden Sie unter [Konfigurieren der konsistenten Ansicht](emrfs-configure-consistent-view.md).
Sie können auch CloudWatch Amazon-Metriken für Ihre EMRFS-Metadaten in der DynamoDB-Konsole anzeigen, wo Sie die Anzahl der gedrosselten Lese- und Schreibanforderungen sehen können. Wenn für gedrosselte Anforderungen ein Wert ungleich null vorliegt, profitiert Ihre Anwendung möglicherweise von einer Erhöhung der zugewiesenen Durchsatzkapazität für Lese- oder Schreiboperationen. Sie realisieren ggf. auch dann eine höhere Performance, wenn Sie sehen, dass sich Ihre Operationen dem zugewiesenen Höchstwert für die Durchsatzkapazität für Lese- und Schreibvorgänge für einen längeren Zeitraum nähern.
**Durchsatzmerkmale für bedeutende EMRFS-Operationen**
Die Standardeinstellung für Lese- und Schreibvorgänge beträgt 400 bzw. 100 Durchsatzkapazitätseinheiten. Die folgenden Leistungsmerkmale geben Ihnen eine Vorstellung davon, welcher Durchsatz für bestimmte Operationen erforderlich ist. Diese Tests wurden unter Verwendung eines `m3.large`-Clusters mit einem einzigen Knoten durchgeführt. Bei allen Operationen handelte es sich um Single-Thread-Vorgänge. Die Performance kann je nach Charakteristika der jeweiligen Anwendung sehr unterschiedlich ausfallen und etwas Experimentieren erfordern, um die Dateisystemoperationen zu optimieren.
| Operation | Durchschnittlich read-per-second | Durchschnittlich write-per-second |
| --- | --- | --- |
| create (Objekt) | 26.79 | 6.70 |
| delete (Objekt) | 10.79 | 10.79 |
| delete (Verzeichnis mit 1000 Objekten) | 21.79 | 338.40 |
| getFileStatus(Objekt) | 34.70 | 0 |
| getFileStatus(Verzeichnis) | 19.96 | 0 |
| listStatus (Verzeichnis mit 1 Objekt) | 43.31 | 0 |
| listStatus (Verzeichnis mit 10 Objekten) | 44.34 | 0 |
| listStatus (Verzeichnis mit 100 Objekten) | 84.44 | 0 |
| listStatus (Verzeichnis mit 1.000 Objekten) | 308.81 | 0 |
| listStatus (Verzeichnis mit 10.000 Objekten) | 416.05 | 0 |
| listStatus (Verzeichnis mit 100.000 Objekten) | 823.56 | 0 |
| listStatus (Verzeichnis mit 1 Million Objekten) | 882.36 | 0 |
| mkdir (durchgehend für 120 Sekunden) | 24.18 | 4.03 |
| mkdir | 12.59 | 0 |
| rename (Objekt) | 19.53 | 4.88 |
| rename (Verzeichnis mit 1000 Objekten) | 23.22 | 339.34 |
**So übermitteln Sie einen Schritt, der alle alten Daten aus Ihren Metadaten entfernt**
Unter Umständen möchten Benutzer bestimmte Einträge in den DynamoDB-basierten Metadaten entfernen. So können Sie die Speicherkosten im Zusammenhang mit der Tabelle reduzieren. Die Benutzer haben die Möglichkeit, mit dem Unterbefehl `delete` der EMRFS-Befehlszeilenschnittstelle bestimmte Einträge manuell oder programmgesteuert zu bereinigen. Wenn Sie jedoch Einträge aus den Metadaten löschen, führt EMRFS keine Konsistenzprüfungen mehr durch.
Die programmgesteuerte Bereinigung nach Abschluss eines Auftrags kann durch Übermittlung eines letzten Schritts zu Ihrem Cluster erfolgen, wodurch ein Befehl in der EMRFS-Befehlszeilenschnittstelle ausgeführt wird. Geben Sie z. B. den folgenden Befehl ein, um einen Schritt zum Löschen aller Einträge an Ihren Cluster zu übermitteln, die älter als zwei Tage sind.
```
aws emr add-steps --cluster-id j-2AL4XXXXXX5T9 --steps Name="emrfsCLI",Jar="command-runner.jar",Args=["emrfs","delete","--time","2","--time-unit","days"]
{
"StepIds": [
"s-B12345678902"
]
}
```
Verwenden Sie den zurückgegebenen StepId Wert, um in den Protokollen nach dem Ergebnis des Vorgangs zu suchen.
# Konsistenzbenachrichtigungen für CloudWatch und Amazon SQS konfigurieren
Sie können CloudWatch Metriken und Amazon SQS SQS-Nachrichten in EMRFS für eventuelle Konsistenzprobleme in Amazon S3 aktivieren.
**CloudWatch**
Wenn CloudWatch Metriken aktiviert sind, wird jedes Mal, wenn ein `FileSystem` API-Aufruf aufgrund der eventuellen **Konsistenz von Amazon S3 fehlschlägt, eine Metrik namens Inconsistency** übertragen.
**So zeigen Sie CloudWatch Metriken für eventuelle Konsistenzprobleme in Amazon S3 an**
**Um die **Inkonsistenz-Metrik** in der CloudWatch Konsole anzuzeigen, wählen Sie die EMRFS-Metriken und dann ein Paar mit dem Namen **JobFlowId**/Metric aus.** Beispiel: `j-162XXXXXXM2CU ListStatus`, `j-162XXXXXXM2CU GetFileStatus` usw.
1. Öffnen Sie die Konsole unter CloudWatch . [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie im **Dashboard (Dashboard)** im Abschnitt **Metrics (Metriken)** die Option **EMRFS (EMRFS)** aus.
1. Wählen Sie im Bereich **Job Flow Metrics** ein oder mehrere **JobFlowId****/Metric Name-Paare** aus. Im Fenster darunter wird eine grafische Darstellung der Metriken angezeigt.
**Amazon SQS**
Wenn Amazon-SQS-Benachrichtigungen aktiviert sind, wird bei Initialisierung von EMRFS eine Amazon SQS-Warteschlange namens `EMRFS-Inconsistency-` erstellt. Amazon-SQS-Nachrichten werden per Push-Verfahren in die Warteschlange gestellt, wenn ein `FileSystem`-API-Aufruf aufgrund eines eventuellen Konsistenzproblems von Amazon S3 fehlschlägt. Die Nachricht enthält Informationen wie API JobFlowId, eine Liste inkonsistenter Pfade, einen Stack-Trace usw. Nachrichten können mit der Amazon-SQS-Konsole oder dem EMRFS-Befehl `read-sqs` gelesen werden.
**Verwalten von Amazon-SQS-Nachrichten bei eventuellen Konsistenzproblemen von Amazon S3**
Amazon-SQS-Nachrichten bei eventuellen Konsistenzproblemen in Amazon S3 können über die EMRFS-CLI gelesen werden. Um Nachrichten aus einer EMRFS-Amazon-SQS-Warteschlange zu lesen, geben Sie den Befehl `read-sqs` ein und geben Sie für die resultierende Ausgabedatei einen Speicherort im lokalen Dateisystem des Hauptknotens an.
Sie können eine EMRFS-Amazon-SQS-Warteschlange mit dem Befehl `delete-sqs` löschen.
1. Zum Lesen von Nachrichten aus einer Amazon-SQS-Warteschlange geben Sie den folgenden Befehl ein. *queuename*Ersetzen Sie durch den Namen der Amazon SQS SQS-Warteschlange, die Sie konfiguriert haben, und */path/filename* ersetzen Sie sie durch den Pfad zur Ausgabedatei:
```
emrfs read-sqs --queue-name queuename --output-file /path/filename
```
Um z. B. Amazon-SQS-Nachrichten aus der Standardwarteschlange zu lesen und auszugeben, geben Sie Folgendes ein:
```
emrfs read-sqs --queue-name EMRFS-Inconsistency-j-162XXXXXXM2CU --output-file /path/filename
```
**Anmerkung**
Sie können auch die Verknüpfungen `-q` und `-o` anstelle von `--queue-name` und `--output-file` verwenden.
1. Zum Löschen einer Amazon-SQS-Warteschlange geben Sie den folgenden Befehl ein:
```
emrfs delete-sqs --queue-name queuename
```
Um z. B. die Standardwarteschlange zu löschen, geben Sie Folgendes ein:
```
emrfs delete-sqs --queue-name EMRFS-Inconsistency-j-162XXXXXXM2CU
```
**Anmerkung**
Sie können auch das Kürzel `-q` anstelle von `--queue-name` verwenden.
# Konfigurieren der konsistenten Ansicht
Sie können zusätzliche Einstellungen für die konsistente Ansicht konfigurieren, indem Sie sie mithilfe von Konfigurationseigenschaften für `emrfs-site`-Eigenschaften bereitstellen. Sie können beispielsweise einen anderen Standard-DynamoDB-Durchsatz wählen, indem Sie die folgenden Argumente an die CLI-`--emrfs`-Option übergeben, die emrfs-site-Konfigurationsklassifizierung (nur Amazon EMR Version 4.x und höher) oder eine Bootstrap-Aktion zur Konfiguration der Datei emrfs-site.xml auf dem Hauptknoten verwenden:
**Example Ändern der Standardwerte zum Lesen und Schreiben von Metadaten bei Cluster-Start**
```
aws emr create-cluster --release-label emr-7.12.0 --instance-type m5.xlarge \
--emrfs Consistent=true,Args=[fs.s3.consistent.metadata.read.capacity=600,\
fs.s3.consistent.metadata.write.capacity=300] --ec2-attributes KeyName=myKey
```
Verwenden Sie alternativ die folgende Konfigurationsdatei und speichern Sie sie lokal oder in Amazon S3:
```
[
{
"Classification": "emrfs-site",
"Properties": {
"fs.s3.consistent.metadata.read.capacity": "600",
"fs.s3.consistent.metadata.write.capacity": "300"
}
}
]
```
Verwenden Sie die Konfiguration, die Sie erstellt haben, mit der folgenden Syntax:
```
aws emr create-cluster --release-label emr-7.12.0 --applications Name=Hive \
--instance-type m5.xlarge --instance-count 2 --configurations file://./myConfig.json
```
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
Die folgenden Optionen können mithilfe von Konfigurationen oder AWS CLI `--emrfs` Argumenten festgelegt werden. Informationen über diese Argumente finden Sie in der [AWS CLI -Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/).
**`emrfs-site.xml`-Eigenschaften für die konsistente Ansicht**
| Eigenschaft | Standardwert | Description |
| --- | --- | --- |
| fs.s3.consistent | false | Wenn diese Eigenschaft auf **true** festgelegt wurde, wird EMRFS für die Verwendung von DynamoDB zur Bereitstellung von Konsistenz konfiguriert. |
| fs.s3.consistent.retryPolicyType | exponential | Diese Eigenschaft gibt die Richtlinie an, die für Wiederholversuche bei Konsistenzproblemen verwendet werden soll. Optionen: exponentiell, fest oder keine. |
| fs.s3.consistent.retryPeriodSeconds | 1 | Diese Eigenschaft legt die Wartezeit zwischen den Wiederholversuchen bei Konsistenzproblemen fest. |
| fs.s3.consistent.retryCount | 10 | Diese Eigenschaft legt die maximale Anzahl von Wiederholversuchen bei erkannten Inkonsistenzen fest. |
| fs.s3.consistent.throwExceptionOnInconsistency | true | Diese Eigenschaft bestimmt, ob eine Konsistenzausnahme ausgelöst oder protokolliert werden soll. Wenn diese Eigenschaft auf true festgelegt wurde, wird eine ConsistencyException ausgelöst. |
| fs.s3.consistent.metadata.autoCreate | true | Wenn diese Eigenschaft auf true festgelegt wurde, ermöglicht sie die automatische Erstellung von Metadatentabellen. |
| fs.s3.consistent.metadata.etag.verification.enabled | true | Mit Amazon EMR 5.29.0 ist diese Eigenschaft standardmäßig aktiviert. Wenn diese Option aktiviert ist, verwendet EMRFS S3, ETags um zu überprüfen, ob es sich bei den gelesenen Objekten um die neueste verfügbare Version handelt. Diese Funktion ist hilfreich für read-after-update Anwendungsfälle, in denen Dateien auf S3 überschrieben werden, während derselbe Name beibehalten wird. Diese ETag Überprüfungsfunktion funktioniert derzeit nicht mit S3 Select. |
| fs.s3.consistent.metadata.tableName | EmrFSMetadata | Diese Eigenschaft gibt den Namen der Metadatentabelle in DynamoDB an. |
| fs.s3.consistent.metadata.read.capacity | 500 | Diese Eigenschaft gibt die DynamoDB-Lesekapazität an, die bei Erstellung der Metadatentabelle bereitgestellt wird. |
| fs.s3.consistent.metadata.write.capacity | 100 | Diese Eigenschaft gibt die DynamoDB-Schreibkapazität an, die bei Erstellung der Metadatentabelle bereitgestellt wird. |
| fs.s3.consistent.fastList | true | Wenn diese Eigenschaft auf true festgelegt wurde, verwendet sie mehrere Threads zum Auflisten eines Verzeichnisses (wenn notwendig). Damit diese Eigenschaft verwendet werden kann, muss Konsistenz aktiviert sein. |
| fs.s3.consistent.fastList.prefetchMetadata | false | Wenn diese Eigenschaft auf true festgelegt wurde, ermöglicht sie den Vorabruf von Metadaten für Verzeichnisse mit mehr als 20.000 Elementen. |
| fs.s3.consistent.notification.CloudWatch | false | Wenn diese Option auf gesetzt isttrue, werden CloudWatch Metriken für FileSystem API-Aufrufe aktiviert, die aufgrund eventueller Konsistenzprobleme von Amazon S3 fehlschlagen. |
| fs.s3.consistent.notification.SQS | false | Wenn diese Eigenschaft auf true festgelegt wurde, werden Benachrichtigungen zu eventuellen Konsistenzproblemen per Push an eine Amazon-SQS-Warteschlange gesendet. |
| fs.s3.consistent.notification.SQS.queueName | EMRFS-Inconsistency- | Wenn Sie diese Eigenschaft ändern, können Sie Ihren eigenen SQS-Warteschlangennamen für Nachrichten zu eventuellen Konsistenzproblemen von Amazon S3 angeben. |
| fs.s3.consistent.notification.SQS.customMsg | none | Über diese Eigenschaft können Sie benutzerdefinierte Informationen angeben, die in SQS-Nachrichten zu eventuellen Konsistenzproblemen von Amazon S3 enthalten sein sollen. Wenn für diese Eigenschaft kein Wert festgelegt ist, ist das entsprechende Feld in der Nachricht leer. |
| fs.s3.consistent.dynamodb.endpoint | none | Über diese Eigenschaft können Sie einen benutzerdefinierten DynamoDB-Endpunkt für Ihre Metadaten der konsistenten Ansicht angeben. |
| fs.s3.useRequesterPaysHeader | false | Wenn diese Eigenschaft auf true gesetzt ist, erlaubt sie Amazon-S3-Anfragen an Buckets mit aktivierter Bezahler-Option. |
# Die EMRFS-CLI-Befehlsreferenz
Die EMRFS-CLI ist standardmäßig auf allen Cluster-Hauptknoten installiert, die mit Amazon EMR Version 3.2.1 oder höher erstellt wurden. Sie können die EMRFS CLI zum Verwalten der Metadaten für die konsistente Ansicht verwenden.
**Anmerkung**
Der **emrfs** Befehl wird nur mit VT100 Terminalemulation unterstützt. Er funktioniert jedoch unter Umständen auch mit anderen Terminal-Emulator-Modi.
## Übergeordneter Befehl "emrfs"
Der Top-Level-Befehl **emrfs** unterstützt die folgende Struktur.
```
emrfs [describe-metadata | set-metadata-capacity | delete-metadata | create-metadata | \
list-metadata-stores | diff | delete | sync | import ] [options] [arguments]
```
Geben Sie [Optionen] mit oder ohne [Argumente] an, wie in der folgenden Tabelle beschrieben. Für [Optionen], die speziell für Unterbefehle (`describe-metadata`, `set-metadata-capacity` usw.) gelten, finden Sie nachstehend die jeweiligen Unterbefehle.
**[Optionen] für emrfs**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-a AWS_ACCESS_KEY_ID \| --access-key AWS_ACCESS_KEY_ID` | Der AWS Zugriffsschlüssel, den Sie verwenden, um Objekte in Amazon S3 zu schreiben und einen Metadatenspeicher in DynamoDB zu erstellen oder darauf zuzugreifen. Standardmäßig *AWS\$1ACCESS\$1KEY\$1ID* ist er auf den Zugriffsschlüssel festgelegt, der zur Erstellung des Clusters verwendet wurde. | Nein |
| `-s AWS_SECRET_ACCESS_KEY \| --secret-key AWS_SECRET_ACCESS_KEY` | Der AWS geheime Schlüssel, der dem Zugriffsschlüssel zugeordnet ist, den Sie verwenden, um Objekte in Amazon S3 zu schreiben und einen Metadatenspeicher in DynamoDB zu erstellen oder darauf zuzugreifen. Standardmäßig *AWS\$1SECRET\$1ACCESS\$1KEY* ist dieser Wert auf den geheimen Schlüssel gesetzt, der dem Zugriffsschlüssel zugeordnet ist, der zur Erstellung des Clusters verwendet wurde. | Nein |
| `-v \| --verbose` | Erzeugt eine ausführliche Ausgabe. | Nein |
| `-h \| --help` | Zeigt die Hilfenachricht für den `emrfs`-Befehl mit einer Verwendungsanweisung an. | Nein |
## Unterbefehl "emrfs describe-metadata"
**[Optionen] für emrfs describe-metadata**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
**Example Beispiel für "emrfs describe-metadata"**
Das folgende Beispiel beschreibt die Standardmetadatentabelle.
```
$ emrfs describe-metadata
EmrFSMetadata
read-capacity: 400
write-capacity: 100
status: ACTIVE
approximate-item-count (6 hour delay): 12
```
## Unterbefehl emrfs set-metadata-capacity
**[Optionen] für emrfs set-metadata-capacity**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
| `-r READ_CAPACITY \| --read-capacity READ_CAPACITY` | Die angeforderte Lesedurchsatzkapazität für die Metadatentabelle. Wenn das *READ\$1CAPACITY* Argument nicht angegeben wird, ist der Standardwert`400`. | Nein |
| `-w WRITE_CAPACITY \| --write-capacity WRITE_CAPACITY` | Die angeforderte Schreibdurchsatzkapazität für die Metadatentabelle. Wenn das *WRITE\$1CAPACITY* Argument nicht angegeben wird, ist der Standardwert`100`. | Nein |
**Example Beispiel für emrfs set-metadata-capacity**
Im folgenden Beispiel ist für die Metadatentabelle `600` die Lesedurchsatzkapazität auf `150` und die Schreibkapazität auf `EmrMetadataAlt` festgelegt.
```
$ emrfs set-metadata-capacity --metadata-name EmrMetadataAlt --read-capacity 600 --write-capacity 150
read-capacity: 400
write-capacity: 100
status: UPDATING
approximate-item-count (6 hour delay): 0
```
## Unterbefehl "emrfs delete-metadata"
**[Optionen] für emrfs delete-metadata**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
**Example Beispiel für "emrfs delete-metadata"**
Das folgende Beispiel löscht die Standardmetadatentabelle.
```
$ emrfs delete-metadata
```
## Unterbefehl "emrfs create-metadata"
**[Optionen] für emrfs create-metadata**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
| `-r READ_CAPACITY \| --read-capacity READ_CAPACITY` | Die angeforderte Lesedurchsatzkapazität für die Metadatentabelle. Wenn das *READ\$1CAPACITY* Argument nicht angegeben wird, ist der Standardwert`400`. | Nein |
| `-w WRITE_CAPACITY \| --write-capacity WRITE_CAPACITY` | Die angeforderte Schreibdurchsatzkapazität für die Metadatentabelle. Wenn das *WRITE\$1CAPACITY* Argument nicht angegeben wird, ist der Standardwert`100`. | Nein |
**Example Beispiel für "emrfs create-metadata"**
Im folgenden Beispiel wird eine Metadatentabelle mit dem Namen `EmrFSMetadataAlt` erstellt.
```
$ emrfs create-metadata -m EmrFSMetadataAlt
Creating metadata: EmrFSMetadataAlt
EmrFSMetadataAlt
read-capacity: 400
write-capacity: 100
status: ACTIVE
approximate-item-count (6 hour delay): 0
```
## Unterbefehl emrfs list-metadata-stores
Der Unterbefehl **emrfs list-metadata-stores** hat keine [Optionen].
**Example List-metadata-stores Beispiel**
Im folgenden Beispiel werden Ihre Metadatentabellen aufgelistet.
```
$ emrfs list-metadata-stores
EmrFSMetadata
```
## Unterbefehl "emrfs diff"
**[Optionen] für emrfs diff**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
| *s3://s3Path* | Der Pfad zu dem Amazon-S3-Bucket für den Vergleich mit der Metadaten-Tabelle. Die Buckets werden rekursiv synchronisiert. | Ja |
**Example Beispiel für "emrfs diff"**
Im folgenden Beispiel wird die Standardmetadatentabelle mit einem Amazon-S3-Bucket verglichen.
```
$ emrfs diff s3://elasticmapreduce/samples/cloudfront
BOTH | MANIFEST ONLY | S3 ONLY
DIR elasticmapreduce/samples/cloudfront
DIR elasticmapreduce/samples/cloudfront/code/
DIR elasticmapreduce/samples/cloudfront/input/
DIR elasticmapreduce/samples/cloudfront/logprocessor.jar
DIR elasticmapreduce/samples/cloudfront/input/XABCD12345678.2009-05-05-14.WxYz1234
DIR elasticmapreduce/samples/cloudfront/input/XABCD12345678.2009-05-05-15.WxYz1234
DIR elasticmapreduce/samples/cloudfront/input/XABCD12345678.2009-05-05-16.WxYz1234
DIR elasticmapreduce/samples/cloudfront/input/XABCD12345678.2009-05-05-17.WxYz1234
DIR elasticmapreduce/samples/cloudfront/input/XABCD12345678.2009-05-05-18.WxYz1234
DIR elasticmapreduce/samples/cloudfront/input/XABCD12345678.2009-05-05-19.WxYz1234
DIR elasticmapreduce/samples/cloudfront/input/XABCD12345678.2009-05-05-20.WxYz1234
DIR elasticmapreduce/samples/cloudfront/code/cloudfront-loganalyzer.tgz
```
## Unterbefehl "emrfs delete"
**[Optionen] für emrfs delete**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
| *s3://s3Path* | Der Pfad zum Amazon-S3-Bucket, den Sie für die konsistente Ansicht verfolgen. Die Buckets werden rekursiv synchronisiert. | Ja |
| -t TIME \$1 --time TIME | Die Ablaufzeit (interpretiert mithilfe des Zeiteinheit-Arguments). Alle Metadateneinträge, die älter als das *TIME* Argument sind, werden für den angegebenen Bucket gelöscht. | |
| `-u UNIT \| --time-unit UNIT` | Die Maßeinheit für die Interpretation des Zeitarguments (Nanosekunden, Mikrosekunden, Millisekunden, Sekunden, Minuten, Stunden oder Tage). Wenn kein Argument angegeben ist, lautet der Standardwert `days`. | |
| `--read-consumption READ_CONSUMPTION` | Die angeforderte Menge an verfügbarem Lesedurchsatz für die Operation **delete**. Wenn das *READ\$1CONSUMPTION* Argument nicht angegeben ist, ist der Standardwert`400`. | Nein |
| `--write-consumption WRITE_CONSUMPTION` | Die angeforderte Menge an verfügbarem Schreibdurchsatz für die Operation **delete**. Wenn das *WRITE\$1CONSUMPTION* Argument nicht angegeben ist, ist der Standardwert`100`. | Nein |
**Example Beispiel für "emrfs delete"**
Im folgenden Beispiel werden alle Objekte in einem Amazon-S3-Bucket aus den verfolgenden Metadaten für die konsistente Ansicht entfernt.
```
$ emrfs delete s3://elasticmapreduce/samples/cloudfront
entries deleted: 11
```
## Unterbefehl "emrfs import"
**[Optionen] für emrfs import**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
| *s3://s3Path* | Der Pfad zum Amazon-S3-Bucket, den Sie für die konsistente Ansicht verfolgen. Die Buckets werden rekursiv synchronisiert. | Ja |
| `--read-consumption READ_CONSUMPTION` | Die angeforderte Menge an verfügbarem Lesedurchsatz für die Operation **delete**. Wenn das *READ\$1CONSUMPTION* Argument nicht angegeben ist, ist der Standardwert`400`. | Nein |
| `--write-consumption WRITE_CONSUMPTION` | Die angeforderte Menge an verfügbarem Schreibdurchsatz für die Operation **delete**. Wenn das *WRITE\$1CONSUMPTION* Argument nicht angegeben ist, ist der Standardwert`100`. | Nein |
**Example Beispiel für "emrfs import"**
Im folgenden Beispiel werden alle Objekte in einem Amazon-S3-Bucket mit den verfolgenden Metadaten für die konsistente Ansicht importiert. Alle unbekannten Schlüssel werden ignoriert.
```
$ emrfs import s3://elasticmapreduce/samples/cloudfront
```
## Unterbefehl "emrfs sync"
**[Optionen] für emrfs sync**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-m METADATA_NAME \| --metadata-name METADATA_NAME` | *METADATA\$1NAME*ist der Name der DynamoDB-Metadatentabelle. Wenn das *METADATA\$1NAME* Argument nicht angegeben wird, ist der Standardwert. `EmrFSMetadata` | Nein |
| *s3://s3Path* | Der Pfad zum Amazon-S3-Bucket, den Sie für die konsistente Ansicht verfolgen. Die Buckets werden rekursiv synchronisiert. | Ja |
| `--read-consumption READ_CONSUMPTION` | Die angeforderte Menge an verfügbarem Lesedurchsatz für die Operation **delete**. Wenn das *READ\$1CONSUMPTION* Argument nicht angegeben ist, ist der Standardwert`400`. | Nein |
| `--write-consumption WRITE_CONSUMPTION` | Die angeforderte Menge an verfügbarem Schreibdurchsatz für die Operation **delete**. Wenn das *WRITE\$1CONSUMPTION* Argument nicht angegeben ist, ist der Standardwert`100`. | Nein |
**Example Beispiel für "emrfs sync"**
Im folgenden Beispiel werden alle Objekte in einem Amazon-S3-Bucket mit den verfolgenden Metadaten für die konsistente Ansicht importiert. Alle unbekannten Schlüssel werden gelöscht.
```
$ emrfs sync s3://elasticmapreduce/samples/cloudfront
Synching samples/cloudfront 0 added | 0 updated | 0 removed | 0 unchanged
Synching samples/cloudfront/code/ 1 added | 0 updated | 0 removed | 0 unchanged
Synching samples/cloudfront/ 2 added | 0 updated | 0 removed | 0 unchanged
Synching samples/cloudfront/input/ 9 added | 0 updated | 0 removed | 0 unchanged
Done synching s3://elasticmapreduce/samples/cloudfront 9 added | 0 updated | 1 removed | 0 unchanged
creating 3 folder key(s)
folders written: 3
```
## Unterbefehl "emrfs read-sqs"
**[Optionen] für emrfs read-sqs**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-q QUEUE_NAME \| --queue-name QUEUE_NAME` | *QUEUE\$1NAME*ist der Name der Amazon SQS SQS-Warteschlange, in `emrfs-site.xml` der konfiguriert ist. Der Standardwert ist **EMRFS-Inconsistency-**. | Ja |
| `-o OUTPUT_FILE \| --output-file OUTPUT_FILE` | *OUTPUT\$1FILE*ist der Pfad zur Ausgabedatei im lokalen Dateisystem des Master-Knotens. Nachrichten, die aus der Warteschlange gelesen werden, werden in diese Datei geschrieben. | Ja |
## Unterbefehl "emrfs delete-sqs"
**[Optionen] für emrfs delete-sqs**
| Option | Description | Erforderlich |
| --- | --- | --- |
| `-q QUEUE_NAME \| --queue-name QUEUE_NAME` | *QUEUE\$1NAME*ist der Name der Amazon SQS SQS-Warteschlange, in `emrfs-site.xml` der konfiguriert ist. Der Standardwert ist **EMRFS-Inconsistency-**. | Ja |
## Übermitteln von EMRFS-CLI-Befehlen als Schritte
Das folgende Beispiel zeigt, wie Sie das `emrfs` Hilfsprogramm auf dem Master-Knoten verwenden, indem Sie die AWS CLI OR-API nutzen und `command-runner.jar` den `emrfs` Befehl als Schritt ausführen. Das Beispiel verwendet den AWS SDK für Python (Boto3) , um einem Cluster einen Schritt hinzuzufügen, der Objekte in einem Amazon S3 S3-Bucket zur standardmäßigen EMRFS-Metadatentabelle hinzufügt.
```
import boto3
from botocore.exceptions import ClientError
def add_emrfs_step(command, bucket_url, cluster_id, emr_client):
"""
Add an EMRFS command as a job flow step to an existing cluster.
:param command: The EMRFS command to run.
:param bucket_url: The URL of a bucket that contains tracking metadata.
:param cluster_id: The ID of the cluster to update.
:param emr_client: The Boto3 Amazon EMR client object.
:return: The ID of the added job flow step. Status can be tracked by calling
the emr_client.describe_step() function.
"""
job_flow_step = {
"Name": "Example EMRFS Command Step",
"ActionOnFailure": "CONTINUE",
"HadoopJarStep": {
"Jar": "command-runner.jar",
"Args": ["/usr/bin/emrfs", command, bucket_url],
},
}
try:
response = emr_client.add_job_flow_steps(
JobFlowId=cluster_id, Steps=[job_flow_step]
)
step_id = response["StepIds"][0]
print(f"Added step {step_id} to cluster {cluster_id}.")
except ClientError:
print(f"Couldn't add a step to cluster {cluster_id}.")
raise
else:
return step_id
def usage_demo():
emr_client = boto3.client("emr")
# Assumes the first waiting cluster has EMRFS enabled and has created metadata
# with the default name of 'EmrFSMetadata'.
cluster = emr_client.list_clusters(ClusterStates=["WAITING"])["Clusters"][0]
add_emrfs_step(
"sync", "s3://elasticmapreduce/samples/cloudfront", cluster["Id"], emr_client
)
if __name__ == "__main__":
usage_demo()
```
Sie können den zurückgegebenen Wert `step_id` verwenden, um die Protokolle auf das Ergebnis der Operation zu prüfen.
# Zugriff auf EMRFS-Daten in Amazon S3 genehmigen
Standardmäßig bestimmt die EMR-Rolle für EC2 die Berechtigungen für den Zugriff auf EMRFS-Daten in Amazon S3. Die IAM-Richtlinien, die dieser Rolle zugeordnet werden, gelten unabhängig von dem oder der Gruppe, die die Anforderung über EMRFS erstellen. Der Standardwert ist `EMR_EC2_DefaultRole`. Weitere Informationen finden Sie unter [Servicerolle für EC2-Cluster-Instances (EC2-Instance-Profil)](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-role-for-ec2.html).
Ab Amazon-EMR-Version 5.10.0 können Sie mittels einer Sicherheitskonfiguration IAM-Rollen für EMRFS angeben. Auf diese Weise können Sie Berechtigungen für EMRFS-Anforderungen an Amazon S3 für Cluster mit mehreren Benutzern anpassen. Sie können verschiedene IAM-Rollen für verschiedene Benutzer und Gruppen und für verschiedene Amazon-S3-Bucket-Speicherorte angeben, basierend auf dem Präfix in Amazon S3. Wenn EMRFS eine Anforderung an Amazon S3 stellt, die mit Benutzern, Gruppen oder Standorten, die Sie angeben, übereinstimmt, verwendet der Cluster die entsprechende Rolle und nicht die EMR-Rolle für EC2. Weitere Informationen finden Sie unter [Konfigurieren von IAM-Rollen für EMRFS-Anforderungen an Amazon S3](https://docs.aws.amazon.com//emr/latest/ManagementGuide/emr-emrfs-iam-roles).
Wenn die Anforderungen Ihrer Amazon-EMR-Lösung über die Möglichkeiten hinausgehen, die IAM-Rollen für EMRFS bereitstellen, können Sie alternativ eine benutzerdefinierte Anmeldeinformationsanbieter-Klasse definieren, mit der Sie den Zugriff auf EMRFS-Daten in Amazon S3 anpassen können.
## Erstellen eines benutzerdefinierten Anmeldeinformationsanbieters für EMRFS-Daten in Amazon S3
[Um einen Anbieter für benutzerdefinierte Anmeldeinformationen zu erstellen, implementieren Sie die Klassen [AWSCredentialsProvider](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/AWSCredentialsProvider.html) und Hadoop Configurable.](https://hadoop.apache.org/docs/stable/api/org/apache/hadoop/conf/Configurable.html)
Eine ausführliche Erläuterung dieses Ansatzes finden Sie im AWS Big Data-Blog unter [Daten aus einem anderen AWS Konto mit EMRFS sicher analysieren](https://aws.amazon.com/blogs/big-data/securely-analyze-data-from-another-aws-account-with-emrfs). Der Blogbeitrag enthält ein Tutorial, das Sie durch den Prozess führtend-to-end, von der Erstellung von IAM-Rollen bis hin zum Starten des Clusters. Er enthält auch ein Java-Codebeispiel zum Implementieren der benutzerdefinierten Anmeldeinformationsanbieter-Klasse.
Die grundlegenden Schritte sind wie folgt:
**So definieren Sie einen benutzerdefinierten Anmeldeinformationsanbieter**
1. Erstellen Sie eine benutzerdefinierte Anmeldeinformationsanbieter-Klasse als JAR-Datei.
1. Führen Sie ein Skript als Bootstrap-Aktion zum Kopieren der JAR-Datei mit dem benutzerdefinierten Anmeldeinformationsanbieter in `/usr/share/aws/emr/emrfs/auxlib` im Master-Knoten des Clusters aus. Weitere Informationen zu Bootstrap-Aktionen finden Sie unter [(Optional) Erstellen von Bootstrap-Aktionen zum Installieren zusätzlicher Software](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-bootstrap.html).
1. Passen Sie die `emrfs-site`-Klassifizierung an, um die in der JAR-Datei implementierte Klasse anzugeben. Weitere Informationen zur Angabe von Konfigurationsobjekten für die Anpassung von Anwendungen finden Sie unter [Konfigurieren von Anwendungen](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) im *Amazon-EMR-Versionshandbuch*.
Das folgende Beispiel zeigt einen `create-cluster`-Befehl, der einen Hive-Cluster mit üblichen Konfigurationsparametern startet und außerdem Folgendes umfasst:
+ Eine Bootstrap-Aktion, die das Skript `copy_jar_file.sh` ausführt, das in `amzn-s3-demo-bucket` in Amazon S3 gespeichert wird.
+ Eine `emrfs-site`-Klassifizierung, in der ein in der JAR-Datei als benutzerdefinierter Anmeldeinformationsanbieter als `MyCustomCredentialsProvider` definiert wird.
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
```
aws emr create-cluster --applications Name=Hive \
--bootstrap-actions '[{"Path":"s3://amzn-s3-demo-bucket/copy_jar_file.sh","Name":"Custom action"}]' \
--ec2-attributes '{"KeyName":"MyKeyPair","InstanceProfile":"EMR_EC2_DefaultRole",\
"SubnetId":"subnet-xxxxxxxx","EmrManagedSlaveSecurityGroup":"sg-xxxxxxxx",\
"EmrManagedMasterSecurityGroup":"sg-xxxxxxxx"}' \
--service-role EMR_DefaultRole_V2 --enable-debugging --release-label emr-7.12.0 \
--log-uri 's3n://amzn-s3-demo-bucket/' --name 'test-awscredentialsprovider-emrfs' \
--instance-type=m5.xlarge --instance-count 3 \
--configurations '[{"Classification":"emrfs-site",\
"Properties":{"fs.s3.customAWSCredentialsProvider":"MyAWSCredentialsProviderWithUri"},\
"Configurations":[]}]'
```
# Verwaltung des Standardendpunkts AWS -Security-Token-Service
EMRFS verwendet das AWS -Security-Token-Service (STS), um temporäre Sicherheitsanmeldeinformationen für den Zugriff auf Ihre Ressourcen abzurufen. AWS Frühere Amazon EMR-Release-Versionen senden alle AWS STS Anfragen an einen einzigen globalen Endpunkt unter`https://sts.amazonaws.com`. Amazon EMR veröffentlicht die Versionen 5.31.0 und 6.1.0 und höher und sendet stattdessen Anfragen an regionale Endpunkte. AWS STS Dies reduziert die Latenz und verbessert die Gültigkeit von Sitzungstoken. *Weitere Informationen zu AWS STS Endpunkten finden Sie im Benutzerhandbuch unter [Verwaltung AWS STS in einer AWS Region](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html).AWS Identity and Access Management *
Wenn Sie die Amazon-EMR-Release-Versionen 5.31.0 und 6.1.0 und höher verwenden, können Sie den AWS STS -Standard-Endpunkt überschreiben. Dazu müssen Sie die `fs.s3.sts.endpoint`-Eigenschaft in Ihrer `emrfs-site`-Konfiguration ändern.
Im folgenden AWS CLI Beispiel wird der von EMRFS verwendete AWS STS Standardendpunkt auf den globalen Endpunkt festgelegt.
```
aws emr create-cluster --release-label --instance-type m5.xlarge \
--emrfs Args=[fs.s3.sts.endpoint=https://sts.amazonaws.com]
```
**Anmerkung**
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).
Alternativ können Sie mithilfe des folgenden Beispiels eine JSON-Konfigurationsdatei erstellen und sie mit dem `--configurations`-Argument von `emr create-cluster` angeben. Weitere Informationen zur Verwendung `--configurations,` finden Sie unter [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-cluster.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/emr/create-cluster.html).
```
[
{
"classification": "emrfs-site",
"properties": {
"fs.s3.sts.endpoint": "https://sts.amazonaws.com"
}
}
]
```
# Angeben der Amazon-S3-Verschlüsselung mit EMRFS-Eigenschaften
**Wichtig**
Ab Amazon-EMR-Version 4.8.0 können Sie Sicherheitskonfigurationen verwenden, um Verschlüsselungseinstellungen einfacher und mit mehr Optionen einzurichten. Wir empfehlen die Verwendung von Sicherheitskonfigurationen. Weitere Informationen finden Sie unter [Datenverschlüsselung konfigurieren](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-create-security-configuration.html#emr-security-configuration-encryption). Die in diesem Abschnitt beschriebenen Konsolenbefehle sind für Versionen vor 4.8.0 verfügbar. Wenn Sie die AWS CLI Amazon S3 S3-Verschlüsselung sowohl in der Cluster-Konfiguration als auch in einer Sicherheitskonfiguration in nachfolgenden Versionen verwenden, überschreibt die Sicherheitskonfiguration die Cluster-Konfiguration.
Wenn Sie einen Cluster erstellen, können Sie serverseitige Verschlüsselung (SSE) oder clientseitige Verschlüsselung (CSE) für EMRFS-Daten in Amazon S3 mithilfe der Konsole oder mithilfe von `emrfs-site` Klassifizierungseigenschaften über das oder das EMR-SDK angeben. AWS CLI SSE und CSE in Amazon S3 schließen sich gegenseitig aus. Sie können jede der beiden Optionen, aber nicht beide auswählen.
AWS CLI Anweisungen finden Sie unten im entsprechenden Abschnitt für Ihren Verschlüsselungstyp.
**Um EMRFS-Verschlüsselungsoptionen anzugeben, verwenden Sie AWS-Managementkonsole**
1. Navigieren Sie zur neuen Amazon-EMR-Konsole und wählen Sie in der Seitennavigation die Option **Zur alten Konsole wechseln** aus. Weitere Informationen darüber, was Sie erwartet, wenn Sie zur alten Konsole wechseln, finden Sie unter [Verwenden der alten Konsole](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Wählen Sie **Create Cluster (Cluster erstellen)** und **Go to advanced options (Zu erweiterten Optionen)** aus.
1. Wählen Sie **Release (Version)** 4.7.2 oder früher aus.
1. Wählen Sie weitere Optionen für **Software and Steps (Software und Steps)** aus wie für Ihre Anwendung erforderlich. Wählen Sie anschließend **Next (Weiter)** aus.
1. Wählen Sie in den Bereichen **Hardware (Hardware)** und **General Cluster Settings (Allgemeine Cluster-Einstellungen)** Einstellungen aus wie für Ihre Anwendung erforderlich.
1. Wählen Sie im Bereich **Security (Sicherheit)** in **Authentication and encryption (Authentifizierung und Verschlüsselung)** die zu verwendende Option **S3 Encryption (with EMRFS) (S3-Verschlüsselung (mit EMFRS))** aus.
**Anmerkung**
**Serverseitige S3-Verschlüsselung mit KMS-Schlüsselverwaltung** (SSE-KMS) steht für Amazon-EMR-Version 4.4 oder früher nicht zur Verfügung.
+ Wenn Sie eine Option wählen, die **AWS -Schlüsselverwaltung** verwendet, müssen Sie eine **AWS -KMS-Schlüssel-ID** auswählen. Weitere Informationen finden Sie unter [Wird AWS KMS keys für die EMRFS-Verschlüsselung verwendet](#emr-emrfs-awskms).
+ Wenn Sie **S3 client-side encryption with custom materials provider (Clientseitige S3-Verschlüsselung mit benutzerdefiniertem Materialanbieter)** auswählen, müssen Sie einen Wert in **Class name (Klassenname)** und **JAR location (JAR-Speicherort)** angeben. Weitere Informationen finden Sie unter [Clientseitige Verschlüsselung für Amazon S3](emr-emrfs-encryption-cse.md).
1. Wählen Sie weitere Optionen wie für Ihre Anwendung erforderlich aus. Wählen Sie anschließend **Create Cluster (Cluster erstellen)** aus.
## Wird AWS KMS keys für die EMRFS-Verschlüsselung verwendet
Der AWS KMS Verschlüsselungsschlüssel muss in derselben Region wie Ihre Amazon EMR-Cluster-Instance und die mit EMRFS verwendeten Amazon S3 S3-Buckets erstellt werden. Wenn sich der von Ihnen angegebene Schlüssel in einem anderen Konto befindet als dem, das Sie zur Konfiguration eines Clusters verwenden, müssen Sie den Schlüssel mit seinem ARN angeben.
Die Rolle für das Amazon-EC2-Instance-Profil muss über die Berechtigung zur Nutzung des von Ihnen angegebenen KMS-Schlüssels verfügen. Die Standardrolle für das Instance-Profil in Amazon EMR ist`EMR_EC2_DefaultRole`. Wenn Sie eine andere Rolle für das Instance-Profil oder IAM-Rollen für EMRFS-Anfragen an Amazon S3 verwenden, stellen Sie sicher, dass jede Rolle je nach Bedarf als Schlüsselbenutzer hinzugefügt wird. So erhält die Rolle die Berechtigung, den KMS-Schlüssel zu verwenden. Weitere Informationen finden Sie unter [Nutzung von Schlüsselrichtlinien](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default-allow-users) im *AWS Key Management Service -Entwicklerhandbuch* und [Konfigurieren von IAM-Rollen für EMRFS-Anfragen an Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-emrfs-iam-roles.html).
Sie können das verwenden AWS-Managementkonsole , um Ihr Instance-Profil oder EC2-Instance-Profil zur Liste der Schlüsselbenutzer für den angegebenen KMS-Schlüssel hinzuzufügen, oder Sie können das oder ein AWS SDK verwenden, um eine AWS CLI entsprechende Schlüsselrichtlinie anzuhängen.
Hinweis: Amazon EMR unterstützt nur [symmetrische KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#symmetric-cmks). Sie können keinen [asymmetrischen KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html#asymmetric-cmks) verwenden, um Data-at-Rest in einem Amazon-EMR-Cluster zu verschlüsseln. Wie Sie feststellen, ob ein KMS-Schlüssel symmetrisch oder asymmetrisch ist, erfahren Sie unter [Erkennen symmetrischer und asymmetrischer KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/find-symm-asymm.html).
Im folgenden Verfahren wird beschrieben, wie Sie das Amazon-EMR-Instance-Profil mithilfe der `EMR_EC2_DefaultRole` als *Schlüsselbenutzer* mit AWS-Managementkonsole hinzufügen. Dabei wird davon ausgegangen, dass Sie bereits einen KMS-Schlüssel erstellt haben. Weitere Informationen über die Erstellung eines neuen KMS-Schlüsseln finden Sie unter [Erstellen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) im *AWS Key Management Service -Entwicklerhandbuch*.
**So fügen Sie das EC2-Instance-Profil für Amazon EMR zur Liste der Verschlüsselungsschlüssel-Benutzer hinzu**
1. Melden Sie sich bei der AWS Key Management Service (AWS KMS) -Konsole an AWS-Managementkonsole und öffnen Sie sie unter [https://console.aws.amazon.com/kms](https://console.aws.amazon.com/kms).
1. Um das zu ändern AWS-Region, verwenden Sie die Regionsauswahl in der oberen rechten Ecke der Seite.
1. Wählen Sie den Alias des zu ändernden KMS-Schlüssels aus.
1. Wählen Sie auf der Seite mit den Schlüsseldetails unter **Key Users (Schlüsselbenutzer(** die Option **Add (Hinzufügen)** aus.
1. Wählen Sie die entsprechende Rolle im Dialogfeld **Add key users (Schlüsselbenutzer hinzufügen)** aus. Der Name der Standardrolle lautet `EMR_EC2_DefaultRole`.
1. Wählen Sie **Hinzufügen** aus.
## Serverseitige Verschlüsselung im Amazon S3
Für alle Amazon S3-Buckets ist die Verschlüsselung standardmäßig konfiguriert, und alle neuen Objekte, die in einen S3-Bucket hochgeladen werden, werden im Ruhezustand automatisch verschlüsselt. Amazon S3 verschlüsselt Daten auf Objektebene, wenn die Daten auf die Festplatte geschrieben werden, und entschlüsselt die Daten, wenn darauf zugegriffen wird. Weitere Informationen über SSE finden Sie unter [Schutz von Daten durch serverseitige Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) im *Amazon Simple Storage Service User Guide*.
Wenn Sie SSE in Amazon EMR einrichten, haben Sie die Wahl zwischen zwei verschiedenen Systemen für die Schlüsselverwaltung:
+ **SSE-S3** – Hierbei verwaltet Amazon S3 die Aktivierungsschlüssel für Sie.
+ **SSE-KMS** — Sie verwenden eine AWS KMS key , um Richtlinien einzurichten, die für Amazon EMR geeignet sind. Weitere Informationen zu den wichtigsten Anforderungen für Amazon EMR finden Sie unter [AWS KMS keys Zur Verschlüsselung verwenden](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-encryption-enable.html#emr-awskms-keys).
SSE mit vom Kunden bereitgestellten Schlüsseln (SSE-C) ist für Amazon EMR nicht verfügbar.
**Um einen Cluster mit aktiviertem SSE-S3 zu erstellen, verwenden Sie AWS CLI**
+ Geben Sie den folgenden Befehl ein:
```
aws emr create-cluster --release-label emr-4.7.2 or earlier \
--instance-count 3 --instance-type m5.xlarge --emrfs Encryption=ServerSide
```
Sie können SSE-S3 auch aktivieren, indem Sie fs.s3 setzen. enableServerSideDie Eigenschaft Encryption ist in den Eigenschaften auf true gesetzt. `emrfs-site` Lesen Sie dazu das Beispiel für SSE-KMS unten, und lassen Sie die Eigenschaft für Key-ID weg.
**Um einen Cluster mit aktiviertem SSE-KMS zu erstellen, verwenden Sie AWS CLI**
**Anmerkung**
SSE-KMS steht nur in Amazon-EMR-Version 4.5.0 und höher zur Verfügung.
+ Geben Sie den folgenden AWS CLI Befehl ein, um einen Cluster mit SSE-KMS zu erstellen, wobei *keyID* es sich beispielsweise um einen handelt AWS KMS key: *a4567b8-9900-12ab-1234-123a45678901*
```
aws emr create-cluster --release-label emr-4.7.2 or earlier --instance-count 3 \
--instance-type m5.xlarge --use-default-roles \
--emrfs Encryption=ServerSide,Args=[fs.s3.serverSideEncryption.kms.keyId=keyId]
```
**--ODER--**
Geben Sie den folgenden AWS CLI Befehl unter Verwendung der `emrfs-site` Klassifizierung ein und stellen Sie eine JSON-Konfigurationsdatei bereit, deren Inhalt dem folgenden Beispiel ähnelt: `myConfig.json`
```
aws emr create-cluster --release-label emr-4.7.2 or earlier --instance-count 3 --instance-type m5.xlarge --applications Name=Hadoop --configurations file://myConfig.json --use-default-roles
```
Beispielinhalt von **myConfig.json**:
```
[
{
"Classification":"emrfs-site",
"Properties": {
"fs.s3.enableServerSideEncryption": "true",
"fs.s3.serverSideEncryption.kms.keyId":"a4567b8-9900-12ab-1234-123a45678901"
}
}
]
```
### Konfigurationseigenschaften für SSE-S3 und SSE-KMS
Diese Eigenschaften können unter Verwendung der `emrfs-site`- Konfigurationsklassifikation konfiguriert werden. SSE-KMS steht nur in Amazon-EMR-Version 4.5.0 und höher zur Verfügung.
| Eigenschaft | Standardwert | Description |
| --- | --- | --- |
| fs.s3.enableServerSideEncryption | false | Wenn dies auf **true** festgelegt wurde, werden in Amazon S3 gespeicherte Objekte mittels serverseitiger Verschlüsselung verschlüsselt. Wenn kein Schlüssel ausgewählt wurde, wird SSE-S3 verwendet. |
| fs.s3.serverSideEncryption.kms.keyId | n/a | Gibt eine AWS KMS Schlüssel-ID oder einen ARN an. Wenn ein Schlüssel ausgewählt wurde, wird SSE-KMS verwendet. |
# Clientseitige Verschlüsselung für Amazon S3
Mit Amazon S3 bei der clientseitigen Verschlüsselung erfolgt der Amazon-S3-Ver- und Entschlüsselungsvorgang im EMRFS-Client auf Ihrem EMR-Cluster. Objekte werden vor dem Hochladen nach Amazon S3 verschlüsselt und nach dem Herunterladen entschlüsselt. Der von Ihnen festgelegte Anbieter stellt den vom Client verwendeten Verschlüsselungsschlüssel bereit. Der Client kann vom AWS KMS bereitgestellte Schlüssel (CSE-KMS) oder eine benutzerdefinierte Java-Klasse verwenden, die den clientseitigen Root-Schlüssel (CSE-C) bereitstellt. Die Verschlüsselungseigenschaften unterscheiden sich geringfügig zwischen CSE-KMS und CSE-C, abhängig vom festgelegten Anbieter und von den Metadaten des Objekts, das entschlüsselt oder verschlüsselt werden soll. Weitere Informationen zu diesen Unterschieden finden Sie unter [Schützen von Daten durch clientseitige Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingClientSideEncryption.html) im *Entwicklerhandbuch von Amazon Simple Storage Service*.
**Anmerkung**
Amazon S3 CSE stellt nur sicher, dass EMRFS-Daten, die mit Amazon S3 ausgetauscht werden, verschlüsselt sind. Nicht alle Daten auf den Cluster-Instance-Volumes werden verschlüsselt. Da Hue EMRFS nicht verwendet, werden darüber hinaus Objekte, die vom Hue-S3-Dateibrowser in Amazon S3 geschrieben werden, nicht verschlüsselt.
**Um CSE-KMS für EMRFS-Daten in Amazon S3 anzugeben, verwenden Sie AWS CLI**
+ Geben Sie den folgenden Befehl ein und *MyKMSKeyID* ersetzen Sie ihn durch die Schlüssel-ID oder den ARN des zu verwendenden KMS-Schlüssels:
```
aws emr create-cluster --release-label emr-4.7.2 or earlier
--emrfs Encryption=ClientSide,ProviderType=KMS,KMSKeyId=MyKMSKeyId
```
## Erstellen eines benutzerdefinierten Schlüsselanbieters
Abhängig von der Art der Verschlüsselung, die Sie bei der Erstellung eines benutzerdefinierten Schlüsselanbieters verwenden, muss die Anwendung auch unterschiedliche EncryptionMaterialsProvider Schnittstellen implementieren. Beide Schnittstellen sind im AWS SDK for Java Version 1.11.0 und höher verfügbar.
+ Um die Amazon S3 S3-Verschlüsselung zu implementieren, verwenden Sie das Modell [com.amazonaws.services.s3.model. EncryptionMaterialsProvider Schnittstelle.](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/model/EncryptionMaterialsProvider.html)
+ Verwenden Sie die Datei [com.amazonaws.services.elasticmapreduce.spi.security, um die lokale Festplattenverschlüsselung zu implementieren. EncryptionMaterialsProvider Schnittstelle.](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/elasticmapreduce/spi/security/EncryptionMaterialsProvider.html)
Sie können jede Strategie verwenden, um Verschlüsselungsmaterial für die Implementierung bereitzustellen. Sie können sich beispielsweise dafür entscheiden, statisches Verschlüsselungsmaterial bereitzustellen oder es in ein komplexeres Schlüsselverwaltungssystem zu integrieren.
Wenn Sie die Amazon S3 S3-Verschlüsselung verwenden, müssen Sie die Verschlüsselungsalgorithmen **AES/GCM/NoPadding**für benutzerdefinierte Verschlüsselungsmaterialien verwenden.
Wenn Sie die lokale Festplattenverschlüsselung verwenden, variiert der Verschlüsselungsalgorithmus, der für benutzerdefinierte Verschlüsselungsmaterialien verwendet werden soll, je nach EMR-Version. Für Amazon EMR 7.0.0 und niedriger müssen Sie verwenden. **AES/GCM/NoPadding** **Für Amazon EMR 7.1.0 und höher müssen Sie AES verwenden.**
Die EncryptionMaterialsProvider Klasse ruft Verschlüsselungsmaterial anhand des Verschlüsselungskontextes ab. Amazon EMR aktualisiert die Verschlüsselungskontextinformationen während der Laufzeit. So wird der Aufrufer bei der Entscheidung unterstützt, welche korrekten Verschlüsselungsmaterialien zurückzugeben sind.
**Example Beispiel: Verwenden eines benutzerdefinierten Schlüsselanbieters für die Amazon-S3-Verschlüsselung mit EMRFS**
Wenn Amazon EMR die Verschlüsselungsmaterialien von der EncryptionMaterialsProvider Klasse abruft, um die Verschlüsselung durchzuführen, füllt EMRFS optional das Argument MaterialsDescription mit zwei Feldern auf: dem Amazon S3 S3-URI für das Objekt und dem des Clusters, die JobFlowId von der Klasse verwendet werden können, um Verschlüsselungsmaterialien selektiv zurückzugeben. EncryptionMaterialsProvider
Beispielsweise kann der Anbieter unterschiedliche Schlüssel für unterschiedliche Amazon-S3-URI-Präfixe zurückgeben. Es ist die Beschreibung der zurückgegebenen Verschlüsselungsmaterialien, die schließlich mit dem Amazon-S3-Objekt gespeichert wird, und nicht der materialsDescription-Wert, der von EMRFS generiert und an den Anbieter weitergeleitet wird. Beim Entschlüsseln eines Amazon S3 S3-Objekts wird die Beschreibung des Verschlüsselungsmaterials an die EncryptionMaterialsProvider Klasse übergeben, sodass sie wiederum selektiv den passenden Schlüssel zur Entschlüsselung des Objekts zurückgeben kann.
Eine EncryptionMaterialsProvider Referenzimplementierung finden Sie weiter unten. Ein weiterer benutzerdefinierter Anbieter [EMRFSRSAEncryptionMaterialsProvider](https://github.com/awslabs/emr-sample-apps/tree/master/emrfs-plugins/EMRFSRSAEncryptionMaterialsProvider),, ist erhältlich bei GitHub.
```
import com.amazonaws.services.s3.model.EncryptionMaterials;
import com.amazonaws.services.s3.model.EncryptionMaterialsProvider;
import com.amazonaws.services.s3.model.KMSEncryptionMaterials;
import org.apache.hadoop.conf.Configurable;
import org.apache.hadoop.conf.Configuration;
import java.util.Map;
/**
* Provides KMSEncryptionMaterials according to Configuration
*/
public class MyEncryptionMaterialsProviders implements EncryptionMaterialsProvider, Configurable{
private Configuration conf;
private String kmsKeyId;
private EncryptionMaterials encryptionMaterials;
private void init() {
this.kmsKeyId = conf.get("my.kms.key.id");
this.encryptionMaterials = new KMSEncryptionMaterials(kmsKeyId);
}
@Override
public void setConf(Configuration conf) {
this.conf = conf;
init();
}
@Override
public Configuration getConf() {
return this.conf;
}
@Override
public void refresh() {
}
@Override
public EncryptionMaterials getEncryptionMaterials(Map materialsDescription) {
return this.encryptionMaterials;
}
@Override
public EncryptionMaterials getEncryptionMaterials() {
return this.encryptionMaterials;
}
}
```
## Angeben eines Anbieters für benutzerdefinierte Materialien mithilfe des AWS CLI
Um die AWS CLI zu verwenden, übergeben Sie die Argumente `Encryption`, `ProviderType`, `CustomProviderClass` und `CustomProviderLocation` an die Option `emrfs`.
```
aws emr create-cluster --instance-type m5.xlarge --release-label emr-4.7.2 or earlier --emrfs Encryption=ClientSide,ProviderType=Custom,CustomProviderLocation=s3://amzn-s3-demo-bucket/myfolder/provider.jar,CustomProviderClass=classname
```
Das Festlegen von `Encryption` auf `ClientSide` aktiviert die clientseitige Verschlüsselung. `CustomProviderClass` ist der Name des `EncryptionMaterialsProvider`-Objekts und `CustomProviderLocation` ist der lokale oder Amazon-S3-Speicherort, aus dem Amazon EMR `CustomProviderClass` zu jedem Knoten im Cluster kopiert und in den Klassenpfad platziert.
## Angabe eines benutzerdefinierten Materialanbieters unter Verwendung eines SDK
Um ein SDK zu verwenden, können Sie die Eigenschaft `fs.s3.cse.encryptionMaterialsProvider.uri` auf das Herunterladen der benutzerdefinierten `EncryptionMaterialsProvider`-Klasse festlegen, die Sie in Amazon S3 auf jedem Knoten Ihres Clusters speichern. Sie konfigurieren dies in der Datei `emrfs-site.xml` zusammen mit der aktivierten CSE sowie dem richtigen Speicherort des benutzerdefinierten Anbieters.
Bei der AWS SDK für Java Verwendung RunJobFlowRequest könnte Ihr Code beispielsweise wie folgt aussehen:
```
Map emrfsProperties = new HashMap();
emrfsProperties.put("fs.s3.cse.encryptionMaterialsProvider.uri","s3://amzn-s3-demo-bucket/MyCustomEncryptionMaterialsProvider.jar");
emrfsProperties.put("fs.s3.cse.enabled","true");
emrfsProperties.put("fs.s3.consistent","true");
emrfsProperties.put("fs.s3.cse.encryptionMaterialsProvider","full.class.name.of.EncryptionMaterialsProvider");
Configuration myEmrfsConfig = new Configuration()
.withClassification("emrfs-site")
.withProperties(emrfsProperties);
RunJobFlowRequest request = new RunJobFlowRequest()
.withName("Custom EncryptionMaterialsProvider")
.withReleaseLabel("emr-7.12.0")
.withApplications(myApp)
.withConfigurations(myEmrfsConfig)
.withServiceRole("EMR_DefaultRole_V2")
.withJobFlowRole("EMR_EC2_DefaultRole")
.withLogUri("s3://myLogUri/")
.withInstances(new JobFlowInstancesConfig()
.withEc2KeyName("myEc2Key")
.withInstanceCount(2)
.withKeepJobFlowAliveWhenNoSteps(true)
.withMasterInstanceType("m5.xlarge")
.withSlaveInstanceType("m5.xlarge")
);
RunJobFlowResult result = emr.runJobFlow(request);
```
## EncryptionMaterialsProvider benutzerdefiniert mit Argumenten
Möglicherweise müssen Sie Argumente direkt dem Anbieter übergeben. Zu diesem Zweck können Sie die `emrfs-site`-Konfigurationsklassifizierung mit benutzerdefinierten Argumente als Eigenschaften verwenden. Eine Beispielkonfiguration ist nachfolgend gezeigt, die als Datei gespeichert wird, `myConfig.json`:
```
[
{
"Classification": "emrfs-site",
"Properties": {
"myProvider.arg1":"value1",
"myProvider.arg2":"value2"
}
}
]
```
Mit dem `create-cluster` Befehl von können Sie die `--configurations` Option verwenden AWS CLI, um die Datei wie unten gezeigt anzugeben:
```
aws emr create-cluster --release-label emr-7.12.0 --instance-type m5.xlarge --instance-count 2 --configurations file://myConfig.json --emrfs Encryption=ClientSide,CustomProviderLocation=s3://amzn-s3-demo-bucket/myfolder/myprovider.jar,CustomProviderClass=classname
```
## Konfiguration der EMRFS-S3EC-V2-Unterstützung
S3-Java-SDK-Versionen (1.11.837 und höher) unterstützen den Verschlüsselungsclient Version 2 (S3EC V2) mit verschiedenen Sicherheitsverbesserungen. Weitere Informationen finden Sie im S3-Blogbeitrag: [Updates für den Amazon S3 Encryption Client](https://aws.amazon.com/blogs/developer/updates-to-the-amazon-s3-encryption-client/). Weitere Informationen finden Sie im AWS SDK für Java Developer Guide unter [Migration des Amazon S3 S3-Verschlüsselungsclients](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/s3-encryption-migration.html).
Der Encryption Client V1 ist aus Gründen der Abwärtskompatibilität weiterhin im SDK verfügbar. Standardmäßig verwendet EMRFS S3EC V1 zum Verschlüsseln und Entschlüsseln von S3-Objekten, wenn CSE aktiviert ist.
Mit S3EC V2 verschlüsselte S3-Objekte können nicht von EMRFS auf einem EMR-Cluster entschlüsselt werden, dessen Release-Version älter als emr-5.31.0 ist (emr-5.30.1 und früher, emr-6.1.0 und früher).
**Example Konfigurieren Sie EMRFS für die Verwendung von S3EC V2**
Um EMRFS für die Verwendung von S3EC V2 zu konfigurieren, fügen Sie die folgende Konfiguration hinzu:
```
{
"Classification": "emrfs-site",
"Properties": {
"fs.s3.cse.encryptionV2.enabled": "true"
}
}
```
## `emrfs-site.xml`-Eigenschaften für die Amazon-S3-clientseitige Verschlüsselung
| Eigenschaft | Standardwert | Description |
| --- | --- | --- |
| fs.s3.cse.enabled | false | Wenn dies auf **true** festgelegt ist, werden in Amazon S3 gespeicherte EMRFS-Objekte mittels clientseitiger Verschlüsselung verschlüsselt. |
| fs.s3.cse.encryptionV2.enabled | false | Wenn diese Option auf `true` gesetzt ist, verwendet EMRFS den S3-Verschlüsselungsclient Version 2 zum Verschlüsseln und Entschlüsseln von Objekten auf S3. Verfügbar in der EMR-Version 5.31.0 und höher verfügbar. |
| fs.s3.cse.encryptionMaterialsProvider.uri | N/A | Gilt bei der Verwendung benutzerdefinierter Verschlüsselungsmaterialien. Die Amazon-S3-URI, in der sich die JAR mit dem EncryptionMaterialsProvider befindet. Wenn Sie diesen URI bereitstellen, Amazon EMR automatisch die JAR-Datei auf alle Knoten im Cluster herunter. |
| fs.s3.cse.encryptionMaterialsProvider | N/A | Der `EncryptionMaterialsProvider`-Klassenpfad, der bei der clientseitigen Verschlüsselung verwendet wird. Bei der Verwendung von CSE-KMS geben `com.amazon.ws.emr.hadoop.fs.cse.KMSEncryptionMaterialsProvider` an. |
| fs.s3.cse.materialsDescription.enabled | false | Wenn auf gesetzt`true`, füllt die MaterialsDescription verschlüsselter Objekte mit dem Amazon S3 S3-URI für das Objekt und den. JobFlowId Bei der Verwendung benutzerdefinierter Verschlüsselungsmaterialien auf `true` setzen. |
| fs.s3.cse.kms.keyId | N/A | Gilt bei der Verwendung von CSE-KMS. Der Wert des KeyId, ARN oder Alias des KMS-Schlüssels, der für die Verschlüsselung verwendet wird. |
| fs.s3.cse.cryptoStorageMode | ObjectMetadata | Der Amazon-S3-Speichermodus. Standardmäßig wird die Beschreibung der Verschlüsselungsdaten in den Objektmetadaten gespeichert. Sie können die Beschreibung auch in einer Anweisungsdatei speichern. Gültige Werte sind ObjectMetadata undInstructionFile. Weitere Informationen finden Sie unter [Clientseitige Datenverschlüsselung mit dem AWS SDK für Java und Amazon S3](https://aws.amazon.com/articles/client-side-data-encryption-with-the-aws-sdk-for-java-and-amazon-s3/). |