Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menggunakan Apache Livy dengan Amazon EMR di EKS
<a name="job-runs-apache-livy"></a>

Dengan Amazon EMR rilis 7.1.0 dan yang lebih tinggi, Anda dapat menggunakan Apache Livy untuk mengirimkan pekerjaan di Amazon EMR di EKS. Menggunakan Apache Livy, Anda dapat mengatur titik akhir Apache Livy REST Anda sendiri dan menggunakannya untuk menyebarkan dan mengelola aplikasi Spark di kluster Amazon EKS Anda. Setelah Anda menginstal Livy di kluster Amazon EKS Anda, Anda dapat menggunakan titik akhir Livy untuk mengirimkan aplikasi Spark ke server Livy Anda. Server mengelola siklus hidup aplikasi Spark.

**catatan**  
Amazon EMR menghitung harga di Amazon EKS berdasarkan vCPU dan konsumsi memori. Perhitungan ini berlaku untuk pod driver dan executor. Perhitungan ini dimulai dari saat Anda mengunduh image aplikasi Amazon EMR hingga pod Amazon EKS berakhir dan dibulatkan ke detik terdekat.

**Topics**
+ [Menyiapkan Apache Livy untuk Amazon EMR di EKS](job-runs-apache-livy-setup.md)
+ [Memulai dengan Apache Livy di Amazon EMR di EKS](job-runs-apache-livy-install.md)
+ [Menjalankan aplikasi Spark dengan Apache Livy untuk Amazon EMR di EKS](job-runs-apache-livy-run-spark.md)
+ [Menghapus instalasi Apache Livy dengan Amazon EMR di EKS](job-runs-apache-livy-uninstall.md)
+ [Keamanan untuk Apache Livy dengan Amazon EMR di EKS](job-runs-apache-livy-security.md)
+ [Properti instalasi untuk Apache Livy di Amazon EMR pada rilis EKS](job-runs-apache-livy-installation-properties.md)
+ [Memecahkan masalah kesalahan format variabel lingkungan yang umum](job-runs-apache-livy-troubleshooting.md)

# Menyiapkan Apache Livy untuk Amazon EMR di EKS
<a name="job-runs-apache-livy-setup"></a>

Sebelum Anda dapat menginstal Apache Livy di kluster Amazon EKS Anda, Anda harus menginstal dan mengkonfigurasi satu set alat prasyarat. Ini termasuk AWS CLI, yang merupakan alat baris perintah dasar untuk bekerja dengan AWS sumber daya, alat baris perintah untuk bekerja dengan Amazon EKS, dan pengontrol yang digunakan dalam kasus penggunaan ini untuk membuat aplikasi cluster Anda tersedia ke internet dan untuk merutekan lalu lintas jaringan.
+ **[Instal atau perbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)** - Jika Anda sudah menginstal AWS CLI, konfirmasikan bahwa Anda memiliki versi terbaru.
+ **[Siapkan kubectl dan eksctl - eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)** adalah alat baris perintah yang Anda gunakan untuk berkomunikasi dengan Amazon EKS.
+ **[Instal Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)** — Manajer paket Helm untuk Kubernetes membantu Anda menginstal dan mengelola aplikasi di klaster Kubernetes Anda. 
+ **[Memulai Amazon EKS — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)** — Ikuti langkah-langkah untuk membuat cluster Kubernetes baru dengan node di Amazon EKS.
+ **[Pilih label rilis Amazon EMR](docker-custom-images-tag.md)** - Apache Livy didukung dengan rilis Amazon EMR 7.1.0 dan yang lebih tinggi.
+ **[Instal pengontrol ALB — pengontrol](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html)** ALB mengelola AWS Elastic Load Balancing untuk klaster Kubernetes. Ini menciptakan AWS Network Load Balancer (NLB) ketika Anda membuat Kubernetes Ingress saat menyiapkan Apache Livy.

# Memulai dengan Apache Livy di Amazon EMR di EKS
<a name="job-runs-apache-livy-install"></a>

