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.

# Verwenden von Apache Livy mit Amazon EMR auf EKS
<a name="job-runs-apache-livy"></a>

Mit Amazon EMR-Versionen 7.1.0 und höher können Sie Apache Livy verwenden, um Jobs auf Amazon EMR auf EKS einzureichen. Mit Apache Livy können Sie Ihren eigenen Apache Livy REST-Endpunkt einrichten und ihn verwenden, um Spark-Anwendungen auf Ihren Amazon EKS-Clustern bereitzustellen und zu verwalten. Nachdem Sie Livy in Ihrem Amazon EKS-Cluster installiert haben, können Sie den Livy-Endpunkt verwenden, um Spark-Anwendungen an Ihren Livy-Server zu senden. Der Server verwaltet den Lebenszyklus der Spark-Anwendungen.

**Anmerkung**  
Amazon EMR berechnet die Preise für Amazon EKS auf der Grundlage des vCPU- und Speicherverbrauchs. Diese Berechnung gilt für Treiber- und Executor-Pods. Diese Berechnung beginnt mit dem Herunterladen Ihres Amazon EMR-Anwendungsabbilds, bis der Amazon EKS-Pod endet und auf die nächste Sekunde gerundet wird.

**Topics**
+ [Apache Livy für Amazon EMR auf EKS einrichten](job-runs-apache-livy-setup.md)
+ [Erste Schritte mit Apache Livy auf Amazon EMR auf EKS](job-runs-apache-livy-install.md)
+ [Ausführen einer Spark-Anwendung mit Apache Livy für Amazon EMR auf EKS](job-runs-apache-livy-run-spark.md)
+ [Deinstallation von Apache Livy mit Amazon EMR auf EKS](job-runs-apache-livy-uninstall.md)
+ [Sicherheit für Apache Livy mit Amazon EMR auf EKS](job-runs-apache-livy-security.md)
+ [Installationseigenschaften für Apache Livy auf Amazon EMR auf EKS-Versionen](job-runs-apache-livy-installation-properties.md)
+ [Beheben Sie häufig auftretende Formatfehler bei Umgebungsvariablen](job-runs-apache-livy-troubleshooting.md)

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

Bevor Sie Apache Livy auf Ihrem Amazon EKS-Cluster installieren können, müssen Sie eine Reihe von erforderlichen Tools installieren und konfigurieren. Dazu gehören der AWS CLI, ein grundlegendes Befehlszeilentool für die Arbeit mit AWS Ressourcen, Befehlszeilentools für die Arbeit mit Amazon EKS und ein Controller, der in diesem Anwendungsfall verwendet wird, um Ihre Cluster-Anwendung im Internet verfügbar zu machen und den Netzwerkverkehr weiterzuleiten.
+ **[Installation oder Aktualisierung auf die neueste Version von AWS CLI— Falls Sie die](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)** bereits installiert haben, vergewissern Sie sich AWS CLI, dass Sie über die neueste Version verfügen.
+ **[Richten Sie kubectl und eksctl ein — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)** ist ein Befehlszeilentool, das Sie für die Kommunikation mit Amazon EKS verwenden.
+ **[Helm installieren](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)** – Der Helm-Paketmanager für Kubernetes unterstützt Sie bei der Installation und Verwaltung von Anwendungen in Ihrem Kubernetes-Cluster. 
+ **[Erste Schritte mit Amazon EKS — eksctl —](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)** Folgen Sie den Schritten, um einen neuen Kubernetes-Cluster mit Knoten in Amazon EKS zu erstellen.
+ **[Wählen Sie ein Amazon EMR-Release-Label](docker-custom-images-tag.md)** aus — Apache Livy wird von Amazon EMR-Versionen 7.1.0 und höher unterstützt.
+ **[Installieren Sie den ALB-Controller](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html)** — Der ALB-Controller verwaltet AWS Elastic Load Balancing für Kubernetes-Cluster. Es erstellt einen AWS Network Load Balancer (NLB), wenn Sie bei der Einrichtung von Apache Livy einen Kubernetes-Ingress erstellen.

# Erste Schritte mit Apache Livy auf Amazon EMR auf EKS
<a name="job-runs-apache-livy-install"></a>

