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

# 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