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

# Menjalankan pekerjaan Spark dengan Amazon EMR di EKS
<a name="job-runs-main"></a>

*Job run* adalah unit kerja, seperti jar Spark, PySpark skrip, atau kueri SparkSQL, yang Anda kirimkan ke Amazon EMR di EKS. Topik ini memberikan ikhtisar tentang mengelola pekerjaan yang dijalankan menggunakan AWS CLI, melihat pekerjaan berjalan menggunakan konsol EMR Amazon, dan memecahkan masalah kesalahan umum menjalankan pekerjaan.

Perhatikan bahwa Anda tidak dapat menjalankan pekerjaan IPv6 Spark di Amazon EMR di EKS

**catatan**  
Sebelum Anda mengirimkan pekerjaan dengan Amazon EMR di EKS, Anda harus menyelesaikan langkah-langkahnya. [Menyiapkan Amazon EMR di EKS](setting-up.md)

**Topics**
+ [Menjalankan pekerjaan Spark dengan `StartJobRun`](job-runs.md)
+ [Menjalankan pekerjaan Spark dengan operator Spark](spark-operator.md)
+ [Menjalankan pekerjaan Spark dengan spark-submit](spark-submit.md)
+ [Menggunakan Apache Livy dengan Amazon EMR di EKS](job-runs-apache-livy.md)
+ [Mengelola Amazon EMR pada pekerjaan EKS](emr-eks-jobs-manage.md)
+ [Menggunakan template pekerjaan](job-templates.md)
+ [Menggunakan templat pod](pod-templates.md)
+ [Menggunakan kebijakan coba lagi pekerjaan](jobruns-using-retry-policies.md)
+ [Menggunakan rotasi log peristiwa Spark](emr-eks-log-rotation.md)
+ [Menggunakan rotasi log kontainer Spark](emr-eks-log-rotation-container.md)
+ [Menggunakan penskalaan otomatis vertikal dengan pekerjaan Amazon EMR Spark](jobruns-vas.md)

# Menjalankan pekerjaan Spark dengan `StartJobRun`
<a name="job-runs"></a>

Bagian ini mencakup langkah-langkah penyiapan terperinci untuk menyiapkan lingkungan Anda untuk menjalankan pekerjaan Spark dan kemudian memberikan step-by-step instruksi untuk mengirimkan pekerjaan yang dijalankan dengan parameter tertentu.

**Topics**
+ [Menyiapkan Amazon EMR di EKS](setting-up.md)
+ [Kirim pekerjaan yang dijalankan dengan `StartJobRun`](emr-eks-jobs-submit.md)
+ [Menggunakan klasifikasi pengirim pekerjaan](emr-eks-job-submitter.md)
+ [Menggunakan klasifikasi default penampung EMR Amazon](emr-eks-job-submitter-container-defaults.md)

# Menyiapkan Amazon EMR di EKS
<a name="setting-up"></a>

Selesaikan tugas-tugas berikut untuk menyiapkan Amazon EMR di EKS. Jika Anda telah mendaftar untuk Amazon Web Services (AWS) dan telah menggunakan Amazon EKS, Anda hampir siap untuk menggunakan Amazon EMR di EKS. Lewati salah satu tugas yang telah Anda selesaikan.

**catatan**  
Anda juga dapat mengikuti [Amazon EMR di EKS Workshop](https://emr-on-eks.workshop.aws/amazon-emr-eks-workshop.html) untuk menyiapkan semua sumber daya yang diperlukan untuk menjalankan pekerjaan Spark di Amazon EMR di EKS. Lokakarya ini juga menyediakan otomatisasi dengan menggunakan CloudFormation templat untuk membuat sumber daya yang diperlukan bagi Anda untuk memulai. Untuk templat dan praktik terbaik lainnya, lihat [Panduan Praktik Terbaik Kontainer EMR](https://aws.github.io/aws-emr-containers-best-practices/) kami di. GitHub

1. [Instal atau perbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

1. [Siapkan kubectl dan eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)

1. [Memulai dengan Amazon EKS — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)

1. [Aktifkan akses cluster untuk Amazon EMR di EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html)

1. [Aktifkan Peran IAM untuk kluster EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM-roles.html)

1. [Memberikan pengguna akses ke Amazon EMR di EKS](setting-up-iam.md)

1. [Daftarkan klaster Amazon EKS dengan Amazon EMR](setting-up-registration.md)

# Aktifkan akses klaster untuk Amazon EMR di EKS
<a name="setting-up-cluster-access"></a>

Bagian berikut menunjukkan beberapa cara untuk mengaktifkan akses cluster. Yang pertama adalah dengan menggunakan Amazon EKS cluster access management (CAM) dan yang terakhir menunjukkan cara mengambil langkah-langkah manual untuk mengaktifkan akses cluster.

## Aktifkan akses cluster menggunakan EKS Access Entry (disarankan)
<a name="setting-up-cluster-access-cam-integration"></a>

**catatan**  
`aws-auth` ConfigMap Itu sudah usang. [Metode yang disarankan untuk mengelola akses ke Kubernetes APIs adalah Access Entries.](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html)

Amazon EMR terintegrasi dengan [Amazon EKS cluster access management (CAM)](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html), sehingga Anda dapat mengotomatiskan konfigurasi kebijakan AuthN dan AuthZ yang diperlukan untuk menjalankan pekerjaan Amazon EMR Spark di ruang nama cluster Amazon EKS. Saat Anda membuat klaster virtual dari namespace klaster Amazon EKS, Amazon EMR secara otomatis mengonfigurasi semua izin yang diperlukan, sehingga Anda tidak perlu menambahkan langkah tambahan apa pun ke alur kerja Anda saat ini.

**catatan**  
Integrasi Amazon EMR dengan Amazon EKS CAM hanya didukung untuk EMR Amazon baru di kluster virtual EKS. Anda tidak dapat memigrasi klaster virtual yang ada untuk menggunakan integrasi ini.

### Prasyarat
<a name="setting-up-cluster-access-cam-integration-prereqs"></a>
+ Pastikan Anda menjalankan versi 2.15.3 atau lebih tinggi AWS CLI
+ Cluster Amazon EKS Anda harus menggunakan versi 1.23 atau lebih tinggi.

### Pengaturan
<a name="setting-up-cluster-access-cam-integration-setup"></a>

Untuk mengatur integrasi antara Amazon EMR dan operasi AccessEntry API dari Amazon EKS, pastikan Anda telah menyelesaikan item berikut:
+ Pastikan `authenticationMode` klaster Amazon EKS Anda disetel ke`API_AND_CONFIG_MAP`.

  ```
  aws eks describe-cluster --name <eks-cluster-name>
  ```

  Jika belum, atur `authenticationMode` ke`API_AND_CONFIG_MAP`.

  ```
  aws eks update-cluster-config 
      --name <eks-cluster-name> 
      --access-config authenticationMode=API_AND_CONFIG_MAP
  ```

  Untuk informasi selengkapnya tentang mode autentikasi, lihat Mode [otentikasi klaster](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html#authentication-modes).
+ Pastikan bahwa [peran IAM](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-iam.html) yang Anda gunakan untuk menjalankan operasi `CreateVirtualCluster` dan `DeleteVirtualCluster` API juga memiliki izin berikut:

  ```
  {
    "Effect": "Allow",
    "Action": [
      "eks:CreateAccessEntry"
    ],
    "Resource": "arn:<AWS_PARTITION>:eks:<AWS_REGION>:<AWS_ACCOUNT_ID>:cluster/<EKS_CLUSTER_NAME>"
  }, 
  {
    "Effect": "Allow",
    "Action": [
      "eks:DescribeAccessEntry",
      "eks:DeleteAccessEntry",
      "eks:ListAssociatedAccessPolicies",
      "eks:AssociateAccessPolicy",
      "eks:DisassociateAccessPolicy"
    ],
    "Resource": "arn:<AWS_PARTITION>:eks:<AWS_REGION>:<AWS_ACCOUNT_ID>:access-entry/<EKS_CLUSTER_NAME>/role/<AWS_ACCOUNT_ID>/AWSServiceRoleForAmazonEMRContainers/*"
  }
  ```

### Konsep dan terminologi
<a name="setting-up-cluster-access-cam-integration-concepts"></a>

Berikut ini adalah daftar terminologi dan konsep yang terkait dengan Amazon EKS CAM.
+ Virtual cluster (VC) — representasi logis dari namespace yang dibuat di Amazon EKS. Ini adalah tautan 1:1 ke namespace cluster Amazon EKS. Anda dapat menggunakannya untuk menjalankan beban kerja Amazon EMR di klaster Amazon EKS dalam namespace yang ditentukan.
+ Namespace — mekanisme untuk mengisolasi kelompok sumber daya dalam satu kluster EKS.
+ Kebijakan akses — izin yang memberikan akses dan tindakan ke peran IAM dalam klaster EKS.
+ Akses entri — entri yang dibuat dengan peran arn. Anda dapat menautkan entri akses ke kebijakan akses untuk menetapkan izin tertentu di klaster Amazon EKS.
+ Kluster virtual terintegrasi entri akses EKS — cluster virtual yang dibuat menggunakan [operasi API entri akses](https://docs.aws.amazon.com/eks/latest/APIReference/API_Operations_Amazon_Elastic_Kubernetes_Service.html) dari Amazon EKS.

## Aktifkan akses cluster menggunakan `aws-auth`
<a name="setting-up-cluster-access-aws-auth"></a>

Anda harus mengizinkan akses Amazon EMR di EKS ke namespace tertentu di klaster Anda dengan mengambil tindakan berikut: membuat peran Kubernetes, mengikat peran ke pengguna Kubernetes, dan memetakan pengguna Kubernetes dengan peran terkait layanan [https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/using-service-linked-roles.html](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/using-service-linked-roles.html). Tindakan ini diotomatiskan di `eksctl` ketika perintah pemetaan identitas IAM digunakan dengan `emr-containers` sebagai nama layanan. Anda dapat melakukan operasi ini dengan mudah menggunakan perintah berikut.

```
eksctl create iamidentitymapping \
    --cluster my_eks_cluster \
    --namespace kubernetes_namespace \
    --service-name "emr-containers"
```

Ganti *my\$1eks\$1cluster* dengan nama cluster Amazon EKS Anda dan ganti *kubernetes\$1namespace* dengan namespace Kubernetes yang dibuat untuk menjalankan beban kerja Amazon EMR. 

**penting**  
Anda harus mengunduh eksctl terbaru menggunakan langkah sebelumnya [Mengatur kubectl dan eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) untuk menggunakan fungsi ini. 

### Langkah manual untuk mengaktifkan akses klaster untuk Amazon EMR di EKS
<a name="setting-up-cluster-access-manual"></a>

Anda juga dapat menggunakan langkah manual berikut untuk mengaktifkan akses klaster untuk Amazon EMR di EKS.

1. **Buat peran Kubernetes di namespace tertentu**

------
#### [ Amazon EKS 1.22 - 1.29 ]

   Dengan Amazon EKS 1.22 - 1.29, jalankan perintah berikut untuk membuat peran Kubernetes dalam namespace tertentu. Peran ini memberikan izin RBAC yang diperlukan untuk Amazon EMR di EKS.

   ```
   namespace=my-namespace
   cat - >>EOF | kubectl apply -f - >>namespace "${namespace}"
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: emr-containers
     namespace: ${namespace}
   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: ["apps"]
       resources: ["statefulsets", "deployments"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "annotate", "patch", "label"]
     - apiGroups: ["batch"]
       resources: ["jobs"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "annotate", "patch", "label"]
     - apiGroups: ["extensions", "networking.k8s.io"]
       resources: ["ingresses"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "annotate", "patch", "label"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["roles", "rolebindings"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "deletecollection", "annotate", "patch", "label"]
     - apiGroups: [""]
       resources: ["persistentvolumeclaims"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete",  "deletecollection", "annotate", "patch", "label"]
   EOF
   ```

------
#### [ Amazon EKS 1.21 and below ]

   Dengan Amazon EKS 1.21 dan di bawahnya, jalankan perintah berikut untuk membuat peran Kubernetes di namespace tertentu. Peran ini memberikan izin RBAC yang diperlukan untuk Amazon EMR di EKS.

   ```
   namespace=my-namespace
   cat - >>EOF | kubectl apply -f - >>namespace "${namespace}"
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: emr-containers
     namespace: ${namespace}
   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: ["apps"]
       resources: ["statefulsets", "deployments"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "annotate", "patch", "label"]
     - apiGroups: ["batch"]
       resources: ["jobs"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "annotate", "patch", "label"]
     - apiGroups: ["extensions"]
       resources: ["ingresses"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "annotate", "patch", "label"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["roles", "rolebindings"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "deletecollection", "annotate", "patch", "label"]
     - apiGroups: [""]
       resources: ["persistentvolumeclaims"]
       verbs: ["get", "list", "watch", "describe", "create", "edit", "delete", "deletecollection", "annotate", "patch", "label"]
   EOF
   ```

------

1. **Buat ikatan peran Kubernetes yang dicakup ke namespace**

   Jalankan perintah berikut untuk membuat peran mengikat Kubernetes mengikat di namespace yang diberikan. Pengikatan peran ini memberikan izin yang ditetapkan dalam peran yang dibuat di langkah sebelumnya ke pengguna bernama `emr-containers`. Pengguna ini mengidentifikasi [peran terkait layanan untuk Amazon EMR di EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/using-service-linked-roles.html) dan dengan demikian memungkinkan Amazon EMR di EKS untuk melakukan tindakan seperti yang didefinisikan oleh peran yang Anda buat.

   ```
   namespace=my-namespace
   
   cat - <<EOF | kubectl apply -f - --namespace "${namespace}"
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: emr-containers
     namespace: ${namespace}
   subjects:
   - kind: User
     name: emr-containers
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: Role
     name: emr-containers
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

1. **Perbarui peta konfigurasi Kubernetes `aws-auth`**

   Anda dapat menggunakan salah satu opsi berikut untuk memetakan Amazon EMR di EKS peran terkait layanan dengan pengguna `emr-containers` yang terikat dengan peran Kubernetes pada langkah sebelumnya.

   **Opsi 1: Menggunakan `eksctl`**

   Jalankan perintah `eksctl` berikut untuk memetakan peran terkait layanan EMR Amazon di EKS dengan pengguna `emr-containers`.

   ```
   eksctl create iamidentitymapping \
       --cluster my-cluster-name \
       --arn "arn:aws:iam::my-account-id:role/AWSServiceRoleForAmazonEMRContainers" \
       --username emr-containers
   ```

   **Opsi 2: Tanpa menggunakan eksctl**

   1. Jalankan perintah berikut untuk membuka peta konfigurasi `aws-auth` dalam editor teks. 

      ```
      kubectl edit -n kube-system configmap/aws-auth
      ```
**catatan**  
Jika Anda menerima kesalahan yang menyatakan`Error from server (NotFound): configmaps "aws-auth" not found`, lihat langkah-langkah dalam [Menambahkan peran pengguna](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) di Panduan Pengguna Amazon EKS untuk menerapkan stok ConfigMap. 

   1. Tambahkan detail peran terkait Amazon EMR di EKS ke bagian `mapRoles` dari `ConfigMap`, di bawah `data`. Tambahkan bagian ini jika belum ada dalam file. Bagian `mapRoles` yang diperbarui di bawah data terlihat seperti contoh berikut.

      ```
      apiVersion: v1
      data:
        mapRoles: |
          - rolearn: arn:aws:iam::<your-account-id>:role/AWSServiceRoleForAmazonEMRContainers
            username: emr-containers
          - ... <other previously existing role entries, if there's any>.
      ```

   1. Simpan file , dan tutup editor teks Anda.

# Aktifkan Peran IAM untuk kluster EKS
<a name="setting-up-enable-IAM-roles"></a>

Topik berikut merinci opsi untuk mengaktifkan peran IAM.

**Topics**
+ [Opsi 1: Aktifkan Identitas Pod EKS pada Kluster EKS](setting-up-enable-IAM.md)
+ [Opsi 2: Aktifkan Peran IAM untuk Akun Layanan (IRSA) di kluster EKS](setting-up-enable-IAM-service-accounts.md)

# Opsi 1: Aktifkan Identitas Pod EKS pada Kluster EKS
<a name="setting-up-enable-IAM"></a>

Pengaitan Identitas Pod Amazon EKS menyediakan kemampuan untuk mengelola kredensial untuk aplikasi Anda, mirip dengan cara profil instans Amazon EC2 memberikan kredensial ke instans Amazon EC2. Amazon EKS Pod Identity memberikan kredensi ke beban kerja Anda dengan API Auth EKS tambahan dan pod agen yang berjalan di setiap node.

Amazon EMR di EKS mulai mendukung identitas pod EKS sejak rilis emr-7.3.0 untuk model pengiriman. StartJobRun 

Untuk informasi lebih lanjut tentang identitas pod EKS, lihat [Memahami cara kerja EKS Pod Identity](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html).

## Mengapa Identitas EKS Pod?
<a name="setting-up-enable-IAM-pod-identity-why"></a>

Sebagai bagian dari pengaturan EMR, Job Execution Role perlu menetapkan batas kepercayaan antara peran IAM dan akun layanan di namespace tertentu (dari cluster virtual EMR). Dengan IRSA, ini dicapai dengan memperbarui kebijakan kepercayaan Peran Pelaksanaan Job EMR. Namun, karena batas keras 4096 karakter pada panjang kebijakan kepercayaan IAM, ada kendala untuk berbagi Peran IAM Eksekusi Job tunggal di maksimum dua belas (12) kluster EKS.

Dengan dukungan EMR untuk Pod Identities, batas kepercayaan antara peran IAM dan akun layanan sekarang dikelola oleh tim EKS melalui asosiasi identitas pod EKS. APIs

**catatan**  
Batas keamanan untuk identitas pod EKS masih pada level akun layanan, bukan pada level pod.

## Pertimbangan Identitas Pod
<a name="setting-up-enable-IAM-pod-identity-consider"></a>

Untuk informasi tentang Batasan Identitas Pod, lihat [pertimbangan Identitas Pod EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html#pod-id-considerations).

## Siapkan Identitas Pod EKS di EKS Cluster
<a name="setting-up-enable-IAM-pod-eks-cluster"></a>

### Periksa apakah izin yang diperlukan ada di NodeInstanceRole
<a name="setting-up-enable-IAM-pod-eks-cluster-permission"></a>

Peran node `NodeInstanceRole` memerlukan izin bagi agen untuk melakukan `AssumeRoleForPodIdentity` tindakan di EKS Auth API. Anda dapat menambahkan yang berikut ini ke [Amazon EKSWorker NodePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/security-iam-awsmanpol.html#security-iam-awsmanpol-amazoneksworkernodepolicy), yang ditentukan dalam Panduan Pengguna Amazon EKS, atau menggunakan kebijakan khusus.

Jika kluster EKS Anda dibuat dengan versi eksctl lebih tinggi dari **0.181.0**, EKSWorker NodePolicy Amazon, termasuk izin yang `AssumeRoleForPodIdentity` diperlukan, akan dilampirkan ke peran node secara otomatis. Jika izin tidak ada, tambahkan izin berikut secara manual ke Amazon EKSWorker NodePolicy yang memungkinkan asumsi peran untuk identitas pod. Izin ini diperlukan oleh agen identitas pod EKS untuk mengambil kredensil untuk pod.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "eks-auth:AssumeRoleForPodIdentity"
      ],
      "Resource": [
        "*"
      ],
      "Sid": "AllowEKSAUTHAssumeroleforpodidentity"
    }
  ]
}
```

------

### Buat add-on agen identitas pod EKS
<a name="setting-up-enable-IAM-pod-eks-cluster-agent"></a>

Gunakan perintah berikut untuk membuat add-on EKS Pod Identity Agent dengan versi terbaru:

```
aws eks create-addon --cluster-name cluster-name --addon-name eks-pod-identity-agent

kubectl get pods -n kube-system | grep 'eks-pod-identity-agent'
```

Gunakan langkah-langkah berikut untuk membuat add-on EKS Pod Identity Agent dari konsol Amazon EKS:

1. Buka konsol Amazon EKS: konsol [Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Di panel navigasi sebelah kiri, pilih **Clusters**, lalu pilih nama cluster yang ingin Anda konfigurasikan untuk add-on EKS Pod Identity Agent.

1. Pilih tab **Add-ons**.

1. Pilih **Get more add-ons**

1. Pilih kotak di kanan atas kotak add-on untuk EKS Pod Identity Agent dan kemudian pilih **Berikutnya**.

1. Pada halaman **Konfigurasi pengaturan add-on yang dipilih**, pilih versi apa pun di daftar drop-down **Versi**.

1. (Opsional) Perluas **pengaturan konfigurasi opsional** untuk memasukkan konfigurasi tambahan. Misalnya, Anda dapat memberikan lokasi gambar kontainer alternatif dan`ImagePullSecrets`. Skema JSON dengan kunci yang diterima ditampilkan dalam skema konfigurasi **Add-on**.

   Masukkan tombol konfigurasi dan nilai dalam **nilai Konfigurasi**.

1. Pilih **Berikutnya**.

1. Konfirmasikan bahwa pod agen berjalan di klaster Anda melalui CLI.

   `kubectl get pods -n kube-system | grep 'eks-pod-identity-agent'`

Contoh output adalah sebagai berikut:

```
NAME                              READY   STATUS    RESTARTS      AGE
eks-pod-identity-agent-gmqp7      1/1     Running   1 (24h ago)   24h
eks-pod-identity-agent-prnsh      1/1     Running   1 (24h ago)   24h
```

Ini mengatur yang baru DaemonSet di `kube-system` namespace. Amazon EKS Pod Identity Agent, yang berjalan di setiap node EKS, menggunakan [AssumeRoleForPodIdentity](https://docs.aws.amazon.com/eks/latest/APIReference/API_auth_AssumeRoleForPodIdentity.html)action tersebut untuk mengambil kredensi sementara dari EKS Auth API. Kredensi ini kemudian tersedia untuk AWS SDKs yang Anda jalankan di dalam wadah Anda.

Untuk informasi selengkapnya, periksa prasyarat di dokumen publik: [Siapkan Agen Identitas Pod Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-setup.html).

## Membuat Peran Eksekusi Job
<a name="setting-up-enable-IAM-pod-create-job-role"></a>

### Membuat atau memperbarui peran eksekusi pekerjaan yang memungkinkan EKS Pod Identity
<a name="setting-up-enable-IAM-pod-create-job-role-update"></a>

Untuk menjalankan beban kerja dengan Amazon EMR di EKS, Anda perlu membuat peran IAM. Kami menyebut peran ini sebagai peran eksekusi tugas dalam dokumentasi ini. Untuk informasi selengkapnya tentang cara membuat peran IAM, lihat [Membuat peran IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) di Panduan pengguna.

Selain itu, Anda harus membuat kebijakan IAM yang menentukan izin yang diperlukan untuk peran eksekusi pekerjaan dan kemudian melampirkan kebijakan ini ke peran untuk mengaktifkan EKS Pod Identity.

Misalnya, Anda memiliki peran eksekusi pekerjaan berikut. Untuk informasi selengkapnya, lihat [Membuat peran eksekusi pekerjaan](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html).

```
arn:aws:iam::111122223333:role/PodIdentityJobExecutionRole
```

**penting**  
Amazon EMR di EKS secara otomatis membuat Akun Layanan Kubernetes, berdasarkan nama peran eksekusi pekerjaan Anda. Pastikan nama peran tidak terlalu panjang, karena pekerjaan Anda mungkin gagal jika kombinasi`cluster_name`,`pod_name`, dan `service_account_name` melebihi batas panjang.

**Job Execution Role Configuration** - Pastikan peran eksekusi pekerjaan dibuat dengan izin kepercayaan di bawah ini untuk EKS Pod Identity. Untuk memperbarui peran eksekusi pekerjaan yang ada, konfigurasikan untuk mempercayai prinsip layanan EKS berikut sebagai izin tambahan dalam kebijakan kepercayaan. Izin kepercayaan ini dapat hidup berdampingan dengan kebijakan kepercayaan IRSA yang ada.

```
cat >trust-relationship.json <<EOF
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
            "Effect": "Allow",
            "Principal": {
                "Service": "pods.eks.amazonaws.com"
            },
            "Action": [
                "sts:AssumeRole",
                "sts:TagSession"
            ]
        }
    ]
}
EOF
```

**Izin** Pengguna: Pengguna memerlukan `iam:PassRole` izin untuk menjalankan panggilan `StartJobRun` API atau mengirimkan pekerjaan. Izin ini memungkinkan pengguna untuk meneruskan peran eksekusi pekerjaan ke EMR di EKS. Administrator Job harus memiliki izin secara default.

Di bawah ini adalah izin yang diperlukan untuk pengguna:

```
{
    "Effect": "Allow",
    "Action": "iam:PassRole",
    "Resource": "arn:aws:iam::111122223333:role/PodIdentityJobExecutionRole",
    "Condition": {
        "StringEquals": {
            "iam:PassedToService": "pods.eks.amazonaws.com"
        }
    }
}
```

Untuk lebih membatasi akses pengguna ke kluster EKS tertentu, tambahkan filter AssociatedResourceArn atribut ke kebijakan IAM. Ini membatasi asumsi peran untuk klaster EKS resmi, memperkuat kontrol keamanan tingkat sumber daya Anda.

```
"Condition": {
        "ArnLike": {
            "iam:AssociatedResourceARN": [
                "arn:aws:eks:us-west-2:111122223333:cluster/*"
            ]
        }
```

## Siapkan asosiasi identitas pod EKS
<a name="setting-up-enable-IAM-pod-identity-asociations"></a>

### Prasyarat
<a name="setting-up-enable-IAM-pod-identity-asociations-prereq"></a>

Pastikan IAM Identity yang membuat asosiasi identitas pod, seperti pengguna admin EKS, memiliki izin `eks:CreatePodIdentityAssociation` dan`iam:PassRole`.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "eks:CreatePodIdentityAssociation"
      ],
      "Resource": [
        "arn:aws:eks:*:*:cluster/*"
      ],
      "Sid": "AllowEKSCreatepodidentityassociation"
    },
    {
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource": [
        "arn:aws:iam::*:role/*"
      ],
      "Condition": {
        "StringEquals": {
          "iam:PassedToService": "pods.eks.amazonaws.com"
        }
      },
      "Sid": "AllowIAMPassrole"
    }
  ]
}
```

------

### Buat Asosiasi untuk peran dan akun layanan EMR
<a name="setting-up-enable-IAM-pod-identity-asociations-emr-service"></a>

------
#### [ Create EMR role associations through the AWS CLI ]

Ketika Anda mengirimkan pekerjaan ke namespace Kubernetes, administrator harus membuat asosiasi antara peran eksekusi pekerjaan dan identitas akun layanan terkelola EMR. Perhatikan bahwa akun layanan terkelola EMR secara otomatis dibuat pada pengiriman tugas, dicakup ke namespace di mana tugas dikirimkan.

Dengan AWS CLI (versi di atas 2.24.0), jalankan perintah berikut untuk membuat asosiasi peran dengan identitas pod.

Jalankan perintah berikut untuk membuat asosiasi peran dengan identitas pod:

```
aws emr-containers create-role-associations \
        --cluster-name mycluster \
        --namespace mynamespace \
        --role-name JobExecutionRoleIRSAv2
```

Catatan:
+ Setiap cluster dapat memiliki batas 1.000 asosiasi. Setiap peran eksekusi pekerjaan - pemetaan namespace akan membutuhkan 3 asosiasi untuk pod pengirim pekerjaan, driver, dan pelaksana.
+ Anda hanya dapat mengaitkan peran yang berada di AWS akun yang sama dengan cluster. Anda dapat mendelegasikan akses dari akun lain ke peran di akun ini yang Anda konfigurasikan untuk Identitas Pod EKS untuk digunakan. Untuk tutorial tentang mendelegasikan akses dan`AssumeRole`, lihat [tutorial IAM: Mendelegasikan akses di seluruh AWS akun menggunakan](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) peran IAM.

------
#### [ Create EMR role associations through Amazon EKS ]

EMR membuat akun layanan dengan pola penamaan tertentu saat pekerjaan dikirimkan. Untuk membuat asosiasi manual atau mengintegrasikan alur kerja ini dengan AWS SDK, ikuti langkah-langkah berikut:

Buat Nama Akun Layanan:

```
emr-containers-sa-spark-%(SPARK_ROLE)s-%(AWS_ACCOUNT_ID)s-%(BASE36_ENCODED_ROLE_NAME)s
```

Contoh di bawah ini membuat asosiasi peran untuk contoh peran eksekusi Job JobExecutionRoleIRSAv2.

**Contoh Asosiasi Peran:**

```
RoleName: JobExecutionRoleIRSAv2
Base36EncodingOfRoleName: 2eum5fah1jc1kwyjc19ikdhdkdegh1n26vbe
```

**Contoh perintah CLI:**

```
# setup for the client service account (used by job runner pod)
# emr-containers-sa-spark-client-111122223333-2eum5fah1jc1kwyjc19ikdhdkdegh1n26vbe
aws eks create-pod-identity-association --cluster-name mycluster --role-arn arn:aws:iam::111122223333:role/JobExecutionRoleIRSAv2 --namespace mynamespace --service-account emr-containers-sa-spark-client-111122223333-2eum5fah1jc1kwyjc19ikdhdkdegh1n26vbe

# driver service account
# emr-containers-sa-spark-driver-111122223333-2eum5fah1jc1kwyjc19ikdhdkdegh1n26vbe        
aws eks create-pod-identity-association --cluster-name mycluster --role-arn arn:aws:iam::111122223333:role/JobExecutionRoleIRSAv2 --namespace mynamespace --service-account emr-containers-sa-spark-driver-111122223333-2eum5fah1jc1kwyjc19ikdhdkdegh1n26vbe

# executor service account
# emr-containers-sa-spark-executor-111122223333-2eum5fah1jc1kwyjc19ikdhdkdegh1n26vbe
aws eks create-pod-identity-association --cluster-name mycluster --role-arn arn:aws:iam::111122223333:role/JobExecutionRoleIRSAv2 --namespace mynamespace --service-account emr-containers-sa-spark-executor-111122223333-2eum5fah1jc1kwyjc19ikdhdkdegh1n26vbe
```

------

Setelah Anda menyelesaikan semua langkah yang diperlukan untuk identitas pod EKS, Anda dapat melewati langkah-langkah berikut untuk pengaturan IRSA:
+ [Aktifkan Peran IAM untuk Akun Layanan (IRSA) di kluster EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html)
+ [Buat peran eksekusi pekerjaan](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html)
+ [Perbarui kebijakan kepercayaan dari peran pelaksanaan pekerjaan](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-trust-policy.html)

Anda dapat langsung melewati langkah berikut: [Berikan pengguna akses ke Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-iam.html) di EKS

## Hapus Asosiasi Peran
<a name="setting-up-enable-IAM-pod-identity-asociations-delete-associations"></a>

Setiap kali Anda menghapus klaster virtual atau peran eksekusi pekerjaan dan Anda tidak lagi ingin memberikan akses ke EMR ke akun layanannya, Anda harus menghapus asosiasi untuk peran tersebut. Ini karena EKS memungkinkan asosiasi dengan sumber daya yang tidak ada (namespace dan akun layanan). Amazon EMR di EKS merekomendasikan untuk menghapus asosiasi jika namespace dihapus atau peran tidak lagi digunakan, untuk mengosongkan ruang bagi asosiasi lain.

**catatan**  
Asosiasi yang tersisa berpotensi memengaruhi kemampuan Anda untuk menskalakan jika Anda tidak menghapusnya, karena EKS memiliki batasan pada jumlah asosiasi yang dapat Anda buat (batas lunak: 1000 asosiasi per cluster). Anda dapat mencantumkan asosiasi identitas pod di namespace tertentu untuk memeriksa apakah Anda memiliki asosiasi yang masih ada yang perlu dibersihkan:

```
aws eks list-pod-identity-associations --cluster-name mycluster --namespace mynamespace
```

Dengan AWS CLI (versi 2.24.0 atau lebih tinggi), jalankan perintah emr-container berikut untuk menghapus asosiasi peran EMR:

```
aws emr-containers delete-role-associations \
        --cluster-name mycluster \
        --namespace mynamespace \
        --role-name JobExecutionRoleIRSAv2
```

## Secara Otomatis Migrasi IRSA yang Ada ke Identitas Pod
<a name="setting-up-enable-IAM-pod-identity-auto-migrate"></a>

Anda dapat menggunakan alat eksctl untuk memigrasikan Peran IAM yang ada untuk Akun Layanan (IRSA) ke asosiasi identitas pod:

```
eksctl utils migrate-to-pod-identity \
    --cluster mycluster \
    --remove-oidc-provider-trust-relationship \
    --approve
```

Menjalankan perintah tanpa `--approve` bendera hanya akan menampilkan rencana yang mencerminkan langkah migrasi, dan tidak ada migrasi aktual yang akan terjadi.

## Pemecahan masalah
<a name="setting-up-enable-IAM-pod-identity-troubleshooting"></a>

### Pekerjaan saya gagal dengan NoClassDefinitionFound atau ClassNotFound Pengecualian untuk Penyedia Kredensial, atau gagal mendapatkan penyedia kredensil.
<a name="setting-up-enable-IAM-pod-identity-troubleshooting-no-class"></a>

EKS Pod Identity menggunakan Container Credentials Provider untuk mengambil kredensi yang diperlukan. Jika Anda telah menentukan penyedia kredensi khusus, pastikan itu berfungsi dengan benar. Atau, pastikan Anda menggunakan versi AWS SDK yang benar yang mendukung EKS Pod Identity. Untuk informasi selengkapnya, lihat [Memulai Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html).

### Job gagal dengan kesalahan “Failed to Retrieve Credentials Due to [x] Size Limit” yang ditampilkan di log. eks-pod-identity-agent
<a name="setting-up-enable-IAM-pod-identity-troubleshooting-creds"></a>

EMR di EKS membuat Akun Layanan Kubernetes berdasarkan nama peran eksekusi pekerjaan. Jika nama peran terlalu panjang, EKS Auth akan gagal mengambil kredensil karena kombinasi`cluster_name`,`pod_name`, dan `service_account_name` melebihi batas panjang. Identifikasi komponen mana yang paling banyak mengambil ruang dan sesuaikan ukurannya.

### Job gagal dengan kesalahan “Failed to Retrieve Credentials xxx” yang ditampilkan di log. eks-pod-identity
<a name="setting-up-enable-IAM-pod-identity-troubleshooting-creds-error"></a>

Salah satu kemungkinan penyebab masalah ini adalah kluster EKS dikonfigurasi di bawah subnet pribadi tanpa mengonfigurasi PrivateLink cluster dengan benar. Periksa apakah cluster Anda berada di jaringan pribadi dan konfigurasikan AWS PrivateLink untuk mengatasi masalah tersebut. Untuk petunjuk terperinci, lihat [Memulai Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html)..

# Opsi 2: Aktifkan Peran IAM untuk Akun Layanan (IRSA) di kluster EKS
<a name="setting-up-enable-IAM-service-accounts"></a>

IAM role untuk fitur akun layanan tersedia di Amazon EKS versi 1.14 dan yang lebih baru dan untuk klaster EKS yang diperbarui ke versi 1.13 atau yang lebih baru pada atau setelah 3 September 2019. Untuk menggunakan fitur ini, Anda dapat memperbarui klaster EKS yang ada ke versi 1.14 atau yang lebih baru. Untuk informasi lebih lanjut, lihat [Memperbarui versi Kubernetes klaster Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/update-cluster.html).

Jika klaster Anda mendukung IAM role untuk akun layanan, klaster Anda memiliki URL penerbit [Connect OpenID](https://openid.net/connect/) yang terkait dengannya. Anda dapat melihat URL ini di konsol Amazon EKS, atau Anda dapat menggunakan AWS CLI perintah berikut untuk mengambilnya.

**penting**  
Anda harus menggunakan versi terbaru dari AWS CLI untuk menerima output yang tepat dari perintah ini.

```
aws eks describe-cluster --name cluster_name --query "cluster.identity.oidc.issuer" --output text
```

Output yang diharapkan adalah sebagai berikut.

```
https://oidc.eks.<region-code>.amazonaws.com/id/EXAMPLED539D4633E53DE1B716D3041E
```

Untuk menggunakan IAM role untuk akun layanan di klaster Anda, Anda harus membuat penyedia identitas OIDC menggunakan baik [eksctl](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html#create-oidc-eksctl) atau [Konsol Manajemen AWS](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html#create-oidc-console).

## Untuk membuat penyedia identitas IAM OIDC untuk klaster Anda dengan `eksctl`
<a name="setting-up-OIDC-eksctl"></a>

Periksa versi `eksctl` Anda dengan perintah berikut. Prosedur ini mengasumsikan bahwa Anda telah menginstal `eksctl` dan bahwa `eksctl` versi 0.32.0 atau yang lebih baru.

```
eksctl version
```

Untuk informasi selengkapnya tentang menginstal atau meningkatkan eksctl, lihat [Menginstal atau meningkatkan eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl).

Buat penyedia identitas OIDC Anda untuk klaster Anda dengan perintah berikut. Ganti *cluster\$1name* dengan nilai milik Anda sendiri.

```
eksctl utils associate-iam-oidc-provider --cluster cluster_name --approve
```

## Untuk membuat penyedia identitas IAM OIDC untuk cluster Anda dengan Konsol Manajemen AWS
<a name="setting-up-OIDC-console"></a>

Ambil URL penerbit OIDC dari deskripsi konsol Amazon EKS klaster Anda, atau gunakan perintah berikut. AWS CLI 

Gunakan perintah berikut untuk mengambil URL penerbit OIDC dari AWS CLI.

```
aws eks describe-cluster --name <cluster_name> --query "cluster.identity.oidc.issuer" --output text
```

Gunakan langkah-langkah berikut untuk mengambil URL penerbit OIDC dari konsol Amazon EKS. 

1. Buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Di panel navigasi, pilih **Penyedia Identitas**, lalu pilih **Buat Penyedia**.

   1. Untuk **Jenis Penyedia**, pilih **Pilih jenis penyedia**, lalu pilih **OpenID Connect**.

   1. Untuk **Penyedia URL**, tempelkan URL penerbit OIDC untuk klaster Anda.

   1. Untuk Audiens, ketik sts.amazonaws.com dan pilih **Langkah Selanjutnya**.

1. Verifikasi bahwa informasi penyedia sudah benar, kemudian pilih **Buat** untuk membuat penyedia identitas Anda.

# Untuk membuat peran eksekusi tugas
<a name="creating-job-execution-role"></a>

Untuk menjalankan beban kerja di Amazon EMR di EKS, Anda perlu membuat peran IAM. Kami menyebut peran ini sebagai *peran eksekusi tugas* dalam dokumentasi ini. Untuk informasi selengkapnya tentang cara membuat peran IAM, lihat [Membuat peran IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) di Panduan pengguna IAM. 

Anda juga harus membuat kebijakan IAM yang menentukan izin untuk peran eksekusi pekerjaan dan kemudian melampirkan kebijakan IAM ke peran eksekusi pekerjaan. 

Kebijakan berikut untuk peran eksekusi pekerjaan memungkinkan akses ke target sumber daya, Amazon S3, dan. CloudWatch Izin ini diperlukan untuk memantau tugas dan log akses. Untuk mengikuti proses yang sama menggunakan AWS CLI: 

Buat Peran IAM untuk eksekusi pekerjaan: Mari kita buat peran yang akan digunakan EMR untuk eksekusi pekerjaan. Ini adalah peran, pekerjaan EMR akan diasumsikan ketika mereka berjalan di EKS.

```
cat <<EoF > ~/environment/emr-trust-policy.json
 {
   "Version": "2012-10-17",		 	 	 
   "Statement": [
     {
       "Effect": "Allow",
       "Principal": {
         "Service": "elasticmapreduce.amazonaws.com"
       },
       "Action": "sts:AssumeRole"
     }
   ]
 }
 EoF
  
 aws iam create-role --role-name EMRContainers-JobExecutionRole --assume-role-policy-document file://~/environment/emr-trust-policy.json
```

Selanjutnya, kita perlu melampirkan kebijakan IAM yang diperlukan ke peran sehingga dapat menulis log ke s3 dan cloudwatch.

```
cat <<EoF > ~/environment/EMRContainers-JobExecutionRole.json
 {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
         {
             "Effect": "Allow",
             "Action": [
                 "s3:PutObject",
                 "s3:GetObject",
                 "s3:ListBucket"
             ],
             "Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
         },
         {
             "Effect": "Allow",
             "Action": [
                 "logs:PutLogEvents",
                 "logs:CreateLogStream",
               "logs:DescribeLogGroups",
                 "logs:DescribeLogStreams"
             ],
             "Resource": [
                 "arn:aws:logs:*:*:*"
             ]
         }
     ]
 } 
 EoF
 aws iam put-role-policy --role-name EMRContainers-JobExecutionRole --policy-name EMR-Containers-Job-Execution --policy-document file://~/environment/EMRContainers-JobExecutionRole.json
