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.

# Sicherheit für Apache Livy mit Amazon EMR auf EKS
<a name="job-runs-apache-livy-security"></a>

In den folgenden Themen erfahren Sie mehr über die Konfiguration der Sicherheit für Apache Livy mit Amazon EMR auf EKS. Zu diesen Optionen gehören die Verwendung von Transportschichtsicherheit, die rollenbasierte Zugriffskontrolle, bei der der Zugriff auf der Rolle einer Person innerhalb einer Organisation basiert, und die Verwendung von IAM-Rollen, die den Zugriff auf Ressourcen auf der Grundlage erteilter Berechtigungen ermöglichen.

**Topics**
+ [

# Einrichtung eines sicheren Apache Livy-Endpunkts mit TLS/SSL
](job-runs-apache-livy-secure-endpoint.md)
+ [

# Einrichtung der Anwendungsberechtigungen für Apache Livy und Spark mit rollenbasierter Zugriffskontrolle (RBAC)
](job-runs-apache-livy-rbac.md)
+ [

# Einrichtung von Zugriffsberechtigungen mit IAM-Rollen für Dienstkonten (IRSA)
](job-runs-apache-livy-irsa.md)

# Einrichtung eines sicheren Apache Livy-Endpunkts mit TLS/SSL
<a name="job-runs-apache-livy-secure-endpoint"></a>

In den folgenden Abschnitten erfahren Sie mehr über die Einrichtung von Apache Livy für Amazon EMR auf EKS mit end-to-end TLS- und SSL-Verschlüsselung.

## Einrichtung der TLS- und SSL-Verschlüsselung
<a name="job-runs-apache-livy-security-tls"></a>

Gehen Sie folgendermaßen vor, um die SSL-Verschlüsselung auf Ihrem Apache Livy-Endpunkt einzurichten.
+ [Installieren Sie den Secrets Store CSI-Treiber und den AWS Secrets and Configuration Provider (ASCP)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_csi_driver.html) — der Secrets Store CSI-Treiber und ASCP speichern sicher die JKS-Zertifikate und Passwörter von Livy, die der Livy-Server-Pod benötigt, um SSL zu aktivieren. Sie können auch nur den Secrets Store CSI-Treiber installieren und jeden anderen unterstützten Secrets-Anbieter verwenden.
+ [Erstellen Sie ein ACM-Zertifikat](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html) — dieses Zertifikat ist erforderlich, um die Verbindung zwischen dem Client und dem ALB-Endpunkt zu sichern.
+ Richten Sie ein JKS-Zertifikat, ein Schlüsselkennwort und ein Keystore-Passwort für ein AWS Secrets Manager — erforderlich, um die Verbindung zwischen dem ALB-Endpunkt und dem Livy-Server zu sichern.
+ Fügen Sie dem Livy-Dienstkonto Berechtigungen zum Abrufen von Geheimnissen hinzu AWS Secrets Manager — der Livy-Server benötigt diese Berechtigungen, um Geheimnisse von ASCP abzurufen und die Livy-Konfigurationen hinzuzufügen, um den Livy-Server zu sichern. Informationen zum Hinzufügen von IAM-Berechtigungen zu einem Dienstkonto finden Sie unter Einrichten von Zugriffsberechtigungen mit IAM-Rollen für Dienstkonten (IRSA).

### Einrichten eines JKS-Zertifikats mit einem Schlüssel und einem Keystore-Passwort für AWS Secrets Manager
<a name="job-runs-apache-livy-jks-certificate"></a>

Gehen Sie wie folgt vor, um ein JKS-Zertifikat mit einem Schlüssel und einem Keystore-Passwort einzurichten.

1. Generieren Sie eine Keystore-Datei für den Livy-Server.

   ```
   keytool -genkey -alias <host> -keyalg RSA -keysize 2048 –dname CN=<host>,OU=hw,O=hw,L=<your_location>,ST=<state>,C=<country> –keypass <keyPassword> -keystore <keystore_file> -storepass <storePassword> --validity 3650
   ```

1. Erstellen Sie ein Zertifikat.

   ```
   keytool -export -alias <host> -keystore mykeystore.jks -rfc -file mycertificate.cert -storepass <storePassword>
   ```

1. Erstellen Sie eine Truststore-Datei.

   ```
   keytool -import -noprompt -alias <host>-file <cert_file> -keystore <truststore_file> -storepass <truststorePassword>
   ```

