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

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