```

**catatan**  
Akses harus dicakup dengan tepat, tidak diberikan ke semua objek S3 dalam peran eksekusi pekerjaan.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::amzn-s3-demo-bucket"
      ],
      "Sid": "AllowS3Putobject"
    },
    {
      "Effect": "Allow",
      "Action": [
        "logs:PutLogEvents",
        "logs:CreateLogStream",
        "logs:DescribeLogGroups",
        "logs:DescribeLogStreams"
      ],
      "Resource": [
        "arn:aws:logs:*:*:*"
      ],
      "Sid": "AllowLOGSPutlogevents"
    }
  ]
}
```

------

Untuk informasi selengkapnya, lihat [Menggunakan peran eksekusi pekerjaan](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/iam-execution-role.html), [Mengonfigurasi proses pekerjaan untuk menggunakan log S3](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-s3), dan [Mengonfigurasi proses pekerjaan untuk menggunakan CloudWatch Log](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-cloudwatch).

# Perbarui kebijakan kepercayaan dari peran eksekusi tugas
<a name="setting-up-trust-policy"></a>

Ketika Anda menggunakan IAM Role untuk Akun Layanan (IRSA) untuk menjalankan tugas di namespace Kubernetes, administrator harus membuat hubungan kepercayaan antara peran eksekusi tugas dan identitas akun layanan terkelola EMR. Hubungan kepercayaan dapat dibuat dengan memperbarui kebijakan kepercayaan dari peran pelaksanaan tugas. Perhatikan bahwa akun layanan terkelola EMR secara otomatis dibuat pada pengiriman tugas, dicakup ke namespace di mana tugas dikirimkan.

Jalankan perintah berikut untuk memperbarui kebijakan kepercayaan.

```
 aws emr-containers update-role-trust-policy \
       --cluster-name cluster \
       --namespace namespace \
       --role-name iam_role_name_for_job_execution
```

Untuk informasi selengkapnya, lihat [Menggunakan peran eksekusi tugas dengan Amazon EMR di EKS](iam-execution-role.md).

**penting**  
Operator yang menjalankan perintah di atas harus memiliki izin berikut: `eks:DescribeCluster`, `iam:GetRole`, `iam:UpdateAssumeRolePolicy`.

# Memberikan pengguna akses ke Amazon EMR di EKS
<a name="setting-up-iam"></a>

Untuk setiap tindakan yang Anda lakukan di Amazon EMR di EKS, Anda memerlukan izin IAM yang sesuai untuk tindakan itu. Anda harus membuat kebijakan IAM yang memungkinkan Anda untuk melakukan tindakan Amazon EMR di EKS dan melampirkan kebijakan pada pengguna atau peran IAM yang Anda gunakan. 

Topik ini menyediakan langkah-langkah untuk membuat kebijakan baru dan melampirkannya ke pengguna. Hal ini juga mencakup izin dasar yang Anda butuhkan untuk mengatur lingkungan Amazon EMR di EKS Anda. Sebaiknya Anda menyempurnakan izin ke sumber daya tertentu bila memungkinkan berdasarkan kebutuhan bisnis Anda.

## Membuat kebijakan IAM baru dan melampirkannya ke pengguna di konsol IAM
<a name="setting-up-iam-console"></a>

**Buat kebijakan IAM baru**

1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Di panel navigasi kiri konsol IAM, pilih **Kebijakan**.

1. Pada halaman **Kebijakan**, pilih **Buat Kebijakan**.

1. Di jendela **Buat Kebijakan**, navigasikan ke tab **Edit JSON**. Buat dokumen kebijakan dengan satu atau lebih pernyataan JSON seperti yang ditunjukkan dalam contoh prosedur berikut ini. Selanjutnya, pilih **Tinjau kebijakan**.

1. Pada layar **Tinjau Kebijakan**, masukkan **Nama kebijakan**Anda, misalnya `AmazonEMROnEKSPolicy`. Masukkan deskripsi opsional, lalu pilih **Buat kebijakan**. 

**Lampirkan kebijakan ke pengguna atau peran**

1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 

1. Di panel navigasi, pilih **Kebijakan**.

1. Dalam daftar kebijakan, pilih kotak centang di samping kebijakan yang dibuat dalam bagian sebelumnya. Anda bisa memakai menu **Filter** dan kotak pencarian untuk memfilter daftar kebijakan. 

1. Pilih **Tindakan kebijakan**, lalu pilih **Lampirkan**.

1. Pilih pengguna atau peran untuk melampirkan kebijakan. Anda bisa memakai menu **Filter** dan kotak pencarian untuk memfilter daftar entitas prinsipiel. Setelah memilih pengguna atau peran untuk melampirkan kebijakan, pilih **Lampirkan kebijakan**.

## Izin untuk mengelolaklaster virtual
<a name="permissions-virtual-cluster"></a>

Untuk mengelola klaster virtual di AWS akun Anda, buat kebijakan IAM dengan izin berikut. Izin ini memungkinkan Anda membuat, membuat daftar, mendeskripsikan, dan menghapus klaster virtual di akun Anda AWS .

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:CreateServiceLinkedRole"
      ],
      "Resource": [
        "*"
      ],
      "Condition": {
        "StringLike": {
          "iam:AWSServiceName": "emr-containers.amazonaws.com"
        }
      },
      "Sid": "AllowIAMCreateservicelinkedrole"
    },
    {
      "Effect": "Allow",
      "Action": [
        "emr-containers:CreateVirtualCluster",
        "emr-containers:ListVirtualClusters",
        "emr-containers:DescribeVirtualCluster",
        "emr-containers:DeleteVirtualCluster"
      ],
      "Resource": [
        "*"
      ],
      "Sid": "AllowEMRCONTAINERSCreatevirtualcluster"
    }
  ]
}
```

------

Amazon EMR terintegrasi dengan Amazon EKS cluster access management (CAM), sehingga Anda dapat mengotomatiskan konfigurasi kebijakan AuthN dan AuthZ yang diperlukan untuk menjalankan pekerjaan Amazon EMR Spark di ruang nama cluster Amazon EKS. Untuk melakukannya, Anda harus memiliki izin berikut:

```
{
  "Effect": "Allow",
  "Action": [
    "eks:CreateAccessEntry"
  ],
  "Resource": "arn:<AWS_PARTITION>:eks:<AWS_REGION>:<AWS_ACCOUNT_ID>:cluster/<EKS_CLUSTER_NAME>"
}, 
{
  "Effect": "Allow",
  "Action": [
    "eks:DescribeAccessEntry",
    "eks:DeleteAccessEntry",
    "eks:ListAssociatedAccessPolicies",
    "eks:AssociateAccessPolicy",
    "eks:DisassociateAccessPolicy"
  ],
  "Resource": "arn:<AWS_PARTITION>:eks:<AWS_REGION>:<AWS_ACCOUNT_ID>:access-entry/<EKS_CLUSTER_NAME>/role/<AWS_ACCOUNT_ID>/AWSServiceRoleForAmazonEMRContainers/*"
}
```

Untuk informasi selengkapnya, lihat [Mengotomatiskan mengaktifkan akses klaster untuk Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html#setting-up-cluster-access-cam-integration) di EKS.

Saat `CreateVirtualCluster` operasi dipanggil untuk pertama kalinya dari AWS akun, Anda juga memerlukan `CreateServiceLinkedRole` izin untuk membuat peran terkait layanan untuk Amazon EMR di EKS. Untuk informasi selengkapnya, lihat [Menggunakan peran terkait layanan untuk Amazon EMR di EKS](using-service-linked-roles.md). 

## Izin untuk mengirimkan tugas
<a name="permissions-submitting-jobs"></a>

Untuk mengirimkan pekerjaan di klaster virtual di AWS akun Anda, buat kebijakan IAM dengan izin berikut. Izin ini memungkinkan Anda untuk memulai, mendaftar, menjelaskan, dan membatalkan klaster virtual di akun Anda. Anda harus mempertimbangkan menambahkan izin untuk membuat daftar atau menjelaskan klaster virtual, yang memungkinkan Anda untuk memeriksa keadaan klaster virtual sebelum mengirimkan tugas.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "emr-containers:StartJobRun",
        "emr-containers:ListJobRuns",
        "emr-containers:DescribeJobRun",
        "emr-containers:CancelJobRun"
      ],
      "Resource": [
        "*"
      ],
      "Sid": "AllowEMRCONTAINERSStartjobrun"
    }
  ]
}
```

------

## Izin untuk melakukan debug dan pemantauan
<a name="permissions-debugging-monitoring"></a>

Untuk mendapatkan akses ke log yang didorong ke Amazon S3 dan CloudWatch, atau untuk melihat log peristiwa aplikasi di konsol EMR Amazon, buat kebijakan IAM dengan izin berikut. Sebaiknya Anda menyempurnakan izin ke sumber daya tertentu bila memungkinkan berdasarkan kebutuhan bisnis Anda.

