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.
# Amazon EMR für Apache Ranger einrichten
Bevor Sie Apache Ranger installieren, überprüfen Sie die Informationen in diesem Abschnitt, um sicherzustellen, dass Amazon EMR ordnungsgemäß konfiguriert ist.
**Topics**
+ [
# Richten Sie einen Ranger Admin-Server für die Integration mit Amazon EMR ein
](emr-ranger-admin.md)
+ [
# IAM-Rollen für die native Integration mit Apache Ranger
](emr-ranger-iam.md)
+ [
# Erstellen einer EMR-Sicherheitskonfiguration
](emr-ranger-security-config.md)
+ [
# Speichern Sie TLS-Zertifikate in AWS Secrets Manager
](emr-ranger-tls-certificates.md)
+ [
# Starten Sie einen EMR-Cluster mit Apache Ranger
](emr-ranger-start-emr-cluster.md)
+ [
# Zeppelin für Apache-Ranger-fähige Amazon-EMR-Cluster konfigurieren
](emr-ranger-configure-zeppelin.md)
+ [
# Bekannte Probleme bei der Amazon EMR-Integration
](emr-ranger-security-considerations.md)
# Richten Sie einen Ranger Admin-Server für die Integration mit Amazon EMR ein
Für die Amazon-EMR-Integration müssen die Apache-Ranger-Anwendungs-Plugins über TLS/SSL mit dem Admin-Server kommunizieren.
**Voraussetzung: SSL-Aktivierung des Ranger-Admin-Servers**
Apache Ranger auf Amazon EMR erfordert bidirektionale SSL-Kommunikation zwischen Plugins und dem Ranger-Admin-Server. Um sicherzustellen, dass Plugins über SSL mit dem Apache Ranger-Server kommunizieren, aktivieren Sie das folgende Attribut in ranger-admin-site .xml auf dem Ranger Admin-Server.
```
ranger.service.https.attrib.ssl.enabled
true
```
Darüber hinaus sind die folgenden Konfigurationen erforderlich.
```
ranger.https.attrib.keystore.file
__
ranger.service.https.attrib.keystore.file
__
ranger.service.https.attrib.keystore.pass
__
ranger.service.https.attrib.keystore.keyalias
ranger.service.https.attrib.clientAuth
want
ranger.service.https.port
6182
```
# TLS-Zertifikate für die Apache Ranger-Integration mit Amazon EMR
Die Apache-Ranger-Integration mit Amazon EMR erfordert, dass der Datenverkehr von Amazon-EMR-Knoten zum Ranger-Admin-Server mit TLS verschlüsselt wird und dass Ranger-Plugins sich beim Apache-Ranger-Server mithilfe der wechselseitigen TLS-Authentifizierung authentifizieren. Der Amazon-EMR-Service benötigt das öffentliche Zertifikat Ihres Ranger- Admin-Servers (wie im vorherigen Beispiel angegeben) und das private Zertifikat.
**Zertifikate für das Apache-Ranger-Plugin**
Öffentliche TLS-Zertifikate für das Apache Ranger-Plugin müssen für den Apache-Ranger-Admin-Server zugänglich sein, um zu überprüfen, wann die Plugins eine Verbindung herstellen. Es gibt drei verschiedene Methoden, dies zu tun.
**Methode 1: Konfigurieren Sie einen Truststore auf dem Apache-Ranger-Admin-Server**
Füllen Sie die folgenden Konfigurationen in ranger-admin-site .xml aus, um einen Truststore zu konfigurieren.
```
ranger.truststore.file
ranger.truststore.password
```
**Methode 2: Laden Sie das Zertifikat in den Truststore von Java cacerts**
Wenn Ihr Ranger- Admin-Server in seinen JVM-Optionen keinen Truststore angibt, können Sie die öffentlichen Plugin-Zertifikate im Standard-Cacerts-Speicher ablegen.
**Methode 3: Erstellen Sie einen Truststore und geben Sie ihn als Teil der JVM-Optionen an**
Ändern Sie die `{RANGER_HOME_DIRECTORY}/ews/ranger-admin-services.sh` innerhalb von `JAVA_OPTS`, dass sie `"-Djavax.net.ssl.trustStore="` und `"-Djavax.net.ssl.trustStorePassword="` einschließt. Fügen Sie beispielsweise die folgende Zeile nach dem vorhandenen JAVA\$1OPTS hinzu.
```
JAVA_OPTS=" ${JAVA_OPTS} -Djavax.net.ssl.trustStore=${RANGER_HOME}/truststore/truststore.jck -Djavax.net.ssl.trustStorePassword=changeit"
```
**Anmerkung**
Diese Spezifikation kann das Truststore-Passwort offenlegen, wenn sich ein Benutzer beim Apache- Ranger Admin-Server anmelden und laufende Prozesse sehen kann, z. B. wenn er den `ps`-Befehl verwendet.
**Verwenden selbstsignierter Zertifikate**
Selbstsignierte Zertifikate werden als Zertifikate nicht empfohlen. Selbstsignierte Zertifikate können nicht gesperrt werden, und selbstsignierte Zertifikate entsprechen möglicherweise nicht den internen Sicherheitsanforderungen.
# Installation der Servicedefinition für die Ranger-Integration mit Amazon EMR
Eine Servicedefinition wird vom Ranger-Admin-Server verwendet, um die Attribute von Richtlinien für eine Anwendung zu beschreiben. Die Richtlinien werden dann in einem Richtlinien-Repository gespeichert, sodass die Clients sie herunterladen können.
Um Servicedefinitionen konfigurieren zu können, müssen REST-Aufrufe an den Ranger-Admin-Server getätigt werden. Informationen zu den [Anforderungen finden Sie im folgenden Abschnitt unter Apache Ranger Public APIsv2](https://ranger.apache.org/apidocs/resource_PublicAPIsv2.html#resource_PublicAPIsv2_createServiceDef_POST). APIs
**Installation der Servicedefinition von Apache Spark**
Informationen zur Installation der Servicedefinition von Apache Spark finden Sie unter [Apache Spark-Plugin für die Ranger-Integration mit Amazon EMR](emr-ranger-spark.md).
**Installation der EMRFS-Servicedefinition**
Informationen zur Installation der S3-Servicedefinition für Amazon EMR finden Sie unter [EMRFS S3-Plugin für die Ranger-Integration mit Amazon EMR](emr-ranger-emrfs.md).
**Verwenden der Hive-Servicedefinition**
Apache Hive kann die bestehende Ranger-Servicedefinition verwenden, die im Lieferumfang von Apache Ranger 2.0 und höher enthalten ist. Weitere Informationen finden Sie unter [Apache Hive-Plugin für die Ranger-Integration mit Amazon EMR](emr-ranger-hive.md).
# Regeln für den Netzwerkverkehr für die Integration mit Amazon EMR
Wenn Apache Ranger in Ihren EMR-Cluster integriert ist, muss der Cluster mit zusätzlichen Servern und AWS kommunizieren.
Alle Amazon-EMR-Knoten, einschließlich Core- und Aufgabenknoten, müssen in der Lage sein, mit den Apache-Ranger-Admin-Servern zu kommunizieren, um Richtlinien herunterzuladen. Wenn Ihr Apache-Ranger-Admin auf Amazon EC2 läuft, müssen Sie die Sicherheitsgruppe aktualisieren, um Datenverkehr vom EMR-Cluster entgegennehmen zu können.
Zusätzlich zur Kommunikation mit dem Ranger Admin-Server müssen alle Knoten in der Lage sein, mit den folgenden AWS Diensten zu kommunizieren:
+ Amazon S3
+ AWS KMS (bei Verwendung von EMRFS SSE-KMS)
+ Amazon CloudWatch
+ AWS STS
Wenn Sie planen, Ihren EMR-Cluster in einem privaten Subnetz auszuführen, konfigurieren Sie die VPC so, dass sie mit diesen Services entweder über [AWS PrivateLink und VPC-Endpunkte](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) im *Amazon-VPC-Benutzerhandbuch* oder mithilfe der [Network Address Translation (NAT)-Instance](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html) im *Amazon-VPC-Benutzerhandbuch* kommunizieren kann.
# IAM-Rollen für die native Integration mit Apache Ranger
Die Integration zwischen Amazon EMR und Apache Ranger basiert auf drei Schlüsselrollen, die Sie erstellen sollten, bevor Sie Ihren Cluster starten:
+ Ein benutzerdefiniertes Amazon-EC2-Instance-Profil für Amazon EMR
+ Eine IAM-Rolle für Apache Ranger Engines
+ Eine IAM-Rolle für andere Dienste AWS
Dieser Abschnitt bietet eine Übersicht über diese Rollen und die Richtlinien, die Sie für jede dieser IAM-Rollen einschließen müssen. Informationen zum Erstellen dieser Rollen finden Sie unter [Richten Sie einen Ranger Admin-Server für die Integration mit Amazon EMR ein](emr-ranger-admin.md).
# EC2-Instanzprofil für Amazon EMR
Amazon EMR verwendet eine IAM-Servicerolle, um in Ihrem Namen Aktionen zur Bereitstellung und Verwaltung von Clustern durchzuführen. Die Servicerolle für EC2-Instance-Cluster (auch als EC2-Instance-Profil für Amazon EMR bezeichnet) ist eine spezielle Art von Servicerolle, die jeder EC2-Instance in einem Amazon-EMR-Cluster zugewiesen wird, wenn die Instance startet.
Um Berechtigungen für die EMR-Cluster-Interaktion mit Amazon S3 S3-Daten und mit dem durch Apache Ranger und andere AWS Dienste geschützten Hive-Metastore zu definieren, definieren Sie ein benutzerdefiniertes EC2-Instance-Profil, das anstelle des `EMR_EC2_DefaultRole` beim Starten Ihres Clusters verwendet werden soll.
Weitere Informationen erhalten Sie unter [Servicerolle für EC2-Cluster-Instances (EC2-Instance-Profil)](emr-iam-role-for-ec2.md) und [Passen Sie IAM-Rollen mit Amazon EMR an](emr-iam-roles-custom.md).
Sie müssen die folgenden Anweisungen zum standardmäßigen EC2-Instance-Profil für Amazon EMR hinzufügen, um Sitzungen taggen und auf die zugreifen zu können, in AWS Secrets Manager denen TLS-Zertifikate gespeichert sind.
```
{
"Sid": "AllowAssumeOfRolesAndTagging",
"Effect": "Allow",
"Action": ["sts:TagSession", "sts:AssumeRole"],
"Resource": [
"arn:aws:iam:::role/",
"arn:aws:iam:::role/"
]
},
{
"Sid": "AllowSecretsRetrieval",
"Effect": "Allow",
"Action": "secretsmanager:GetSecretValue",
"Resource": [
"arn:aws:secretsmanager:::secret:*",
"arn:aws:secretsmanager:::secret:*"
]
}
```
**Anmerkung**
Vergessen Sie bei den Secrets- Manager-Berechtigungen nicht den Platzhalter („\$1“) am Ende des geheimen Namens, da Ihre Anfragen sonst fehlschlagen. Der Platzhalter gilt für geheime Versionen.
**Anmerkung**
Beschränken Sie den Geltungsbereich der AWS Secrets Manager Richtlinie auf die Zertifikate, die für die Bereitstellung erforderlich sind.
# IAM-Rolle für Apache Ranger
Diese Rolle stellt Anmeldeinformationen für vertrauenswürdige Ausführungs-Engines wie Apache Hive und Amazon EMR Record Server bereit, um auf Amazon-S3-Daten zuzugreifen. Verwenden Sie nur diese Rolle, um auf Amazon-S3-Daten, einschließlich aller KMS-Schlüssel, zuzugreifen, wenn Sie S3 SSE-KMS verwenden.
Diese Rolle muss mit der im folgenden Beispiel angegebenen Mindestrichtlinie erstellt werden.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CloudwatchLogsPermissions",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Effect": "Allow",
"Resource": [
"arn:aws:logs:*:123456789012:log-group:CLOUDWATCH_LOG_GROUP_NAME_IN_SECURITY_CONFIGURATION:*"
]
},
{
"Sid": "BucketPermissionsInS3Buckets",
"Action": [
"s3:CreateBucket",
"s3:DeleteBucket",
"s3:ListAllMyBuckets",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket2"
]
},
{
"Sid": "ObjectPermissionsInS3Objects",
"Action": [
"s3:GetObject",
"s3:DeleteObject",
"s3:PutObject"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1/*",
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
}
]
}
```
------
**Wichtig**
Das Sternchen „\$1“ am Ende der CloudWatch Protokollressource muss enthalten sein, um Schreibberechtigungen für die Protokolldatenströme zu erteilen.
**Anmerkung**
Wenn Sie die EMRFS-Konsistenzansicht oder die S3-SSE-Verschlüsselung verwenden, fügen Sie den DynamoDB-Tabellen und KMS-Schlüsseln Berechtigungen hinzu, damit die Ausführungsmodule mit diesen Engines interagieren können.
Die IAM-Rolle für Apache Ranger wird von der EC2-Instance-Profilrolle übernommen. Verwenden Sie das folgende Beispiel, um eine Vertrauensrichtlinie zu erstellen, die es ermöglicht, dass die IAM-Rolle für Apache Ranger von der EC2-Instance-Profilrolle übernommen wird.
```
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/"
},
"Action": ["sts:AssumeRole", "sts:TagSession"]
}
```
# IAM-Rolle für andere AWS Services für die Amazon EMR-Integration
Diese Rolle stellt Benutzern, denen Execution Engines nicht vertraut werden, bei Bedarf Anmeldeinformationen für die Interaktion mit AWS Diensten zur Verfügung. Verwenden Sie diese IAM-Rolle nicht, um Zugriff auf Amazon-S3-Daten zu gewähren, es sei denn, es handelt sich um Daten, auf die alle Benutzer zugreifen können sollten.
Diese Rolle wird von der EC2-Instance-Profilrolle übernommen. Verwenden Sie das folgende Beispiel, um eine Vertrauensrichtlinie zu erstellen, die es ermöglicht, dass die IAM-Rolle für Apache Ranger von der EC2-Instance-Profilrolle übernommen wird.
```
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:::role/"
},
"Action": ["sts:AssumeRole", "sts:TagSession"]
}
```
# Überprüfen Sie Ihre Berechtigungen für die Amazon EMR-Integration mit Apache Ranger
Anweisungen zum Überprüfen von Berechtigungen finden Sie unter [Fehlerbehebung für Apache Ranger](emr-ranger-troubleshooting.md).
# Erstellen einer EMR-Sicherheitskonfiguration
**Eine Amazon-EMR-Sicherheitskonfiguration für Apache Ranger erstellen**
Bevor Sie einen in Apache Ranger integrierten Amazon-EMR-Cluster starten, erstellen Sie eine Sicherheitskonfiguration.
------
#### [ Console ]
**Um eine Sicherheitskonfiguration zu erstellen, die die AWS Ranger-Integrationsoption spezifiziert**
1. Wählen Sie in der Amazon-EMR-Konsole die Optionen **Sicherheitskonfigurationen** und dann **Erstellen** aus.
1. Geben Sie in **Name (Name)** einen Namen für die Sicherheitskonfiguration ein. Verwenden Sie diesen Namen zum Angeben der Sicherheitskonfiguration, wenn Sie einen Cluster erstellen.
1. Wählen Sie unter **AWS -Ranger-Integration** die Option **Aktivieren einer von Apache Ranger verwalteten feinkörnigen Zugriffskontrolle**.
1. Wählen Sie Ihre **IAM-Rolle für die Apache Ranger**, die angewendet werden soll. Weitere Informationen finden Sie unter [IAM-Rollen für die native Integration mit Apache Ranger](emr-ranger-iam.md).
1. Wählen Sie eine **IAM-Rolle für andere AWS -Services** aus, die angewendet werden soll.
1. Konfigurieren Sie die Plugins so, dass sie eine Verbindung zum Ranger Admin-Server herstellen, indem Sie den Secrets Manager Manager-ARN für den Admin-Server und die Adresse eingeben.
1. Wählen Sie die Anwendungen aus, um Ranger-Plugins zu konfigurieren. Geben Sie den Secrets Manager ARN ein, der das private TLS-Zertifikat für das Plugin enthält.
Wenn Sie Apache Spark oder Apache Hive nicht konfigurieren und diese als Anwendung für Ihren Cluster ausgewählt wurden, schlägt die Anfrage fehl.
1. Richten Sie weitere Sicherheitskonfigurationsoptionen ein wie erforderlich. Wählen Sie **Create (Erstellen)** aus. Sie müssen die Kerberos-Authentifizierung mit dem Cluster-spezifischen oder externen KDC aktivieren.
**Anmerkung**
Sie können die Konsole derzeit nicht verwenden, um eine Sicherheitskonfiguration zu erstellen, die die AWS Ranger-Integrationsoption in der AWS GovCloud (US) Region spezifiziert. Die Sicherheitskonfiguration kann mit der CLI durchgeführt werden.
------
#### [ CLI ]
**Wie Sie eine Sicherheitskonfiguration für die Apache Ranger-Integration erstellen**
1. Ersetzen Sie es `` durch Ihre AWS Konto-ID.
1. Ersetzen Sie `` durch die Region, in der sich die Ressource befindet.
1. Geben Sie einen Wert für `TicketLifetimeInHours` an, um den Zeitraum zu anzugeben, für den ein vom KDC ausgestelltes Kerberos-Ticket gültig ist.
1. Geben Sie die Adresse des Ranger-Admin-Servers für `AdminServerURL` an.
```
{
"AuthenticationConfiguration": {
"KerberosConfiguration": {
"Provider": "ClusterDedicatedKdc",
"ClusterDedicatedKdcConfiguration": {
"TicketLifetimeInHours": 24
}
}
},
"AuthorizationConfiguration":{
"RangerConfiguration":{
"AdminServerURL":"https://__:6182",
"RoleForRangerPluginsARN":"arn:aws:iam::__:role/__",
"RoleForOtherAWSServicesARN":"arn:aws:iam::__:role/__",
"AdminServerSecretARN":"arn:aws:secretsmanager:__:__:secret:__",
"RangerPluginConfigurations":[
{
"App":"Spark",
"ClientSecretARN":"arn:aws:secretsmanager:__:__:secret:__",
"PolicyRepositoryName":""
},
{
"App":"Hive",
"ClientSecretARN":"arn:aws:secretsmanager:__:__:secret:__",
"PolicyRepositoryName":""
},
{
"App":"EMRFS-S3",
"ClientSecretARN":"arn:aws:secretsmanager:__:__:secret:__",
"PolicyRepositoryName":""
},
{
"App":"Trino",
"ClientSecretARN":"arn:aws:secretsmanager:__:__:secret:__",
"PolicyRepositoryName":""
}
],
"AuditConfiguration":{
"Destinations":{
"AmazonCloudWatchLogs":{
"CloudWatchLogGroup":"arn:aws:logs::__:log-group:__"
}
}
}
}
}
}
```
Dies PolicyRespositoryNames sind die Dienstnamen, die in Ihrem Apache Ranger Admin angegeben sind.
Erstellen Sie eine Amazon-EMR-Datei für die Sicherheitskonfiguration mit dem folgenden Befehl. Ersetzen Sie Sicherheitskonfiguration durch einen beliebigen Namen. Wählen Sie diese Konfiguration beim Erstellen Ihres Clusters nach Namen aus.
```
aws emr create-security-configuration \
--security-configuration file://./security-configuration.json \
--name security-configuration
```
------
**Konfigurieren von zusätzlichen Sicherheits-Features**
Um sicherzustellen, dass Amazon EMR sicher in Apache Ranger integriert ist, konfigurieren Sie die folgenden EMR-Sicherheits-Features:
+ Aktivieren Sie die Kerberos-Authentifizierung über den Cluster-spezifischen oder externen KDC. Detaillierte Anweisungen finden Sie unter [Verwenden Sie Kerberos für die Authentifizierung mit Amazon EMR](emr-kerberos.md).
+ (Optional) Aktivieren Sie die Verschlüsselung von Daten während der Übertragung oder im Ruhezustand. Weitere Informationen finden Sie unter [Verschlüsselungsoptionen für Amazon EMR](emr-data-encryption-options.md).
Weitere Informationen finden Sie unter [Sicherheit in Amazon EMR](emr-security.md).
# Speichern Sie TLS-Zertifikate in AWS Secrets Manager
Die auf einem Amazon-EMR-Cluster installierten Ranger-Plugins und der Ranger- Admin-Server müssen über TLS kommunizieren, um sicherzustellen, dass Richtliniendaten und andere gesendete Informationen nicht gelesen werden können, wenn sie abgefangen werden. EMR schreibt außerdem vor, dass sich die Plugins beim Ranger-Admin-Server authentifizieren, indem sie ein eigenes TLS-Zertifikat bereitstellen und eine bidirektionale TLS-Authentifizierung durchführen. Für dieses Setup mussten vier Zertifikate erstellt werden: zwei Paare von privaten und öffentlichen TLS-Zertifikaten. Anweisungen zur Installation des Zertifikats auf Ihrem Ranger Admin-Server finden Sie unter [Richten Sie einen Ranger Admin-Server für die Integration mit Amazon EMR ein](emr-ranger-admin.md). Um die Einrichtung abzuschließen, benötigen die auf dem EMR-Cluster installierten Ranger-Plugins zwei Zertifikate: das öffentliche TLS-Zertifikat Ihres Admin-Servers und das private Zertifikat, das das Plugin zur Authentifizierung gegenüber dem Ranger-Admin-Server verwendet. Um diese TLS-Zertifikate bereitstellen zu können, müssen sie sich in der EMR-Sicherheitskonfiguration befinden AWS Secrets Manager und in dieser bereitgestellt werden.
**Anmerkung**
Es wird dringend empfohlen, aber nicht vorgeschrieben, für jede Ihrer Anwendungen ein Zertifikatspaar zu erstellen, um die Auswirkungen zu begrenzen, falls eines der Plugin-Zertifikate kompromittiert wird.
**Anmerkung**
Sie müssen Zertifikate vor ihrem Ablaufdatum nachverfolgen und rotieren.
## Zertifikatformat
Das Importieren der Zertifikate in das AWS Secrets Manager ist identisch, unabhängig davon, ob es sich um das private Plugin-Zertifikat oder das öffentliche Ranger-Administratorzertifikat handelt. Vor dem Import der TLS-Zertifikate müssen die Zertifikate im 509x PEM-Format vorliegen.
Ein Beispiel für ein öffentliches Zertifikat hat das folgende Format:
```
-----BEGIN CERTIFICATE-----
...Certificate Body...
-----END CERTIFICATE-----
```
Ein Beispiel für ein privates Zertifikat hat das folgende Format:
```
-----BEGIN PRIVATE KEY-----
...Private Certificate Body...
-----END PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
...Trust Certificate Body...
-----END CERTIFICATE-----
```
Das private Zertifikat sollte auch ein Vertrauenszertifikat enthalten.
Mit folgendem Befehl können Sie prüfen, ob die Zertifikate das richtige Format haben:
```
openssl x509 -in -text
```
## Importieren eines Zertifikats in das AWS Secrets Manager
Wenn Sie Ihr Geheimnis im Secrets Manager erstellen, wählen Sie **Andere Art von Geheimnissen** unter **Geheimnistyp** und fügen Sie Ihr PEM-codiertes Zertifikat in das **Klartext-Feld** ein.
![\[Ein Zertifikat importieren in AWS Secrets Manager.\]](http://docs.aws.amazon.com/de_de/emr/latest/ManagementGuide/images/ranger-tls-cert-import.png)
# Starten Sie einen EMR-Cluster mit Apache Ranger
Bevor Sie einen Amazon-EMR-Cluster mit Apache Ranger starten, stellen Sie sicher, dass jede Komponente die folgenden Mindestanforderungen an die Version erfüllt:
+ Amazon EMR 5.32.0 oder höher oder 6.3.0 oder höher. Es wird empfohlen, die neueste Amazon-EMR-Release-Version zu verwenden.
+ Apache Ranger Admin-Server 2.x.
Führen Sie folgende Schritte aus.
+ Installieren Sie Apache Ranger, wenn das noch nicht geschehen ist. Weitere Informationen finden Sie unter [Installation von Apache Ranger 0.5.0](https://cwiki.apache.org/confluence/display/RANGER/Apache+Ranger+0.5.0+Installation).
+ Stellen Sie sicher, dass zwischen Ihrem Amazon-EMR-Cluster und dem Apache-Ranger-Admin-Server eine Netzwerkverbindung besteht. Siehe [Richten Sie einen Ranger Admin-Server für die Integration mit Amazon EMR ein](emr-ranger-admin.md)
+ Erstellen Sie die erforderlichen IAM-Rollen. Siehe [IAM-Rollen für die native Integration mit Apache Ranger](emr-ranger-iam.md).
+ Erstellen Sie eine EMR-Sicherheitskonfiguration für die Apache-Ranger-Installation. Weitere Informationen finden Sie unter [Erstellen einer EMR-Sicherheitskonfiguration](emr-ranger-security-config.md).
# Zeppelin für Apache-Ranger-fähige Amazon-EMR-Cluster konfigurieren
Das Thema behandelt die Konfiguration von [Apache Zeppelin](https://zeppelin.apache.org/) für einen Apache-Ranger-fähigen Amazon-EMR-Cluster, sodass Sie Zeppelin als Notizbuch für die interaktive Datenexploration verwenden können. Zeppelin ist in Amazon-EMR-Versionen 5.0.0 und höher enthalten. Frühere Versionen enthalten Zeppelin als Sandbox-Anwendung. Weitere Informationen finden Sie unter [Informationen zu Amazon-EMR–4.x-Versionen](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-4x.html) in den *Amazon-EMR-Versionshinweisen*.
Standardmäßig ist Zeppelin mit einem Standard-Login und Passwort konfiguriert, was in einer Umgebung mit mehreren Mandanten nicht sicher ist.
Führen Sie für die Konfiguration von Zeppelin die folgenden Schritte aus.
1. **Verändern Sie den Authentifizierungsmechanismus**.
Ändern Sie die `shiro.ini`-Datei, um Ihren bevorzugten Authentifizierungsmechanismus zu implementieren. Zeppelin unterstützt Active Directory, LDAP, PAM und Knox SSO. Weitere Informationen finden Sie unter [Apache-Shiro-Authentifizierung für Apache Zeppelin](https://zeppelin.apache.org/docs/0.8.2/setup/security/shiro_authentication.html).
1. **Konfigurieren Sie Zeppelin so, dass es sich als Endbenutzer ausgibt**
Wenn Sie Zeppelin erlauben, sich als Endbenutzer auszugeben, können von Zeppelin eingereichte Aufträge als dieser Endbenutzer ausgeführt werden. Fügen Sie die folgende Konfiguration zu `core-site.xml` hinzu:
```
[
{
"Classification": "core-site",
"Properties": {
"hadoop.proxyuser.zeppelin.hosts": "*",
"hadoop.proxyuser.zeppelin.groups": "*"
},
"Configurations": [
]
}
]
```
Fügen Sie als Nächstes die folgende Konfiguration zu `hadoop-kms-site.xml` in `/etc/hadoop/conf` hinzu:
```
[
{
"Classification": "hadoop-kms-site",
"Properties": {
"hadoop.kms.proxyuser.zeppelin.hosts": "*",
"hadoop.kms.proxyuser.zeppelin.groups": "*"
},
"Configurations": [
]
}
]
```
Sie können diese Konfigurationen auch mithilfe der Konsole zu Ihrem Amazon-EMR-Cluster hinzufügen, indem Sie die Schritte unter [Instance-Gruppe in der Konsole neu konfigurieren](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps-running-cluster.html#emr-configure-apps-running-cluster-console) befolgen.
1. **Erlauben Sie Zeppelin, als Endbenutzer sudo auszuführen**
Erstellen Sie eine Datei `/etc/sudoers.d/90-zeppelin-user`, die folgendes enthält:
```
zeppelin ALL=(ALL) NOPASSWD:ALL
```
1. **Ändern Sie die Einstellungen der Interpreter, um Benutzeraufträge in ihren eigenen Prozessen auszuführen**.
Konfigurieren Sie alle Interpreter so, dass sie die Interpreter „pro Benutzer“ in „isolierten“ Prozessen instanziieren.
![\[Architekturdiagramm von Amazon EMR und Apache Ranger.\]](http://docs.aws.amazon.com/de_de/emr/latest/ManagementGuide/images/per_user.png)
1. **Modifizieren Sie `zeppelin-env.sh`**
Fügen Sie Folgendes zu `zeppelin-env.sh` hinzu, damit Zeppelin die Interpreter als Endbenutzer startet:
```
ZEPPELIN_IMPERSONATE_USER=`echo ${ZEPPELIN_IMPERSONATE_USER} | cut -d @ -f1`
export ZEPPELIN_IMPERSONATE_CMD='sudo -H -u ${ZEPPELIN_IMPERSONATE_USER} bash -c'
```
Fügen Sie Folgendes zu `zeppelin-env.sh` hinzu, um die standardmäßigen Notebookberechtigungen für den Ersteller auf Schreibgeschützt zu ändern:
```
export ZEPPELIN_NOTEBOOK_PUBLIC="false"
```
Fügen Sie abschließend Folgendes hinzu, `zeppelin-env.sh` um den RecordServer EMR-Klassenpfad nach der ersten `CLASSPATH` Anweisung einzubeziehen:
```
export CLASSPATH="$CLASSPATH:/usr/share/aws/emr/record-server/lib/aws-emr-record-server-connector-common.jar:/usr/share/aws/emr/record-server/lib/aws-emr-record-server-spark-connector.jar:/usr/share/aws/emr/record-server/lib/aws-emr-record-server-client.jar:/usr/share/aws/emr/record-server/lib/aws-emr-record-server-common.jar:/usr/share/aws/emr/record-server/lib/jars/secret-agent-interface.jar"
```
1. **Starten Sie Zeppelin neu.**
Führen Sie für den folgenden Befehle aus, um Zeppelin neu zu starten:
```
sudo systemctl restart zeppelin
```
# Bekannte Probleme bei der Amazon EMR-Integration
**Bekannte Probleme**
Es gibt ein bekanntes Problem in Amazon-EMR-Version 5.32, bei dem die Berechtigungen für `hive-site.xml` geändert wurden, sodass nur privilegierte Benutzer es lesen können, da möglicherweise Anmeldeinformationen darin gespeichert sind. Dies könnte Hue am Lesen von `hive-site.xml` hindern und dazu führen, dass Webseiten ständig neu geladen werden. Wenn dieses Problem auftritt, fügen Sie die folgende Konfiguration hinzu, um das Problem zu beheben:
```
[
{
"Classification": "hue-ini",
"Properties": {},
"Configurations": [
{
"Classification": "desktop",
"Properties": {
"server_group":"hive_site_reader"
},
"Configurations":[
]
}
]
}
]
```
Es gibt ein bekanntes Problem, dass das EMRFS-S3-Plugin für Apache Ranger das Security-Zone-Feature von Apache Ranger derzeit nicht unterstützt. Einschränkungen der Zugriffskontrolle, die mit demr Sicherheitszone-Feature definiert wurden, gelten nicht für Ihre Amazon-EMR-Cluster.
**Anwendung UIs**
Standardmäßig führen Benutzeroberflächen von Anwendungen keine Authentifizierung durch. Dazu gehören unter anderem die ResourceManager Benutzeroberfläche, die NodeManager Benutzeroberfläche und die Livy-Benutzeroberfläche. Darüber hinaus kann jeder Benutzer, der auf die UIs zugreifen kann, Informationen zu den Jobs aller anderen Benutzer einsehen.
Wenn dieses Verhalten nicht erwünscht ist, sollten Sie sicherstellen, dass eine Sicherheitsgruppe verwendet wird, um den Zugriff der Benutzer auf die Anwendung UIs einzuschränken.
**HDFS-Standardberechtigungen**
Standardmäßig erhalten die Objekte, die Benutzer in HDFS erstellen, weltweit lesbare Berechtigungen. Dies kann möglicherweise dazu führen, dass Daten von Benutzern gelesen werden, die keinen Zugriff darauf haben sollten. Gehen Sie wie folgt vor, um dieses Verhalten so zu ändern, dass die standardmäßigen Dateiberechtigungen nur vom Ersteller des Auftrags auf Lese- und Schreibzugriff festgelegt werden.
Geben Sie bei der Erstellung Ihres EMR-Clusters die folgende Konfiguration an:
```
[
{
"Classification": "hdfs-site",
"Properties": {
"dfs.namenode.acls.enabled": "true",
"fs.permissions.umask-mode": "077",
"dfs.permissions.superusergroup": "hdfsadmingroup"
}
}
]
```
Führen Sie außerdem die folgende Bootstrap-Aktion aus:
```
--bootstrap-actions Name='HDFS UMask Setup',Path=s3://elasticmapreduce/hdfs/umask/umask-main.sh
```