1. Speichern Sie das JKS-Zertifikat in. AWS Secrets Manager`livy-jks-secret`Ersetzen Sie es durch Ihr Geheimnis und `fileb://mykeystore.jks` durch den Pfad zu Ihrem Keystore-JKS-Zertifikat.

   ```
   aws secretsmanager create-secret \ 
   --name livy-jks-secret \
   --description "My Livy keystore JKS secret" \
   --secret-binary fileb://mykeystore.jks
   ```

1. Speichern Sie den Keystore und das Schlüsselkennwort in Secrets Manager. Stellen Sie sicher, dass Sie Ihre eigenen Parameter verwenden.

   ```
   aws secretsmanager create-secret \
   --name livy-jks-secret \
   --description "My Livy key and keystore password secret" \
   --secret-string "{\"keyPassword\":\"<test-key-password>\",\"keyStorePassword\":\"<test-key-store-password>\"}"
   ```

1. Erstellen Sie mit dem folgenden Befehl einen Livy-Server-Namespace.

   ```
   kubectl create ns <livy-ns>
   ```

1. Erstellen Sie das `ServiceProviderClass` Objekt für den Livy-Server, der über das JKS-Zertifikat und die Passwörter verfügt.

   ```
   cat >livy-secret-provider-class.yaml << EOF
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: aws-secrets
   spec:
     provider: aws
     parameters:
       objects: |
           - objectName: "livy-jks-secret"
             objectType: "secretsmanager"
           - objectName: "livy-passwords"
             objectType: "secretsmanager"
                        
   EOF
   kubectl apply -f livy-secret-provider-class.yaml -n <livy-ns>
   ```

## Erste Schritte mit dem SSL-fähigen Apache Livy
<a name="job-runs-apache-livy-ssl-enabled-getting-started"></a>

Nachdem Sie SSL auf Ihrem Livy-Server aktiviert haben, müssen Sie das einrichten, um Zugriff auf die und `serviceAccount` Secrets auf zu haben. `keyStore` `keyPasswords` AWS Secrets Manager

1. Erstellen Sie den Livy-Server-Namespace.

   ```
   kubectl create namespace <livy-ns>
   ```