**penting**  
Jika Anda belum membuat bucket Amazon S3, Anda perlu menambahkan izin `s3:CreateBucket` pada pernyataan kebijakan. Jika Anda belum membuat grup log, Anda perlu menambahkan `logs:CreateLogGroup` pada pernyataan kebijakan.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "emr-containers:DescribeJobRun",
        "elasticmapreduce:CreatePersistentAppUI",
        "elasticmapreduce:DescribePersistentAppUI",
        "elasticmapreduce:GetPersistentAppUIPresignedURL"
      ],
      "Resource": [
        "*"
      ],
      "Sid": "AllowEMRCONTAINERSDescribejobrun"
    },
    {
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "*"
      ],
      "Sid": "AllowS3Getobject"
    },
    {
      "Effect": "Allow",
      "Action": [
        "logs:Get*",
        "logs:DescribeLogGroups",
        "logs:DescribeLogStreams"
      ],
      "Resource": [
        "*"
      ],
      "Sid": "AllowLOGSGet"
    }
  ]
}
```

------

Untuk informasi selengkapnya tentang cara mengonfigurasi proses pekerjaan untuk mendorong log ke Amazon S3 dan CloudWatch, lihat [Mengonfigurasi proses pekerjaan untuk menggunakan log S3](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-s3) dan [Mengonfigurasi proses pekerjaan untuk menggunakan Log](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-cloudwatch). CloudWatch 

# Daftarkan klaster Amazon EKS dengan Amazon EMR
<a name="setting-up-registration"></a>

Mendaftarkan klaster Anda adalah langkah terakhir yang diperlukan untuk mengatur Amazon EMR di EKS untuk menjalankan beban kerja.

Gunakan perintah berikut untuk membuat klaster virtual dengan nama pilihan Anda untuk klaster Amazon EKS dan namespace yang Anda atur dalam langkah-langkah sebelumnya.

**catatan**  
Setiap cluster virtual harus memiliki nama unik di semua cluster EKS. Jika dua cluster virtual memiliki nama yang sama, proses penyebaran akan gagal bahkan jika dua cluster virtual milik cluster EKS yang berbeda. 

```
aws emr-containers create-virtual-cluster \
--name virtual_cluster_name \
--container-provider '{
    "id": "cluster_name",
    "type": "EKS",
    "info": {
        "eksInfo": {
            "namespace": "namespace_name"
        }
    }
}'
```

Atau, Anda dapat membuat file JSON yang mencakup parameter yang diperlukan untuk klaster virtual dan kemudian jalankan perintah `create-virtual-cluster` dengan jalur ke file JSON. Untuk informasi selengkapnya, lihat [Mengelola klaster virtual](virtual-cluster.md).

**catatan**  
Untuk memvalidasi keberhasilan pembuatan klaster virtual, lihat status klaster virtual menggunakan operasi `list-virtual-clusters` atau dengan masuk ke halaman **Klaster Virtual** di konsol Amazon EMR. 

# Kirim pekerjaan yang dijalankan dengan `StartJobRun`
<a name="emr-eks-jobs-submit"></a>

**Untuk mengirimkan pekerjaan yang dijalankan dengan file JSON dengan parameter tertentu**

1. Buat file `start-job-run-request.json` dan tentukan parameter yang diperlukan untuk menjalankan tugas Anda, seperti contoh yang ditunjukkan file JSON berikut. Untuk informasi tentang parameter, lihat [Pilihan untuk mengonfigurasi tugas berjalan](emr-eks-jobs-CLI.md#emr-eks-jobs-parameters).

   ```
   {
     "name": "myjob", 
     "virtualClusterId": "123456",  
     "executionRoleArn": "iam_role_name_for_job_execution", 
     "releaseLabel": "emr-6.2.0-latest", 
     "jobDriver": {
       "sparkSubmitJobDriver": {
         "entryPoint": "entryPoint_location",
         "entryPointArguments": ["argument1", "argument2", ...],  
          "sparkSubmitParameters": "--class <main_class> --conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"
       }
     }, 
     "configurationOverrides": {
       "applicationConfiguration": [
         {
           "classification": "spark-defaults", 
           "properties": {
             "spark.driver.memory":"2G"
            }
         }
       ], 
       "monitoringConfiguration": {
         "persistentAppUI": "ENABLED", 
         "cloudWatchMonitoringConfiguration": {
           "logGroupName": "my_log_group", 
           "logStreamNamePrefix": "log_stream_prefix"
         }, 
         "s3MonitoringConfiguration": {
           "logUri": "s3://my_s3_log_location"
         }
       }
     }
   }
   ```

1. Gunakan `start-job-run` perintah dengan path ke `start-job-run-request.json` file yang disimpan secara lokal.

   ```
   aws emr-containers start-job-run \
   --cli-input-json file://./start-job-run-request.json
   ```

**Untuk memulai tugas berjalan menggunakan perintah `start-job-run`**

1. Pasokan semua parameter yang ditentukan dalam perintah `StartJobRun`, seperti yang ditunjukkan contoh berikut.

   ```
   aws emr-containers start-job-run \
   --virtual-cluster-id 123456 \
   --name myjob \
   --execution-role-arn execution-role-arn \
   --release-label emr-6.2.0-latest \
   --job-driver '{"sparkSubmitJobDriver": {"entryPoint": "entryPoint_location", "entryPointArguments": ["argument1", "argument2", ...], "sparkSubmitParameters": "--class <main_class> --conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"}}' \
   --configuration-overrides '{"applicationConfiguration": [{"classification": "spark-defaults", "properties": {"spark.driver.memory": "2G"}}], "monitoringConfiguration": {"cloudWatchMonitoringConfiguration": {"logGroupName": "log_group_name", "logStreamNamePrefix": "log_stream_prefix"}, "persistentAppUI":"ENABLED",  "s3MonitoringConfiguration": {"logUri": "s3://my_s3_log_location" }}}'
   ```

1. Untuk Spark SQL, sediakan semua parameter yang ditentukan dalam `StartJobRun` perintah, seperti yang ditunjukkan contoh berikut.

   ```
   aws emr-containers start-job-run \
   --virtual-cluster-id 123456 \
   --name myjob \
   --execution-role-arn execution-role-arn \
   --release-label emr-6.7.0-latest \
   --job-driver '{"sparkSqlJobDriver": {"entryPoint": "entryPoint_location", "sparkSqlParameters": "--conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"}}' \
   --configuration-overrides '{"applicationConfiguration": [{"classification": "spark-defaults", "properties": {"spark.driver.memory": "2G"}}], "monitoringConfiguration": {"cloudWatchMonitoringConfiguration": {"logGroupName": "log_group_name", "logStreamNamePrefix": "log_stream_prefix"}, "persistentAppUI":"ENABLED",  "s3MonitoringConfiguration": {"logUri": "s3://my_s3_log_location" }}}'
   ```

# Menggunakan klasifikasi pengirim pekerjaan
<a name="emr-eks-job-submitter"></a>

## Ikhtisar
<a name="emr-eks-job-submitter-overview"></a>

EMR Amazon `StartJobRun` berdasarkan permintaan EKS membuat pod *pengirim pekerjaan* (juga dikenal sebagai pod *job-runner*) untuk menelurkan driver Spark. Anda dapat menggunakan `emr-job-submitter` klasifikasi untuk mengonfigurasi pemilih node, menambahkan toleransi, menyesuaikan logging, dan membuat modifikasi lain pada pod pengirim pekerjaan.

Pengaturan berikut tersedia di bawah `emr-job-submitter` klasifikasi:

** `jobsubmitter.node.selector.[selectorKey]` **  
Menambahkan ke pemilih node dari pod pengirim pekerjaan, dengan kunci *selectorKey* dan nilai sebagai nilai konfigurasi. Misalnya, Anda dapat mengatur ` jobsubmitter.node.selector.identifier` ke `myIdentifier` dan pod pengirim pekerjaan akan memiliki pemilih node dengan kunci `identifier` dan nilai. `myIdentifier` Ini dapat digunakan untuk menentukan node mana pod pengirim pekerjaan dapat ditempatkan. Untuk menambahkan beberapa kunci pemilih node, atur beberapa konfigurasi dengan awalan ini.

** `jobsubmitter.label.[labelKey]` **  
Menambahkan label pod pengirim pekerjaan, dengan kunci *labelKey* dan nilai sebagai nilai konfigurasi. Untuk menambahkan beberapa label, atur beberapa konfigurasi dengan awalan ini.

** `jobsubmitter.annotation.[annotationKey]` **  
Menambahkan anotasi pod pengirim pekerjaan, dengan kunci *annotationKey* dan nilai sebagai nilai konfigurasi. Untuk menambahkan beberapa anotasi, atur beberapa konfigurasi dengan awalan ini.

** `jobsubmitter.node.toleration.[tolerationKey]` **  
Menambahkan [toleransi ke pod pengirim](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/) pekerjaan. Secara default tidak ada toleransi yang ditambahkan ke pod. Kunci toleransi akan menjadi *tolerationKey* dan nilai toleransi akan menjadi nilai konfigurasi. Jika nilai konfigurasi diatur ke string yang tidak kosong, operator akan menjadi`Equals`. Jika nilai konfigurasi diatur ke`""`, maka operator akan`Exists`.

** `jobsubmitter.node.toleration.[tolerationKey].[effect]` **  
Menambahkan efek toleransi ke awalan*tolerationKey*. Bidang ini diperlukan saat menambahkan toleransi. Nilai yang diizinkan untuk bidang efek adalah` NoExecute`,`NoSchedule`, dan`PreferNoSchedule`.

** `jobsubmitter.node.toleration.[tolerationKey].[tolerationSeconds]` **  
Menambahkan TolerationSeconds ke awalan. *tolerationKey* Bidang opsional. Hanya berlaku ketika efeknya`NoExecute`.

** `jobsubmitter.scheduler.name` **  
Menetapkan schedulerName kustom untuk pod pengirim pekerjaan.

** `jobsubmitter.logging` **  
Mengaktifkan atau menonaktifkan logging pada pod pengirim pekerjaan. Ketika ini disetel ke ` DISABLED` container logging akan dihapus dari pod pengirim pekerjaan, yang akan menonaktifkan setiap logging untuk pod ini yang ditentukan dalam`monitoringConfiguration`, seperti `s3MonitoringConfiguration` or. `cloudWatchMonitoringConfiguration` Ketika pengaturan ini tidak disetel atau disetel ke nilai lain, logging pada pod pengirim pekerjaan diaktifkan.

** `jobsubmitter.logging.image` **  
Menetapkan gambar kustom yang akan digunakan untuk penampung logging pada pod pengirim pekerjaan.

** `jobsubmitter.logging.request.cores` **  
Menetapkan nilai kustom untuk jumlah CPUs, dalam unit CPU, untuk penampung logging pada pod pengirim pekerjaan. Secara default, ini diatur ke **100m**.

** `jobsubmitter.logging.request.memory` **  
Menetapkan nilai kustom untuk jumlah memori, dalam byte, untuk penampung logging pada pod pengirim pekerjaan. Secara default, ini diatur ke **200Mi**. Mebibyte adalah satuan ukuran yang mirip dengan megabyte.

** `jobsubmitter.container.image` **  
Menetapkan image kustom untuk container pod job submitter. `job-runner`

** `jobsubmitter.container.image.pullPolicy` **  
Menetapkan [imagePullPolicy](https://kubernetes.io/docs/concepts/containers/images/#image-pull-policy)container untuk job submitter pod.

Kami merekomendasikan untuk menempatkan pod pengirim pekerjaan pada Instans Sesuai Permintaan. Menempatkan pod pengirim pekerjaan pada instans Spot dapat mengakibatkan kegagalan pekerjaan jika instance tempat pod pengirim pekerjaan berjalan tunduk pada interupsi Instance Spot. Kamu juga bisa [menempatkan job submitter pod dalam Availability Zone tunggal atau menggunakan label Kubernetes yang diterapkan](#emr-eks-job-submitter-ex-ec2) pada node.

## Contoh klasifikasi pengirim pekerjaan
<a name="emr-eks-job-submitter-examples"></a>

**Topics**
+ [`StartJobRun`permintaan dengan penempatan node On-Demand untuk pod pengirim pekerjaan](#emr-eks-job-submitter-ex-od)
+ [`StartJobRun`request dengan penempatan node single-AZ dan penempatan tipe instans Amazon EC2 untuk pod pengirim pekerjaan](#emr-eks-job-submitter-ex-ec2)
+ [`StartJobRun`permintaan dengan label, anotasi, dan penjadwal khusus untuk pod pengirim pekerjaan](#emr-eks-job-submitter-label-annotation-scheduler)
+ [`StartJobRun`permintaan dengan toleransi yang diterapkan pada pod pengirim pekerjaan dengan kunci`dedicated`, nilai, efek `graviton_machines``NoExecute`, dan 60 detik `tolerationSeconds`](#emr-eks-job-submitter-tolerations)
+ [`StartJobRun`permintaan dengan logging dinonaktifkan untuk pod pengirim pekerjaan](#emr-eks-job-submitter-logging-disabled)
+ [`StartJobRun`permintaan dengan image container logging kustom, CPU, dan memori untuk pod pengirim pekerjaan](#emr-eks-job-submitter-custom)
+ [`StartJobRun`permintaan dengan gambar kontainer pengirim pekerjaan khusus dan kebijakan tarik](#emr-eks-job-submitter-custom-container)

### `StartJobRun`permintaan dengan penempatan node On-Demand untuk pod pengirim pekerjaan
<a name="emr-eks-job-submitter-ex-od"></a>

```
cat >spark-python-in-s3-nodeselector-job-submitter.json << EOF
{
  "name": "spark-python-in-s3-nodeselector", 
  "virtualClusterId": "virtual-cluster-id", 
  "executionRoleArn": "execution-role-arn", 
  "releaseLabel": "emr-6.11.0-latest", 
  "jobDriver": {
    "sparkSubmitJobDriver": {
      "entryPoint": "s3://S3-prefix/trip-count.py", 
      "sparkSubmitParameters": "--conf spark.driver.cores=5  --conf spark.executor.memory=20G --conf spark.driver.memory=15G --conf spark.executor.cores=6"
    }
  }, 
  "configurationOverrides": {
    "applicationConfiguration": [
      {
        "classification": "spark-defaults", 
        "properties": {
          "spark.dynamicAllocation.enabled":"false"
        }
      },
      {
        "classification": "emr-job-submitter",
        "properties": {
          "jobsubmitter.node.selector.eks.amazonaws.com/capacityType": "ON_DEMAND"
        }
      }
    ], 
    "monitoringConfiguration": {
      "cloudWatchMonitoringConfiguration": {
        "logGroupName": "/emr-containers/jobs", 
        "logStreamNamePrefix": "demo"
      }, 
      "s3MonitoringConfiguration": {
        "logUri": "s3://joblogs"
      }
    }
  }
}
EOF
aws emr-containers start-job-run --cli-input-json file:///spark-python-in-s3-nodeselector-job-submitter.json
```

### `StartJobRun`request dengan penempatan node single-AZ dan penempatan tipe instans Amazon EC2 untuk pod pengirim pekerjaan
<a name="emr-eks-job-submitter-ex-ec2"></a>

```
"configurationOverrides": {
  "applicationConfiguration": [
    {
      "classification": "emr-job-submitter",
      "properties": {
        "jobsubmitter.node.selector.topology.kubernetes.io/zone": "Availability Zone",
        "jobsubmitter.node.selector.node.kubernetes.io/instance-type":"m5.4xlarge"
      }
    }
  ]
}
```

### `StartJobRun`permintaan dengan label, anotasi, dan penjadwal khusus untuk pod pengirim pekerjaan
<a name="emr-eks-job-submitter-label-annotation-scheduler"></a>

```
"configurationOverrides": { 
  "applicationConfiguration": [ 
    {
      "classification": "emr-job-submitter", 
      "properties": {
        "jobsubmitter.label.label1": "value1",
        "jobsubmitter.label.label2": "value2",
        "jobsubmitter.annotation.ann1": "value1",
        "jobsubmitter.annotation.ann2": "value2",
        "jobsubmitter.scheduler.name": "custom-scheduler"
      }
    }
  ]
}
```

### `StartJobRun`permintaan dengan toleransi yang diterapkan pada pod pengirim pekerjaan dengan kunci`dedicated`, nilai, efek `graviton_machines``NoExecute`, dan 60 detik `tolerationSeconds`
<a name="emr-eks-job-submitter-tolerations"></a>

```
"configurationOverrides": {
  "applicationConfiguration": [
    {
      "classification": "emr-job-submitter",
      "properties": {
        "jobsubmitter.node.toleration.dedicated":"graviton_machines",
        "jobsubmitter.node.toleration.dedicated.effect":"NoExecute",
        "jobsubmitter.node.toleration.dedicated.tolerationSeconds":"60"
      }
    }
  ]
}
```

### `StartJobRun`permintaan dengan logging dinonaktifkan untuk pod pengirim pekerjaan
<a name="emr-eks-job-submitter-logging-disabled"></a>

```
"configurationOverrides": {
  "applicationConfiguration": [
    {
      "classification": "emr-job-submitter",
      "properties": {
        "jobsubmitter.logging": "DISABLED"
      }
    }
  ], 
  "monitoringConfiguration": {
    "cloudWatchMonitoringConfiguration": {
      "logGroupName": "/emr-containers/jobs", 
      "logStreamNamePrefix": "demo"
    }, 
    "s3MonitoringConfiguration": {
      "logUri": "s3://joblogs"
    }
  }
}
```

### `StartJobRun`permintaan dengan image container logging kustom, CPU, dan memori untuk pod pengirim pekerjaan
<a name="emr-eks-job-submitter-custom"></a>

```
"configurationOverrides": {
  "applicationConfiguration": [
    {
      "classification": "emr-job-submitter",
      "properties": {
        "jobsubmitter.logging.image": "YOUR_ECR_IMAGE_URL",
        "jobsubmitter.logging.request.memory": "200Mi",
        "jobsubmitter.logging.request.cores": "0.5"
      }
    }
  ], 
  "monitoringConfiguration": {
    "cloudWatchMonitoringConfiguration": {
      "logGroupName": "/emr-containers/jobs", 
      "logStreamNamePrefix": "demo"
    }, 
    "s3MonitoringConfiguration": {
      "logUri": "s3://joblogs"
    }
  }
}
```

### `StartJobRun`permintaan dengan gambar kontainer pengirim pekerjaan khusus dan kebijakan tarik
<a name="emr-eks-job-submitter-custom-container"></a>

```
"configurationOverrides": {
  "applicationConfiguration": [
    {
      "classification": "emr-job-submitter",
      "properties": {
        "jobsubmitter.container.image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/emr6.11_custom_repo",
        "jobsubmitter.container.image.pullPolicy": "kubernetes pull policy"
      }
    }
  ]
}
```

# Menggunakan klasifikasi default penampung EMR Amazon
<a name="emr-eks-job-submitter-container-defaults"></a>

## Ikhtisar
<a name="emr-eks-job-submitter-container-defaults-overview"></a>

Pengaturan berikut tersedia di bawah `emr-containers-defaults` klasifikasi:

** `job-start-timeout` **  
Secara default, pekerjaan akan habis jika tidak dapat dimulai dan menunggu di ` SUBMITTED` negara bagian selama 15 menit. Konfigurasi ini mengubah jumlah detik untuk menunggu sebelum waktu kerja habis.

** `executor.logging` **  
Mengaktifkan atau menonaktifkan logging pada pod eksekutor. Ketika ini disetel ke ` DISABLED` container logging akan dihapus dari pod eksekutor, yang akan menonaktifkan setiap logging untuk pod ini yang ditentukan dalam`monitoringConfiguration`, seperti `s3MonitoringConfiguration` atau`cloudWatchMonitoringConfiguration`. Ketika pengaturan ini tidak disetel atau disetel ke nilai lain, logging pada pod pelaksana diaktifkan.

** `logging.image` **  
Menetapkan gambar kustom yang akan digunakan untuk penampung logging pada driver dan pod eksekutor.

** `logging.request.cores` **  
Menetapkan nilai kustom untuk jumlah CPUs, dalam unit CPU, untuk container logging pada driver dan executor pod. Secara default, ini tidak diatur.

** `logging.request.memory` **  
Menetapkan nilai kustom untuk jumlah memori, dalam byte, untuk container logging pada driver dan executor pod. Secara default, ini diatur ke **512Mi**. Mebibyte adalah satuan ukuran yang mirip dengan megabyte.

## Contoh klasifikasi pengirim pekerjaan
<a name="emr-eks-job-submitter-container-examples"></a>

**Topics**
+ [`StartJobRun`permintaan dengan batas waktu kerja khusus](#emr-eks-job-submitter-container-custom-timeout)
+ [`StartJobRun`permintaan dengan logging dinonaktifkan untuk pod pelaksana](#emr-eks-executor-logging-disabled)
+ [`StartJobRun`permintaan dengan image container logging kustom, CPU, dan memori untuk driver dan pod pelaksana](#emr-eks-job-submitter-container-custom-image-cpu)

### `StartJobRun`permintaan dengan batas waktu kerja khusus
<a name="emr-eks-job-submitter-container-custom-timeout"></a>

```
{
  "name": "spark-python", 
  "virtualClusterId": "virtual-cluster-id", 
  "executionRoleArn": "execution-role-arn", 
  "releaseLabel": "emr-6.11.0-latest", 
  "jobDriver": {
    "sparkSubmitJobDriver": {
      "entryPoint": "s3://S3-prefix/trip-count.py"
    }
  }, 
  "configurationOverrides": {
    "applicationConfiguration": [
      {
        "classification": "emr-containers-defaults", 
        "properties": {
          "job-start-timeout": "1800"
        }
      }
    ], 
    "monitoringConfiguration": {
      "cloudWatchMonitoringConfiguration": {
        "logGroupName": "/emr-containers/jobs", 
        "logStreamNamePrefix": "demo"
      }, 
      "s3MonitoringConfiguration": {
        "logUri": "s3://joblogs"
      }
    }
  }
}
```

### `StartJobRun`permintaan dengan logging dinonaktifkan untuk pod pelaksana
<a name="emr-eks-executor-logging-disabled"></a>

```
"configurationOverrides": {
  "applicationConfiguration": [
    {
      "classification": "emr-containers-defaults", 
      "properties": {
        "executor.logging": "DISABLED"
      }
    }
  ], 
  "monitoringConfiguration": {
    "cloudWatchMonitoringConfiguration": {
      "logGroupName": "/emr-containers/jobs", 
      "logStreamNamePrefix": "demo"
    }, 
    "s3MonitoringConfiguration": {
      "logUri": "s3://joblogs"
    }
  }
}
```

### `StartJobRun`permintaan dengan image container logging kustom, CPU, dan memori untuk driver dan pod pelaksana
<a name="emr-eks-job-submitter-container-custom-image-cpu"></a>

```
"configurationOverrides": {
  "applicationConfiguration": [
    {
      "classification": "emr-containers-defaults", 
      "properties": {
        "logging.image": "YOUR_ECR_IMAGE_URL",
        "logging.request.memory": "200Mi",
        "logging.request.cores": "0.5"
      }
    }
  ], 
  "monitoringConfiguration": {
    "cloudWatchMonitoringConfiguration": {
      "logGroupName": "/emr-containers/jobs", 
      "logStreamNamePrefix": "demo"
    }, 
    "s3MonitoringConfiguration": {
      "logUri": "s3://joblogs"
    }
  }
}
```

# Menjalankan pekerjaan Spark dengan operator Spark
<a name="spark-operator"></a>

Amazon EMR merilis 6.10.0 dan lebih tinggi mendukung operator Kubernetes untuk Apache Spark, atau operator Spark, *sebagai model pengiriman pekerjaan untuk Amazon EMR di* EKS. Dengan operator Spark, Anda dapat menerapkan dan mengelola aplikasi Spark dengan runtime rilis Amazon EMR di kluster Amazon EKS Anda sendiri. Setelah Anda menerapkan operator Spark di cluster Amazon EKS Anda, Anda dapat langsung mengirimkan aplikasi Spark dengan operator. Operator 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 operator Spark untuk Amazon EMR di EKS](spark-operator-setup.md)
+ [Memulai dengan operator Spark untuk Amazon EMR di EKS](spark-operator-gs.md)
+ [Gunakan penskalaan otomatis vertikal dengan operator Spark untuk Amazon EMR di EKS](spark-operator-vas.md)
+ [Menghapus instalasi operator Spark untuk Amazon EMR di EKS](spark-operator-uninstall.md)
+ [Menggunakan konfigurasi pemantauan untuk memantau operator Spark Kubernetes dan pekerjaan Spark](spark-operator-monitoring-configuration.md)
+ [Keamanan dan operator Spark dengan Amazon EMR di EKS](spark-operator-security.md)

# Menyiapkan operator Spark untuk Amazon EMR di EKS
<a name="spark-operator-setup"></a>

Selesaikan tugas-tugas berikut untuk menyiapkan sebelum Anda menginstal operator Spark di Amazon EKS. Jika Anda sudah mendaftar untuk Amazon Web Services (AWS) dan telah menggunakan Amazon EKS, Anda hampir siap untuk menggunakan Amazon EMR di EKS. Selesaikan tugas-tugas berikut untuk menyiapkan operator Spark di Amazon EKS. Jika Anda telah menyelesaikan salah satu prasyarat, Anda dapat melewatinya dan melanjutkan ke yang berikutnya.
+ **[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 URI gambar dasar EMR Amazon](docker-custom-images-tag.md) (rilis 6.10.0 atau lebih tinggi)** — operator Spark didukung dengan rilis Amazon EMR 6.10.0 dan yang lebih tinggi.

# Memulai dengan operator Spark untuk Amazon EMR di EKS
<a name="spark-operator-gs"></a>

Topik ini membantu Anda mulai menggunakan operator Spark di Amazon EKS dengan menerapkan aplikasi Spark dan aplikasi Schedule Spark.

## Instal operator Spark
<a name="spark-operator-install"></a>

Gunakan langkah-langkah berikut untuk menginstal operator Kubernetes untuk Apache Spark.

1. Jika Anda belum melakukannya, selesaikan langkah-langkahnya[Menyiapkan operator Spark untuk Amazon EMR di EKS](spark-operator-setup.md).

1. Otentikasi klien Helm Anda ke registri Amazon ECR. Dalam perintah berikut, ganti *region-id* nilai dengan pilihan Anda Wilayah AWS, dan *ECR-registry-account* nilai yang sesuai untuk Wilayah dari [Akun registri Amazon ECR berdasarkan Wilayah](docker-custom-images-tag.md#docker-custom-images-ECR) halaman.

   ```
   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 operator Spark dengan perintah berikut.

   Untuk `--version` parameter bagan Helm, gunakan label rilis Amazon EMR Anda dengan awalan dan `emr-` akhiran tanggal dihapus. Misalnya, dengan `emr-6.12.0-java17-latest` rilis, tentukan`6.12.0-java17`. Contoh dalam perintah berikut menggunakan `emr-7.12.0-latest` rilis, sehingga menentukan `7.12.0` bagan Helm. `--version`

   ```
   helm install spark-operator-demo \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/spark-operator \
     --set emrContainers.awsRegion=region-id \
     --version 7.12.0 \
     --namespace spark-operator \
     --create-namespace
   ```

   Secara default, perintah membuat akun layanan `emr-containers-sa-spark-operator` untuk operator Spark. Untuk menggunakan akun layanan yang berbeda, berikan argumennya`serviceAccounts.sparkoperator.name`. Contoh:

   ```
   --set serviceAccounts.sparkoperator.name my-service-account-for-spark-operator
   ```

   Jika Anda ingin [menggunakan penskalaan otomatis vertikal dengan operator Spark](), tambahkan baris berikut ke perintah instalasi untuk mengizinkan webhook untuk operator:

   ```
   --set webhook.enable=true
   ```

1. Verifikasi bahwa Anda menginstal bagan Helm dengan `helm list` perintah:

   ```
   helm list --namespace spark-operator -o yaml
   ```

   `helm list`Perintah harus mengembalikan informasi rilis bagan Helm yang baru Anda gunakan:

   ```
   app_version: v1beta2-1.3.8-3.1.1
   chart: spark-operator-7.12.0
   name: spark-operator-demo
   namespace: spark-operator
   revision: "1"
   status: deployed
   updated: 2023-03-14 18:20:02.721638196 +0000 UTC
   ```

1. Instalasi lengkap dengan opsi tambahan apa pun yang Anda butuhkan. Untuk informasi lebih lanjut, lihat [https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/blob/master/charts/spark-operator-chart/README.md](https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/blob/master/charts/spark-operator-chart/README.md)dokumentasi di GitHub.

## Jalankan aplikasi Spark
<a name="spark-operator-run"></a>

Operator Spark didukung dengan Amazon EMR 6.10.0 atau lebih tinggi. Ketika Anda menginstal operator Spark, itu membuat akun layanan `emr-containers-sa-spark` untuk menjalankan aplikasi Spark secara default. Gunakan langkah-langkah berikut untuk menjalankan aplikasi Spark dengan operator Spark di Amazon EMR di EKS 6.10.0 atau lebih tinggi.