Selesaikan langkah-langkah berikut untuk menginstal Apache Livy. Mereka termasuk mengonfigurasi manajer paket, membuat namespace untuk menjalankan beban kerja Spark, menginstal Livy, menyiapkan load balancing, dan langkah-langkah verifikasi. Anda harus menyelesaikan langkah-langkah ini untuk menjalankan pekerjaan batch dengan Spark.

1. Jika Anda belum melakukannya, siapkan [Apache Livy untuk Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) di EKS.

1. Otentikasi klien Helm Anda ke registri Amazon ECR. Anda dapat menemukan `ECR-registry-account` nilai yang sesuai untuk [akun Wilayah AWS registri Amazon ECR Anda berdasarkan Wilayah](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   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. Menyiapkan Livy membuat akun layanan untuk server Livy dan akun lain untuk aplikasi Spark. Untuk menyiapkan IRSA untuk akun layanan, lihat [Menyiapkan izin akses dengan peran IAM untuk akun layanan (](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)IRSA). 

1. Buat namespace untuk menjalankan beban kerja Spark Anda.

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

1. Gunakan perintah berikut untuk menginstal Livy.

   Endpoint Livy ini hanya tersedia secara internal untuk VPC di cluster EKS. Untuk mengaktifkan akses di luar VPC, atur perintah instalasi `—-set loadbalancer.internal=false` Helm Anda.
**catatan**  
Secara default, SSL tidak diaktifkan dalam titik akhir Livy ini dan titik akhir hanya terlihat di dalam VPC cluster EKS. Jika Anda mengatur `loadbalancer.internal=false` dan`ssl.enabled=false`, Anda mengekspos titik akhir yang tidak aman di luar VPC Anda. Untuk menyiapkan titik akhir Livy yang aman, lihat [Mengonfigurasi titik akhir Apache Livy yang aman dengan](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html) TLS/SSL. 

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

   Anda akan melihat output berikut.

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

   Nama akun layanan default untuk server Livy dan sesi Spark adalah `emr-containers-sa-livy` dan. `emr-containers-sa-spark-livy` Untuk menggunakan nama khusus, gunakan `sparkServiceAccount.name` parameter `serviceAccounts.name` dan.

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

1. Verifikasi bahwa Anda menginstal bagan Helm.

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

   `helm list`Perintah harus mengembalikan informasi tentang bagan Helm baru Anda.

   ```
   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. Pastikan Network Load Balancer aktif.

   ```
   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. Sekarang verifikasi bahwa kelompok target di Network Load Balancer sehat.

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

   Berikut ini adalah contoh output yang menunjukkan status kelompok target:

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

   Setelah status NLB Anda menjadi `active` dan kelompok target Anda`healthy`, Anda dapat melanjutkan. Mungkin butuh beberapa menit.

1. Ambil titik akhir Livy dari instalasi Helm. Apakah titik akhir Livy Anda aman atau tidak tergantung pada apakah Anda mengaktifkan SSL.

   ```
   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. Ambil akun layanan Spark dari instalasi Helm

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

   Anda akan melihat sesuatu yang mirip dengan output berikut:

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

1. Jika Anda mengatur `internalALB=true` untuk mengaktifkan akses dari luar VPC Anda, buat EC2 instans Amazon dan pastikan Network Load Balancer memungkinkan lalu lintas jaringan yang berasal dari instans. EC2 Anda harus melakukannya misalnya untuk memiliki akses ke titik akhir Livy Anda. Untuk informasi selengkapnya tentang mengekspos titik akhir Anda dengan aman di luar VPC Anda, lihat [Menyiapkan dengan titik akhir Apache Livy yang aman dengan](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html) TLS/SSL.

1. Menginstal Livy membuat akun layanan `emr-containers-sa-spark` untuk menjalankan aplikasi Spark. Jika aplikasi Spark Anda menggunakan AWS sumber daya apa pun seperti S3 atau memanggil operasi AWS API atau CLI, Anda harus menautkan peran IAM dengan izin yang diperlukan ke akun layanan spark Anda. Untuk informasi selengkapnya, lihat [Menyiapkan izin akses dengan peran IAM untuk akun layanan (IRSA](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)).

Apache Livy mendukung konfigurasi tambahan yang dapat Anda gunakan saat menginstal Livy. Untuk informasi selengkapnya, lihat Properti instalasi untuk Apache Livy di Amazon EMR pada rilis EKS.

# Menjalankan aplikasi Spark dengan Apache Livy untuk Amazon EMR di EKS
<a name="job-runs-apache-livy-run-spark"></a>

Sebelum Anda dapat menjalankan aplikasi Spark dengan Apache Livy, pastikan bahwa Anda telah menyelesaikan langkah-langkah dalam [Menyiapkan Apache Livy untuk Amazon EMR di EKS dan [Memulai dengan Apache Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) untuk Amazon EMR di EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html).

Anda dapat menggunakan Apache Livy untuk menjalankan dua jenis aplikasi:
+ Batch session — jenis beban kerja Livy untuk mengirimkan pekerjaan batch Spark.
+ Sesi interaktif — jenis beban kerja Livy yang menyediakan antarmuka terprogram dan visual untuk menjalankan kueri Spark.

**catatan**  
Pod driver dan executor dari sesi yang berbeda dapat berkomunikasi satu sama lain. Namespace tidak menjamin keamanan antar pod. Kubernetes tidak mengizinkan izin selektif pada subset pod di dalam namespace tertentu.

## Menjalankan sesi batch
<a name="job-runs-apache-livy-run-spark-batch"></a>

Untuk mengirimkan pekerjaan batch, gunakan perintah berikut.

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

Untuk memantau pekerjaan batch Anda, gunakan perintah berikut.

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

## Menjalankan sesi interaktif
<a name="job-runs-apache-livy-run-spark-interactive"></a>

Untuk menjalankan sesi interaktif dengan Apache Livy, lihat langkah-langkah berikut.

1. Pastikan Anda memiliki akses ke notebook Jupyter yang dihosting sendiri atau yang dikelola, seperti notebook SageMaker AI Jupyter. Notebook jupyter Anda harus menginstal [sparkmagic](https://github.com/jupyter-incubator/sparkmagic/blob/master/README.md).

1. Buat ember untuk konfigurasi `spark.kubernetes.file.upload.path` Spark. Pastikan akun layanan Spark telah membaca dan menulis akses ke bucket. Untuk detail selengkapnya tentang cara mengonfigurasi akun layanan spark, lihat Menyiapkan izin akses dengan peran IAM untuk akun layanan (IRSA)

1. Muat sparkmagic di notebook Jupyter dengan perintah. `%load_ext sparkmagic.magics`

1. Jalankan perintah `%manage_spark` untuk mengatur titik akhir Livy Anda dengan notebook Jupyter. **Pilih tab **Tambah Titik Akhir**, pilih jenis autentikasi yang dikonfigurasi, tambahkan titik akhir Livy ke buku catatan, lalu pilih Tambah titik akhir.**

1. Jalankan `%manage_spark` lagi untuk membuat konteks Spark dan kemudian pergi ke **sesi Create**. Pilih titik akhir Livy, tentukan nama sesi unik pilih bahasa, lalu tambahkan properti berikut.

   ```
   {
     "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. Kirim aplikasi dan tunggu sampai membuat konteks Spark.

1. Untuk memantau status sesi interaktif, jalankan perintah berikut.

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

## Memantau aplikasi Spark
<a name="job-runs-apache-livy-run-ui"></a>

Untuk memantau kemajuan aplikasi Spark Anda dengan Livy UI, gunakan tautan. `http://<livy-endpoint>/ui`

# Menghapus instalasi Apache Livy dengan Amazon EMR di EKS
<a name="job-runs-apache-livy-uninstall"></a>

Ikuti langkah-langkah ini untuk menghapus instalasi Apache Livy.

1. Hapus pengaturan Livy menggunakan nama namespace dan nama aplikasi Anda. Dalam contoh ini, nama aplikasi adalah `livy-demo` dan namespace adalah. `livy-ns`

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

1. Saat mencopot pemasangan, Amazon EMR di EKS menghapus layanan Kubernetes di Livy, penyeimbang beban, dan grup AWS target yang Anda buat selama instalasi. Menghapus sumber daya dapat memakan waktu beberapa menit. Pastikan sumber daya dihapus sebelum menginstal Livy di namespace lagi.

1. Hapus namespace Spark.

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

# Keamanan untuk Apache Livy dengan Amazon EMR di EKS
<a name="job-runs-apache-livy-security"></a>

Lihat topik berikut untuk mempelajari lebih lanjut tentang mengonfigurasi keamanan Apache Livy dengan Amazon EMR di EKS. Opsi ini termasuk menggunakan keamanan lapisan transportasi, kontrol akses berbasis peran, yang merupakan akses berdasarkan peran seseorang dalam suatu organisasi, dan menggunakan peran IAM, yang menyediakan akses ke sumber daya, berdasarkan izin yang diberikan.

**Topics**
+ [Menyiapkan endpoint Apache Livy yang aman dengan TLS/SSL](job-runs-apache-livy-secure-endpoint.md)
+ [Menyiapkan izin aplikasi Apache Livy dan Spark dengan kontrol akses berbasis peran (RBAC)](job-runs-apache-livy-rbac.md)
+ [Menyiapkan izin akses dengan peran IAM untuk akun layanan (IRSA)](job-runs-apache-livy-irsa.md)

# Menyiapkan endpoint Apache Livy yang aman dengan TLS/SSL
<a name="job-runs-apache-livy-secure-endpoint"></a>

Lihat bagian berikut untuk mempelajari lebih lanjut tentang pengaturan Apache Livy untuk Amazon EMR di EKS dengan enkripsi end-to-end TLS dan SSL.

## Menyiapkan enkripsi TLS dan SSL
<a name="job-runs-apache-livy-security-tls"></a>

Untuk mengatur enkripsi SSL pada endpoint Apache Livy Anda, ikuti langkah-langkah berikut.
+ [Instal Secrets Store CSI Driver dan AWS Secrets and Configuration Provider (ASCP)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_csi_driver.html) — Secrets Store CSI Driver dan ASCP dengan aman menyimpan sertifikat dan kata sandi JKS Livy yang dibutuhkan pod server Livy untuk mengaktifkan SSL. Anda juga dapat menginstal hanya Secrets Store CSI Driver dan menggunakan penyedia rahasia lain yang didukung.
+ [Buat sertifikat ACM — sertifikat](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html) ini diperlukan untuk mengamankan koneksi antara klien dan titik akhir ALB.
+ Siapkan sertifikat JKS, kata sandi kunci, dan kata sandi keystore untuk AWS Secrets Manager — diperlukan untuk mengamankan koneksi antara titik akhir ALB dan server Livy.
+ Tambahkan izin ke akun layanan Livy untuk mengambil rahasia dari AWS Secrets Manager — server Livy memerlukan izin ini untuk mengambil rahasia dari ASCP dan menambahkan konfigurasi Livy untuk mengamankan server Livy. Untuk menambahkan izin IAM ke akun layanan, lihat Menyiapkan izin akses dengan peran IAM untuk akun layanan (IRSA).

### Menyiapkan sertifikat JKS dengan kunci dan kata sandi keystore untuk AWS Secrets Manager
<a name="job-runs-apache-livy-jks-certificate"></a>

Ikuti langkah-langkah ini untuk menyiapkan sertifikat JKS dengan kunci dan kata sandi keystore.

1. Hasilkan file keystore untuk server Livy.

   ```
   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. Buat sertifikat.

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

1. Buat file truststore.

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

1. Simpan sertifikat JKS di AWS Secrets Manager. Ganti `livy-jks-secret` dengan rahasia Anda dan `fileb://mykeystore.jks` dengan jalur ke sertifikat JKS keystore Anda.

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

1. Simpan keystore dan kata sandi kunci di Secrets Manager. Pastikan untuk menggunakan parameter Anda sendiri.

   ```
   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. Buat namespace server Livy dengan perintah berikut.

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

1. Buat `ServiceProviderClass` objek untuk server Livy yang memiliki sertifikat JKS dan kata sandi.

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

## Memulai dengan Apache Livy yang mendukung SSL
<a name="job-runs-apache-livy-ssl-enabled-getting-started"></a>

Setelah mengaktifkan SSL di server Livy Anda, Anda harus mengatur `serviceAccount` agar memiliki akses ke `keyStore` dan `keyPasswords` rahasia. AWS Secrets Manager

1. Buat namespace server Livy.

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

1. Siapkan akun layanan Livy untuk memiliki akses ke rahasia di Secrets Manager. Untuk informasi selengkapnya tentang pengaturan IRSA, lihat [Menyiapkan IRSA saat menginstal Apache](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html#job-runs-apache-livy-irsa) Livy.

   ```
   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. Instal Livy. Untuk parameter Helm chart --version, gunakan label rilis Amazon EMR Anda, seperti. `7.1.0` Anda juga harus mengganti ID akun registri Amazon ECR dan ID Wilayah dengan ID Anda sendiri IDs. Anda dapat menemukan `ECR-registry-account` nilai yang sesuai untuk [akun Wilayah AWS registri Amazon ECR Anda berdasarkan Wilayah](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   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. Lanjutkan dari langkah 5 dari [Menginstal Apache Livy di Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html#job-runs-apache-livy-install) di EKS.

# Menyiapkan izin aplikasi Apache Livy dan Spark dengan kontrol akses berbasis peran (RBAC)
<a name="job-runs-apache-livy-rbac"></a>

Untuk menyebarkan Livy, Amazon EMR di EKS membuat akun dan peran layanan server serta akun dan peran layanan Spark. Peran ini harus memiliki izin RBAC yang diperlukan untuk menyelesaikan pengaturan dan menjalankan aplikasi Spark.

**Izin RBAC untuk akun dan peran layanan server**

Amazon EMR di EKS membuat akun layanan server Livy dan berperan untuk mengelola sesi Livy untuk pekerjaan Spark dan merutekan lalu lintas ke dan dari ingress dan sumber daya lainnya.

Nama default untuk akun layanan ini adalah`emr-containers-sa-livy`. Itu harus memiliki izin berikut.

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

**Izin RBAC untuk akun dan peran layanan spark**

Pod driver Spark membutuhkan akun layanan Kubernetes di namespace yang sama dengan pod. Akun layanan ini memerlukan izin untuk mengelola pod pelaksana dan sumber daya apa pun yang diperlukan oleh pod driver. Kecuali akun layanan default di namespace memiliki izin yang diperlukan, driver gagal dan keluar. Izin RBAC berikut diperlukan.

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

# Menyiapkan izin akses dengan peran IAM untuk akun layanan (IRSA)
<a name="job-runs-apache-livy-irsa"></a>

Secara default, server Livy dan driver dan pelaksana aplikasi Spark tidak memiliki akses ke sumber daya. AWS Akun layanan server dan akun layanan spark mengontrol akses ke AWS sumber daya untuk server Livy dan pod aplikasi spark. Untuk memberikan akses, Anda perlu memetakan akun layanan dengan peran IAM yang memiliki AWS izin yang diperlukan.

Anda dapat mengatur pemetaan IRSA sebelum Anda menginstal Apache Livy, selama instalasi, atau setelah Anda menyelesaikan instalasi.

## Menyiapkan IRSA saat menginstal Apache Livy (untuk akun layanan server)
<a name="job-runs-apache-livy-irsa"></a>

**catatan**  
Pemetaan ini hanya didukung untuk akun layanan server.

1. Pastikan Anda telah selesai [menyiapkan Apache Livy untuk Amazon EMR di EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) dan sedang [menginstal Apache Livy dengan Amazon](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) EMR di EKS. 

1. Buat namespace Kubernetes untuk server Livy. Dalam contoh ini, nama namespace adalah. `livy-ns`

1. Buat kebijakan IAM yang menyertakan izin yang Layanan AWS ingin diakses oleh pod Anda. Contoh berikut membuat kebijakan IAM untuk mendapatkan sumber daya Amazon S3 untuk titik masuk Spark.

   ```
   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. Gunakan perintah berikut untuk mengatur Akun AWS ID Anda ke variabel.

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

1. Setel penyedia identitas OpenID Connect (OIDC) cluster Anda ke variabel lingkungan.

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

1. Tetapkan variabel untuk namespace dan nama akun layanan. Pastikan untuk menggunakan nilai Anda sendiri.

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

1. Buat file kebijakan kepercayaan dengan perintah berikut. Jika Anda ingin memberikan akses peran ke semua akun layanan dalam namespace, salin perintah berikut, dan ganti dengan dan ganti `StringEquals` dengan`StringLike`. `$service_account` `*`

   ```
   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. Buat peran.

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

1. Gunakan perintah Helm install berikut untuk mengatur untuk memetakan IRSA`serviceAccount.executionRoleArn`. Berikut ini adalah contoh perintah Helm install. Anda dapat menemukan `ECR-registry-account` nilai yang sesuai untuk [akun Wilayah AWS registri Amazon ECR Anda berdasarkan Wilayah](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

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

## Memetakan IRSA ke akun layanan Spark
<a name="job-runs-apache-livy-irsa-spark"></a>

Sebelum Anda memetakan IRSA ke akun layanan Spark, pastikan Anda telah menyelesaikan item berikut:
+ Pastikan Anda telah selesai [menyiapkan Apache Livy untuk Amazon EMR di EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) dan sedang [menginstal Apache Livy dengan Amazon](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) EMR di EKS. 
+ Anda harus memiliki provdider IAM OpenID Connect (OIDC) untuk klaster Anda. Untuk melihat apakah Anda sudah memilikinya atau cara membuatnya, lihat [Membuat penyedia IAM OIDC untuk](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) klaster Anda.
+ Pastikan Anda telah menginstal versi 0.171.0 atau yang lebih baru dari `eksctl` CLI yang diinstal atau. AWS CloudShell Untuk menginstal atau memperbarui`eksctl`, lihat [Instalasi](https://eksctl.io/installation/) `eksctl` dokumentasi.

Ikuti langkah-langkah berikut untuk memetakan IRSA ke akun layanan Spark Anda:

1. Gunakan perintah berikut untuk mendapatkan akun layanan Spark.

   ```
   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. Tetapkan variabel Anda untuk namespace dan nama akun layanan.

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

1. Gunakan perintah berikut untuk membuat file kebijakan kepercayaan untuk peran IAM. Contoh berikut memberikan izin ke semua akun layanan dalam namespace untuk menggunakan peran. Untuk melakukannya, ganti `StringEquals` dengan `StringLike` dan ganti `$service_account` dengan\$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. Buat peran.

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

1. Petakan server atau akun layanan spark dengan `eksctl` perintah berikut. Pastikan untuk menggunakan nilai Anda sendiri.

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

# Properti instalasi untuk Apache Livy di Amazon EMR pada rilis EKS
<a name="job-runs-apache-livy-installation-properties"></a>

Instalasi Apache Livy memungkinkan Anda memilih versi bagan Livy Helm. Bagan Helm menawarkan berbagai properti untuk menyesuaikan pengalaman instalasi dan penyiapan Anda. Properti ini didukung untuk Amazon EMR pada rilis EKS 7.1.0 dan yang lebih tinggi.

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

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

Tabel berikut menjelaskan semua properti Livy yang didukung. Saat menginstal Apache Livy, Anda dapat memilih versi bagan Livy Helm. Untuk mengatur properti selama instalasi, gunakan perintah`--set <property>=<value>`.


| Properti | Deskripsi | Default | 
| --- | --- | --- | 
| gambar | URI rilis EMR Amazon dari server Livy. Ini adalah konfigurasi yang diperlukan. | "" | 
| SparkNamespace | Namespace untuk menjalankan sesi Livy Spark. Misalnya, tentukan “livy”. Ini adalah konfigurasi yang diperlukan. | "" | 
| NameOverride | Berikan nama, bukanlivy. Nama ditetapkan sebagai label untuk semua sumber daya Livy | “hidup” | 
| FullNameOverride | Berikan nama untuk digunakan alih-alih nama lengkap sumber daya. | "" | 
| ssl.enabled | Mengaktifkan end-to-end SSL dari titik akhir Livy ke server Livy. | SALAH | 
| SSL.CertificatEarn | Jika SSL diaktifkan, ini adalah sertifikat ACM ARN untuk NLB yang dibuat oleh layanan.. | "" | 
| ssl. secretProviderClassNama | Jika SSL diaktifkan, ini adalah nama kelas penyedia rahasia untuk mengamankan NLB untuk koneksi server Livy dengan SSL. | "" | 
| ssl. keyStoreObjectNama | Jika SSL diaktifkan, nama objek untuk sertifikat keystore di kelas penyedia rahasia. | "" | 
| ssl. keyPasswordsObjectNama | Jika SSL diaktifkan, nama objek untuk rahasia yang memiliki keystore dan kata sandi kunci. | "" | 
| rbac.create | Jika benar, membuat sumber daya RBAC. | SALAH | 
| ServiceAccount.Create | Jika benar, buat akun layanan Livy. | BETUL | 
| ServiceAccount.name | Nama akun layanan yang akan digunakan untuk Livy. Jika Anda tidak menyetel properti ini dan membuat akun layanan, Amazon EMR di EKS secara otomatis menghasilkan nama menggunakan properti fullname override. | "emr-containers-sa-livy" | 
| ServiceAccount. executionRoleArn | Peran eksekusi ARN dari akun layanan Livy. | "" | 
| sparkServiceAccount.buat | JIKA benar, buat akun layanan Spark di .Release.Namespace | BETUL | 
| sparkServiceAccount.nama | Nama akun layanan yang akan digunakan untuk Spark. Jika Anda tidak menyetel properti ini dan membuat akun layanan Spark, Amazon EMR di EKS secara otomatis menghasilkan nama dengan properti -spark-livy dengan fullnameOverride akhiran. | “emr-containers-sa-spark-hidup” | 
| service.name | Nama layanan Livy | "emr-containers-livy" | 
| service.annotations | Anotasi layanan Livy | \$1\$1 | 
| loadbalancer.enabled | Apakah akan membuat penyeimbang beban untuk layanan Livy yang digunakan untuk mengekspos titik akhir Livy di luar klaster Amazon EKS. | FALSE | 
| loadbalancer.internal | Apakah akan mengonfigurasi titik akhir Livy sebagai internal ke VPC atau eksternal. Menyetel properti ini untuk `FALSE` mengekspos titik akhir ke sumber di luar VPC. Kami merekomendasikan mengamankan titik akhir Anda dengan TLS/SSL. Untuk informasi selengkapnya, lihat [Menyiapkan enkripsi TLS dan SSL](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 | Daftar imagePullSecret nama yang akan digunakan untuk menarik gambar Livy dari repositori pribadi. | [] | 
| sumber daya | Permintaan sumber daya dan batasan untuk kontainer Livy. | \$1\$1 | 
| NodeSelector | Node untuk menjadwalkan pod Livy. | \$1\$1 | 
| toleransi | Daftar yang berisi toleransi Pod Livy untuk didefinisikan. | [] | 
| afinitas | Aturan afinitas pod Livy. | \$1\$1 | 
| persistence.enabled | Jika benar, aktifkan persistansi untuk direktori sesions. | SALAH | 
| Persistence.subpath | Subpath PVC untuk dipasang ke direktori sesi. | "" | 
| Persistence.ExistingClaim | PVC untuk digunakan alih-alih membuat yang baru. | \$1\$1 | 
| Persistence.storageClass | Kelas penyimpanan yang akan digunakan. Untuk menentukan parameter ini, gunakan formatstorageClassName: <storageClass>. Menyetel parameter ini untuk "-" menonaktifkan penyediaan dinamis. Jika Anda menyetel parameter ini ke null atau tidak menentukan apa pun, Amazon EMR di EKS tidak menyetel storageClassName dan menggunakan penyedia default. | "" | 
| Persistence.accessMode | Mode akses PVC. | ReadWriteOnce | 
| kegigihan. Ukuran | Ukuran PVC. | 20Gi | 
| persistence.annotations | Anotasi tambahan untuk PVC. | \$1\$1 | 
| env. \$1 | Env tambahan untuk disetel ke wadah Livy. Untuk informasi selengkapnya, lihat [Memasukkan konfigurasi Livy dan Spark Anda sendiri](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-troubleshooting.html) saat menginstal Livy. | \$1\$1 | 
| EnvFrom. \$1 | Env tambahan untuk disetel ke Livy dari peta konfigurasi Kubernetes atau rahasia. | [] | 
| LivyConf. \$1 | Entri livy.conf tambahan untuk disetel dari peta konfigurasi Kubernetes atau rahasia yang dipasang. | \$1\$1 | 
| sparkDefaultsConf.\$1 | spark-defaults.confEntri tambahan untuk disetel dari peta konfigurasi Kubernetes atau rahasia yang dipasang. | \$1\$1 | 

# Memecahkan masalah kesalahan format variabel lingkungan yang umum
<a name="job-runs-apache-livy-troubleshooting"></a>

Saat Anda memasukkan konfigurasi Livy dan Spark, ada format variabel lingkungan yang tidak didukung dan dapat menyebabkan kesalahan. Prosedur ini membawa Anda melalui serangkaian langkah untuk membantu memastikan bahwa Anda menggunakan format yang benar.

**Memasukkan konfigurasi Livy dan Spark Anda sendiri saat menginstal Livy**

Anda dapat mengonfigurasi variabel lingkungan Apache Livy atau Apache Spark dengan properti Helm. `env.*` Ikuti langkah-langkah di bawah ini untuk mengonversi konfigurasi contoh `example.config.with-dash.withUppercase` ke format variabel lingkungan yang didukung.

1. Ganti huruf besar dengan huruf 1 dan huruf kecil. Misalnya, `example.config.with-dash.withUppercase` menjadi `example.config.with-dash.with1uppercase`.

1. Ganti tanda hubung (-) dengan 0. Sebagai contoh, `example.config.with-dash.with1uppercase` menjadi `example.config.with0dash.with1uppercase`

1. Ganti titik (.) dengan garis bawah (\$1). Misalnya, `example.config.with0dash.with1uppercase` menjadi `example_config_with0dash_with1uppercase`.

1. Ganti semua huruf kecil dengan huruf besar.

1. Tambahkan awalan `LIVY_` ke nama variabel.

1. Gunakan variabel saat menginstal Livy melalui bagan helm menggunakan format --set env. *YOUR\$1VARIABLE\$1NAME*.nilai = *yourvalue*

Misalnya, untuk mengatur konfigurasi Livy dan Spark `livy.server.recovery.state-store = filesystem` dan`spark.kubernetes.executor.podNamePrefix = my-prefix`, gunakan properti Helm ini:

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