1. Richten Sie das Livy-Dienstkonto ein, um Zugriff auf die Geheimnisse im Secrets Manager zu haben. Weitere Informationen zur Einrichtung von IRSA finden Sie unter [IRSA während der Installation von Apache Livy einrichten](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html#job-runs-apache-livy-irsa).

   ```
   aws ecr get-login-password \--region region-id | helm registry login \
   --username AWS \
   --password-stdin ECR-registry-account.dkr.ecr.region-id.amazonaws.com
   ```

1. Installieren Sie Livy. Verwenden Sie für den Parameter Helm chart --version Ihr Amazon EMR-Release-Label, z. B. `7.1.0` Sie müssen auch die Amazon ECR-Registrierungskonto-ID und die Region-ID durch Ihre eigene IDs ersetzen. Sie können den entsprechenden `ECR-registry-account` Wert für Ihre AWS-Region [Amazon ECR-Registrierungskonten nach Regionen](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR) suchen.

   ```
   helm install <livy-app-name> \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-namespace-name \
     --set image=<ECR-registry-account.dkr.ecr>.<region>.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=spark-namespace \
     --set ssl.enabled=true
     --set ssl.CertificateArn=livy-acm-certificate-arn
     --set ssl.secretProviderClassName=aws-secrets
     --set ssl.keyStoreObjectName=livy-jks-secret
     --set ssl.keyPasswordsObjectName=livy-passwords
     --create-namespace
   ```

1. Fahren Sie mit Schritt 5 der [Installation von Apache Livy auf Amazon EMR auf](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html#job-runs-apache-livy-install) EKS fort.

# Einrichtung der Anwendungsberechtigungen für Apache Livy und Spark mit rollenbasierter Zugriffskontrolle (RBAC)
<a name="job-runs-apache-livy-rbac"></a>

Um Livy bereitzustellen, erstellt Amazon EMR auf EKS ein Serverdienstkonto und eine Serverdienstrolle sowie ein Spark-Servicekonto und eine Rolle. Diese Rollen müssen über die erforderlichen RBAC-Berechtigungen verfügen, um die Einrichtung abzuschließen und Spark-Anwendungen auszuführen.

**RBAC-Berechtigungen für das Serverdienstkonto und die Serverrolle**

Amazon EMR on EKS erstellt das Livy-Serverdienstkonto und die Rolle zur Verwaltung von Livy-Sitzungen für Spark-Jobs und zur Weiterleitung von Datenverkehr zu und von den Eingangs- und anderen Ressourcen.

Der Standardname für dieses Servicekonto lautet `emr-containers-sa-livy`. Es muss über die folgenden Berechtigungen verfügen.

```
rules:
- apiGroups:
  - ""
  resources:
  - "namespaces"
  verbs:
  - "get"
- apiGroups:
  - ""
  resources:
  - "serviceaccounts"
    "services"
    "configmaps"
    "events"
    "pods"
    "pods/log"
  verbs:
  - "get"
    "list"
    "watch"
    "describe"
    "create"
    "edit"
    "delete"
    "deletecollection"
    "annotate"
    "patch"
    "label"
 - apiGroups:
   - ""
   resources:
   - "secrets"
   verbs:
   - "create"
     "patch"
     "delete"
     "watch"
 - apiGroups:
   - ""
   resources:
   - "persistentvolumeclaims"
   verbs:
   - "get"
     "list"
     "watch"
     "describe"
     "create"
     "edit"
     "delete"
     "annotate"
     "patch"
     "label"
```

**RBAC-Berechtigungen für das Spark-Dienstkonto und die Spark-Rolle**

Ein Spark-Treiber-Pod benötigt ein Kubernetes-Servicekonto im selben Namespace wie der Pod. Dieses Dienstkonto benötigt Berechtigungen zur Verwaltung von Executor-Pods und allen Ressourcen, die für den Treiber-Pod benötigt werden. Sofern das Standarddienstkonto im Namespace nicht über die erforderlichen Berechtigungen verfügt, schlägt der Treiber fehl und wird beendet. Die folgenden RBAC-Berechtigungen sind erforderlich.

```
rules:
- apiGroups:
  - ""
    "batch"
    "extensions"
    "apps"
  resources:
  - "configmaps"
    "serviceaccounts"
    "events"
    "pods"
    "pods/exec"
    "pods/log"
    "pods/portforward"
    "secrets"
    "services"
    "persistentvolumeclaims"
    "statefulsets"
  verbs:
  - "create"
    "delete"
    "get"
    "list"
    "patch"
    "update"
    "watch"
    "describe"
    "edit"
    "deletecollection"
    "patch"
    "label"
```

# Einrichtung von Zugriffsberechtigungen mit IAM-Rollen für Dienstkonten (IRSA)
<a name="job-runs-apache-livy-irsa"></a>

Standardmäßig haben der Livy-Server und die Treiber und Executoren der Spark-Anwendung keinen Zugriff auf Ressourcen. AWS Das Serverdienstkonto und das Spark-Dienstkonto steuern den Zugriff auf AWS Ressourcen für den Livy-Server und die Pods der Spark-Anwendung. Um Zugriff zu gewähren, müssen Sie die Dienstkonten einer IAM-Rolle zuordnen, die über die erforderlichen AWS Berechtigungen verfügt.

Sie können die IRSA-Zuordnung vor der Installation von Apache Livy, während der Installation oder nach Abschluss der Installation einrichten.

## IRSA während der Installation von Apache Livy einrichten (für ein Serverdienstkonto)
<a name="job-runs-apache-livy-irsa"></a>

**Anmerkung**  
Diese Zuordnung wird nur für das Serverdienstkonto unterstützt.

1. Stellen Sie sicher, dass Sie die [Einrichtung von Apache Livy für Amazon EMR auf EKS abgeschlossen haben und gerade](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) dabei sind, [Apache Livy mit Amazon EMR auf EKS zu installieren](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html). 

1. Erstellen Sie einen Kubernetes-Namespace für den Livy-Server. In diesem Beispiel lautet der Name des Namespaces. `livy-ns`

1. Erstellen Sie eine IAM-Richtlinie, die die Berechtigungen AWS-Services für die enthält, auf die Ihre Pods zugreifen sollen. Im folgenden Beispiel wird eine IAM-Richtlinie zum Abrufen von Amazon S3 S3-Ressourcen für den Spark-Einstiegspunkt erstellt.

   ```
   cat >my-policy.json <<EOF{
   "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-spark-entrypoint-bucket"
           }
       ]
   }
   EOF
   
   aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
   ```

1. Verwenden Sie den folgenden Befehl, um Ihre AWS-Konto ID auf eine Variable festzulegen.

   ```
   account_id=$(aws sts get-caller-identity --query "Account" --output text)
   ```

1. Setzen Sie den OpenID Connect (OIDC) -Identitätsanbieter Ihres Clusters auf eine Umgebungsvariable.

   ```
   oidc_provider=$(aws eks describe-cluster --name my-cluster --region $AWS_REGION --query "cluster.identity.oidc.issuer" --output text | sed -e "s/^https:\/\///")
   ```

1. Legen Sie Variablen für den Namespace und den Namen des Servicekontos fest. Achten Sie darauf, Ihre eigenen Werte zu verwenden.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Erstellen Sie mit dem folgenden Befehl eine Vertrauensrichtliniendatei. Wenn Sie allen Dienstkonten in einem Namespace Zugriff auf die Rolle gewähren möchten, kopieren Sie den folgenden Befehl und ersetzen Sie ihn durch `StringLike` und `StringEquals` `$service_account` ersetzen `*` Sie ihn durch.

   ```
   cat >trust-relationship.json <<EOF
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::$account_id:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   EOF
   ```

1. Erstellen Sie die Rolle.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Verwenden Sie den folgenden Helm-Installationsbefehl, um die IRSA `serviceAccount.executionRoleArn` auf die Zuordnung festzulegen. Das Folgende ist ein Beispiel für den Befehl Helm install. Sie können den entsprechenden `ECR-registry-account` Wert für Ihre AWS-Region [Amazon ECR-Registrierungskonten nach Regionen](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR) suchen.

   ```
   helm install livy-demo \
     oci://895885662937.dkr.ecr.us-west-2.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-ns \
     --set image=ECR-registry-account.dkr.ecr.region-id.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=spark-ns \
     --set serviceAccount.executionRoleArn=arn:aws:iam::123456789012:role/my-role
   ```

## Zuordnung von IRSA zu einem Spark-Dienstkonto
<a name="job-runs-apache-livy-irsa-spark"></a>

Bevor Sie IRSA einem Spark-Dienstkonto zuordnen, stellen Sie sicher, dass Sie die folgenden Schritte abgeschlossen haben:
+ Stellen Sie sicher, dass Sie die [Einrichtung von Apache Livy für Amazon EMR auf EKS abgeschlossen haben und gerade](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) dabei sind, [Apache Livy mit Amazon EMR auf EKS zu installieren](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html). 
+ Sie müssen über einen vorhandenen IAM OpenID Connect (OIDC) -Anbieter für Ihren Cluster verfügen. Informationen darüber, ob Sie bereits einen haben oder wie Sie einen erstellen, finden Sie unter [Erstellen eines IAM-OIDC-Anbieters](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) für Ihren Cluster.
+ Stellen Sie sicher, dass Sie Version 0.171.0 oder höher der `eksctl` CLI installiert haben oder. AWS CloudShell Informationen zur Installation oder Aktualisierung `eksctl` finden Sie unter [Installation](https://eksctl.io/installation/) der `eksctl` Dokumentation.

Gehen Sie wie folgt vor, um IRSA Ihrem Spark-Dienstkonto zuzuordnen:

1. Verwenden Sie den folgenden Befehl, um das Spark-Dienstkonto abzurufen.

   ```
   SPARK_NAMESPACE=<spark-ns>
   LIVY_APP_NAME=<livy-app-name>
   kubectl --namespace $SPARK_NAMESPACE describe sa -l "app.kubernetes.io/instance=$LIVY_APP_NAME" | awk '/^Name:/ {print $2}'
   ```

1. Legen Sie Ihre Variablen für den Namespace und den Namen des Dienstkontos fest.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Verwenden Sie den folgenden Befehl, um eine Vertrauensrichtliniendatei für die IAM-Rolle zu erstellen. Das folgende Beispiel erteilt allen Dienstkonten innerhalb des Namespace die Erlaubnis, die Rolle zu verwenden. Ersetzen Sie dazu durch `StringLike` und `StringEquals` ersetzen Sie es `$service_account` durch \$1.

   ```
   cat >trust-relationship.json <<EOF
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::$account_id:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   EOF
   ```

1. Erstellen Sie die Rolle.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Ordnen Sie das Server- oder Spark-Dienstkonto mit dem folgenden `eksctl` Befehl zu. Stellen Sie sicher, dass Sie Ihre eigenen Werte verwenden.

   ```
    eksctl create iamserviceaccount --name spark-sa \
    --namespace spark-namespace --cluster livy-eks-cluster \
    --attach-role-arn arn:aws:iam::0123456789012:role/my-role \
    --approve --override-existing-serviceaccounts
   ```