1. Sebelum Anda dapat menjalankan aplikasi Spark dengan operator Spark, selesaikan langkah-langkah di [Menyiapkan operator Spark untuk Amazon EMR di EKS](spark-operator-setup.md) dan. [Instal operator Spark](#spark-operator-install) 

1. Buat file `SparkApplication` definisi `spark-pi.yaml` dengan isi contoh berikut: 

   ```
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: spark-pi
     namespace: spark-operator
   spec:
     type: Scala
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.SparkPi
     mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples.jar"
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     volumes:
       - name: "test-volume"
         hostPath:
           path: "/tmp"
           type: Directory
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: emr-containers-sa-spark
       volumeMounts:
         - name: "test-volume"
           mountPath: "/tmp"
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
       volumeMounts:
         - name: "test-volume"
           mountPath: "/tmp"
   ```

1. Sekarang, kirimkan aplikasi Spark dengan perintah berikut. Ini juga akan membuat `SparkApplication` objek bernama`spark-pi`:

   ```
   kubectl apply -f spark-pi.yaml
   ```

1. Periksa peristiwa untuk `SparkApplication` objek dengan perintah berikut: 

   ```
   kubectl describe sparkapplication spark-pi --namespace spark-operator
   ```

Untuk informasi selengkapnya tentang mengirimkan aplikasi ke Spark melalui operator Spark, lihat [Menggunakan a `SparkApplication`](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) dalam dokumentasi pada. `spark-on-k8s-operator` GitHub

## Gunakan Amazon S3 untuk penyimpanan
<a name="spark-operator-s3-storage"></a>

Untuk menggunakan Amazon S3 sebagai opsi penyimpanan file Anda, tambahkan konfigurasi berikut ke file YAMM Anda.

```
hadoopConf:
# EMRFS filesystem
  fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
  fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
  fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
  fs.s3.buffer.dir: /mnt/s3
  fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
  mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
  mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
sparkConf:
 # Required for EMR Runtime
 spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
 spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
 spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
 spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
```

 Jika Anda menggunakan Amazon EMR rilis 7.2.0 dan yang lebih tinggi, konfigurasi disertakan secara default. Dalam hal ini, Anda dapat mengatur jalur file `s3://<bucket_name>/<file_path>` alih-alih `local://<file_path>` di file YAMM aplikasi Spark. 

Kemudian kirimkan aplikasi Spark seperti biasa.

# Gunakan penskalaan otomatis vertikal dengan operator Spark untuk Amazon EMR di EKS
<a name="spark-operator-vas"></a>

Dimulai dengan Amazon EMR 7.0, Anda dapat menggunakan Amazon EMR pada penskalaan otomatis vertikal EKS untuk menyederhanakan manajemen sumber daya. Ini secara otomatis menyetel memori dan sumber daya CPU untuk beradaptasi dengan kebutuhan beban kerja yang Anda sediakan untuk aplikasi Amazon EMR Spark. Untuk informasi selengkapnya, lihat [Menggunakan penskalaan otomatis vertikal dengan pekerjaan Amazon EMR Spark](jobruns-vas.md).

Bagian ini menjelaskan cara mengkonfigurasi operator Spark untuk menggunakan penskalaan otomatis vertikal.

## Prasyarat
<a name="spark-operator-vas-prereqs"></a>

Sebelum Anda mengonfigurasi pemantauan, pastikan untuk menyelesaikan tugas penyiapan berikut:
+ Selesaikan langkah-langkah dalam [Menyiapkan operator Spark untuk Amazon EMR di EKS](spark-operator-setup.md).
+ (opsional) Jika sebelumnya Anda menginstal versi operator Spark yang lebih lama, hapus SparkApplication/ScheduledSparkApplication CRD.

  ```
  kubectl delete crd sparkApplication
  kubectl delete crd scheduledSparkApplication
  ```
+ Selesaikan langkah-langkah dalam [Instal operator Spark](spark-operator-gs.md#spark-operator-install). Pada langkah 3, tambahkan baris berikut ke perintah instalasi untuk mengizinkan webhook untuk operator:

  ```
  --set webhook.enable=true
  ```
+ Selesaikan langkah-langkah dalam [Menyiapkan penskalaan otomatis vertikal untuk Amazon EMR di EKS](jobruns-vas-setup.md).
+ Berikan akses ke file di lokasi Amazon S3 Anda:

  1. Beri anotasi akun layanan driver dan operator Anda dengan `JobExecutionRole` yang memiliki izin S3.

     ```
     kubectl annotate serviceaccount -n spark-operator emr-containers-sa-spark eks.amazonaws.com/role-arn=JobExecutionRole
     kubectl annotate serviceaccount -n spark-operator emr-containers-sa-spark-operator eks.amazonaws.com/role-arn=JobExecutionRole
     ```

  1. Perbarui kebijakan kepercayaan peran eksekusi pekerjaan Anda di namespace tersebut.

     ```
     aws emr-containers update-role-trust-policy \
     --cluster-name cluster \
     --namespace ${Namespace}\
     --role-name iam_role_name_for_job_execution
     ```

  1. Edit kebijakan kepercayaan peran IAM dari peran eksekusi pekerjaan Anda dan perbarui `serviceaccount` dari `emr-containers-sa-spark-*-*-xxxx` ke`emr-containers-sa-*`.

     ```
     {
         "Effect": "Allow",
         "Principal": {
             "Federated": "OIDC-provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
             "StringLike": {
                 "OIDC": "system:serviceaccount:${Namespace}:emr-containers-sa-*"
             }
         }
     }
     ```

  1. Jika Anda menggunakan Amazon S3 sebagai penyimpanan file, tambahkan default berikut ke file yaml Anda.

     ```
     hadoopConf:
     # EMRFS filesystem
       fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
       fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
       fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
       fs.s3.buffer.dir: /mnt/s3
       fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
       mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
       mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
     sparkConf:
      # Required for EMR Runtime
      spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
      spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
      spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
      spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
     ```

## Jalankan pekerjaan dengan penskalaan otomatis vertikal pada operator Spark
<a name="spark-operator-vas-run"></a>

Sebelum Anda dapat menjalankan aplikasi Spark dengan operator Spark, Anda harus menyelesaikan langkah-langkahnya. [Prasyarat](#spark-operator-vas-prereqs) 

Untuk menggunakan penskalaan otomatis vertikal dengan operator Spark, tambahkan konfigurasi berikut ke driver untuk spesifikasi Aplikasi Spark Anda untuk mengaktifkan penskalaan otomatis vertikal:

```
dynamicSizing:
  mode: Off
  signature: "my-signature"
```

Konfigurasi ini memungkinkan penskalaan otomatis vertikal dan merupakan konfigurasi tanda tangan wajib yang memungkinkan Anda memilih tanda tangan untuk pekerjaan Anda.

Untuk informasi selengkapnya tentang konfigurasi dan nilai parameter, lihat [Mengonfigurasi penskalaan otomatis vertikal untuk Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/jobruns-vas-configure.html) di EKS. Secara default, pekerjaan Anda dikirimkan dalam mode Monitoring-Only **Off dari** penskalaan otomatis vertikal. Status pemantauan ini memungkinkan Anda menghitung dan melihat rekomendasi sumber daya tanpa melakukan penskalaan otomatis. Untuk informasi selengkapnya, lihat Mode [penskalaan otomatis vertikal](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/jobruns-vas-configure.html#jobruns-vas-parameters-opt-mode).

Berikut ini adalah file `SparkApplication` definisi sampel bernama `spark-pi.yaml` dengan konfigurasi yang diperlukan untuk menggunakan penskalaan otomatis vertikal.

```
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-pi
  namespace: spark-operator
spec:
  type: Scala
  mode: cluster
  image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-7.12.0:latest"
  imagePullPolicy: Always
  mainClass: org.apache.spark.examples.SparkPi
  mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples.jar"
  sparkVersion: "3.4.1"
  dynamicSizing:
    mode: Off
    signature: "my-signature"
  restartPolicy:
    type: Never
  volumes:
    - name: "test-volume"
      hostPath:
        path: "/tmp"
        type: Directory
  driver:
    cores: 1
    coreLimit: "1200m"
    memory: "512m"
    labels:
      version: 3.4.1
    serviceAccount: emr-containers-sa-spark
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
  executor:
    cores: 1
    instances: 1
    memory: "512m"
    labels:
      version: 3.4.1
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
```

Sekarang, kirimkan aplikasi Spark dengan perintah berikut. Ini juga akan membuat `SparkApplication` objek bernama`spark-pi`:

```
kubectl apply -f spark-pi.yaml
```

Untuk informasi selengkapnya tentang mengirimkan aplikasi ke Spark melalui operator Spark, lihat [Menggunakan a `SparkApplication`](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) dalam dokumentasi pada. `spark-on-k8s-operator` GitHub

## Memverifikasi fungsionalitas penskalaan otomatis vertikal
<a name="spark-operator-vas-verify"></a>

Untuk memverifikasi bahwa penskalaan otomatis vertikal berfungsi dengan benar untuk pekerjaan yang dikirimkan, gunakan kubectl untuk mendapatkan sumber daya `verticalpodautoscaler` kustom dan melihat rekomendasi penskalaan Anda.

```
kubectl get verticalpodautoscalers --all-namespaces \ 
-l=emr-containers.amazonaws.com/dynamic.sizing.signature=my-signature
```

Output dari kueri ini harus menyerupai yang berikut:

```
NAMESPACE        NAME                                                          MODE   CPU   MEM         PROVIDED   AGE
spark-operator   ds-p73j6mkosvc4xeb3gr7x4xol2bfcw5evqimzqojrlysvj3giozuq-vpa   Off          580026651   True       15m
```

Jika output Anda tidak terlihat serupa atau berisi kode kesalahan, lihat langkah-langkah [Memecahkan masalah Amazon EMR pada penskalaan otomatis vertikal EKS](troubleshooting-vas.md) untuk membantu menyelesaikan masalah.

Untuk menghapus pod dan aplikasi, jalankan perintah berikut:

```
kubectl delete sparkapplication spark-pi
```

# Menghapus instalasi operator Spark untuk Amazon EMR di EKS
<a name="spark-operator-uninstall"></a>

Gunakan langkah-langkah berikut untuk menghapus instalan operator Spark.

1. Hapus operator Spark menggunakan namespace yang benar. Untuk contoh ini, namespace adalah. `spark-operator-demo`

   ```
   helm uninstall spark-operator-demo -n spark-operator
   ```

1. Hapus akun layanan operator Spark:

   ```
   kubectl delete sa emr-containers-sa-spark-operator -n spark-operator
   ```

1. Hapus operator Spark `CustomResourceDefinitions` (CRDs):

   ```
   kubectl delete crd sparkapplications.sparkoperator.k8s.io
   kubectl delete crd scheduledsparkapplications.sparkoperator.k8s.io
   ```

# Menggunakan konfigurasi pemantauan untuk memantau operator Spark Kubernetes dan pekerjaan Spark
<a name="spark-operator-monitoring-configuration"></a>

Konfigurasi pemantauan memungkinkan Anda dengan mudah mengatur pengarsipan log aplikasi Spark dan log operator Anda ke Amazon S3 atau ke. Amazon CloudWatch Anda dapat memilih salah satu atau keduanya. Melakukan hal itu menambahkan sespan agen log ke pod operator spark, driver, dan pod pelaksana Anda, dan selanjutnya meneruskan log komponen ini ke sink yang dikonfigurasi.

## Prasyarat
<a name="spark-operator-monitoring-configuration-prereqs"></a>

Sebelum Anda mengonfigurasi pemantauan, pastikan untuk menyelesaikan tugas penyiapan berikut:

1. (Opsional) Jika sebelumnya Anda menginstal versi operator Spark yang lebih lama, hapus *SparkApplication/ScheduledSparkApplication*CRD.

   ```
   kubectl delete crd scheduledsparkapplications.sparkoperator.k8s.io
   kubectl delete crd sparkapplications.sparkoperator.k8s.io
   ```

1. Buat peran operator/job eksekusi di IAM jika Anda belum memilikinya.

1. Jalankan perintah berikut untuk memperbarui kebijakan kepercayaan dari peran operator/job eksekusi yang baru saja Anda buat:

   ```
   aws emr-containers update-role-trust-policy \ 
   --cluster-name cluster \
   --namespace namespace \
   --role-name iam_role_name_for_operator/job_execution_role
   ```

1. Edit kebijakan kepercayaan peran IAM dari peran operator/job eksekusi Anda menjadi berikut:

   ```
   {
       "Effect": "Allow",
       "Principal": {
           "Federated": "${OIDC-provider}"
       },
       "Action": "sts:AssumeRoleWithWebIdentity",
       "Condition": {
           "StringLike": {
               "OIDC_PROVIDER:sub": "system:serviceaccount:${Namespace}:emr-containers-sa-*"
           }
       }
   }
   ```

1. Buat kebijakan *MonitoringConfiguration* di IAM dengan izin berikut:

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "logs:DescribeLogStreams",
           "logs:CreateLogStream",
           "logs:CreateLogGroup",
           "logs:PutLogEvents"
         ],
         "Resource": [
           "arn:aws:logs:*:*:log-group:log_group_name",
           "arn:aws:logs:*:*:log-group:log_group_name:*"
         ],
         "Sid": "AllowLOGSDescribelogstreams"
       },
       {
         "Effect": "Allow",
         "Action": [
           "logs:DescribeLogGroups"
         ],
         "Resource": [
           "*"
         ],
         "Sid": "AllowLOGSDescribeloggroups"
       },
       {
         "Effect": "Allow",
         "Action": [
           "s3:PutObject",
           "s3:GetObject",
           "s3:ListBucket"
         ],
         "Resource": [
           "arn:aws:s3:::bucket_name",
           "arn:aws:s3:::bucket_name/*"
         ],
         "Sid": "AllowS3Putobject"
       }
     ]
   }
   ```

------

1. Lampirkan kebijakan di atas ke peran operator/job eksekusi Anda.

# Log Operator Spark
<a name="spark-operator-monitoring-configuration-logs"></a>

Anda dapat menentukan konfigurasi pemantauan dengan cara berikut saat melakukan`helm install`:

```
helm install spark-operator spark-operator \
--namespace namespace \
--set emrContainers.awsRegion=aws_region \
--set emrContainers.monitoringConfiguration.image=log_agent_image_url \
--set emrContainers.monitoringConfiguration.s3MonitoringConfiguration.logUri=S3_bucket_uri \
--set emrContainers.monitoringConfiguration.cloudWatchMonitoringConfiguration.logGroupName=log_group_name \
--set emrContainers.monitoringConfiguration.cloudWatchMonitoringConfiguration.logStreamNamePrefix=log_stream_prefix \
--set emrContainers.monitoringConfiguration.sideCarResources.limits.cpuLimit=500m \
--set emrContainers.monitoringConfiguration.sideCarResources.limits.memoryLimit=512Mi \
--set emrContainers.monitoringConfiguration.containerLogRotationConfiguration.rotationSize=2GB \
--set emrContainers.monitoringConfiguration.containerLogRotationConfiguration.maxFilesToKeep=10 \
--set webhook.enable=true \
--set emrContainers.operatorExecutionRoleArn=operator_execution_role_arn
```

**Konfigurasi pemantauan**

Berikut ini adalah opsi konfigurasi yang tersedia di bawah **MonitoringConfiguration**.
+ **Gambar** (opsional) - URL gambar agen log. Akan diambil emrReleaseLabel jika tidak disediakan.
+ **s3 MonitoringConfiguration** - Atur opsi ini untuk mengarsipkan ke Amazon S3.
  + **LoGuri** — (wajib) — Jalur bucket Amazon S3 tempat Anda ingin menyimpan log Anda.
  + Berikut ini adalah contoh format untuk jalur bucket Amazon S3, setelah log diunggah. Contoh pertama menunjukkan tidak ada rotasi log yang diaktifkan.

    ```
    s3://${logUri}/${POD NAME}/operator/stdout.gz
    s3://${logUri}/${POD NAME}/operator/stderr.gz
    ```

    Rotasi log diaktifkan secara default. Anda dapat melihat file yang diputar, dengan indeks incrementing, dan file saat ini, yang sama dengan sampel sebelumnya.

    ```
    s3://${logUri}/${POD NAME}/operator/stdout_YYYYMMDD_index.gz
    s3://${logUri}/${POD NAME}/operator/stderr_YYYYMMDD_index.gz
    ```
+ **cloudWatchMonitoringKonfigurasi** - Kunci konfigurasi untuk mengatur penerusan ke. Amazon CloudWatch
  + **logGroupName**(wajib) - Nama grup Amazon CloudWatch log yang ingin Anda kirimi log. Grup secara otomatis akan dibuat jika tidak ada.
  + **logStreamNameAwalan** (opsional) - Nama aliran log yang ingin Anda kirim log ke. Nilai default adalah string kosong. Formatnya Amazon CloudWatch adalah sebagai berikut:

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
+ **sideCarResources**(opsional) — Kunci konfigurasi untuk menetapkan batas sumber daya pada wadah sidecar Fluentd yang diluncurkan.
  + **MemoryLimit** (opsional) - Batas memori. Sesuaikan sesuai dengan kebutuhan Anda. Defaultnya adalah 512Mi.
  + **CPULimit** (opsional) — Batas CPU. Sesuaikan sesuai dengan kebutuhan Anda. Defaultnya adalah 500m.
+ **containerLogRotationKonfigurasi** (opsional) - Mengontrol perilaku rotasi log kontainer. Agen tidak diaktifkan secara default.
  + **RotationSize** (wajib) - Menentukan ukuran file untuk rotasi log. Kisaran nilai yang mungkin adalah dari 2KB hingga 2GB. Bagian unit numerik dari parameter RotationSize dilewatkan sebagai bilangan bulat. Karena nilai desimal tidak didukung, Anda dapat menentukan ukuran rotasi 1,5GB, misalnya, dengan nilai 1500MB. Defaultnya adalah 2GB.
  + **maxFilesToKeep** (required) - Menentukan jumlah maksimum file untuk mempertahankan dalam wadah setelah rotasi telah terjadi. Nilai minimum adalah 1, dan nilai maksimum adalah 50. Default-nya adalah 10.

Setelah *MonitoringConfiguration dikonfigurasi*, Anda harus dapat memeriksa log pod operator spark pada bucket Amazon S3 atau atau keduanya. Amazon CloudWatch Untuk bucket Amazon S3, Anda harus menunggu 2 menit agar file log pertama dibilas.

Untuk menemukan log in Amazon CloudWatch, Anda dapat menavigasi ke berikut: **CloudWatch**> **Grup log** > > ***Log group name**Pod name*****/operator/stderr**

Atau Anda dapat menavigasi ke: **CloudWatch**> **Grup log** > > ***Log group name**Pod name*****/operator/stdout**

# Log Aplikasi Spark
<a name="spark-operator-monitoring-application-logs"></a>

Anda dapat menentukan konfigurasi ini dengan cara berikut.

```
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-pi
  namespace: namespace
spec:
  type: Scala
  mode: cluster
  imagePullPolicy: Always
  mainClass: org.apache.spark.examples.SparkPi
  mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples.jar"
  sparkVersion: "3.3.1"
  emrReleaseLabel: emr_release_label
  executionRoleArn: job_execution_role_arn
  restartPolicy:
    type: Never
  volumes:
    - name: "test-volume"
      hostPath:
        path: "/tmp"
        type: Directory
  driver:
    cores: 1
    coreLimit: "1200m"
    memory: "512m"
    labels:
      version: 3.3.1
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
  executor:
    cores: 1
    instances: 1
    memory: "512m"
    labels:
      version: 3.3.1
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
  monitoringConfiguration:
    image: "log_agent_image"
    s3MonitoringConfiguration:
      logUri: "S3_bucket_uri"
    cloudWatchMonitoringConfiguration:
      logGroupName: "log_group_name"
      logStreamNamePrefix: "log_stream_prefix"
    sideCarResources:
      limits:
        cpuLimit: "500m"
        memoryLimit: "250Mi"
    containerLogRotationConfiguration:
      rotationSize: "2GB"
      maxFilesToKeep: "10"
```

Berikut ini adalah opsi konfigurasi yang tersedia di bawah **MonitoringConfiguration**.
+ **Gambar** (opsional) - URL gambar agen log. Akan diambil emrReleaseLabel jika tidak disediakan.
+ **s3 MonitoringConfiguration** - Atur opsi ini untuk mengarsipkan ke Amazon S3.
  + **LoGuri** (wajib) - Jalur bucket Amazon S3 tempat Anda ingin menyimpan log Anda. Contoh pertama menunjukkan tidak ada rotasi log yang diaktifkan:

    ```
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout.gz
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr.gz
    ```

    Rotasi log diaktifkan secara default. Anda dapat menggunakan file yang diputar (dengan indeks incrementing) dan file saat ini (satu tanpa cap tanggal).

    ```
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout_YYYYMMDD_index.gz
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr_YYYYMMDD_index.gz
    ```
+ **cloudWatchMonitoringKonfigurasi** - Kunci konfigurasi untuk mengatur penerusan ke. Amazon CloudWatch
  + **logGroupName**(wajib) — Nama grup log Cloudwatch yang ingin Anda kirimi log. Grup secara otomatis dibuat jika tidak ada.
  + **logStreamNameAwalan** (opsional) - Nama aliran log yang ingin Anda kirim log ke. Nilai default adalah string kosong. Formatnya CloudWatch adalah sebagai berikut:

    ```
    ${logStreamNamePrefix}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout
    ${logStreamNamePrefix}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr
    ```
+ **sideCarResources**(opsional) — Kunci konfigurasi untuk menetapkan batas sumber daya pada wadah sidecar Fluentd yang diluncurkan.
  + **MemoryLimit** (opsional) - Batas memori. Sesuaikan sesuai dengan kebutuhan Anda. Defaultnya adalah 250Mi.
  + **CPULimit** — Batas CPU. Sesuaikan sesuai dengan kebutuhan Anda. Defaultnya adalah 500m.
+ **containerLogRotationKonfigurasi** (opsional) - Mengontrol perilaku rotasi log kontainer. Agen tidak diaktifkan secara default.
  + **RotationSize** (wajib) - Menentukan ukuran file untuk rotasi log. Kisaran nilai yang mungkin adalah dari 2KB hingga 2GB. Bagian unit numerik dari parameter RotationSize dilewatkan sebagai bilangan bulat. Karena nilai desimal tidak didukung, Anda dapat menentukan ukuran rotasi 1,5GB, misalnya, dengan nilai 1500MB. Defaultnya adalah 2GB.
  + **maxFilesToKeep** (required) - Menentukan jumlah maksimum file untuk mempertahankan dalam wadah setelah rotasi telah terjadi. Nilai minimum adalah 1. Nilai maksimumnya adalah 50. Default-nya adalah 10.

Setelah mengonfigurasi MonitoringConfiguration, Anda harus dapat memeriksa driver aplikasi spark dan log pelaksana Anda di bucket Amazon S3 atau atau keduanya. CloudWatch Untuk bucket Amazon S3, Anda harus menunggu 2 menit agar file log pertama dibilas. Misalnya, di Amazon S3, jalur bucket muncul seperti berikut:

**Amazon S3** **> **Ember** > > ***Bucket name***> stderr.gz *Spark application name - UUID* *Pod Name***

Atau:

**Amazon S3** **> **Ember** > > ***Bucket name***> stdout.gz *Spark application name - UUID* *Pod Name***

Di CloudWatch, jalur muncul seperti berikut:

**CloudWatch**> **Grup log** > ***Log group name***>*Spark application name - UUID*/*Pod name***/stderr**

Atau:

**CloudWatch**> **Grup log** > ***Log group name***>*Spark application name - UUID*/*Pod name***/stdout**

# Keamanan dan operator Spark dengan Amazon EMR di EKS
<a name="spark-operator-security"></a>

Ada beberapa cara untuk mengatur izin akses cluster saat Anda menggunakan operator Spark. Yang pertama adalah menggunakan kontrol akses berbasis peran, kontrol akses berbasis peran (RBAC) membatasi akses berdasarkan peran seseorang dalam suatu organisasi. Ini telah menjadi cara utama untuk menangani akses. Metode akses kedua adalah untuk mengambil AWS Identity and Access Management peran, yang menyediakan akses sumber daya melalui izin tertentu yang ditetapkan.

**Topics**
+ [Menyiapkan izin akses cluster dengan kontrol akses berbasis peran (RBAC)](spark-operator-security-rbac.md)
+ [Menyiapkan izin akses klaster dengan peran IAM untuk akun layanan (IRSA)](spark-operator-security-irsa.md)

# Menyiapkan izin akses cluster dengan kontrol akses berbasis peran (RBAC)
<a name="spark-operator-security-rbac"></a>

Untuk menyebarkan operator Spark, Amazon EMR di EKS membuat dua peran dan akun layanan untuk operator Spark dan aplikasi Spark.

**Topics**
+ [Akun dan peran layanan operator](#spark-operator-sa-oper)
+ [Akun dan peran layanan Spark](#spark-operator-sa-spark)

## Akun dan peran layanan operator
<a name="spark-operator-sa-oper"></a>

Amazon EMR di EKS membuat **akun layanan operator dan peran** `SparkApplications` untuk mengelola pekerjaan Spark dan sumber daya lain seperti layanan.

Nama default untuk akun layanan ini adalah`emr-containers-sa-spark-operator`.

Aturan berikut berlaku untuk peran layanan ini: 

```
 rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - services
  - configmaps
  - secrets
  verbs:
  - create
  - get
  - delete
  - update
- apiGroups:
  - extensions
  - networking.k8s.io
  resources:
  - ingresses
  verbs:
  - create
  - get
  - delete
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
- apiGroups:
  - ""
  resources:
  - events
  verbs:
  - create
  - update
  - patch
- apiGroups:
  - ""
  resources:
  - resourcequotas
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - create
  - get
  - update
  - delete
- apiGroups:
  - admissionregistration.k8s.io
  resources:
  - mutatingwebhookconfigurations
  - validatingwebhookconfigurations
  verbs:
  - create
  - get
  - update
  - delete
- apiGroups:
  - sparkoperator.k8s.io
  resources:
  - sparkapplications
  - sparkapplications/status
  - scheduledsparkapplications
  - scheduledsparkapplications/status
  verbs:
  - "*"
  {{- if .Values.batchScheduler.enable }}
  # required for the `volcano` batch scheduler
- apiGroups:
  - scheduling.incubator.k8s.io
  - scheduling.sigs.dev
  - scheduling.volcano.sh
  resources:
  - podgroups
  verbs:
  - "*"
  {{- end }}
  {{ if .Values.webhook.enable }}
- apiGroups:
  - batch
  resources:
  - jobs
  verbs:
  - delete
  {{- end }}
```

## Akun dan peran layanan Spark
<a name="spark-operator-sa-spark"></a>

Pod driver Spark membutuhkan akun layanan Kubernetes di namespace yang sama dengan pod. Akun layanan ini membutuhkan izin untuk membuat, mendapatkan, membuat daftar, menambal, dan menghapus pod pelaksana, dan untuk membuat layanan tanpa kepala Kubernetes untuk driver. Driver gagal dan keluar tanpa akun layanan kecuali akun layanan default di namespace pod memiliki izin yang diperlukan.

Nama default untuk akun layanan ini adalah`emr-containers-sa-spark`.

Aturan berikut berlaku untuk peran layanan ini: 

```
 rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - services
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - configmaps
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - persistentvolumeclaims
  verbs:
  - "*"
```

# Menyiapkan izin akses klaster dengan peran IAM untuk akun layanan (IRSA)
<a name="spark-operator-security-irsa"></a>

Bagian ini menggunakan contoh untuk menunjukkan cara mengonfigurasi akun layanan Kubernetes untuk mengambil peran. AWS Identity and Access Management Pod yang menggunakan akun layanan kemudian dapat mengakses AWS layanan apa pun yang perannya memiliki izin untuk diakses.

Contoh berikut menjalankan aplikasi Spark untuk menghitung kata-kata dari file di Amazon S3. Untuk melakukan ini, Anda dapat mengatur peran IAM untuk akun layanan (IRSA) untuk mengautentikasi dan mengotorisasi akun layanan Kubernetes.

**catatan**  
Contoh ini menggunakan namespace “spark-operator” untuk operator Spark dan untuk namespace tempat Anda mengirimkan aplikasi Spark.

## Prasyarat
<a name="spark-operator-security-irsa-prereqs"></a>

Sebelum Anda mencoba contoh di halaman ini, lengkapi prasyarat berikut:
+ [Siapkan untuk operator Spark]().
+ [Instal operator Spark](spark-operator-gs.md#spark-operator-install).
+ [Buat bucket Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).
+ Simpan puisi favorit Anda dalam file teks bernama`poem.txt`, dan unggah file ke bucket S3 Anda. Aplikasi Spark yang Anda buat di halaman ini akan membaca isi file teks. Untuk informasi selengkapnya tentang mengunggah file ke S3, lihat [Mengunggah objek ke bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) di *Panduan Pengguna Layanan Penyimpanan Sederhana Amazon*.

## Konfigurasikan akun layanan Kubernetes untuk mengambil peran IAM
<a name="spark-operator-security-irsa-config"></a>

Gunakan langkah-langkah berikut untuk mengonfigurasi akun layanan Kubernetes untuk mengambil peran IAM yang dapat digunakan pod untuk mengakses AWS layanan yang memiliki izin untuk diakses oleh peran tersebut.

1. Setelah menyelesaikan[Prasyarat](#spark-operator-security-irsa-prereqs), gunakan AWS Command Line Interface untuk membuat `example-policy.json` file yang memungkinkan akses hanya-baca ke file yang Anda unggah ke Amazon S3:

   ```
   cat >example-policy.json <<EOF
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::my-pod-bucket",
                   "arn:aws:s3:::my-pod-bucket/*"
               ]
           }
       ]
   }
   EOF
   ```

1. Kemudian, buat kebijakan `example-policy` IAM:

   ```
   aws iam create-policy --policy-name example-policy --policy-document file://example-policy.json
   ```

1. Selanjutnya, buat peran IAM `example-role` dan kaitkan dengan akun layanan Kubernetes untuk driver Spark:

   ```
   eksctl create iamserviceaccount --name driver-account-sa --namespace spark-operator \
   --cluster my-cluster --role-name "example-role" \
   --attach-policy-arn arn:aws:iam::111122223333:policy/example-policy --approve
   ```

1. Buat file yaml dengan binding peran cluster yang diperlukan untuk akun layanan driver Spark:

   ```
   cat >spark-rbac.yaml <<EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: driver-account-sa
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: spark-role
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: edit
   subjects:
     - kind: ServiceAccount
       name: driver-account-sa
       namespace: spark-operator
   EOF
   ```

1. Menerapkan konfigurasi pengikatan peran cluster:

   ```
   kubectl apply -f spark-rbac.yaml
   ```

Perintah kubectl harus mengonfirmasi keberhasilan pembuatan akun:

```
serviceaccount/driver-account-sa created
clusterrolebinding.rbac.authorization.k8s.io/spark-role configured
```

## Menjalankan aplikasi dari operator Spark
<a name="spark-operator-security-irsa-run"></a>

Setelah Anda [mengkonfigurasi akun layanan Kubernetes](), Anda dapat menjalankan aplikasi Spark yang menghitung jumlah kata dalam file teks yang Anda unggah sebagai bagian dari. [Prasyarat](#spark-operator-security-irsa-prereqs)

1. Buat file baru`word-count.yaml`, dengan `SparkApplication` definisi untuk aplikasi penghitungan kata Anda, berdasarkan Amazon EMR versi 6.

   ```
   cat >word-count.yaml <<EOF
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: word-count
     namespace: spark-operator
   spec:
     type: Java
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.JavaWordCount
     mainApplicationFile: local:///usr/lib/spark/examples/jars/spark-examples.jar
     arguments:
       - s3://my-pod-bucket/poem.txt
     hadoopConf:
      # EMRFS filesystem
       fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
       fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
       fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
       fs.s3.buffer.dir: /mnt/s3
       fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
       mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
       mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
     sparkConf:
       # Required for EMR Runtime
       spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
       spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: my-spark-driver-sa
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
   EOF
   ```

   Jika Anda menggunakan operator percikan dengan rilis versi 7, Anda menyesuaikan beberapa nilai konfigurasi:

   ```
   cat >word-count.yaml <<EOF
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: word-count
     namespace: spark-operator
   spec:
     type: Java
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-7.7.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.JavaWordCount
     mainApplicationFile: local:///usr/lib/spark/examples/jars/spark-examples.jar
     arguments:
       - s3://my-pod-bucket/poem.txt
     hadoopConf:
      # EMRFS filesystem
       fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
       fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
       fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
       fs.s3.buffer.dir: /mnt/s3
       fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
       mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
       mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
     sparkConf:
       # Required for EMR Runtime
       spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/aws-java-sdk-v2/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
       spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/aws-java-sdk-v2/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: my-spark-driver-sa
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
   EOF
   ```

1. Kirim aplikasi Spark.

   ```
   kubectl apply -f word-count.yaml
   ```

   Perintah kubectl harus mengembalikan konfirmasi bahwa Anda berhasil membuat objek yang `SparkApplication` dipanggil. `word-count`

   ```
   sparkapplication.sparkoperator.k8s.io/word-count configured
   ```

1. Untuk memeriksa peristiwa untuk `SparkApplication` objek, jalankan perintah berikut:

   ```
   kubectl describe sparkapplication word-count -n spark-operator
   ```

   Perintah kubectl harus mengembalikan deskripsi `SparkApplication` dengan peristiwa:

   ```
   Events:
     Type     Reason                               Age                    From            Message
     ----     ------                               ----                   ----            -------
     Normal   SparkApplicationSpecUpdateProcessed  3m2s (x2 over 17h)     spark-operator  Successfully processed spec update for SparkApplication word-count
     Warning  SparkApplicationPendingRerun         3m2s (x2 over 17h)     spark-operator  SparkApplication word-count is pending rerun
     Normal   SparkApplicationSubmitted            2m58s (x2 over 17h)    spark-operator  SparkApplication word-count was submitted successfully
     Normal   SparkDriverRunning                   2m56s (x2 over 17h)    spark-operator  Driver word-count-driver is running
     Normal   SparkExecutorPending                 2m50s                  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] is pending
     Normal   SparkExecutorRunning                 2m48s                  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] is running
     Normal   SparkDriverCompleted                 2m31s (x2 over 17h)    spark-operator  Driver word-count-driver completed
     Normal   SparkApplicationCompleted            2m31s (x2 over 17h)    spark-operator  SparkApplication word-count completed
     Normal   SparkExecutorCompleted               2m31s (x2 over 2m31s)  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] completed
   ```

Aplikasi ini sekarang menghitung kata-kata dalam file S3 Anda. Untuk menemukan jumlah kata, lihat file log untuk driver Anda:

```
kubectl logs pod/word-count-driver -n spark-operator
```

Perintah kubectl harus mengembalikan isi file log dengan hasil aplikasi hitungan kata Anda.

```
INFO DAGScheduler: Job 0 finished: collect at JavaWordCount.java:53, took 5.146519 s
                Software: 1