Gehen Sie wie folgt vor, um Apache Livy zu installieren. Dazu gehören die Konfiguration des Paketmanagers, die Erstellung eines Namespaces für die Ausführung von Spark-Workloads, die Installation von Livy, die Einrichtung des Lastenausgleichs und die Schritte zur Überprüfung. Sie müssen diese Schritte ausführen, um einen Batch-Job mit Spark auszuführen.

1. Falls Sie es noch nicht getan haben, richten Sie [Apache Livy für Amazon EMR auf](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) EKS ein.

1. Authentifizieren Ihren Helm-Client in Ihrer Amazon-ECR-Registry. 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.

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

1. Durch die Einrichtung von Livy wird ein Dienstkonto für den Livy-Server und ein weiteres Konto für die Spark-Anwendung erstellt. Informationen zum Einrichten von IRSA für die Dienstkonten finden Sie unter [Einrichten von Zugriffsberechtigungen mit IAM-Rollen für Dienstkonten](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html) (IRSA). 

1. Erstellen Sie einen Namespace, um Ihre Spark-Workloads auszuführen.

   ```
   kubectl create ns <spark-ns>
   ```

1. Verwenden Sie den folgenden Befehl, um Livy zu installieren.

   Dieser Livy-Endpunkt ist nur intern für die VPC im EKS-Cluster verfügbar. Um den Zugriff über die VPC hinaus zu ermöglichen, geben Sie `—-set loadbalancer.internal=false` Ihren Helm-Installationsbefehl ein.
**Anmerkung**  
Standardmäßig ist SSL in diesem Livy-Endpunkt nicht aktiviert und der Endpunkt ist nur innerhalb der VPC des EKS-Clusters sichtbar. Wenn Sie `loadbalancer.internal=false` und festlegen`ssl.enabled=false`, setzen Sie einen unsicheren Endpunkt außerhalb Ihrer VPC offen. Informationen zum Einrichten eines sicheren Livy-Endpunkts finden Sie unter [Konfiguration eines sicheren Apache Livy-Endpunkts mit TLS/SSL](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html). 

   ```
   helm install livy-demo \
     oci://895885662937.dkr.ecr.region-id.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> \
     --create-namespace
   ```

   Die Ausgabe sollte folgendermaßen aussehen.

   ```
   NAME: livy-demo
   LAST DEPLOYED: Mon Mar 18 09:23:23 2024
   NAMESPACE: livy-ns
   STATUS: deployed
   REVISION: 1
   TEST SUITE: None
   NOTES:
   The Livy server has been installed.
   Check installation status:
   1. Check Livy Server pod is running
     kubectl --namespace livy-ns get pods -l "app.kubernetes.io/instance=livy-demo"
   2. Verify created NLB is in Active state and it's target groups are healthy (if loadbalancer.enabled is true)
   
   Access LIVY APIs:
       # Ensure your NLB is active and healthy
       # Get the Livy endpoint using command:
       LIVY_ENDPOINT=$(kubectl get svc -n livy-ns -l app.kubernetes.io/instance=livy-demo,emr-containers.amazonaws.com/type=loadbalancer -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}' |  awk '{printf "%s:8998\n", $0}')
       # Access Livy APIs using http://$LIVY_ENDPOINT or https://$LIVY_ENDPOINT (if SSL is enabled)
       # Note: While uninstalling Livy, makes sure the ingress and NLB are deleted after running the helm command to avoid dangling resources
   ```

   Die Standardnamen der Dienstkonten für den Livy-Server und die Spark-Sitzung lauten und. `emr-containers-sa-livy` `emr-containers-sa-spark-livy` Um benutzerdefinierte Namen zu verwenden, verwenden Sie die `sparkServiceAccount.name` Parameter `serviceAccounts.name` und.

   ```
   --set serviceAccounts.name=my-service-account-for-livy
   --set sparkServiceAccount.name=my-service-account-for-spark
   ```

1. Stellen Sie sicher, dass Sie das Helm-Diagramm installiert haben.

   ```
   helm list -n livy-ns -o yaml
   ```

   Der `helm list` Befehl sollte Informationen über Ihr neues Helm-Diagramm zurückgeben.

   ```
   app_version: 0.7.1-incubating
   chart: livy-emr-7.12.0
   name: livy-demo
   namespace: livy-ns
   revision: "1"
   status: deployed
   updated: 2024-02-08 22:39:53.539243 -0800 PST
   ```