```

Untuk informasi selengkapnya tentang cara mengirimkan aplikasi ke Spark melalui operator Spark, lihat dokumentasi [Using a SparkApplication](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) in the *Kubernetes Operator for Apache Spark (8s-operator*). spark-on-k GitHub

# Menjalankan pekerjaan Spark dengan spark-submit
<a name="spark-submit"></a>

Amazon EMR merilis 6.10.0 dan dukungan yang lebih tinggi `spark-submit` sebagai alat baris perintah yang dapat Anda gunakan untuk mengirimkan dan menjalankan aplikasi Spark ke EMR Amazon di kluster EKS.

**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 spark-submit untuk Amazon EMR di EKS](spark-submit-setup.md)
+ [Memulai dengan spark-submit untuk Amazon EMR di EKS](spark-submit-gs.md)
+ [Verifikasi persyaratan keamanan akun layanan driver Spark untuk pengiriman spark](spark-submit-security.md)

# Menyiapkan spark-submit untuk Amazon EMR di EKS
<a name="spark-submit-setup"></a>

Selesaikan tugas-tugas berikut untuk menyiapkan sebelum Anda dapat menjalankan aplikasi dengan spark-submit di Amazon EMR di EKS. Jika Anda sudah mendaftar untuk Amazon Web Services (AWS) dan telah menggunakan Amazon EKS, Anda hampir siap untuk menggunakan Amazon EMR di EKS. Jika Anda telah menyelesaikan salah satu prasyarat, Anda dapat melewatinya dan melanjutkan ke yang berikutnya.
+ **[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.
+ **[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 URI gambar dasar EMR Amazon](docker-custom-images-tag.md) (rilis 6.10.0 atau lebih tinggi)** — `spark-submit` perintah ini didukung dengan rilis Amazon EMR 6.10.0 dan yang lebih tinggi.
+ Konfirmasikan bahwa akun layanan driver memiliki izin yang sesuai untuk membuat dan menonton pod pelaksana. Untuk informasi selengkapnya, lihat [Verifikasi persyaratan keamanan akun layanan driver Spark untuk pengiriman spark](spark-submit-security.md).
+ Siapkan profil [AWS kredensial](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) lokal Anda.
+ Dari konsol Amazon EKS, pilih kluster EKS Anda, lalu temukan titik akhir klaster EKS, yang terletak di bawah **Ikhtisar**, **Detail**, lalu titik **akhir server API**.

# Memulai dengan spark-submit untuk Amazon EMR di EKS
<a name="spark-submit-gs"></a>

Amazon EMR 6.10.0 dan yang lebih tinggi mendukung spark-submit untuk menjalankan aplikasi Spark di cluster Amazon EKS. Bagian berikut menunjukkan kepada Anda cara mengirimkan perintah untuk aplikasi Spark.

## Jalankan aplikasi Spark
<a name="spark-submit-run"></a>

Untuk menjalankan aplikasi Spark, ikuti langkah-langkah berikut:

1. Sebelum Anda dapat menjalankan aplikasi Spark dengan `spark-submit` perintah, selesaikan langkah-langkahnya. [Menyiapkan spark-submit untuk Amazon EMR di EKS](spark-submit-setup.md) 

1. Jalankan wadah dengan EMR Amazon pada gambar dasar EKS. Lihat [Cara memilih URI gambar dasar](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html) untuk informasi selengkapnya.

   ```
   kubectl run -it containerName --image=EMRonEKSImage --command -n namespace /bin/bash
   ```

1. Tetapkan nilai untuk variabel lingkungan berikut:

   ```
   export SPARK_HOME=spark-home
   export MASTER_URL=k8s://Amazon EKS-cluster-endpoint
   ```

1. Sekarang, kirimkan aplikasi Spark dengan perintah berikut:

   ```
   $SPARK_HOME/bin/spark-submit \
    --class org.apache.spark.examples.SparkPi \
    --master $MASTER_URL \
    --conf spark.kubernetes.container.image=895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest \
    --conf spark.kubernetes.authenticate.driver.serviceAccountName=spark \
    --deploy-mode cluster \
    --conf spark.kubernetes.namespace=spark-operator \
    local:///usr/lib/spark/examples/jars/spark-examples.jar 20
   ```

Untuk informasi selengkapnya tentang mengirimkan aplikasi ke Spark, lihat [Mengirimkan aplikasi](https://spark.apache.org/docs/latest/submitting-applications.html) dalam dokumentasi Apache Spark.

**penting**  
`spark-submit`hanya mendukung mode cluster sebagai mekanisme pengiriman.

# Verifikasi persyaratan keamanan akun layanan driver Spark untuk pengiriman spark
<a name="spark-submit-security"></a>

Pod driver Spark menggunakan akun layanan Kubernetes untuk mengakses server API Kubernetes untuk membuat dan menonton pod pelaksana. Akun layanan driver harus memiliki izin yang sesuai untuk membuat daftar, membuat, mengedit, menambal, dan menghapus pod di klaster Anda. Anda dapat memverifikasi bahwa Anda dapat mencantumkan sumber daya ini dengan menjalankan perintah berikut:

```
kubectl auth can-i list|create|edit|delete|patch pods
```

Verifikasi bahwa Anda memiliki izin yang diperlukan dengan menjalankan setiap perintah.

```
kubectl auth can-i list pods
kubectl auth can-i create pods
kubectl auth can-i edit pods
kubectl auth can-i delete pods
kubectl auth can-i patch pods
```

Aturan berikut berlaku untuk peran layanan ini: 

```
 rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - services
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - configmaps
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - persistentvolumeclaims
  verbs:
  - "*"
```

# Menyiapkan peran IAM untuk akun layanan (IRSA) untuk spark-submit
<a name="spark-submit-security-irsa"></a>

Bagian berikut menjelaskan cara mengatur peran IAM untuk akun layanan (IRSA) untuk mengautentikasi dan mengotorisasi akun layanan Kubernetes sehingga Anda dapat menjalankan aplikasi Spark yang disimpan di Amazon S3.

## Prasyarat
<a name="spark-submit-security-irsa-prereqs"></a>

Sebelum mencoba salah satu contoh dalam dokumentasi ini, pastikan Anda telah menyelesaikan prasyarat berikut:
+ [Selesai menyiapkan spark-submit](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/spark-submit-setup.html)
+ [Membuat ember S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) dan [mengunggah toples aplikasi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) percikan

## Mengonfigurasi akun layanan Kubernetes untuk mengambil peran IAM
<a name="spark-submit-security-irsa-configure-kubernetes"></a>

Langkah-langkah berikut mencakup cara mengkonfigurasi akun layanan Kubernetes untuk mengambil peran AWS Identity and Access Management (IAM). Setelah Anda mengonfigurasi pod untuk menggunakan akun layanan, mereka kemudian dapat mengakses apa pun Layanan AWS yang memiliki izin untuk diakses oleh peran tersebut.

1. [Buat file kebijakan untuk mengizinkan akses hanya-baca ke objek Amazon S3 yang Anda unggah:](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html)

   ```
   cat >my-policy.json <<EOF
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::<my-spark-jar-bucket>",
                   "arn:aws:s3:::<my-spark-jar-bucket>/*"
               ]
           }
       ]
   }
   EOF
   ```

1. Buat kebijakan IAM.

   ```
   aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
   ```

1. Buat peran IAM dan kaitkan dengan akun layanan Kubernetes untuk driver Spark

   ```
   eksctl create iamserviceaccount --name my-spark-driver-sa --namespace spark-operator \
   --cluster my-cluster --role-name "my-role" \
   --attach-policy-arn arn:aws:iam::111122223333:policy/my-policy --approve
   ```

1. Buat file YAMAL dengan [izin yang diperlukan untuk akun](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/spark-submit-security.html) layanan driver Spark:

   ```
   cat >spark-rbac.yaml <<EOF
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     namespace: default
     name: emr-containers-role-spark
   rules:
   - apiGroups:
     - ""
     resources:
     - pods
     verbs:
     - "*"
   - apiGroups:
     - ""
     resources:
     - services
     verbs:
     - "*"
   - apiGroups:
     - ""
     resources:
     - configmaps
     verbs:
     - "*"
   - apiGroups:
     - ""
     resources:
     - persistentvolumeclaims
     verbs:
     - "*"
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: spark-role-binding
     namespace: default
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: emr-containers-role-spark
   subjects:
   - kind: ServiceAccount
     name: emr-containers-sa-spark
     namespace: default
   EOF
   ```

1. Menerapkan konfigurasi pengikatan peran cluster.

   ```
   kubectl apply -f spark-rbac.yaml
   ```

1. `kubectl`Perintah harus mengembalikan konfirmasi akun yang dibuat.

   ```
   serviceaccount/emr-containers-sa-spark created
   clusterrolebinding.rbac.authorization.k8s.io/emr-containers-role-spark configured
   ```

## Menjalankan aplikasi Spark
<a name="spark-submit-security-irsa-app-run"></a>

Amazon EMR 6.10.0 dan yang lebih tinggi mendukung spark-submit untuk menjalankan aplikasi Spark di cluster Amazon EKS. Untuk menjalankan aplikasi Spark, ikuti langkah-langkah berikut:

1. Pastikan Anda telah menyelesaikan langkah-langkah dalam [Menyiapkan spark-submit untuk Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/spark-submit-setup.html) di EKS.

1. Tetapkan nilai untuk variabel lingkungan berikut:

   ```
   export SPARK_HOME=spark-home
   export MASTER_URL=k8s://Amazon EKS-cluster-endpoint
   ```

1. Sekarang, kirimkan aplikasi Spark dengan perintah berikut:

   ```
   $SPARK_HOME/bin/spark-submit \
    --class org.apache.spark.examples.SparkPi \
    --master $MASTER_URL \
    --conf spark.kubernetes.container.image=895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.15.0:latest \
    --conf spark.kubernetes.authenticate.driver.serviceAccountName=emr-containers-sa-spark \
    --deploy-mode cluster \
    --conf spark.kubernetes.namespace=default \
    --conf "spark.driver.extraClassPath=/usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*" \
    --conf "spark.driver.extraLibraryPath=/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native" \
    --conf "spark.executor.extraClassPath=/usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*" \
    --conf "spark.executor.extraLibraryPath=/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native" \
    --conf spark.hadoop.fs.s3.customAWSCredentialsProvider=com.amazonaws.auth.WebIdentityTokenCredentialsProvider \
    --conf spark.hadoop.fs.s3.impl=com.amazon.ws.emr.hadoop.fs.EmrFileSystem \
    --conf spark.hadoop.fs.AbstractFileSystem.s3.impl=org.apache.hadoop.fs.s3.EMRFSDelegate \
    --conf spark.hadoop.fs.s3.buffer.dir=/mnt/s3 \
    --conf spark.hadoop.fs.s3.getObject.initialSocketTimeoutMilliseconds="2000" \
    --conf spark.hadoop.mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem="2" \
    --conf spark.hadoop.mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem="true" \
    s3://my-pod-bucket/spark-examples.jar 20
   ```

1. Setelah driver percikan menyelesaikan pekerjaan Spark, Anda akan melihat baris log di akhir kiriman yang menunjukkan bahwa pekerjaan Spark telah selesai.

   ```
   23/11/24 17:02:14 INFO LoggingPodStatusWatcherImpl: Application org.apache.spark.examples.SparkPi with submission ID default:org-apache-spark-examples-sparkpi-4980808c03ff3115-driver finished
   23/11/24 17:02:14 INFO ShutdownHookManager: Shutdown hook called
   ```

## Pembersihan
<a name="spark-submit-security-irsa-cleanup"></a>

Setelah selesai menjalankan aplikasi, Anda dapat melakukan pembersihan dengan perintah berikut.

```
kubectl delete -f spark-rbac.yaml
```

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

# Mengelola Amazon EMR pada pekerjaan EKS
<a name="emr-eks-jobs-manage"></a>

Bagian berikut mencakup topik yang membantu Anda mengelola EMR Amazon Anda di pekerjaan EKS. Ini termasuk mengonfigurasi parameter job run saat Anda menggunakan AWS CLI, mengonfigurasi bagaimana data log Anda disimpan, menjalankan skrip Spark SQL untuk menjalankan kueri, memahami status job run, dan mengetahui cara memantau pekerjaan. Anda dapat mengerjakan topik-topik ini, umumnya secara berurutan, jika Anda ingin mengatur dan menyelesaikan pekerjaan untuk memproses data.

**Topics**
+ [Mengelola pekerjaan berjalan dengan AWS CLI](emr-eks-jobs-CLI.md)
+ [Menjalankan skrip Spark SQL melalui API StartJobRun](emr-eks-jobs-spark-sql-parameters.md)
+ [Status tugas berjalan](emr-eks-jobs-states.md)
+ [Melihat tugas di konsol Amazon EMR](emr-eks-jobs-console.md)
+ [Kesalahan umum saat menjalankan tugas](emr-eks-jobs-error.md)

# Mengelola pekerjaan berjalan dengan AWS CLI
<a name="emr-eks-jobs-CLI"></a>

Topik ini mencakup cara mengelola pekerjaan berjalan dengan AWS Command Line Interface (AWS CLI). Ini masuk ke detail mengenai properti, seperti parameter keamanan, driver, dan berbagai pengaturan penggantian. Ini juga mencakup subtopik yang mencakup berbagai cara untuk mengonfigurasi logging.

**Topics**
+ [Pilihan untuk mengonfigurasi tugas berjalan](#emr-eks-jobs-parameters)
+ [Konfigurasikan pekerjaan yang dijalankan untuk menggunakan log Amazon S3](emr-eks-jobs-s3.md)
+ [Mengonfigurasi pekerjaan yang dijalankan untuk menggunakan Amazon CloudWatch Logs](emr-eks-jobs-cloudwatch.md)
+ [Daftar tugas berjalan](#emr-eks-jobs-list)
+ [Jelaskan tugas berjalan](#emr-eks-jobs-describe)
+ [Membatalkan tugas berjalan](#emr-eks-jobs-cancel)

## Pilihan untuk mengonfigurasi tugas berjalan
<a name="emr-eks-jobs-parameters"></a>

Gunakan opsi berikut untuk mengonfigurasi parameter tugas berjalan:
+ `--execution-role-arn`: Anda harus menyediakan IAM role yang digunakan untuk menjalankan tugas. Untuk informasi selengkapnya, lihat [Menggunakan peran eksekusi tugas dengan Amazon EMR di EKS](iam-execution-role.md). 
+ `--release-label`: Anda dapat menyebarkan Amazon EMR di EKS dengan Amazon EMR versi 5.32.0 dan 6.2.0 dan lebih baru. Amazon EMR di EKS tidak didukung dalam versi rilis Amazon EMR sebelumnya. Untuk informasi selengkapnya, lihat [Amazon EMR pada rilis EKS](emr-eks-releases.md). 
+ `--job-driver`: Driver tugas digunakan untuk memberikan input pada tugas utama. Ini adalah bidang jenis serikat di mana Anda hanya dapat meloloskan salah satu nilai untuk jenis tugas yang ingin Anda jalankan. Jenis tugas yang didukung meliputi:
  + Tugas Spark submit - Digunakan untuk menjalankan perintah melalui Spark submit. Anda dapat menggunakan jenis pekerjaan ini untuk menjalankan Scala,, SparkR PySpark, SparkSQL, dan pekerjaan lain yang didukung melalui Spark Submit. Tugas ini memiliki parameter berikut:
    + Entrypoint - Ini adalah referensi HCFS (sistem file yang kompatibel dengan Hadoop) ke file utama jar/py yang ingin Anda jalankan.
    + EntryPointArguments - Ini adalah array argumen yang ingin Anda lewatkan ke jar/py file utama Anda. Anda harus menangani membaca parameter ini menggunakan kode entrypoint Anda. Setiap argumen dalam array harus dipisahkan dengan koma. EntryPointArguments tidak dapat berisi tanda kurung atau tanda kurung, seperti (), \$1\$1, atau []. 
    + SparkSubmitParameters - Ini adalah parameter percikan tambahan yang ingin Anda kirim ke pekerjaan. Gunakan parameter ini untuk menimpa properti default Spark seperti memori driver atau jumlah pelaksana seperti —conf atau —class. Untuk informasi tambahan, lihat [Peluncuran Aplikasi dengan spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit).
  + Spark SQL jobs - Digunakan untuk menjalankan file query SQL melalui Spark SQL. Anda dapat menggunakan jenis pekerjaan ini untuk menjalankan pekerjaan SparkSQL. Tugas ini memiliki parameter berikut:
    + Entrypoint - Ini adalah referensi HCFS (sistem file yang kompatibel dengan Hadoop) ke file query SQL yang ingin Anda jalankan.

      Untuk daftar parameter Spark tambahan yang dapat Anda gunakan untuk pekerjaan Spark SQL, lihat. [Menjalankan skrip Spark SQL melalui API StartJobRun](emr-eks-jobs-spark-sql-parameters.md)
+ `--configuration-overrides`: Anda dapat menimpa konfigurasi default untuk aplikasi dengan menyediakan objek konfigurasi. Anda dapat menggunakan sintaks singkatan untuk menyediakan konfigurasi atau Anda dapat mereferensikan objek konfigurasi dalam file JSON. Objek konfigurasi terdiri dari klasifikasi, properti, dan konfigurasi bersarang opsional. Properti terdiri dari pengaturan yang ingin Anda timpa dalam file tersebut. Anda dapat menentukan beberapa klasifikasi untuk beberapa aplikasi dalam objek JSON tunggal. Klasifikasi konfigurasi yang tersedia bervariasi berdasarkan versi rilis Amazon EMR. Untuk daftar klasifikasi konfigurasi yang tersedia untuk setiap versi rilis Amazon EMR, lihat [Amazon EMR pada rilis EKS](emr-eks-releases.md).

  Jika Anda melewati konfigurasi yang sama dalam penimpaan aplikasi dan di parameter kirim Spark, parameter kirim Spark diutamakan. Daftar prioritas konfigurasi lengkap mengikuti, dalam urutan prioritas tertinggi ke prioritas terendah.
  + Konfigurasi disediakan saat membuat `SparkSession`.
  + Konfigurasi disediakan sebagai bagian dari `sparkSubmitParameters` menggunakan `—conf`.
  + Konfigurasi disediakan sebagai bagian dari penimpaan aplikasi.
  + Konfigurasi yang dioptimalkan dipilih oleh Amazon EMR untuk rilisan.
  + Konfigurasi sumber terbuka default untuk aplikasi.

  Untuk memantau pekerjaan berjalan menggunakan Amazon CloudWatch atau Amazon S3, Anda harus memberikan detail konfigurasi untuk. CloudWatch Untuk informasi selengkapnya, lihat [Konfigurasikan pekerjaan yang dijalankan untuk menggunakan log Amazon S3](emr-eks-jobs-s3.md) dan [Mengonfigurasi pekerjaan yang dijalankan untuk menggunakan Amazon CloudWatch Logs](emr-eks-jobs-cloudwatch.md). Jika bucket S3 atau grup CloudWatch log tidak ada, Amazon EMR membuatnya sebelum mengunggah log ke bucket.
+ Untuk daftar tambahan opsi konfigurasi Kubernetes, lihat [Properti Spark di Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html#configuration). 

  Konfigurasi Spark berikut tidak didukung.
  + `spark.kubernetes.authenticate.driver.serviceAccountName`
  + `spark.kubernetes.authenticate.executor.serviceAccountName`
  + `spark.kubernetes.namespace`
  + `spark.kubernetes.driver.pod.name`
  + `spark.kubernetes.container.image.pullPolicy`
  + `spark.kubernetes.container.image`
**catatan**  
Anda dapat menggunakan `spark.kubernetes.container.image` untuk gambar Docker yang disesuaikan. Untuk informasi selengkapnya, lihat [Menyesuaikan gambar Docker untuk Amazon EMR di EKS](docker-custom-images.md).

# Konfigurasikan pekerjaan yang dijalankan untuk menggunakan log Amazon S3
<a name="emr-eks-jobs-s3"></a>

Untuk dapat memantau kemajuan pekerjaan dan memecahkan masalah kegagalan, Anda harus mengonfigurasi pekerjaan Anda untuk mengirim informasi log ke Amazon S3, Amazon Log, CloudWatch atau keduanya. Topik ini membantu Anda mulai menerbitkan log aplikasi ke Amazon S3 pada pekerjaan Anda yang diluncurkan dengan Amazon EMR di EKS.

**S3 log kebijakan IAM**

Sebelum tugas Anda dapat mengirim data log ke Amazon S3, izin berikut harus disertakan dalam kebijakan perizinan untuk peran eksekusi tugas. Ganti *amzn-s3-demo-logging-bucket* dengan nama bucket logging Anda.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:ListBucket"
      ],
      "Resource": [
        "arn:aws:s3:::amzn-s3-demo-bucket",
        "arn:aws:s3:::amzn-s3-demo-bucket/*"
      ],
      "Sid": "AllowS3Putobject"
    }
  ]
}
```

------

**catatan**  
Amazon EMR di EKS juga dapat membuat bucket Amazon S3. Jika bucket Amazon S3 tidak tersedia, sertakan `“s3:CreateBucket”` izin tersebut dalam kebijakan IAM.

Setelah Anda memberi peran eksekusi izin yang tepat untuk mengirim log ke Amazon S3, data log Anda dikirim ke lokasi Amazon S3 berikut `s3MonitoringConfiguration` saat diteruskan di `monitoringConfiguration` bagian permintaan, seperti `start-job-run` yang ditunjukkan pada. [Mengelola pekerjaan berjalan dengan AWS CLI](emr-eks-jobs-CLI.md)
+ Log Pengirim -//*virtual-cluster-id*/jobs/ /containers/*logUri*/(*job-id*stderr.gz/stdout.gz) *pod-name*
+ Log Driver -//*virtual-cluster-id*/jobs/ *logUri* *job-id* /containers/ /spark- -driver/ (*spark-application-id*stderr.gz/stdout.gz) *job-id*
+ Log Pelaksana -//*virtual-cluster-id*/jobs/ *logUri* *job-id* /containers///(*spark-application-id*stderr.gz/stdout.gz) *executor-pod-name*

# Mengonfigurasi pekerjaan yang dijalankan untuk menggunakan Amazon CloudWatch Logs
<a name="emr-eks-jobs-cloudwatch"></a>

Untuk memantau kemajuan pekerjaan dan memecahkan masalah kegagalan, Anda harus mengonfigurasi pekerjaan Anda untuk mengirim informasi log ke Amazon S3, Amazon Log, CloudWatch atau keduanya. Topik ini membantu Anda mulai menggunakan CloudWatch Log pada pekerjaan Anda yang diluncurkan dengan Amazon EMR di EKS. Untuk informasi selengkapnya tentang CloudWatch Log, lihat [Memantau File Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatchLogs.html) di Panduan CloudWatch Pengguna Amazon.

**CloudWatch Log kebijakan IAM**

Agar pekerjaan Anda dapat mengirim data CloudWatch log ke Log, izin berikut harus disertakan dalam kebijakan izin untuk peran eksekusi pekerjaan. Ganti *my\$1log\$1group\$1name* dan *my\$1log\$1stream\$1prefix* dengan nama grup CloudWatch log dan nama aliran log Anda, masing-masing. Amazon EMR di EKS menciptakan grup log dan stream log jika mereka tidak ada selama peran eksekusi ARN memiliki izin yang sesuai. 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "logs:CreateLogStream",
        "logs:DescribeLogGroups",
        "logs:DescribeLogStreams"
      ],
      "Resource": [
        "arn:aws:logs:*:*:*"
      ],
      "Sid": "AllowLOGSCreatelogstream"
    },
    {
      "Effect": "Allow",
      "Action": [
        "logs:PutLogEvents"
      ],
      "Resource": [
        "arn:aws:logs:*:*:log-group:my_log_group_name:log-stream:my_log_stream_prefix/*"
      ],
      "Sid": "AllowLOGSPutlogevents"
    }
  ]
}
```

------

**catatan**  
Amazon EMR di EKS juga dapat membuat aliran log. Jika aliran log tidak ada, kebijakan IAM harus menyertakan `"logs:CreateLogGroup"` izin.

Setelah Anda memberikan izin yang tepat pada peran eksekusi, aplikasi Anda mengirimkan data lognya ke CloudWatch Log saat `cloudWatchMonitoringConfiguration` diteruskan di `monitoringConfiguration` bagian `start-job-run` permintaan, seperti yang ditunjukkan pada[Mengelola pekerjaan berjalan dengan AWS CLI](emr-eks-jobs-CLI.md).

Di `StartJobRun` API, *log\$1group\$1name * adalah nama grup log untuk CloudWatch, dan *log\$1stream\$1prefix* merupakan awalan nama aliran log untuk CloudWatch. Anda dapat melihat dan mencari log ini di Konsol Manajemen AWS.
+ Log pengirim -//*virtual-cluster-id*/jobs/ *logGroup* /containers/*logStreamPrefix*/(stderr/stdout*job-id*) *pod-name*
+ Log driver -*logGroup*//*virtual-cluster-id*/jobs/ *logStreamPrefix* *job-id* /containers/ /spark- -driver/ *spark-application-id* (stderrstdout) *job-id*
+ Log pelaksana -*logGroup*//*virtual-cluster-id*/jobs/ *logStreamPrefix* *job-id* /containers///(stderr/stdout*spark-application-id*) *executor-pod-name*

## Daftar tugas berjalan
<a name="emr-eks-jobs-list"></a>

Anda dapat menjalankan `list-job-run` untuk menunjukkan keadaan tugas berjalan, seperti yang ditunjukkan contoh berikut. 

```
aws emr-containers list-job-runs --virtual-cluster-id <cluster-id>
```

## Jelaskan tugas berjalan
<a name="emr-eks-jobs-describe"></a>

Anda dapat menjalankan `describe-job-run` untuk mendapatkan detail lebih lanjut tentang tugas, seperti status tugas, detail tugas, dan nama tugas, seperti yang ditunjukkan contoh berikut. 

```
aws emr-containers describe-job-run --virtual-cluster-id cluster-id --id job-run-id
```

## Membatalkan tugas berjalan
<a name="emr-eks-jobs-cancel"></a>

Anda dapat menjalankan `cancel-job-run` untuk membatalkan tugas berjalan, seperti yang ditunjukkan contoh berikut.

```
aws emr-containers cancel-job-run --virtual-cluster-id cluster-id --id job-run-id
```

# Menjalankan skrip Spark SQL melalui API StartJobRun
<a name="emr-eks-jobs-spark-sql-parameters"></a>

Amazon EMR di EKS merilis 6.7.0 dan yang lebih tinggi menyertakan driver pekerjaan Spark SQL sehingga Anda dapat menjalankan skrip Spark SQL melalui API. `StartJobRun` Anda dapat menyediakan file entry-point SQL untuk langsung menjalankan kueri Spark SQL di Amazon EMR di EKS `StartJobRun` dengan API, tanpa modifikasi apa pun pada skrip Spark SQL yang ada. Tabel berikut mencantumkan parameter Spark yang didukung untuk pekerjaan Spark SQL melalui API. StartJobRun 

Anda dapat memilih dari parameter Spark berikut untuk dikirim ke pekerjaan Spark SQL. Gunakan parameter ini untuk mengganti properti Spark default.


| Opsi | Deskripsi | 
| --- | --- | 
|  --nama NAMA  | Nama Aplikasi | 
| --guci toples | Daftar stoples dipisahkan koma untuk disertakan dengan driver dan jalankan classpath. | 
| --paket | Daftar koordinat maven stoples yang dipisahkan koma untuk disertakan pada classpath driver dan eksekutor. | 
| --exclude-paket | Daftar groupId:ArtifactID yang dipisahkan koma, untuk dikecualikan saat menyelesaikan dependensi yang disediakan di —packages untuk menghindari konflik ketergantungan. | 
| --repositori | Daftar repositori jarak jauh tambahan yang dipisahkan koma untuk mencari koordinat maven yang diberikan dengan —packages. | 
| --file BERKAS | Daftar file yang dipisahkan koma untuk ditempatkan di direktori kerja masing-masing pelaksana. | 
| --conf PROP=NILAI | Properti konfigurasi percikan. | 
| --properties-file BERKAS | Jalur ke file untuk memuat properti tambahan. | 
| --driver-memori MEM | Memori untuk pengemudi. Standar 1024MB. | 
| --driver-java-options | Opsi Java ekstra untuk diteruskan ke driver. | 
| --driver-library-path | Entri jalur perpustakaan tambahan untuk diteruskan ke pengemudi. | 
| --driver-class-path | Entri classpath ekstra untuk diteruskan ke pengemudi. | 
| --executor-memori MEM | Memori per eksekutor. Standar 1GB. | 
| --driver-core NUM | Jumlah core yang digunakan oleh driver. | 
| -- total-executor-cores JUMLAH | Total core untuk semua pelaksana. | 
| --executor-core NUM | Jumlah core yang digunakan oleh masing-masing eksekutor. | 
| --num-pelaksana NUM | Jumlah pelaksana yang akan diluncurkan. | 
| -hivevar <kunci=nilai> | Substitusi variabel untuk diterapkan pada perintah Hive, misalnya, -hivevar A=B | 
| -hiveconf <property=nilai> | Nilai yang akan digunakan untuk properti yang diberikan. | 

Untuk pekerjaan Spark SQL, buat start-job-run-request file.json dan tentukan parameter yang diperlukan untuk menjalankan pekerjaan Anda, seperti pada contoh berikut:

```
{
  "name": "myjob", 
  "virtualClusterId": "123456",  
  "executionRoleArn": "iam_role_name_for_job_execution", 
  "releaseLabel": "emr-6.7.0-latest", 
  "jobDriver": {
    "sparkSqlJobDriver": {
      "entryPoint": "entryPoint_location",
       "sparkSqlParameters": "--conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"
    }
  }, 
  "configurationOverrides": {
    "applicationConfiguration": [
      {
        "classification": "spark-defaults", 
        "properties": {
          "spark.driver.memory":"2G"
         }
      }
    ], 
    "monitoringConfiguration": {
      "persistentAppUI": "ENABLED", 
      "cloudWatchMonitoringConfiguration": {
        "logGroupName": "my_log_group", 
        "logStreamNamePrefix": "log_stream_prefix"
      }, 
      "s3MonitoringConfiguration": {
        "logUri": "s3://my_s3_log_location"
      }
    }
  }
}
```

# Status tugas berjalan
<a name="emr-eks-jobs-states"></a>

Ketika Anda mengirimkan tugas berjalan ke antrean tugas Amazon EMR di EKS, tugas berjalan memasuki status `PENDING`. Kemudian melewati status-status berikut sampai berhasil (keluar dengan kode `0`) atau gagal (keluar dengan kode bukan nol). 

Tugas berjalan dapat memiliki status berikut:
+ `PENDING` - Status tugas awal saat tugas berjalan dikirimkan ke Amazon EMR di EKS. Tugas sedang menunggu untuk dikirimkan ke klaster virtual, dan Amazon EMR di EKS sedang bekerja untuk mengirimkan tugas ini.
+ `SUBMITTED` - Tugas berjalan yang telah berhasil dikirimkan ke klaster virtual. Penjadwal klaster kemudian mencoba untuk menjalankan tugas ini di cluster.
+ `RUNNING` - Tugas berjalan yang berjalan di klaster virtual. Dalam aplikasi Spark, ini berarti bahwa proses driver Spark ada di status `running`.
+ `FAILED` - Tugas berjalan yang gagal untuk dikirimkan ke klaster virtual atau yang gagal diselesaikan. Lihatlah StateDetails dan FailureReason untuk menemukan informasi tambahan tentang kegagalan pekerjaan ini.
+ `COMPLETED` - Tugas berjalan yang telah berhasil diselesaikan.
+ `CANCEL_PENDING` - Tugas berjalan telah diminta untuk pembatalan. Amazon EMR di EKS sedang mencoba untuk membatalkan tugas pada klaster virtual.
+ `CANCELLED` - Tugas berjalan yang berhasil dibatalkan.

# Melihat tugas di konsol Amazon EMR
<a name="emr-eks-jobs-console"></a>

Data Job run tersedia untuk dilihat, sehingga Anda dapat memantau setiap pekerjaan saat melewati status. Untuk melihat pekerjaan di konsol EMR Amazon, lakukan langkah-langkah berikut.

1. **Di menu kiri konsol EMR Amazon, di bawah Amazon EMR di EKS, pilih Cluster virtual.**

1. Dari daftar cluster virtual, pilih cluster virtual yang ingin Anda lihat pekerjaannya.

1. Pada tabel **Tugas berjalan**, pilih **Lihat log** untuk melihat detail tugas.

**catatan**  
Dukungan untuk pengalaman satu klik diaktifkan secara default. Ini dapat dimatikan dengan mengatur `persistentAppUI` ke `DISABLED` dalam `monitoringConfiguration` selama pengiriman tugas. Untuk informasi selengkapnya, lihat [Melihat Antarmuka Pengguna Aplikasi Persisten](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html).

# Kesalahan umum saat menjalankan tugas
<a name="emr-eks-jobs-error"></a>

Kesalahan berikut dapat terjadi ketika Anda menjalankan API `StartJobRun`. Tabel mencantumkan setiap kesalahan dan menyediakan langkah-langkah mitigasi sehingga Anda dapat mengatasi masalah dengan cepat.


| Pesan Kesalahan | Kondisi Kesalahan | Langkah Selanjutnya yang Disarankan | 
| --- | --- | --- | 
|  error: argumen -- *argument* diperlukan  | Parameter yang diperlukan hilang. | Tambahkan argumen yang hilang ke permintaan API. | 
| Terjadi kesalahan (AccessDeniedException) saat memanggil StartJobRun operasi: Pengguna: ARN tidak berwenang untuk melakukan: emr-container: StartJobRun | Peran eksekusi hilang. | Lihat Menggunakan [Menggunakan peran eksekusi tugas dengan Amazon EMR di EKS](iam-execution-role.md).  | 
|  Terjadi kesalahan (AccessDeniedException) saat memanggil StartJobRun operasi: Pengguna: *ARN* tidak berwenang untuk melakukan: emr-container: StartJobRun  |  Pemanggil tidak memiliki izin untuk peran eksekusi [format valid / tidak valid] melalui kunci kondisi.  | Lihat [Menggunakan peran eksekusi tugas dengan Amazon EMR di EKS](iam-execution-role.md).  | 
|  Terjadi kesalahan (AccessDeniedException) saat memanggil StartJobRun operasi: Pengguna: *ARN* tidak berwenang untuk melakukan: emr-container: StartJobRun  |  Pengirim tugas dan Peran eksekusi ARN berasal dari akun yang berbeda.  | Pastikan bahwa pengirim tugas dan peran eksekusi ARN adalah dari akun AWS yang sama. | 
|  1 kesalahan validasi terdeteksi: Nilai *Role* pada 'executionRoleArn' gagal memenuhi pola ekspresi reguler ARN: ^arn :( aws [A-za-z0-9-] \$1) :iam: :(\$1 d \$112\$1)? : (peran ((\$1 u002f) \$1 (\$1 u002f [\$1 u0021-\$1 u007f] \$1\$1 u002f)) [\$1 w\$1=, .@-] \$1)  |  Pemanggil memiliki izin untuk peran eksekusi melalui kunci kondisi, tetapi peran tidak memenuhi batasan format ARN.  | Berikan peran eksekusi mengikuti format ARN berikut. Lihat [Menggunakan peran eksekusi tugas dengan Amazon EMR di EKS](iam-execution-role.md).  | 
|  Terjadi kesalahan (ResourceNotFoundException) saat memanggil StartJobRun operasi: Kluster virtual *Virtual Cluster ID* tidak ada.  |  ID klaster virtual tidak ditemukan.  | Menyediakan klaster virtual ID terdaftar dengan Amazon EMR di EKS. | 
|  Terjadi kesalahan (ValidationException) saat memanggil StartJobRun operasi: Status klaster virtual *state* tidak valid untuk membuat sumber daya JobRun.  |  Klaster virtual tidak siap untuk melaksanakan tugas.  | Lihat [Status klaster virtual](virtual-cluster.md#virtual-cluster-states).  | 
|  Terjadi kesalahan (ResourceNotFoundException) saat memanggil StartJobRun operasi: Rilis *RELEASE* tidak ada.  |  Rilis yang ditentukan dalam pengiriman tugas tidak benar.  | Lihat [Amazon EMR pada rilis EKS](emr-eks-releases.md).  | 
|  Terjadi kesalahan (AccessDeniedException) saat memanggil StartJobRun operasi: Pengguna: tidak *ARN* diizinkan untuk melakukan: emr-container: StartJobRun on resource: *ARN* dengan penolakan eksplisit. Terjadi kesalahan (AccessDeniedException) saat memanggil StartJobRun operasi: Pengguna: *ARN* tidak berwenang untuk melakukan: emr-container: StartJobRun on resource: *ARN*  | Pengguna tidak berwenang untuk menelepon StartJobRun. | Lihat [Menggunakan peran eksekusi tugas dengan Amazon EMR di EKS](iam-execution-role.md).  | 
|  Terjadi galat (ValidationException) saat memanggil StartJobRun operasi: ConfigurationOverrides.MonitoringConfiguration.s3 .loguri gagal memenuhi batasanMonitoringConfiguration: %s  |  Jalur S3 sintaks URI tidak valid.  | logURI harus dalam format s3://...  | 

Kesalahan berikut dapat terjadi ketika Anda menjalankan API `DescribeJobRun` sebelum tugas berjalan.


| Pesan Kesalahan | Kondisi Kesalahan | Langkah Selanjutnya yang Disarankan | 
| --- | --- | --- | 
|  StateDetails: JobRun pengiriman gagal.  Klasifikasi *classification* tidak didukung. failureReason: VALIDATION\$1ERROR status: GAGAL.  | Parameter StartJobRun dalam tidak valid. | Lihat [Amazon EMR pada rilis EKS](emr-eks-releases.md).  | 
|  StateDetails: Cluster *EKS Cluster ID* tidak ada. failureReason: CLUSTER\$1UNAVAILABLE status: GAGAL  | Klaster EKS tidak tersedia. | Periksa apakah klaster EKS ada dan memiliki izin yang tepat. Untuk informasi selengkapnya, lihat [Menyiapkan Amazon EMR di EKS](setting-up.md). | 
|  StateDetails: Cluster *EKS Cluster ID* tidak memiliki izin yang memadai. failureReason: CLUSTER\$1UNAVAILABLE status: GAGAL  |  Amazon EMR tidak memiliki izin untuk mengakses klaster EKS.  | Verifikasi bahwa izin diatur untuk Amazon EMR pada namespace terdaftar. Untuk informasi selengkapnya, lihat [Menyiapkan Amazon EMR di EKS](setting-up.md). | 
|  StateDetails: Cluster saat ini *EKS Cluster ID* tidak dapat dijangkau. failureReason: CLUSTER\$1UNAVAILABLE status: GAGAL  |  Klaster EKS tidak dapat dijangkau.  | Periksa apakah Klaster EKS ada dan memiliki izin yang tepat. Untuk informasi selengkapnya, lihat [Menyiapkan Amazon EMR di EKS](setting-up.md). | 
|  StateDetails: JobRun pengiriman gagal karena kesalahan internal. failureReason: INTERNAL\$1ERROR status: GAGAL  |  Kesalahan internal telah terjadi dengan klaster EKS.  | N/A | 
|  StateDetails: Cluster *EKS Cluster ID* tidak memiliki sumber daya yang cukup. failureReason: USER\$1ERROR status: GAGAL  |  Ada sumber daya yang tidak mencukupi di klaster EKS untuk menjalankan tugas.  | Tambahkan lebih banyak kapasitas ke grup simpul EKS atau atur EKS Autoscaler. Untuk informasi lebih lanjut, lihat [Klaster Autoscaler](https://docs.aws.amazon.com/eks/latest/userguide/cluster-autoscaler.html). | 

Kesalahan berikut dapat terjadi ketika Anda menjalankan API `DescribeJobRun` setelah tugas berjalan.


| Pesan Kesalahan | Kondisi Kesalahan | Langkah Selanjutnya yang Disarankan | 
| --- | --- | --- | 
|  StateDetails: Kesulitan memantau Anda. JobRun  Cluster *EKS Cluster ID* tidak ada. failureReason: CLUSTER\$1UNAVAILABLE status: GAGAL  | Klaster EKS tidak ada. | Periksa apakah Klaster EKS ada dan memiliki izin yang tepat. Untuk informasi selengkapnya, lihat [Menyiapkan Amazon EMR di EKS](setting-up.md). | 
|  StateDetails: Kesulitan memantau Anda. JobRun Cluster *EKS Cluster ID* tidak memiliki izin yang memadai. failureReason: CLUSTER\$1UNAVAILABLE status: GAGAL  | Amazon EMR tidak memiliki izin untuk mengakses klaster EKS. | Verifikasi bahwa izin diatur untuk Amazon EMR pada namespace terdaftar. Untuk informasi selengkapnya, lihat [Menyiapkan Amazon EMR di EKS](setting-up.md). | 
|  StateDetails: Kesulitan memantau Anda. JobRun Cluster saat *EKS Cluster ID* ini tidak dapat dijangkau. failureReason: CLUSTER\$1UNAVAILABLE status: GAGAL  |  Klaster EKS tidak dapat dijangkau.  | Periksa apakah Klaster EKS ada dan memiliki izin yang tepat. Untuk informasi selengkapnya, lihat [Menyiapkan Amazon EMR di EKS](setting-up.md). | 
|  StateDetails: Kesulitan memantau Anda JobRun karena kesalahan internal failureReason: INTERNAL\$1ERROR status: GAGAL  |  Kesalahan internal telah terjadi dan mencegah JobRun pemantauan.  | N/A | 

Kesalahan berikut dapat terjadi ketika pekerjaan tidak dapat dimulai dan pekerjaan menunggu dalam keadaan DIKIRIM selama 15 menit. Hal ini dapat disebabkan oleh kurangnya sumber daya cluster.


| Pesan Kesalahan | Kondisi Kesalahan | Langkah Selanjutnya yang Disarankan | 
| --- | --- | --- | 
|  batas waktu cluster  | Pekerjaan telah dalam keadaan DIKIRIM selama 15 menit atau lebih. | Anda dapat mengganti pengaturan default 15 menit untuk parameter ini dengan penggantian konfigurasi yang ditunjukkan di bawah ini.  | 

Gunakan konfigurasi berikut untuk mengubah pengaturan batas waktu cluster menjadi 30 menit. Perhatikan bahwa Anda memberikan `job-start-timeout` nilai baru dalam hitungan detik:

```
{
"configurationOverrides": {
  "applicationConfiguration": [{
      "classification": "emr-containers-defaults",
      "properties": {
          "job-start-timeout":"1800"
      }
  }]
}
```

# Menggunakan template pekerjaan
<a name="job-templates"></a>

Template pekerjaan menyimpan nilai yang dapat dibagikan di seluruh pemanggilan `StartJobRun` API saat memulai menjalankan pekerjaan. Ini mendukung dua kasus penggunaan:
+ Untuk mencegah nilai permintaan `StartJobRun` API berulang berulang.
+ Untuk menegakkan aturan bahwa nilai tertentu harus disediakan melalui permintaan `StartJobRun` API.

Job templates memungkinkan Anda untuk menentukan template yang dapat digunakan kembali untuk menjalankan pekerjaan untuk menerapkan kustomisasi tambahan, misalnya:
+ Mengkonfigurasi kapasitas komputasi eksekutor dan driver
+ Menetapkan properti keamanan dan tata kelola seperti peran IAM
+ Menyesuaikan image docker untuk digunakan di beberapa aplikasi dan pipeline data

Topik berikut memberikan informasi terperinci tentang penggunaan templat, termasuk cara menggunakannya untuk memulai pekerjaan dan cara mengubah parameter templat.

**Topics**
+ [Membuat dan menggunakan template pekerjaan untuk memulai pekerjaan](create-job-template.md)
+ [Mendefinisikan parameter template pekerjaan](use-job-template-parameters.md)
+ [Mengontrol akses ke templat pekerjaan](iam-job-template.md)

# Membuat dan menggunakan template pekerjaan untuk memulai pekerjaan
<a name="create-job-template"></a>

Bagian ini menjelaskan pembuatan template pekerjaan dan menggunakan template untuk memulai pekerjaan dengan AWS Command Line Interface (AWS CLI).

**Untuk membuat template pekerjaan**

1. Buat `create-job-template-request.json` file dan tentukan parameter yang diperlukan untuk template pekerjaan Anda, seperti yang ditunjukkan dalam contoh file JSON berikut. Untuk informasi tentang semua parameter yang tersedia, lihat [CreateJobTemplate](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/Welcome.html)API.

   Sebagian besar nilai yang diperlukan untuk `StartJobRun` API juga diperlukan untuk`jobTemplateData`. Jika Anda ingin menggunakan placeholder untuk parameter apa pun dan memberikan nilai saat memanggil StartJobRun menggunakan templat pekerjaan, silakan lihat bagian selanjutnya pada parameter templat pekerjaan.

   ```
   {
      "name": "mytemplate",
      "jobTemplateData": {
           "executionRoleArn": "iam_role_arn_for_job_execution", 
           "releaseLabel": "emr-6.7.0-latest",
           "jobDriver": {
               "sparkSubmitJobDriver": { 
                   "entryPoint": "entryPoint_location",
                   "entryPointArguments": [ "argument1","argument2",...],
                   "sparkSubmitParameters": "--class <main_class> --conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"
               }
           },
           "configurationOverrides": {
               "applicationConfiguration": [
                   {
                       "classification": "spark-defaults", 
                       "properties": {
                            "spark.driver.memory":"2G"
                       }
                   }
               ], 
               "monitoringConfiguration": {
                   "persistentAppUI": "ENABLED", 
                   "cloudWatchMonitoringConfiguration": {
                       "logGroupName": "my_log_group", 
                       "logStreamNamePrefix": "log_stream_prefix"
                   }, 
                   "s3MonitoringConfiguration": {
                       "logUri": "s3://my_s3_log_location/"
                   }
               }
           }
        }
   }
   ```

1. Gunakan `create-job-template` perintah dengan path ke `create-job-template-request.json` file yang disimpan secara lokal.

   ```
   aws emr-containers create-job-template \ 
   --cli-input-json file://./create-job-template-request.json
   ```

**Untuk memulai pekerjaan dengan menggunakan template pekerjaan**

Berikan id cluster virtual, id template pekerjaan, dan nama pekerjaan dalam `StartJobRun` perintah, seperti yang ditunjukkan pada contoh berikut.

```
aws emr-containers start-job-run \
--virtual-cluster-id 123456 \
--name myjob \
--job-template-id 1234abcd
```

# Mendefinisikan parameter template pekerjaan
<a name="use-job-template-parameters"></a>

Parameter template Job memungkinkan Anda untuk menentukan variabel dalam template pekerjaan. Nilai untuk variabel parameter ini perlu ditentukan saat memulai pekerjaan yang dijalankan menggunakan template pekerjaan itu. Parameter template Job ditentukan dalam `${parameterName}` format. Anda dapat memilih untuk menentukan nilai apa pun di `jobTemplateData` bidang sebagai parameter template pekerjaan. Untuk setiap variabel parameter template pekerjaan, tentukan tipe datanya (`STRING`atau`NUMBER`) dan secara opsional nilai default. Contoh di bawah ini menunjukkan bagaimana Anda dapat menentukan parameter template pekerjaan untuk lokasi titik masuk, kelas utama, dan nilai lokasi log S3.

**Untuk menentukan lokasi titik masuk, kelas utama, dan lokasi log Amazon S3 sebagai parameter templat pekerjaan**

1. Buat `create-job-template-request.json` file dan tentukan parameter yang diperlukan untuk template pekerjaan Anda, seperti yang ditunjukkan dalam contoh file JSON berikut. Untuk informasi selengkapnya tentang parameter, lihat [CreateJobTemplate](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/Welcome.html)API.

   ```
   {
      "name": "mytemplate",
      "jobTemplateData": {
           "executionRoleArn": "iam_role_arn_for_job_execution", 
           "releaseLabel": "emr-6.7.0-latest",
           "jobDriver": {
               "sparkSubmitJobDriver": { 
                   "entryPoint": "${EntryPointLocation}",
                   "entryPointArguments": [ "argument1","argument2",...],
                   "sparkSubmitParameters": "--class ${MainClass} --conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"
               }
           },
           "configurationOverrides": {
               "applicationConfiguration": [
                   {
                       "classification": "spark-defaults", 
                       "properties": {
                            "spark.driver.memory":"2G"
                       }
                   }
               ], 
               "monitoringConfiguration": {
                   "persistentAppUI": "ENABLED", 
                   "cloudWatchMonitoringConfiguration": {
                       "logGroupName": "my_log_group", 
                       "logStreamNamePrefix": "log_stream_prefix"
                   }, 
                   "s3MonitoringConfiguration": {
                       "logUri": "${LogS3BucketUri}"
                   }
               }
           },
           "parameterConfiguration": {
               "EntryPointLocation": {
                   "type": "STRING"
               },
               "MainClass": {
                   "type": "STRING",
                   "defaultValue":"Main"
               },
               "LogS3BucketUri": {
                   "type": "STRING",
                   "defaultValue":"s3://my_s3_log_location/"
               }
           }
       }
   }
   ```

1. Gunakan perintah `create-job-template` dengan jalur ke file `create-job-template-request.json` yang disimpan secara lokal atau di Amazon S3.

   ```
   aws emr-containers create-job-template \ 
   --cli-input-json file://./create-job-template-request.json
   ```

**Untuk memulai pekerjaan dengan menggunakan template pekerjaan dengan parameter template pekerjaan**

Untuk memulai pekerjaan dengan template pekerjaan yang berisi parameter template pekerjaan, tentukan id templat pekerjaan serta nilai untuk parameter template pekerjaan dalam permintaan `StartJobRun` API seperti yang ditunjukkan di bawah ini.

```
aws emr-containers start-job-run \
--virtual-cluster-id 123456 \
--name myjob \
--job-template-id 1234abcd \
--job-template-parameters '{"EntryPointLocation": "entry_point_location","MainClass": "ExampleMainClass","LogS3BucketUri": "s3://example_s3_bucket/"}'
```

# Mengontrol akses ke templat pekerjaan
<a name="iam-job-template"></a>

`StartJobRun`policy memungkinkan Anda menegakkan bahwa pengguna atau peran hanya dapat menjalankan pekerjaan menggunakan templat pekerjaan yang Anda tentukan dan tidak dapat menjalankan `StartJobRun` operasi tanpa menggunakan templat pekerjaan yang ditentukan. Untuk mencapai hal ini, pertama-tama pastikan bahwa Anda memberi pengguna atau peran izin baca ke templat pekerjaan yang ditentukan seperti yang ditunjukkan di bawah ini.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "emr-containers:DescribeJobRun"
      ],
      "Resource": [
        "arn:aws:emr-containers:*:*:jobtemplate/job_template_1_id",
        "arn:aws:emr-containers:*:*:jobtemplate/job_template_2_id"
      ],
      "Sid": "AllowEMRCONTAINERSDescribejobtemplate"
    }
  ]
}
```

------

Untuk menegakkan bahwa pengguna atau peran hanya dapat menjalankan `StartJobRun` operasi saat menggunakan templat pekerjaan tertentu, Anda dapat menetapkan izin `StartJobRun` kebijakan berikut ke pengguna atau peran tertentu.

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "emr-containers:StartJobRun"
      ],
      "Resource": [
        "arn:aws:emr-containers:*:*:/virtualclusters/virtual_cluster_id"
      ],
      "Condition": {
        "ArnLike": {
          "emr-containers:JobTemplateArn": [
            "arn:aws:emr-containers:*:*:jobtemplate/job_template_1_id",
            "arn:aws:emr-containers:*:*:jobtemplate/job_template_2_id"
          ]
        }
      },
      "Sid": "AllowEMRCONTAINERSStartjobrun"
    }
  ]
}
```

------

Jika template pekerjaan menentukan parameter template pekerjaan di dalam bidang ARN peran eksekusi, maka pengguna akan dapat memberikan nilai untuk parameter ini dan dengan demikian dapat `StartJobRun` memanggil menggunakan peran eksekusi arbitrer. Untuk membatasi peran eksekusi yang dapat diberikan pengguna, lihat **Mengontrol akses ke peran eksekusi**. [Menggunakan peran eksekusi tugas dengan Amazon EMR di EKS](iam-execution-role.md) 

Jika tidak ada kondisi yang ditentukan dalam kebijakan `StartJobRun` tindakan di atas untuk pengguna atau peran tertentu, pengguna atau peran tersebut akan diizinkan untuk memanggil `StartJobRun` tindakan pada klaster virtual yang ditentukan menggunakan templat pekerjaan arbitrer yang telah mereka baca akses atau menggunakan peran eksekusi arbitrer.

# Menggunakan templat pod
<a name="pod-templates"></a>

Dimulai dengan Amazon EMR versi 5.33.0 atau 6.3.0, Amazon EMR di EKS mendukung fitur templat pod Spark. Sebuah pod adalah sekelompok satu atau lebih kontainer, dengan penyimpanan bersama dan sumber daya jaringan, dan spesifikasi cara menjalankan kontainer. Templat pod adalah spesifikasi yang menentukan cara menjalankan setiap pod. Anda dapat menggunakan file templat pod untuk menentukan konfigurasi driver atau pelaksana pod yang tidak didukung konfigurasi Spark. Untuk informasi selengkapnya tentang fitur templat pod Spark, lihat [Templat Pod](https://spark.apache.org/docs/latest/running-on-kubernetes.html#pod-template). 

**catatan**  
Fitur templat pod hanya bekerja dengan driver dan pelaksana pod. Anda tidak dapat mengonfigurasi pod pengirim pekerjaan menggunakan templat pod.

## Skenario umum
<a name="pod-template-use-cases"></a>

Anda dapat menentukan cara menjalankan tugas Spark di klaster EKS yang dibagikan dengan menggunakan templat pod dengan Amazon EMR di EKS dan menghemat biaya dan meningkatkan pemanfaatan sumber daya dan performa.
+ Untuk mengurangi biaya, Anda dapat menjadwalkan tugas driver Spark untuk dijalankan di Instans EC2 Sesuai Permintaan Amazon sambil menjadwalkan tugas pelaksana Spark untuk dijalankan di Instans Spot Amazon. EC2 
+ Untuk meningkatkan pemanfaatan sumber daya, Anda dapat mendukung beberapa tim yang menjalankan beban kerja mereka pada klaster EKS yang sama. Setiap tim akan mendapatkan grup EC2 node Amazon yang ditunjuk untuk menjalankan beban kerja mereka. Anda dapat menggunakan templat pod untuk menerapkan toleransi yang sesuai untuk beban kerja mereka. 
+ Untuk meningkatkan pemantauan, Anda dapat menjalankan kontainer pencatatan terpisah untuk meneruskan log pada aplikasi pemantauan yang ada. 

Sebagai contoh, file templat pod berikut menunjukkan skenario penggunaan umum. 

```
apiVersion: v1
kind: Pod
spec:
  volumes:
    - name: source-data-volume
      emptyDir: {}
    - name: metrics-files-volume
      emptyDir: {}
  nodeSelector:
    eks.amazonaws.com/nodegroup: emr-containers-nodegroup
  containers:
  - name: spark-kubernetes-driver # This will be interpreted as driver Spark main container
    env:
      - name: RANDOM
        value: "random"
    volumeMounts:
      - name: shared-volume
        mountPath: /var/data
      - name: metrics-files-volume
        mountPath: /var/metrics/data
  - name: custom-side-car-container # Sidecar container
    image: <side_car_container_image>
    env:
      - name: RANDOM_SIDECAR
        value: random
    volumeMounts:
      - name: metrics-files-volume
        mountPath: /var/metrics/data
    command:
      - /bin/sh
      - '-c'
      -  <command-to-upload-metrics-files>
  initContainers:
  - name: spark-init-container-driver # Init container
    image: <spark-pre-step-image>
    volumeMounts:
      - name: source-data-volume # Use EMR predefined volumes
        mountPath: /var/data
    command:
      - /bin/sh
      - '-c'
      -  <command-to-download-dependency-jars>