1. Stellen Sie sicher, dass der Network Load Balancer aktiv ist.

   ```
   LIVY_NAMESPACE=<livy-ns>
   LIVY_APP_NAME=<livy-app-name>
   AWS_REGION=<AWS_REGION>
   
   # Get the NLB Endpoint URL
   NLB_ENDPOINT=$(kubectl --namespace $LIVY_NAMESPACE get svc -l "app.kubernetes.io/instance=$LIVY_APP_NAME,emr-containers.amazonaws.com/type=loadbalancer" -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}') 
   
   # Get all the load balancers in the account's region
   ELB_LIST=$(aws elbv2 describe-load-balancers --region $AWS_REGION)
   
   # Get the status of the NLB that matching the endpoint from the Kubernetes service
   NLB_STATUS=$(echo $ELB_LIST | grep -A 8 "\"DNSName\": \"$NLB_ENDPOINT\"" | awk '/Code/{print $2}/}/' | tr -d '"},\n')
   echo $NLB_STATUS
   ```

1. Stellen Sie nun sicher, dass die Zielgruppe im Network Load Balancer fehlerfrei ist.

   ```
   LIVY_NAMESPACE=<livy-ns>
   LIVY_APP_NAME=<livy-app-name>
   AWS_REGION=<AWS_REGION>
   
   # Get the NLB endpoint
   NLB_ENDPOINT=$(kubectl --namespace $LIVY_NAMESPACE get svc -l "app.kubernetes.io/instance=$LIVY_APP_NAME,emr-containers.amazonaws.com/type=loadbalancer" -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}') 
   
   # Get all the load balancers in the account's region
   ELB_LIST=$(aws elbv2 describe-load-balancers --region $AWS_REGION)
   
   # Get the NLB ARN from the NLB endpoint
   NLB_ARN=$(echo $ELB_LIST | grep -B 1 "\"DNSName\": \"$NLB_ENDPOINT\"" | awk '/"LoadBalancerArn":/,/"/'| awk '/:/{print $2}' | tr -d \",)
   
   # Get the target group from the NLB. Livy setup only deploys 1 target group
   TARGET_GROUP_ARN=$(aws elbv2 describe-target-groups --load-balancer-arn $NLB_ARN --region $AWS_REGION | awk '/"TargetGroupArn":/,/"/'| awk '/:/{print $2}' | tr -d \",)
   
   # Get health of target group
   aws elbv2 describe-target-health --target-group-arn $TARGET_GROUP_ARN
   ```

   Im Folgenden finden Sie eine Beispielausgabe, die den Status der Zielgruppe zeigt:

   ```
   {
       "TargetHealthDescriptions": [
           {
               "Target": {
                   "Id": "<target IP>",
                   "Port": 8998,
                   "AvailabilityZone": "us-west-2d"
               },
               "HealthCheckPort": "8998",
               "TargetHealth": {
                   "State": "healthy"
               }
           }
       ]
   }
   ```

   Sobald der Status Ihrer NLB den `active` Status Ihrer Zielgruppe erreicht hat`healthy`, können Sie fortfahren. Dies kann ein paar Minuten dauern.

1. Rufen Sie den Livy-Endpunkt aus der Helm-Installation ab. Ob Ihr Livy-Endpunkt sicher ist oder nicht, hängt davon ab, ob Sie SSL aktiviert haben.

   ```
   LIVY_NAMESPACE=<livy-ns>
    LIVY_APP_NAME=livy-app-name
    LIVY_ENDPOINT=$(kubectl get svc -n livy-ns -l app.kubernetes.io/instance=livy-app-name,emr-containers.amazonaws.com/type=loadbalancer -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}' |  awk '{printf "%s:8998\n", $0}')
    echo "$LIVY_ENDPOINT"
   ```

1. Rufen Sie das Spark-Dienstkonto aus der Helm-Installation ab

   ```
   SPARK_NAMESPACE=spark-ns
   LIVY_APP_NAME=<livy-app-name>
   SPARK_SERVICE_ACCOUNT=$(kubectl --namespace $SPARK_NAMESPACE get sa -l "app.kubernetes.io/instance=$LIVY_APP_NAME" -o jsonpath='{.items[0].metadata.name}')
   echo "$SPARK_SERVICE_ACCOUNT"
   ```

   Die Ausgabe sollte der folgenden Ausgabe ähneln:

   ```
   emr-containers-sa-spark-livy
   ```