```

Templat pod menyelesaikan tugas berikut:
+ Tambahkan [kontainer init](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/)baru yang dieksekusi sebelum kontainer utama Spark dimulai. Wadah init berbagi [EmptyDirvolume](https://kubernetes.io/docs/concepts/storage/volumes/#emptydir) yang disebut `source-data-volume` dengan wadah utama Spark. Anda dapat meminta kontainer init Anda menjalankan langkah inisialisasi, seperti mengunduh dependensi atau menghasilkan data input. Kemudian kontainer utama Spark mengkonsumsi data.
+ Tambahkan [kontainer sidecar](https://kubernetes.io/docs/concepts/workloads/pods/#how-pods-manage-multiple-containers) lain yang dieksekusi bersama dengan kontainer utama Spark. Kedua kontainer berbagi volume `EmptyDir` lain yang disebut `metrics-files-volume`. Tugas Spark Anda dapat menghasilkan metrik, seperti metrik Prometheus. Kemudian tugas Spark dapat menempatkan metrik ke dalam file dan meminta kontainer sidecar mengunggah file ke sistem BI Anda sendiri untuk analisis di masa mendatang.
+ Tambahkan variabel lingkungan baru ke kontainer utama Spark. Anda dapat meminta tugas Anda mengkonsumsi variabel lingkungan.
+ Definisikan sebuah [simpul pemilih](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/), sehingga pod hanya dijadwalkan pada grup simpul `emr-containers-nodegroup`. Hal ini membantu untuk mengisolasi sumber daya komputasi di seluruh tugas dan tim.

## Mengaktifkan templat pod dengan Amazon EMR di EKS
<a name="use-pod-templates"></a>

Untuk mengaktifkan fitur templat pod dengan Amazon EMR pada EKS, konfigurasi properti Spark `spark.kubernetes.driver.podTemplateFile` dan `spark.kubernetes.executor.podTemplateFile` untuk menunjuk ke file templat pod di Amazon S3. Spark kemudian mengunduh file templat pod dan menggunakannya untuk membangun driver dan pod pelaksana.

**catatan**  
Spark menggunakan peran eksekusi tugas untuk memuat templat pod, sehingga peran eksekusi pekerjaan harus memiliki izin untuk mengakses Amazon S3 untuk memuat templat pod. Untuk informasi selengkapnya, lihat [Untuk membuat peran eksekusi tugas](creating-job-execution-role.md).

Anda dapat menggunakan `SparkSubmitParameters` untuk menentukan jalur Amazon S3 ke templat pod, seperti yang ditunjukkan file tugas berjalan JSON berikut.

```
{
  "name": "myjob", 
  "virtualClusterId": "123456",  
  "executionRoleArn": "iam_role_name_for_job_execution", 
  "releaseLabel": "release_label", 
  "jobDriver": {
    "sparkSubmitJobDriver": {
      "entryPoint": "entryPoint_location",
      "entryPointArguments": ["argument1", "argument2", ...], 
       "sparkSubmitParameters": "--class <main_class> \
         --conf spark.kubernetes.driver.podTemplateFile=s3://path_to_driver_pod_template \
         --conf spark.kubernetes.executor.podTemplateFile=s3://path_to_executor_pod_template \
         --conf spark.executor.instances=2 \
         --conf spark.executor.memory=2G \
         --conf spark.executor.cores=2 \
         --conf spark.driver.cores=1"
    }
  }
}
```

Atau, Anda dapat menggunakan `configurationOverrides` untuk menentukan jalur Amazon S3 ke templat pod, seperti yang ditunjukkan file tugas berjalan JSON berikut.

```
{
  "name": "myjob", 
  "virtualClusterId": "123456",  
  "executionRoleArn": "iam_role_name_for_job_execution", 
  "releaseLabel": "release_label", 
  "jobDriver": {
    "sparkSubmitJobDriver": {
      "entryPoint": "entryPoint_location",
      "entryPointArguments": ["argument1", "argument2", ...],  
       "sparkSubmitParameters": "--class <main_class> \
         --conf spark.executor.instances=2 \
         --conf spark.executor.memory=2G \
         --conf spark.executor.cores=2 \
         --conf spark.driver.cores=1"
    }
  }, 
  "configurationOverrides": {
    "applicationConfiguration": [
      {
        "classification": "spark-defaults", 
        "properties": {
          "spark.driver.memory":"2G",
          "spark.kubernetes.driver.podTemplateFile":"s3://path_to_driver_pod_template",
          "spark.kubernetes.executor.podTemplateFile":"s3://path_to_executor_pod_template"
         }
      }
    ]
  }
}
```

**catatan**  
Anda harus mengikuti pedoman keamanan saat menggunakan fitur templat pod dengan Amazon EMR di EKS, seperti mengisolasi kode aplikasi yang tidak dipercaya. Untuk informasi selengkapnya, lihat [Amazon EMR pada praktik terbaik keamanan EKS](security-best-practices.md).
Anda tidak dapat mengubah nama kontainer utama Spark dengan menggunakan `spark.kubernetes.driver.podTemplateContainerName` dan `spark.kubernetes.executor.podTemplateContainerName`, karena nama-nama ini di-hardcode sebagai `spark-kubernetes-driver` dan `spark-kubernetes-executors`. Jika Anda ingin menyesuaikan kontainer utama Spark, Anda harus menentukan kontainer dalam templat pod dengan nama-nama di-hardcode ini.

## Bidang templat pod
<a name="pod-templates-fields"></a>

Pertimbangkan pembatasan bidang berikut ketika mengonfigurasi templat pod dengan Amazon EMR di EKS.
+ Amazon EMR di EKS hanya mengizinkan bidang-bidang berikut dalam templat pod untuk mengaktifkan penjadwalan tugas yang tepat.

  Ini adalah bidang tingkat pod yang diizinkan:
  + `apiVersion`
  + `kind`
  + `metadata`
  + `spec.activeDeadlineSeconds`
  + `spec.affinity`
  + `spec.containers`
  + `spec.enableServiceLinks`
  + `spec.ephemeralContainers`
  + `spec.hostAliases`
  + `spec.hostname`
  + `spec.imagePullSecrets`
  + `spec.initContainers`
  + `spec.nodeName`
  + `spec.nodeSelector`
  + `spec.overhead`
  + `spec.preemptionPolicy`
  + `spec.priority`
  + `spec.priorityClassName`
  + `spec.readinessGates`
  + `spec.runtimeClassName`
  + `spec.schedulerName`
  + `spec.subdomain`
  + `spec.terminationGracePeriodSeconds`
  + `spec.tolerations`
  + `spec.topologySpreadConstraints`
  + `spec.volumes`

  Ini adalah bidang tingkat kontainer utama Spark yang diizinkan:
  + `env`
  + `envFrom`
  + `name`
  + `lifecycle`
  + `livenessProbe`
  + `readinessProbe`
  + `resources`
  + `startupProbe`
  + `stdin`
  + `stdinOnce`
  + `terminationMessagePath`
  + `terminationMessagePolicy`
  + `tty`
  + `volumeDevices`
  + `volumeMounts`
  + `workingDir`

  Saat Anda menggunakan bidang yang tidak diizinkan dalam templat pod, Spark melempar pengecualian dan tugas gagal. Contoh berikut menunjukkan pesan kesalahan dalam log pengendali Spark karena bidang tidak diizinkan. 

  ```
  Executor pod template validation failed.
  Field container.command in Spark main container not allowed but specified.
  ```
+  Amazon EMR di EKS menentukan terlebih dahulu parameter berikut dalam templat pod. Bidang yang Anda tentukan dalam templat pod tidak boleh tumpang tindih dengan bidang ini. 

  Ini adalah nama volume yang telah ditetapkan:
  + `emr-container-communicate`
  + `config-volume`
  + `emr-container-application-log-dir`
  + `emr-container-event-log-dir`
  + `temp-data-dir`
  + `mnt-dir`
  + `home-dir`
  + `emr-container-s3`

  Ini adalah pemasangan volume yang telah ditetapkan yang hanya berlaku untuk kontainer utama Spark:
  + Nama:`emr-container-communicate`; MountPath: `/var/log/fluentd`
  + Nama:`emr-container-application-log-dir`; MountPath: `/var/log/spark/user`
  + Nama:`emr-container-event-log-dir`; MountPath: `/var/log/spark/apps`
  + Nama:`mnt-dir`; MountPath: `/mnt`
  + Nama:`temp-data-dir`; MountPath: `/tmp`
  + Nama:`home-dir`; MountPath: `/home/hadoop`

  Ini adalah variabel lingkungan yang telah ditetapkan yang hanya berlaku untuk kontainer utama Spark:
  + `SPARK_CONTAINER_ID`
  + `K8S_SPARK_LOG_URL_STDERR`
  + `K8S_SPARK_LOG_URL_STDOUT`
  + `SIDECAR_SIGNAL_FILE`
**catatan**  
Anda masih dapat menggunakan volume standar yang telah ditentukan ini dan memasangnya ke kontainer sidecar tambahan Anda. Misalnya, Anda dapat menggunakan `emr-container-application-log-dir` dan memasangnya ke kontainer sidecar Anda sendiri yang didefinisikan dalam templat pod.

  Jika bidang yang Anda tentukan bertentangan dengan salah satu bidang yang telah ditetapkan dalam templat pod, Spark melempar pengecualian dan tugas gagal. Contoh berikut menunjukkan pesan kesalahan dalam log aplikasi Spark karena bertentangan dengan bidang yang telah ditentukan. 

  ```
  Defined volume mount path on main container must not overlap with reserved mount paths: [<reserved-paths>]
  ```

## Pertimbangan kontainer sidecar
<a name="pod-template-sidecar"></a>

Amazon EMR mengendalikan siklus hidup pod yang disediakan oleh Amazon EMR di EKS. Kontainer sidecar harus mengikuti siklus hidup yang sama dengan kontainer utama Spark. Jika Anda menyuntikkan kontainer sidecar tambahan ke pod Anda, kami sarankan Anda mengintegrasikan dengan manajemen siklus hidup pod yang didefinisikan Amazon EMR sehingga kontainer sidecar dapat berhenti sendiri ketika kontainer utama Spark keluar.

Untuk mengurangi biaya, sebaiknya Anda menerapkan proses yang mencegah driver pod dengan kontainer sidecar terus berjalan setelah tugas Anda selesai. Driver Spark menghapus pod pelaksana saat pelaksana selesai. Namun, ketika program driver selesai, kontainer sidecar tambahan terus berjalan. Pod ditagihkan sampai Amazon EMR di EKS membersihkan pod driver, biasanya kurang dari satu menit setelah kontainer utama driver Spark selesai. Untuk mengurangi biaya, Anda dapat mengintegrasikan kontainer sidecar tambahan Anda dengan mekanisme manajemen siklus hidup yang didefinisikan Amazon EMR di EKS untuk driver dan pelaksana pod, seperti yang dijelaskan pada bagian berikut.

Kontainer utama Spark dalam driver dan pelaksana pod mengirimkan `heartbeat` ke `/var/log/fluentd/main-container-terminated` file setiap dua detik. Dengan menambahkan Amazon EMR yang telah ditetapkan `emr-container-communicate` pemasangan volume ke kontainer sidecar Anda, Anda dapat menentukan sub-proses kontainer sidecar Anda untuk secara berkala melacak waktu terakhir diubah untuk file ini. Sub-proses kemudian berhenti sendiri jika menemukan bahwa kontainer utama Spark menghentikan `heartbeat` untuk durasi yang lebih lama. 

Contoh berikut menunjukkan sub-proses yang melacak file detak jantung dan berhenti sendiri. Ganti *your\$1volume\$1mount* dengan jalur tempat Anda memasang volume yang telah ditentukan. Script dipaketkan di dalam gambar yang digunakan oleh kontainer sidecar. Dalam file templat pod, Anda dapat menentukan kontainer sidecar dengan perintah `sub_process_script.sh` dan `main_command` berikut.

```
MOUNT_PATH="your_volume_mount"
FILE_TO_WATCH="$MOUNT_PATH/main-container-terminated"
INITIAL_HEARTBEAT_TIMEOUT_THRESHOLD=60
HEARTBEAT_TIMEOUT_THRESHOLD=15
SLEEP_DURATION=10

function terminate_main_process() {
  # Stop main process
}

# Waiting for the first heartbeat sent by Spark main container
echo "Waiting for file $FILE_TO_WATCH to appear..."
start_wait=$(date +%s)
while ! [[ -f "$FILE_TO_WATCH" ]]; do
    elapsed_wait=$(expr $(date +%s) - $start_wait)
    if [ "$elapsed_wait" -gt "$INITIAL_HEARTBEAT_TIMEOUT_THRESHOLD" ]; then
        echo "File $FILE_TO_WATCH not found after $INITIAL_HEARTBEAT_TIMEOUT_THRESHOLD seconds; aborting"
        terminate_main_process
        exit 1
    fi
    sleep $SLEEP_DURATION;
done;
echo "Found file $FILE_TO_WATCH; watching for heartbeats..."

while [[ -f "$FILE_TO_WATCH" ]]; do
    LAST_HEARTBEAT=$(stat -c %Y $FILE_TO_WATCH)
    ELAPSED_TIME_SINCE_AFTER_HEARTBEAT=$(expr $(date +%s) - $LAST_HEARTBEAT)
    if [ "$ELAPSED_TIME_SINCE_AFTER_HEARTBEAT" -gt "$HEARTBEAT_TIMEOUT_THRESHOLD" ]; then
        echo "Last heartbeat to file $FILE_TO_WATCH was more than $HEARTBEAT_TIMEOUT_THRESHOLD seconds ago at $LAST_HEARTBEAT; terminating"
        terminate_main_process
        exit 0
    fi
    sleep $SLEEP_DURATION;
done;
echo "Outside of loop, main-container-terminated file no longer exists"
    
# The file will be deleted once the fluentd container is terminated