1. Wenn Sie `internalALB=true` den Zugriff von außerhalb Ihrer VPC aktivieren möchten, erstellen Sie eine EC2 Amazon-Instance und stellen Sie sicher, dass der Network Load Balancer Netzwerkverkehr von der EC2 Instance zulässt. Sie müssen dies tun, damit die Instance Zugriff auf Ihren Livy-Endpunkt hat. Weitere Informationen zur sicheren Bereitstellung Ihres Endpunkts außerhalb Ihrer VPC finden Sie unter [Einrichtung eines sicheren Apache Livy-Endpunkts mit](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html) TLS/SSL.

1. Durch die Installation von Livy wird das Dienstkonto für die Ausführung von Spark-Anwendungen erstellt. `emr-containers-sa-spark` Wenn Ihre Spark-Anwendung AWS Ressourcen wie S3 verwendet oder AWS API- oder CLI-Operationen aufruft, müssen Sie eine IAM-Rolle mit den erforderlichen Berechtigungen mit Ihrem Spark-Dienstkonto verknüpfen. Weitere Informationen finden Sie unter [Einrichten von Zugriffsberechtigungen mit IAM-Rollen für Dienstkonten (IRSA](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)).

Apache Livy unterstützt zusätzliche Konfigurationen, die Sie bei der Installation von Livy verwenden können. Weitere Informationen finden Sie unter Installationseigenschaften für Apache Livy auf Amazon EMR auf EKS-Versionen.

# Ausführen einer Spark-Anwendung mit Apache Livy für Amazon EMR auf EKS
<a name="job-runs-apache-livy-run-spark"></a>

Bevor Sie eine Spark-Anwendung mit Apache Livy ausführen können, stellen Sie sicher, dass Sie die Schritte unter [Apache Livy für Amazon EMR auf EKS einrichten](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) und [Erste Schritte mit Apache Livy für Amazon](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) EMR auf EKS ausgeführt haben.

Sie können Apache Livy verwenden, um zwei Arten von Anwendungen auszuführen:
+ Batch-Sitzungen — eine Art von Livy-Workload zum Senden von Spark-Batch-Jobs.
+ Interaktive Sitzungen — eine Art von Livy-Workload, der eine programmatische und visuelle Oberfläche zur Ausführung von Spark-Abfragen bietet.

**Anmerkung**  
Treiber- und Executor-Pods aus verschiedenen Sitzungen können miteinander kommunizieren. Namespaces garantieren keine Sicherheit zwischen Pods. Kubernetes erlaubt keine selektiven Berechtigungen für eine Teilmenge von Pods innerhalb eines bestimmten Namespace.

## Batch-Sitzungen ausführen
<a name="job-runs-apache-livy-run-spark-batch"></a>

Verwenden Sie den folgenden Befehl, um einen Batch-Job zu senden.

```
curl -s -k -H 'Content-Type: application/json' -X POST \
      -d '{
            "name": "my-session",
            "file": "entryPoint_location (S3 or local)",
            "args": ["argument1", "argument2", ...],
            "conf": {
                "spark.kubernetes.namespace": "<spark-namespace>",
                "spark.kubernetes.container.image": "public.ecr.aws/emr-on-eks/spark/emr-7.12.0:latest",
                "spark.kubernetes.authenticate.driver.serviceAccountName": "<spark-service-account>"
            }
          }' <livy-endpoint>/batches
```

Verwenden Sie den folgenden Befehl, um Ihren Batch-Job zu überwachen.

```
curl -s -k -H 'Content-Type: application/json' -X GET <livy-endpoint>/batches/my-session
```

## Interaktive Sitzungen ausführen
<a name="job-runs-apache-livy-run-spark-interactive"></a>

Gehen Sie wie folgt vor, um interaktive Sitzungen mit Apache Livy auszuführen.

1. Stellen Sie sicher, dass Sie Zugriff auf ein selbst gehostetes oder ein verwaltetes Jupyter-Notebook haben, z. B. ein KI-Jupyter-Notebook. SageMaker [Auf Ihrem Jupyter-Notebook muss Sparkmagic installiert sein.](https://github.com/jupyter-incubator/sparkmagic/blob/master/README.md)

1. Erstellen Sie einen Bucket für die Spark-Konfiguration. `spark.kubernetes.file.upload.path` Stellen Sie sicher, dass das Spark-Dienstkonto Lese- und Schreibzugriff auf den Bucket hat. Weitere Informationen zur Konfiguration Ihres Spark-Dienstkontos finden Sie unter Einrichten von Zugriffsberechtigungen mit IAM-Rollen für Dienstkonten (IRSA)

1. Laden Sie sparkmagic mit dem Befehl in das Jupyter-Notebook. `%load_ext sparkmagic.magics`

1. Führen Sie den Befehl aus`%manage_spark`, um Ihren Livy-Endpunkt mit dem Jupyter-Notebook einzurichten. **Wählen Sie die Registerkarte **Endpunkte hinzufügen**, wählen Sie den konfigurierten Authentifizierungstyp aus, fügen Sie den Livy-Endpunkt zum Notizbuch hinzu und wählen Sie dann Endpunkt hinzufügen.**

1. **Führen Sie den `%manage_spark` Vorgang erneut aus, um den Spark-Kontext zu erstellen, und wechseln Sie dann zur Sitzung erstellen.** Wählen Sie den Livy-Endpunkt, geben Sie einen eindeutigen Sitzungsnamen an, wählen Sie eine Sprache und fügen Sie dann die folgenden Eigenschaften hinzu.

   ```
   {
     "conf": {
       "spark.kubernetes.namespace": "livy-namespace",
       "spark.kubernetes.container.image": "public.ecr.aws/emr-on-eks/spark/emr-7.12.0:latest",
       "spark.kubernetes.authenticate.driver.serviceAccountName": "<spark-service-account>", 
       "spark.kubernetes.file.upload.path": "<URI_TO_S3_LOCATION_>"
     }
   }
   ```

1. Reichen Sie die Anwendung ein und warten Sie, bis sie den Spark-Kontext erstellt hat.

1. Führen Sie den folgenden Befehl aus, um den Status der interaktiven Sitzung zu überwachen.

   ```
   curl -s -k -H 'Content-Type: application/json' -X GET livy-endpoint/sessions/my-interactive-session
   ```

## Überwachung von Spark-Anwendungen
<a name="job-runs-apache-livy-run-ui"></a>

Verwenden Sie den Link`http://<livy-endpoint>/ui`, um den Fortschritt Ihrer Spark-Anwendungen mit der Livy-Benutzeroberfläche zu überwachen.

# Deinstallation von Apache Livy mit Amazon EMR auf EKS
<a name="job-runs-apache-livy-uninstall"></a>

Gehen Sie wie folgt vor, um Apache Livy zu deinstallieren.

1. Löschen Sie das Livy-Setup mit den Namen Ihres Namespaces und des Anwendungsnamens. In diesem Beispiel lautet der Anwendungsname `livy-demo` und der Namespace ist. `livy-ns`

   ```
   helm uninstall livy-demo -n livy-ns
   ```

1. Bei der Deinstallation löscht Amazon EMR on EKS den Kubernetes-Service in Livy, die AWS Load Balancer und die Zielgruppen, die Sie während der Installation erstellt haben. Das Löschen von Ressourcen kann einige Minuten dauern. Stellen Sie sicher, dass die Ressourcen gelöscht wurden, bevor Sie Livy erneut im Namespace installieren.

1. Löschen Sie den Spark-Namespace.

   ```
   kubectl delete namespace spark-ns
   ```

# 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
   ```

# Installationseigenschaften für Apache Livy auf Amazon EMR auf EKS-Versionen
<a name="job-runs-apache-livy-installation-properties"></a>

Bei der Installation von Apache Livy können Sie eine Version des Livy Helm-Diagramms auswählen. Das Helm-Diagramm bietet eine Vielzahl von Eigenschaften, mit denen Sie Ihr Installations- und Einrichtungserlebnis individuell anpassen können. Diese Eigenschaften werden für Amazon EMR auf EKS-Versionen 7.1.0 und höher unterstützt.

**Topics**
+ [Amazon EMR 7.1.0-Installationseigenschaften](#job-runs-apache-livy-installation-properties-710)

## Amazon EMR 7.1.0-Installationseigenschaften
<a name="job-runs-apache-livy-installation-properties-710"></a>

In der folgenden Tabelle werden alle unterstützten Livy-Eigenschaften beschrieben. Bei der Installation von Apache Livy können Sie die Livy Helm-Diagrammversion wählen. Verwenden Sie den Befehl, um während der Installation eine Eigenschaft festzulegen. `--set <property>=<value>`


| Property (Eigenschaft) | Description (Beschreibung) | Standard | 
| --- | --- | --- | 
| Abbild | Die Amazon EMR-Release-URI des Livy-Servers. Dies ist eine erforderliche Konfiguration. | "" | 
| Spark-Namespace | Namespace zum Ausführen von Livy Spark-Sitzungen. Geben Sie beispielsweise „Livy“ an. Dies ist eine erforderliche Konfiguration. | "" | 
| NameOverride | Geben Sie einen Namen anstelle von livy ein. Der Name wird als Bezeichnung für alle Livy-Ressourcen festgelegt | „Livy“ | 
| Vollständiger Name überschreiben | Geben Sie einen Namen an, der anstelle der vollständigen Namen der Ressourcen verwendet werden soll. | "" | 
| ssl.aktiviert | Aktiviert end-to-end SSL vom Livy-Endpunkt zum Livy-Server. | FALSE | 
| SSL.CertificateN | Wenn SSL aktiviert ist, ist dies der vom Dienst erstellte ACM-Zertifikat-ARN für den NLB. | "" | 
| ssl. secretProviderClassName | Wenn SSL aktiviert ist, ist dies der geheime Anbieter-Klassenname zur Sicherung von NLB für die Livy-Serververbindung mit SSL. | "" | 
| ssl. keyStoreObjectName | Wenn SSL aktiviert ist, der Objektname für das Keystore-Zertifikat in der Secret-Provider-Klasse. | "" | 
| ssl. keyPasswordsObjectName | Wenn SSL aktiviert ist, der Objektname für das Geheimnis, das den Keystore und das Schlüsselkennwort enthält. | "" | 
| rbac.create | Falls wahr, werden RBAC-Ressourcen erstellt. | FALSE | 
| ServiceAccount.Create | Falls wahr, wird ein Livy-Dienstkonto erstellt. | TRUE | 
| ServiceAccount.Name | Der Name des Dienstkontos, das für Livy verwendet werden soll. Wenn Sie diese Eigenschaft nicht festlegen und ein Servicekonto erstellen, generiert Amazon EMR auf EKS automatisch einen Namen mithilfe der fullname Override-Eigenschaft. | "emr-containers-sa-livy" | 
| Servicekonto. executionRoleArn | Der ARN für die Ausführungsrolle des Livy-Dienstkontos. | "" | 
| sparkServiceAccount.erstellen | FALLS wahr, erstellt das Spark-Dienstkonto in .Release.Namespace | TRUE | 
| sparkServiceAccount.name | Der Name des Dienstkontos, das für Spark verwendet werden soll. Wenn Sie diese Eigenschaft nicht festlegen und ein Spark-Servicekonto erstellen, generiert Amazon EMR auf EKS automatisch einen Namen mit der fullnameOverride Eigenschaft mit -spark-livy Suffix. | „-livy“ emr-containers-sa-spark | 
| Dienstname | Name des Livy-Dienstes | "emr-containers-livy" | 
| service.annotations | Anmerkungen zum Livy-Service | \$1\$1 | 
| loadbalancer.enabled | Ob ein Load Balancer für den Livy-Service erstellt werden soll, der verwendet wird, um den Livy-Endpunkt außerhalb des Amazon EKS-Clusters verfügbar zu machen. | FALSE | 
| loadbalancer.internal | Ob der Livy-Endpunkt als intern in der VPC oder extern konfiguriert werden soll. Wenn Sie diese Eigenschaft auf setzen`FALSE`, wird der Endpunkt Quellen außerhalb der VPC zugänglich gemacht. Wir empfehlen, Ihren Endpunkt mit TLS/SSL zu sichern. Weitere Informationen finden Sie unter [TLS- und SSL-Verschlüsselung einrichten](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-security.html#job-runs-apache-livy-security-tls). | FALSE | 
| imagePullSecrets | Die Liste der imagePullSecret Namen, die verwendet werden sollen, um das Livy-Image aus privaten Repositorys abzurufen. | [] | 
| Ressourcen | Die Ressourcenanforderungen und Grenzwerte für Livy-Container. | \$1\$1 | 
| nodeSelector | Die Knoten, für die Livy-Pods geplant werden sollen. | \$1\$1 | 
| Toleranzen | Eine Liste mit den zu definierenden Toleranzen für Livy-Pods. | [] | 
| Affinität | Die Affinitätsregeln der Livy Pods. | \$1\$1 | 
| Persistenz.aktiviert | Wenn der Wert true ist, wird die Persistenz für Sitzungsverzeichnisse aktiviert. | FALSE | 
| persistence.subPath | Der PVC-Unterpfad, der in Sitzungsverzeichnisse eingebunden werden soll. | "" | 
| Persistence.ExistingClaim | Das PVC, das verwendet werden soll, anstatt ein neues zu erstellen. | \$1\$1 | 
| persistence.storageClass | Die zu verwendende Speicherklasse. Verwenden Sie das Format, um diesen Parameter zu definierenstorageClassName: <storageClass>. Wenn Sie diesen Parameter auf einstellen, wird die dynamische Bereitstellung "-" deaktiviert. Wenn Sie diesen Parameter auf Null setzen oder nichts angeben, legt Amazon EMR on EKS keinen Wert fest storageClassName und verwendet den Standard-Provisioner. | "" | 
| persistence.AccessMode | Der PVC-Zugriffsmodus. | ReadWriteOnce | 
| persistence.size | Die PVC-Größe. | 20 Gi | 
| Persistenz. Anmerkungen | Zusätzliche Anmerkungen für das PVC. | \$1\$1 | 
| Umgebung. \$1 | Zusätzliche Umgebungen, die auf den Livy-Container gesetzt werden sollen. Weitere Informationen finden Sie unter [Eingabe Ihrer eigenen Livy- und Spark-Konfigurationen während der Installation von Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-troubleshooting.html). | \$1\$1 | 
| Umgebung von. \$1 | Zusätzliche Umgebungen, die aus einer Kubernetes-Konfigurationsmap oder einem Secret auf Livy gesetzt werden können. | [] | 
| LivyConf. \$1 | Zusätzliche livy.conf-Einträge, die aus einer bereitgestellten Kubernetes-Konfigurationsübersicht oder einem geheimen Schlüssel gesetzt werden können. | \$1\$1 | 
| sparkDefaultsConf.\$1 | Zusätzliche spark-defaults.conf Einträge, die aus einer bereitgestellten Kubernetes-Konfigurationsübersicht oder einem geheimen Schlüssel gesetzt werden können. | \$1\$1 | 

# Beheben Sie häufig auftretende Formatfehler bei Umgebungsvariablen
<a name="job-runs-apache-livy-troubleshooting"></a>

Wenn Sie Livy- und Spark-Konfigurationen eingeben, gibt es Formate mit Umgebungsvariablen, die nicht unterstützt werden und Fehler verursachen können. Das Verfahren führt Sie durch eine Reihe von Schritten, um sicherzustellen, dass Sie die richtigen Formate verwenden.

**Geben Sie bei der Installation von Livy Ihre eigenen Livy- und Spark-Konfigurationen ein**

Sie können jede Apache Livy- oder Apache Spark-Umgebungsvariable mit der Helm-Eigenschaft konfigurieren. `env.*` Gehen Sie wie folgt vor, um die Beispielkonfiguration in ein unterstütztes Umgebungsvariablenformat `example.config.with-dash.withUppercase` zu konvertieren.

1. Ersetzen Sie Großbuchstaben durch eine 1 und einen Kleinbuchstaben des Buchstabens. Beispielsweise wird `example.config.with-dash.withUppercase` zu `example.config.with-dash.with1uppercase`.

1. Ersetzen Sie Bindestriche (-) durch 0. Zum Beispiel wird `example.config.with-dash.with1uppercase` `example.config.with0dash.with1uppercase`

1. Ersetzt Punkte (.) durch Unterstriche (\$1). Beispielsweise wird `example.config.with0dash.with1uppercase` zu `example_config_with0dash_with1uppercase`.

1. Ersetze alle Kleinbuchstaben durch Großbuchstaben.

1. Fügen Sie dem Variablennamen `LIVY_` das Präfix hinzu.

1. Verwenden Sie die Variable bei der Installation von Livy über das Helmchart im Format --set env. *YOUR\$1VARIABLE\$1NAME*.value= *yourvalue*

Um beispielsweise die Livy- und Spark-Konfigurationen festzulegen und diese `livy.server.recovery.state-store = filesystem` Helm-Eigenschaften `spark.kubernetes.executor.podNamePrefix = my-prefix` zu verwenden:

```
—set env.LIVY_LIVY_SERVER_RECOVERY_STATE0STORE.value=filesystem
—set env.LIVY_SPARK_KUBERNETES_EXECUTOR_POD0NAME0PREFIX.value=myprefix
```