echo "The file $FILE_TO_WATCH doesn't exist any more;"
terminate_main_process
exit 0
```

# Menggunakan kebijakan coba lagi pekerjaan
<a name="jobruns-using-retry-policies"></a>

Di Amazon EMR di EKS versi 6.9.0 dan yang lebih baru, Anda dapat menetapkan kebijakan coba lagi untuk menjalankan pekerjaan Anda. Kebijakan coba lagi menyebabkan pod driver pekerjaan dimulai ulang secara otomatis jika gagal atau dihapus. Ini membuat pekerjaan streaming Spark yang berjalan lama lebih tahan terhadap kegagalan.

## Menetapkan kebijakan coba lagi untuk suatu pekerjaan
<a name="setting-retry-policy"></a>

Untuk mengonfigurasi kebijakan coba lagi, Anda menyediakan `RetryPolicyConfiguration` bidang menggunakan [StartJobRun](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html)API. Contoh `retryPolicyConfiguration` ditampilkan di sini:

```
aws emr-containers start-job-run \
--virtual-cluster-id cluster_id \
--name sample-job-name \
--execution-role-arn execution-role-arn \
--release-label emr-6.9.0-latest \
--job-driver '{
  "sparkSubmitJobDriver": {
    "entryPoint": "local:///usr/lib/spark/examples/src/main/python/pi.py",
    "entryPointArguments": [ "2" ],
    "sparkSubmitParameters": "--conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"
  }
}' \
--retry-policy-configuration '{
    "maxAttempts": 5
  }' \
--configuration-overrides '{
  "monitoringConfiguration": {
    "cloudWatchMonitoringConfiguration": {
      "logGroupName": "my_log_group_name",
      "logStreamNamePrefix": "my_log_stream_prefix"
    },
    "s3MonitoringConfiguration": {
       "logUri": "s3://amzn-s3-demo-logging-bucket"
    }
  }
}'
```

**catatan**  
`retryPolicyConfiguration`hanya tersedia dari versi AWS CLI 1.27.68 dan seterusnya. Untuk memperbarui AWS CLI ke versi terbaru, lihat [Menginstal atau memperbarui versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

Konfigurasikan `maxAttempts` bidang dengan jumlah maksimum kali Anda ingin pod driver pekerjaan dimulai ulang jika gagal atau dihapus. [Interval eksekusi antara dua upaya coba lagi pengemudi pekerjaan adalah interval percobaan ulang eksponensial (10 detik, 20 detik, 40 detik...) yang dibatasi pada 6 menit, seperti yang dijelaskan dalam dokumentasi Kubernetes.](https://kubernetes.io/docs/concepts/workloads/controllers/job/#pod-backoff-failure-policy)

**catatan**  
Setiap eksekusi driver pekerjaan tambahan akan ditagih sebagai pekerjaan lain, dan akan dikenakan [EMR Amazon pada](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS) harga EKS.

### Coba lagi nilai konfigurasi kebijakan
<a name="retry-config"></a>
+ **Kebijakan coba ulang default untuk pekerjaan:** `StartJobRun` menyertakan kebijakan coba ulang yang disetel ke 1 upaya maksimum secara default. Anda dapat mengonfigurasi kebijakan coba lagi sesuai keinginan.
**catatan**  
Jika `maxAttempts` dari set ke 1, itu berarti tidak ada percobaan ulang yang akan dilakukan untuk memunculkan pod driver pada kegagalan. `retryPolicyConfiguration`
+ **Menonaktifkan kebijakan coba lagi untuk pekerjaan:** Untuk menonaktifkan kebijakan coba lagi, tetapkan nilai upaya maksimal ke 1. retryPolicyConfiguration 

  ```
  "retryPolicyConfiguration": {
      "maxAttempts": 1
  }
  ```
+ **Setel MaxAttempt untuk pekerjaan dalam rentang yang valid:** `StartJobRun` panggilan akan gagal jika `maxAttempts` nilainya berada di luar rentang yang valid. `maxAttempts`Rentang yang valid adalah dari 1 hingga 2.147.483.647 (32-bit integer), rentang yang didukung untuk pengaturan konfigurasi Kubernetes. `backOffLimit` Untuk informasi selengkapnya, lihat [Kebijakan kegagalan backoff Pod di dokumentasi](https://kubernetes.io/docs/concepts/workloads/controllers/job/#pod-backoff-failure-policy) Kubernetes. Jika `maxAttempts` nilainya tidak valid, pesan galat berikut dikembalikan:

  ```
  {
   "message": "Retry policy configuration's parameter value of maxAttempts is invalid"
  }
  ```

## Mengambil status kebijakan coba lagi untuk suatu pekerjaan
<a name="retrieve-policy"></a>

Anda dapat melihat status upaya coba lagi untuk pekerjaan dengan [https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_ListJobRuns.html](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_ListJobRuns.html)dan [https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_DescribeJobRun.html](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_DescribeJobRun.html) APIs. Setelah Anda meminta pekerjaan dengan konfigurasi kebijakan coba ulang yang diaktifkan, `DescribeJobRun` respons `ListJobRun` dan akan berisi status kebijakan coba lagi di `RetryPolicyExecution` bidang. Selain itu, `DescribeJobRun` respon akan berisi `RetryPolicyConfiguration` yang dimasukkan dalam `StartJobRun` permintaan untuk pekerjaan itu.

**Sampel tanggapan**

------
#### [ ListJobRuns response ]

```
{
  "jobRuns": [
    ...
    ...
    "retryPolicyExecution" : {
      "currentAttemptCount": 2
    }
    ...
    ...
  ]
}
```

------
#### [ DescribeJobRun response ]

```
{
  ...
  ...
  "retryPolicyConfiguration": {
    "maxAttempts": 5
   },
   "retryPolicyExecution" : {
    "currentAttemptCount": 2
  },
  ...
  ...
}
```

------

Kolom ini tidak akan terlihat saat kebijakan coba ulang dinonaktifkan dalam pekerjaan, seperti yang dijelaskan di [Coba lagi nilai konfigurasi kebijakan](#retry-config) bawah ini. 

## Memantau pekerjaan dengan kebijakan coba lagi
<a name="monitoring-retry"></a>

Saat Anda mengaktifkan kebijakan coba lagi, CloudWatch peristiwa akan dibuat untuk setiap driver pekerjaan yang dibuat. Untuk berlangganan acara ini, siapkan aturan CloudWatch acara menggunakan perintah berikut:

```
aws events put-rule \
--name cwe-test \
--event-pattern '{"detail-type": ["EMR Job Run New Driver Attempt"]}'
```

Acara ini akan mengembalikan informasi tentang`newDriverPodName`, `newDriverCreatedAt` stempel waktu`previousDriverFailureMessage`, dan `currentAttemptCount` driver pekerjaan. Peristiwa ini tidak akan dibuat jika kebijakan coba lagi dinonaktifkan.

Untuk informasi selengkapnya tentang cara memantau pekerjaan Anda dengan CloudWatch acara, lihat[Pantau pekerjaan dengan Amazon CloudWatch Events](monitoring.md#monitoring-cloudwatch-events).

## Menemukan log untuk driver dan pelaksana
<a name="finding-logs"></a>

Nama pod driver mengikuti formatnya`spark-<job id>-driver-<random-suffix>`. `random-suffix`Hal yang sama ditambahkan ke nama pod eksekutor yang muncul driver. Saat Anda menggunakan ini`random-suffix`, Anda dapat menemukan log untuk driver dan pelaksana terkait. Hanya `random-suffix` ada jika [kebijakan coba lagi diaktifkan](#retry-config) untuk pekerjaan; jika tidak, tidak `random-suffix` ada.

Untuk informasi selengkapnya tentang cara mengonfigurasi pekerjaan dengan konfigurasi pemantauan untuk pencatatan, lihat[Jalankan aplikasi Spark](getting-started.md#getting-started-run-spark-app).

# Menggunakan rotasi log peristiwa Spark
<a name="emr-eks-log-rotation"></a>

Dengan Amazon EMR 6.3.0 dan yang lebih baru, Anda dapat mengaktifkan fitur rotasi log peristiwa Spark untuk Amazon EMR di EKS. Alih-alih menghasilkan file log peristiwa tunggal, fitur ini merotasikan file berdasarkan interval waktu terkonfigurasi Anda dan menghapus file log peristiwa terlama.

Merotasi log peristiwa Spark dapat membantu Anda menghindari potensi masalah dengan file log peristiwa Spark besar yang dihasilkan untuk tugas yang dijalankan atau di-stream dalam jangka panjang. Misalnya, Anda memulai tugas Spark berjangka panjang dengan log peristiwa yang diaktifkan dengan parameter `persistentAppUI`. Driver Spark menghasilkan file log peristiwa. Jika tugas berjalan selama berjam-jam atau berhari-hari dan ada ruang disk terbatas pada simpul Kubernetes, file log peristiwa dapat mengkonsumsi semua ruang disk yang tersedia. Mengaktifkan fitur rotasi log peristiwa Spark memecahkan masalah dengan membelah file log ke beberapa file dan menghapus file terlama.

**catatan**  
Fitur ini hanya berfungsi dengan Amazon EMR di EKS. Amazon EMR yang berjalan di Amazon EC2 tidak mendukung rotasi log peristiwa Spark.

Untuk mengaktifkan fitur rotasi log peristiwa Spark, konfigurasi parameter Spark berikut:
+ `spark.eventLog.rotation.enabled` - menyalakan rotasi log. Ini dinonaktifkan secara default dalam file konfigurasi Spark. Atur ke betul untuk mengaktifkan fitur ini. 
+ `spark.eventLog.rotation.interval` - menentukan interval waktu untuk rotasi log. Nilai minimum adalah 60 detik. Nilai default adalah 300 detik. 
+ `spark.eventLog.rotation.minFileSize` - menentukan ukuran file minimum untuk merotasikan file log. Nilai minimum dan default adalah 1 MB. 
+ `spark.eventLog.rotation.maxFilesToRetain` - menentukan berapa banyak dile log yang dirotasikan untuk disimpan selama pembersihan. Rentang validnya adalah 1 hingga 10. Nilai default adalah 2. 

Anda dapat menentukan parameter ini dalam bagian `sparkSubmitParameters` dari API [`StartJobRun`](emr-eks-jobs-submit.md), seperti yang ditunjukkan contoh berikut.

```
"sparkSubmitParameters": "--class org.apache.spark.examples.SparkPi --conf spark.eventLog.rotation.enabled=true --conf spark.eventLog.rotation.interval=300 --conf spark.eventLog.rotation.minFileSize=1m --conf spark.eventLog.rotation.maxFilesToRetain=2"
```

# Menggunakan rotasi log kontainer Spark
<a name="emr-eks-log-rotation-container"></a>

Dengan Amazon EMR 6.11.0 dan yang lebih baru, Anda dapat mengaktifkan fitur rotasi log kontainer Spark untuk Amazon EMR di EKS. Alih-alih menghasilkan file tunggal `stdout` atau `stderr` log, fitur ini memutar file berdasarkan ukuran rotasi yang dikonfigurasi dan menghapus file log tertua dari wadah.

Memutar log kontainer Spark dapat membantu Anda menghindari potensi masalah dengan file log Spark besar yang dihasilkan untuk pekerjaan yang berjalan lama atau streaming. Misalnya, Anda mungkin memulai pekerjaan Spark yang berjalan lama, dan driver Spark menghasilkan file log kontainer. Jika pekerjaan berjalan selama berjam-jam atau berhari-hari dan ruang disk terbatas pada node Kubernetes, file log kontainer dapat menggunakan semua ruang disk yang tersedia. Saat Anda mengaktifkan rotasi log kontainer Spark, Anda membagi file log menjadi beberapa file, dan menghapus file tertua.

Untuk mengaktifkan fitur rotasi log kontainer Spark, konfigurasikan parameter Spark berikut:

**`containerLogRotationConfiguration`**  
Sertakan parameter ini `monitoringConfiguration` untuk mengaktifkan rotasi log. Ini dinonaktifkan secara default. Anda harus menggunakan `containerLogRotationConfiguration` selain`s3MonitoringConfiguration`.

**`rotationSize`**  
`rotationSize`Parameter menentukan ukuran file untuk rotasi log. Kisaran nilai yang mungkin adalah dari `2KB` ke`2GB`. Bagian unit numerik dari `rotationSize` parameter dilewatkan sebagai bilangan bulat. Karena nilai desimal tidak didukung, Anda dapat menentukan ukuran rotasi 1,5GB, misalnya, dengan nilai. `1500MB`

**`maxFilesToKeep`**  
`maxFilesToKeep`Parameter menentukan jumlah maksimum file untuk disimpan dalam wadah setelah rotasi telah terjadi. Nilai minimum adalah 1, dan nilai maksimum adalah 50.

Anda dapat menentukan parameter ini dalam bagian `monitoringConfiguration` dari API `StartJobRun`, seperti yang ditunjukkan contoh berikut. Dalam contoh ini, dengan `rotationSize = "10 MB"` dan`maxFilesToKeep = 3`, Amazon EMR di EKS memutar log Anda pada 10 MB, menghasilkan file log baru, dan kemudian membersihkan file log tertua setelah jumlah file log mencapai 3.

```
{
  "name": "my-long-running-job", 
  "virtualClusterId": "123456",  
  "executionRoleArn": "iam_role_name_for_job_execution", 
  "releaseLabel": "emr-6.11.0-latest", 
  "jobDriver": {
    "sparkSubmitJobDriver": {
      "entryPoint": "entryPoint_location",
      "entryPointArguments": ["argument1", "argument2", ...],  
       "sparkSubmitParameters": "--class main_class --conf spark.executor.instances=2 --conf spark.executor.memory=2G --conf spark.executor.cores=2 --conf spark.driver.cores=1"
    }
  }, 
  "configurationOverrides": {
    "applicationConfiguration": [
      {
        "classification": "spark-defaults", 
        "properties": {
          "spark.driver.memory":"2G"
         }
      }
    ], 
    "monitoringConfiguration": {
      "persistentAppUI": "ENABLED", 
      "cloudWatchMonitoringConfiguration": {
        "logGroupName": "my_log_group", 
        "logStreamNamePrefix": "log_stream_prefix"
      }, 
      "s3MonitoringConfiguration": {
        "logUri": "s3://my_s3_log_location"
      },
      "containerLogRotationConfiguration": {
        "rotationSize":"10MB",
        "maxFilesToKeep":"3"
      }
    }
  }
}
```

Untuk memulai pekerjaan dengan rotasi log kontainer Spark, sertakan jalur ke file json yang Anda konfigurasikan dengan parameter ini dalam perintah. [`StartJobRun`](emr-eks-jobs-submit.md)

```
aws emr-containers start-job-run \
--cli-input-json file://path-to-json-request-file
```

# Menggunakan penskalaan otomatis vertikal dengan pekerjaan Amazon EMR Spark
<a name="jobruns-vas"></a>

Amazon EMR pada penskalaan otomatis vertikal EKS secara otomatis menyetel memori dan sumber daya CPU untuk beradaptasi dengan kebutuhan beban kerja yang Anda sediakan untuk aplikasi Amazon EMR Spark. Ini menyederhanakan manajemen sumber daya.

[Untuk melacak pemanfaatan sumber daya real-time dan historis dari aplikasi Amazon EMR Spark Anda, penskalaan otomatis vertikal memanfaatkan Kubernetes Vertical Pod Autoscaler (VPA).](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler) Kemampuan penskalaan otomatis vertikal menggunakan data yang dikumpulkan VPA untuk secara otomatis menyetel memori dan sumber daya CPU yang ditetapkan ke aplikasi Spark Anda. Proses yang disederhanakan ini meningkatkan keandalan dan mengoptimalkan biaya.

**Topics**
+ [Menyiapkan](jobruns-vas-setup.md)
+ [Memulai](jobruns-vas-gs.md)
+ [Konfigurasi](jobruns-vas-configure.md)
+ [Memantau rekomendasi](jobruns-vas-monitor.md)
+ [Menghapus instalasi](jobruns-vas-uninstall-operator.md)

# Menyiapkan penskalaan otomatis vertikal untuk Amazon EMR di EKS
<a name="jobruns-vas-setup"></a>

Topik ini membantu Anda menyiapkan klaster Amazon EKS Anda untuk mengirimkan pekerjaan Amazon EMR Spark dengan penskalaan otomatis vertikal. Proses penyiapan mengharuskan Anda untuk mengonfirmasi atau menyelesaikan tugas di bagian berikut:

**Topics**
+ [Prasyarat](#jobruns-vas-prereqs)
+ [Instal Operator Lifecycle Manager (OLM) di kluster Amazon EKS](#jobruns-vas-install-olm)
+ [Instal EMR Amazon pada operator penskalaan otomatis vertikal EKS](#jobruns-vas-install-operator)

## Prasyarat
<a name="jobruns-vas-prereqs"></a>

Selesaikan tugas-tugas berikut sebelum Anda menginstal operator Kubernetes penskalaan otomatis vertikal di klaster Anda. Jika Anda telah menyelesaikan salah satu prasyarat, Anda dapat melewatinya dan melanjutkan ke yang berikutnya.
+ **[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.
+ **[Instal kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)** — kubectl adalah alat baris perintah yang Anda gunakan untuk berkomunikasi dengan server API Kubernetes. Anda memerlukan kubectl untuk menginstal dan memantau artefak terkait penskalaan otomatis vertikal di cluster Amazon EKS Anda.
+ **[Instal Operator SDK](https://sdk.operatorframework.io/docs/installation/)** — Amazon EMR di EKS menggunakan Operator SDK sebagai pengelola paket untuk masa pakai operator penskalaan otomatis vertikal yang Anda instal di cluster Anda.
+ **[Instal Docker](https://docs.docker.com/get-docker/)** - Anda memerlukan akses ke CLI Docker untuk mengautentikasi dan mengambil gambar Docker terkait penskalaan otomatis vertikal untuk dipasang di cluster Amazon EKS Anda.
+ **[Instal server Kubernetes Metrics — Anda harus menginstal server](https://docs.aws.amazon.com/eks/latest/userguide/metrics-server.html)** metrik terlebih dahulu agar autoscaler pod vertikal dapat mengambil metrik dari server API Kubernetes.
+ **[Memulai Amazon EKS — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) (versi 1.24 atau lebih tinggi)** — Penskalaan otomatis vertikal didukung dengan Amazon EKS versi 1.24 dan yang lebih tinggi. Setelah Anda membuat cluster, [daftarkan untuk digunakan dengan Amazon EMR](setting-up-registration.md).
+ **[Pilih URI gambar dasar EMR Amazon](docker-custom-images-tag.md) (rilis 6.10.0 atau lebih tinggi)** — Penskalaan otomatis vertikal didukung dengan rilis Amazon EMR 6.10.0 dan yang lebih tinggi.

## Instal Operator Lifecycle Manager (OLM) di kluster Amazon EKS
<a name="jobruns-vas-install-olm"></a>

Gunakan Operator SDK CLI untuk menginstal Operator Lifecycle Manager (OLM) di Amazon EMR pada kluster EKS tempat Anda ingin mengatur penskalaan otomatis vertikal, seperti yang ditunjukkan pada contoh berikut. Setelah mengaturnya, Anda dapat menggunakan OLM untuk menginstal dan mengelola siklus hidup operator penskalaan otomatis vertikal Amazon [EMR](#jobruns-vas-install-operator).

```
operator-sdk olm install
```

Untuk memvalidasi instalasi, jalankan `olm status` perintah:

```
operator-sdk olm status
```

Verifikasi bahwa perintah mengembalikan hasil yang sukses, mirip dengan contoh output berikut:

```
INFO[0007] Successfully got OLM status for version X.XX
```

Jika instalasi Anda tidak berhasil, lihat[Memecahkan masalah Amazon EMR pada penskalaan otomatis vertikal EKS](troubleshooting-vas.md).

## Instal EMR Amazon pada operator penskalaan otomatis vertikal EKS
<a name="jobruns-vas-install-operator"></a>

Gunakan langkah-langkah berikut untuk menginstal operator penskalaan otomatis vertikal di klaster Amazon EKS Anda:

1. Siapkan variabel lingkungan berikut yang akan Anda gunakan untuk menyelesaikan instalasi:
   + **`$REGION`**menunjuk ke Wilayah AWS untuk cluster Anda. Misalnya, `us-west-2`.
   + **`$ACCOUNT_ID`**menunjuk ke ID akun Amazon ECR untuk Wilayah Anda. Untuk informasi selengkapnya, lihat [Akun registri Amazon ECR berdasarkan Wilayah](docker-custom-images-tag.md#docker-custom-images-ECR).
   + **`$RELEASE`**menunjuk ke rilis EMR Amazon yang ingin Anda gunakan untuk cluster Anda. Dengan penskalaan otomatis vertikal, Anda harus menggunakan Amazon EMR rilis 6.10.0 atau lebih tinggi.

1. Selanjutnya, dapatkan token otentikasi ke [registri Amazon ECR](docker-custom-images-tag.md#docker-custom-images-ECR) untuk operator.

   ```
   aws ecr get-login-password \
    --region region-id | docker login \
    --username AWS \
    --password-stdin $ACCOUNT_ID.dkr.ecr.region-id.amazonaws.com
   ```

1. Instal EMR Amazon pada operator penskalaan otomatis vertikal EKS dengan perintah berikut:

   ```
   ECR_URL=$ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com && \
   REPO_DEST=dynamic-sizing-k8s-operator-olm-bundle && \
   BUNDLE_IMG=emr-$RELEASE-dynamic-sizing-k8s-operator && \
   operator-sdk run bundle \
   $ECR_URL/$REPO_DEST/$BUNDLE_IMG\:latest
   ```

   Ini akan membuat rilis operator penskalaan otomatis vertikal di namespace default kluster Amazon EKS Anda. Gunakan perintah ini untuk menginstal di namespace yang berbeda:

   ```
   operator-sdk run bundle \
   $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/dynamic-sizing-k8s-operator-olm-bundle/emr-$RELEASE-dynamic-sizing-k8s-operator:latest \
   -n operator-namespace
   ```
**catatan**  
Jika namespace yang Anda tentukan tidak ada, OLM tidak akan menginstal operator. Untuk informasi selengkapnya, lihat [Namespace Kubernetes tidak ditemukan](troubleshooting-vas.md).

1. Verifikasi bahwa Anda berhasil menginstal operator dengan alat baris perintah kubectl Kubernetes.

   ```
   kubectl get csv -n operator-namespace
   ```

   `kubectl`****Perintah harus mengembalikan operator autoscaler vertikal yang baru digunakan dengan status Fase Succeeded.**** Jika Anda mengalami masalah dengan instalasi atau pengaturan, lihat[Memecahkan masalah Amazon EMR pada penskalaan otomatis vertikal EKS](troubleshooting-vas.md).

# Memulai dengan penskalaan otomatis vertikal untuk Amazon EMR di EKS
<a name="jobruns-vas-gs"></a>

Gunakan penskalaan otomatis vertikal untuk Amazon EMR di EKS saat Anda ingin penyetelan otomatis memori dan sumber daya CPU untuk beradaptasi dengan beban kerja aplikasi Amazon EMR Spark Anda. Untuk informasi selengkapnya, lihat [Menggunakan penskalaan otomatis vertikal dengan pekerjaan Amazon EMR Spark](jobruns-vas.html).

## Mengirimkan pekerjaan Spark dengan autoscaling vertikal
<a name="jobruns-vas-spark-submit"></a>

Saat Anda mengirimkan pekerjaan melalui [StartJobRun](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html)API, tambahkan dua konfigurasi berikut ke driver untuk pekerjaan Spark Anda untuk mengaktifkan penskalaan otomatis vertikal:

```
"spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing":"true",
"spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.signature":"YOUR_JOB_SIGNATURE"
```

Pada kode di atas, baris pertama memungkinkan kemampuan autoscaling vertikal. Baris berikutnya adalah konfigurasi tanda tangan wajib yang memungkinkan Anda memilih tanda tangan untuk pekerjaan Anda.

Untuk informasi selengkapnya tentang konfigurasi ini dan nilai parameter yang dapat diterima, lihat[Mengkonfigurasi penskalaan otomatis vertikal untuk Amazon EMR di EKS](jobruns-vas-configure.md). Secara default, pekerjaan Anda dikirimkan dalam mode Monitoring-Only **Off dari** penskalaan otomatis vertikal. Status pemantauan ini memungkinkan Anda menghitung dan melihat rekomendasi sumber daya tanpa melakukan penskalaan otomatis. Untuk informasi selengkapnya, lihat [Mode penskalaan otomatis vertikal](jobruns-vas-configure.md#jobruns-vas-parameters-opt-mode).

Contoh berikut menunjukkan cara menyelesaikan `start-job-run` perintah sampel dengan autoscaling vertikal:

```
aws emr-containers start-job-run \
--virtual-cluster-id $VIRTUAL_CLUSTER_ID \
--name $JOB_NAME \
--execution-role-arn $EMR_ROLE_ARN \
--release-label emr-6.10.0-latest \
--job-driver '{
  "sparkSubmitJobDriver": {
     "entryPoint": "local:///usr/lib/spark/examples/src/main/python/pi.py"
   }
 }' \
--configuration-overrides '{
    "applicationConfiguration": [{
        "classification": "spark-defaults",
        "properties": {
          "spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing": "true",
          "spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.signature": "test-signature"
        }
    }]
  }'
```

## Memverifikasi fungsionalitas penskalaan otomatis vertikal
<a name="jobruns-vas-verify"></a>

Untuk memverifikasi bahwa penskalaan otomatis vertikal berfungsi dengan benar untuk pekerjaan yang dikirimkan, gunakan kubectl untuk mendapatkan sumber daya `verticalpodautoscaler` kustom dan melihat rekomendasi penskalaan Anda. Misalnya, permintaan perintah berikut untuk rekomendasi pada pekerjaan contoh dari [Mengirimkan pekerjaan Spark dengan autoscaling vertikal](#jobruns-vas-spark-submit) bagian:

```
kubectl get verticalpodautoscalers --all-namespaces \
-l=emr-containers.amazonaws.com/dynamic.sizing.signature=test-signature
```

Output dari kueri ini harus menyerupai yang berikut:

```
NAME                                                          MODE   CPU         MEM PROVIDED   AGE
ds-jceyefkxnhrvdzw6djum3naf2abm6o63a6dvjkkedqtkhlrf25eq-vpa   Off    3304504865  True           87m
```

Jika output Anda tidak terlihat serupa atau berisi kode kesalahan, lihat langkah-langkah [Memecahkan masalah Amazon EMR pada penskalaan otomatis vertikal EKS](troubleshooting-vas.md) untuk membantu menyelesaikan masalah.

# Mengkonfigurasi penskalaan otomatis vertikal untuk Amazon EMR di EKS
<a name="jobruns-vas-configure"></a>

Anda dapat mengonfigurasi penskalaan otomatis vertikal saat mengirimkan pekerjaan Amazon EMR Spark melalui API. [StartJobRun](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html) Atur parameter konfigurasi terkait penskalaan otomatis pada pod driver Spark seperti yang ditunjukkan pada contoh di. [Mengirimkan pekerjaan Spark dengan autoscaling vertikal](jobruns-vas-gs.md#jobruns-vas-spark-submit)

Amazon EMR pada operator penskalaan otomatis vertikal EKS mendengarkan pod driver yang memiliki autoscaling, kemudian mengatur integrasi dengan Kubernetes Vertical Pod Autoscaler (VPA) dengan pengaturan pada pod driver. Ini memfasilitasi pelacakan sumber daya dan penskalaan otomatis pod pelaksana Spark.

Bagian berikut menjelaskan parameter yang dapat Anda gunakan saat mengonfigurasi penskalaan otomatis vertikal untuk klaster Amazon EKS Anda.

**catatan**  
Konfigurasikan parameter sakelar fitur sebagai label, dan konfigurasikan parameter yang tersisa sebagai anotasi pada pod driver Spark. Parameter penskalaan otomatis milik `emr-containers.amazonaws.com/` domain dan memiliki awalan. `dynamic.sizing`

## Parameter yang diperlukan
<a name="jobruns-vas-parameters-req"></a>

Anda harus menyertakan dua parameter berikut pada driver pekerjaan Spark saat Anda mengirimkan pekerjaan Anda:


| Key | Deskripsi | Nilai yang diterima | Nilai default | Tipe | Parameter percikan 1 | 
| --- | --- | --- | --- | --- | --- | 
|  `dynamic.sizing`  |  Fitur toggle  |  `true`, `false`  |  tidak diatur  |  label  |  `spark.kubernetes.driver.label.emr-containers.amazonaws.com/dynamic.sizing`  | 
|  `dynamic.sizing.signature`  |  Tanda tangan Job  |  *tali*  |  tidak diatur  |  anotasi  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.signature`  | 

1 Gunakan parameter ini sebagai `SparkSubmitParameter` atau `ConfigurationOverride` di `StartJobRun` API.
+ **`dynamic.sizing`**— Anda dapat menghidupkan dan mematikan penskalaan otomatis vertikal dengan label. `dynamic.sizing` Untuk mengaktifkan penskalaan otomatis vertikal, atur `dynamic.sizing` ke `true` pada pod driver Spark. Jika Anda menghilangkan label ini atau mengaturnya ke nilai apa pun selain`true`, penskalaan otomatis vertikal tidak aktif.
+ **`dynamic.sizing.signature`**— Atur tanda tangan pekerjaan dengan `dynamic.sizing.signature` anotasi pada pod driver. Penskalaan otomatis vertikal mengumpulkan data penggunaan sumber daya Anda di berbagai pekerjaan Amazon EMR Spark untuk mendapatkan rekomendasi sumber daya. Anda memberikan pengenal unik untuk mengikat pekerjaan bersama-sama.

  
**catatan**  
Jika pekerjaan Anda berulang pada interval tetap seperti harian atau mingguan, maka tanda tangan pekerjaan Anda harus tetap sama untuk setiap contoh pekerjaan baru. Ini memastikan bahwa penskalaan otomatis vertikal dapat menghitung dan mengumpulkan rekomendasi di berbagai pekerjaan.

1 Gunakan parameter ini sebagai `SparkSubmitParameter` atau `ConfigurationOverride` di `StartJobRun` API.

## Parameter opsional
<a name="jobruns-vas-parameters-opt"></a>

Penskalaan otomatis vertikal juga mendukung parameter opsional berikut. Tetapkan mereka sebagai anotasi pada pod driver.


| Key | Deskripsi | Nilai yang diterima | Nilai default | Tipe | Parameter percikan 1 | 
| --- | --- | --- | --- | --- | --- | 
|  `dynamic.sizing.mode`  |  Mode penskalaan otomatis vertikal  |  `Off`, `Initial`, `Auto`  |  `Off`  |  anotasi  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.mode`  | 
|  `dynamic.sizing.scale.memory`  |  Mengaktifkan penskalaan memori  |  *`true`, `false`*  |  `true`  |  anotasi  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.memory`  | 
|  `dynamic.sizing.scale.cpu`  |  Aktifkan atau nonaktifkan penskalaan CPU  |  *`true`, `false`*  |  `false`  |  anotasi  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.cpu`  | 
|  `dynamic.sizing.scale.memory.min`  |  Batas minimum untuk penskalaan memori  | string, [kuantitas sumber daya K8s mis](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity): 1G |  tidak diatur  |  anotasi  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.memory.min | 
|  `dynamic.sizing.scale.memory.max`  |  Batas maksimum untuk penskalaan memori  | string, [kuantitas sumber daya K8s mis](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity): 4G |  tidak diatur  |  anotasi  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.memory.max | 
|  `dynamic.sizing.scale.cpu.min`  |  Batas minimum untuk penskalaan CPU  | string, [kuantitas sumber daya K8s mis](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity): 1 |  tidak diatur  |  anotasi  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.cpu.min | 
|  `dynamic.sizing.scale.cpu.max`  |  Batas maksimum untuk penskalaan CPU  | string, [kuantitas sumber daya K8s mis](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity): 2 |  tidak diatur  |  anotasi  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.cpu.max | 

### Mode penskalaan otomatis vertikal
<a name="jobruns-vas-parameters-opt-mode"></a>

`mode`Parameter memetakan ke berbagai mode penskalaan otomatis yang didukung VPA. Gunakan `dynamic.sizing.mode` anotasi pada pod driver untuk mengatur mode. Nilai-nilai berikut didukung untuk parameter ini:
+ **Off** — Mode dry-run di mana Anda dapat memantau rekomendasi, tetapi penskalaan otomatis tidak dilakukan. Ini adalah mode default untuk penskalaan otomatis vertikal. Dalam mode ini, sumber daya autoscaler pod vertikal terkait menghitung rekomendasi, dan Anda dapat memantau rekomendasi melalui alat seperti kubectl, Prometheus, dan Grafana.
+ **Awal** — Dalam mode ini, VPA menskalakan otomatis sumber daya saat pekerjaan dimulai jika rekomendasi tersedia berdasarkan riwayat pekerjaan, seperti dalam kasus pekerjaan berulang.
+ **Otomatis** — Dalam mode ini, VPA mengusir pod pelaksana Spark, dan menskalakannya secara otomatis dengan pengaturan sumber daya yang disarankan saat pod driver Spark memulai ulang pod. Terkadang, VPA mengusir pod pelaksana Spark yang sedang berjalan, sehingga dapat menghasilkan latensi tambahan saat mencoba ulang eksekutor yang terputus.

### Penskalaan sumber daya
<a name="jobruns-vas-parameters-opt-rs"></a>

Saat Anda mengatur penskalaan otomatis vertikal, Anda dapat memilih apakah akan menskalakan sumber daya CPU dan memori. Atur `dynamic.sizing.scale.cpu` dan `dynamic.sizing.scale.memory` anotasi ke `true` atau`false`. Secara default, penskalaan CPU diatur ke`false`, dan penskalaan memori diatur ke. `true`

### Minimum dan maksimum sumber daya (Batas)
<a name="jobruns-vas-parameters-opt-bounds"></a>

Secara opsional, Anda juga dapat menetapkan batasan pada CPU dan sumber daya memori. Pilih nilai minimum dan maksimum untuk sumber daya ini dengan `dynamic.sizing.[memory/cpu].[min/max]` anotasi saat Anda mengaktifkan penskalaan otomatis. Secara default, sumber daya tidak memiliki batasan. Tetapkan anotasi sebagai nilai string yang mewakili kuantitas sumber daya Kubernetes. Misalnya, atur `dynamic.sizing.memory.max` `4G` untuk mewakili 4 GB.

# Memantau penskalaan otomatis vertikal untuk Amazon EMR di EKS
<a name="jobruns-vas-monitor"></a>

Anda dapat menggunakan alat baris perintah **kubectl** Kubernetes untuk membuat daftar rekomendasi terkait penskalaan otomatis vertikal yang aktif di klaster Anda. Anda juga dapat melihat tanda tangan pekerjaan yang dilacak, dan membersihkan sumber daya yang tidak dibutuhkan yang terkait dengan tanda tangan.



## Buat daftar rekomendasi penskalaan otomatis vertikal untuk klaster Anda
<a name="jobruns-vas-monitor-list"></a>

Gunakan kubectl untuk mendapatkan `verticalpodautoscaler` sumber daya, dan lihat status dan rekomendasi saat ini. Contoh kueri berikut mengembalikan semua sumber daya aktif di klaster Amazon EKS Anda.

```
kubectl get verticalpodautoscalers \
-o custom-columns="NAME:.metadata.name,"\
"SIGNATURE:.metadata.labels.emr-containers\.amazonaws\.com/dynamic\.sizing\.signature,"\
"MODE:.spec.updatePolicy.updateMode,"\
"MEM:.status.recommendation.containerRecommendations[0].target.memory" \
--all-namespaces
```

Output dari kueri ini menyerupai yang berikut:

```
NAME                  SIGNATURE                MODE      MEM
ds-example-id-1-vpa   job-signature-1          Off       none
ds-example-id-2-vpa   job-signature-2          Initial   12936384283
```

## Kueri dan hapus rekomendasi penskalaan otomatis vertikal untuk klaster Anda
<a name="jobruns-vas-monitor-query"></a>

Saat Anda menghapus sumber daya job-run penskalaan otomatis vertikal Amazon EMR, sumber daya ini secara otomatis menghapus objek VPA terkait yang melacak dan menyimpan rekomendasi.

Contoh berikut menggunakan kubectl untuk membersihkan rekomendasi untuk pekerjaan yang diidentifikasi dengan tanda tangan:

```
kubectl delete jobrun -n emr -l=emr-containers\.amazonaws\.com/dynamic\.sizing\.signature=integ-test
jobrun.dynamicsizing.emr.services.k8s.aws "ds-job-signature" deleted
```

Jika Anda tidak mengetahui tanda tangan pekerjaan tertentu, atau ingin membersihkan semua sumber daya di klaster, Anda dapat menggunakan `--all` atau `--all-namespaces` dalam perintah Anda alih-alih ID pekerjaan unik, seperti yang ditunjukkan pada contoh berikut:

```
kubectl delete jobruns --all --all-namespaces
jobrun.dynamicsizing.emr.services.k8s.aws "ds-example-id" deleted
```

# Copot pemasangan EMR Amazon pada operator penskalaan otomatis vertikal EKS
<a name="jobruns-vas-uninstall-operator"></a>

Jika Anda ingin menghapus operator penskalaan otomatis vertikal dari kluster Amazon EKS Anda, gunakan `cleanup` perintah dengan Operator SDK CLI seperti yang ditunjukkan pada contoh berikut. Ini juga menghapus dependensi upstream yang diinstal dengan operator, seperti Vertical Pod Autoscaler.

```
operator-sdk cleanup emr-dynamic-sizing
```

Jika ada pekerjaan yang berjalan di cluster saat Anda menghapus operator, pekerjaan tersebut terus berjalan tanpa penskalaan otomatis vertikal. [Jika Anda mengirimkan pekerjaan di klaster setelah menghapus operator, Amazon EMR di EKS akan mengabaikan parameter terkait penskalaan otomatis vertikal yang mungkin telah Anda tentukan selama konfigurasi.](jobruns-vas-configure.md)