本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 使用 Amazon EMR on EKS 執行 Spark 任務
<a name="job-runs-main"></a>

*作業執行*是您提交至 Amazon EMR on EKS 的工作單位，例如 Spark jar、PySpark 指令碼或 SparkSQL 查詢。本主題概述如何使用 管理任務執行 AWS CLI、使用 Amazon EMR 主控台檢視任務執行，以及疑難排解常見的任務執行錯誤。

請注意，您無法在 Amazon EMR on EKS 上執行 IPv6 Spark 任務

**注意**  
在使用 Amazon EMR on EKS 提交作業執行之前，必須完成 [設定 Amazon EMR on EKS](setting-up.md) 中的步驟。

**Topics**
+ [使用 `StartJobRun` 執行 Spark 作業](job-runs.md)
+ [使用 Spark Operator 執行 Spark 作業](spark-operator.md)
+ [使用 spark-submit 執行 Spark 作業](spark-submit.md)
+ [搭配 Amazon EMR on EKS 使用 Apache Livy](job-runs-apache-livy.md)
+ [管理 Amazon EMR on EKS 作業執行](emr-eks-jobs-manage.md)
+ [使用作業範本](job-templates.md)
+ [使用 Pod 範本](pod-templates.md)
+ [使用作業重試政策](jobruns-using-retry-policies.md)
+ [使用 Spark 事件日誌輪換](emr-eks-log-rotation.md)
+ [使用 Spark 容器日誌輪換](emr-eks-log-rotation-container.md)
+ [搭配使用垂直自動擴展與 Amazon EMR Spark 作業](jobruns-vas.md)

# 使用 `StartJobRun` 執行 Spark 作業
<a name="job-runs"></a>

本節包含詳細的設定步驟，讓您的環境準備好執行 Spark 任務，然後提供step-by-step說明。

**Topics**
+ [設定 Amazon EMR on EKS](setting-up.md)
+ [使用 `StartJobRun` 提交作業執行](emr-eks-jobs-submit.md)
+ [使用作業提交器分類](emr-eks-job-submitter.md)
+ [使用 Amazon EMR 容器預設分類](emr-eks-job-submitter-container-defaults.md)

# 設定 Amazon EMR on EKS
<a name="setting-up"></a>

完成下列任務，為 Amazon EMR on EKS 進行設定。如果已經註冊 Amazon Web Services (AWS) 且已在使用 Amazon EKS，則您幾乎可使用 Amazon EMR on EKS。略過您已完成的任何任務。

**注意**  
還可以按照 [Amazon EMR on EKS 研討會](https://emr-on-eks.workshop.aws/amazon-emr-eks-workshop.html)來設定所有必要的資源，以便在 Amazon EMR on EKS 上執行 Spark 作業。該研討會還透過使用 CloudFormation 範本建立入門所需的資源來提供自動化。如需其他範本和最佳實務，請參閱 GitHub 上的 [EMR 容器最佳實務指南](https://aws.github.io/aws-emr-containers-best-practices/)。

1. [安裝或更新至最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

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

1. [開始使用 Amazon EKS – eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)

1. [啟用 Amazon EMR on EKS 的叢集存取](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html)

1. [啟用 EKS 叢集的 IAM 角色](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM-roles.html)

1. [授予使用者對 Amazon EMR on EKS 的存取權](setting-up-iam.md)

1. [向 Amazon EMR 註冊 Amazon EKS 叢集](setting-up-registration.md)

# 啟用 Amazon EMR on EKS 的叢集存取權
<a name="setting-up-cluster-access"></a>

下列各節顯示啟用叢集存取的幾種方式。第一種是使用 Amazon EKS 叢集存取管理 (CAM)，後一種是示範如何採取手動步驟來啟用叢集存取。

## 使用 EKS Access Entry 啟用叢集存取 （建議）
<a name="setting-up-cluster-access-cam-integration"></a>

**注意**  
ConfigMap `aws-auth` 已棄用。管理 Kubernetes APIs 存取的建議方法是[存取項目](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html)。

Amazon EMR 已與 [Amazon EKS 叢集存取管理 (CAM)](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html) 整合，因此您可以自動設定必要的 AuthN 和 AuthZ 政策，以在 Amazon EKS 叢集命名空間中執行 Amazon EMR Spark 任務。當您從 Amazon EKS 叢集命名空間建立虛擬叢集時，Amazon EMR 會自動設定所有必要的許可，因此您不需要在目前的工作流程中新增任何額外的步驟。

**注意**  
Amazon EMR 與 Amazon EKS CAM 整合僅支援新的 Amazon EMR on EKS 虛擬叢集。您無法遷移現有的虛擬叢集以使用此整合。

### 先決條件
<a name="setting-up-cluster-access-cam-integration-prereqs"></a>
+ 請確定您正在執行 2.15.3 版或更新版本的 AWS CLI
+ 您的 Amazon EKS 叢集必須位於 1.23 版或更新版本。

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

若要從 Amazon EKS 設定 Amazon EMR 與 AccessEntry API 操作之間的整合，請確定您已完成下列項目：
+ 請確定 Amazon EKS 叢集`authenticationMode`的 設定為 `API_AND_CONFIG_MAP`。

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

  如果尚未設定，請將 `authenticationMode`設定為 `API_AND_CONFIG_MAP`。

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

  如需身分驗證模式的詳細資訊，請參閱[叢集身分驗證模式](https://docs.aws.amazon.com/eks/latest/userguide/access-entries.html#authentication-modes)。
+ 請確定您用來執行 `CreateVirtualCluster`和 `DeleteVirtualCluster` API 操作的 [IAM 角色](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-iam.html)也具有下列許可：

  ```
  {
    "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/*"
  }
  ```

### 概念和術語
<a name="setting-up-cluster-access-cam-integration-concepts"></a>

以下是與 Amazon EKS CAM 相關的術語和概念清單。
+ 虛擬叢集 (VC) – 在 Amazon EKS 中建立的命名空間邏輯表示法。這是 Amazon EKS 叢集命名空間的 1：1 連結。您可以使用它在指定命名空間內的 Amazon EKS 叢集上執行 Amazon EMR 工作負載。
+ 命名空間 – 隔離單一 EKS 叢集內資源群組的機制。
+ 存取政策 – 將存取權和動作授予 EKS 叢集中 IAM 角色的許可。
+ 存取項目 – 使用角色 arn 建立的項目。您可以將存取項目連結至存取政策，以在 Amazon EKS 叢集中指派特定許可。
+ EKS 存取項目整合虛擬叢集 – 使用來自 Amazon EKS 的[存取項目 API 操作](https://docs.aws.amazon.com/eks/latest/APIReference/API_Operations_Amazon_Elastic_Kubernetes_Service.html)建立的虛擬叢集。

## 使用 啟用叢集存取 `aws-auth`
<a name="setting-up-cluster-access-aws-auth"></a>

必須採取下列動作，以允許 Amazon EMR on EKS 存取叢集中的特定命名空間：建立 Kubernetes 角色、將角色繫結至 Kubernetes 使用者，以及將 Kubernetes 使用者映射至服務連結角色 [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)。當 IAM 身分映射命令與 `emr-containers` 一起用作服務名稱時，會在 `eksctl` 中自動化這些動作。可以透過使用下列命令輕鬆執行這些操作。

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

將 *my\$1eks\$1cluster* 取代為 Amazon EKS 叢集的名稱，並將 *kubernetes\$1namespace* 取代為執行 Amazon EMR 工作負載而建立的 Kubernetes 命名空間。

**重要**  
您必須使用上一個步驟 [設定 kubectl 和 eksctl 下載最新的 eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)，才能使用此功能。

### 啟用 Amazon EMR on EKS 的叢集存取權的手動步驟
<a name="setting-up-cluster-access-manual"></a>

也可使用以下手動步驟來啟用 Amazon EMR on EKS 的叢集存取權。

1. **在特定命名空間中建立 Kubernetes 角色**

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

   使用 Amazon EKS 1.22 - 1.29，執行下列命令在特定命名空間中建立 Kubernetes 角色。此角色將必要的 RBAC 許可授予 Amazon EMR on 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 ]

   使用 Amazon EKS 1.21 及以下版本，執行下列命令在特定命名空間中建立 Kubernetes 角色。此角色將必要的 RBAC 許可授予 Amazon EMR on 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. **建立範圍為命名空間的 Kubernetes 角色繫結**

   執行下列命令，在指定命名空間中建立 Kubernetes 角色繫結。此角色繫結會將在上一個步驟建立的角色中定義的許可授予名為 `emr-containers` 的使用者。此使用者可識別 [Amazon EMR on EKS 的服務連結角色](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/using-service-linked-roles.html)，因此可讓 Amazon EMR on EKS 執行您建立的角色所定義的動作。

   ```
   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. **更新 Kubernetes `aws-auth` 組態地圖**

   可以使用下列其中一個選項，將 Amazon EMR on EKS 服務連結角色與上一個步驟中受 Kubernetes 角色繫結的 `emr-containers` 使用者進行映射。

   **選項 1：使用 `eksctl`**

   執行下列 `eksctl` 命令，將 Amazon EMR on EKS 服務連結角色與 `emr-containers` 使用者進行映射。

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

   **選項 2：不使用 eksctl**

   1. 執行下列命令，在文字編輯器中開啟 `aws-auth` 組態映射。

      ```
      kubectl edit -n kube-system configmap/aws-auth
      ```
**注意**  
如果收到錯誤訊息，指出 `Error from server (NotFound): configmaps "aws-auth" not found`，請參閱《Amazon EKS 使用者指南》中的[新增使用者角色](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html)中的步驟，以套用儲存的 ConfigMap。

   1. 將 Amazon EMR on EKS 服務連結角色詳細資訊新增至 `data` 下 `ConfigMap` 的 `mapRoles` 章節。若此區段在檔案不存在，則將其新增。資料下的已更新 `mapRoles` 章節類似下列範例。

      ```
      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. 儲存檔案並結束您的文字編輯器。

# 啟用 EKS 叢集的 IAM 角色
<a name="setting-up-enable-IAM-roles"></a>

下列主題詳細說明啟用 IAM 角色的選項。

**Topics**
+ [選項 1：在 EKS 叢集上啟用 EKS Pod 身分](setting-up-enable-IAM.md)
+ [選項 2：在 EKS 叢集上啟用服務帳戶的 IAM 角色 (IRSA)](setting-up-enable-IAM-service-accounts.md)

# 選項 1：在 EKS 叢集上啟用 EKS Pod 身分
<a name="setting-up-enable-IAM"></a>

Amazon EKS Pod 身分識別關聯提供管理應用程式憑證的功能，類似 Amazon EC2 執行個體設定檔將憑證提供給 Amazon EC2 執行個體的方式。Amazon EKS Pod 身分識別透過其他 EKS 驗證 API 和在每個節點上執行的代理程式 Pod，為您的工作負載提供憑證。

自 emr-7.3.0 發行以來，Amazon EMR on EKS 開始支援 StartJobRun 提交模型的 EKS Pod 身分。

如需 EKS Pod 身分的詳細資訊，請參閱[了解 EKS Pod 身分的運作方式](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-how-it-works.html)。

## 為什麼選擇 EKS Pod 身分？
<a name="setting-up-enable-IAM-pod-identity-why"></a>

作為 EMR 設定的一部分，任務執行角色需要在特定命名空間 (EMR 虛擬叢集） 中的 IAM 角色和服務帳戶之間建立信任界限。使用 IRSA，這可透過更新 EMR 任務執行角色的信任政策來實現。不過，由於 IAM 信任政策長度有 4096 個字元的硬性限制，在最多十二 (12) 個 EKS 叢集之間共用單一任務執行 IAM 角色有其限制。

EMR 支援 Pod 身分，IAM 角色和服務帳戶之間的信任界限現在由 EKS 團隊透過 EKS Pod 身分的關聯 APIs 管理。

**注意**  
EKS Pod 身分的安全界限仍在服務帳戶層級，而非 Pod 層級。

## Pod 身分考量事項
<a name="setting-up-enable-IAM-pod-identity-consider"></a>

如需 Pod 身分限制的資訊，請參閱 [EKS Pod 身分考量](https://docs.aws.amazon.com/eks/latest/userguide/pod-identities.html#pod-id-considerations)事項。

## 在 EKS 叢集中準備 EKS Pod 身分
<a name="setting-up-enable-IAM-pod-eks-cluster"></a>

### 檢查 NodeInstanceRole 中是否存在所需的許可
<a name="setting-up-enable-IAM-pod-eks-cluster-permission"></a>

節點角色`NodeInstanceRole`需要代理程式在 EKS 驗證 API 中執行`AssumeRoleForPodIdentity`動作的許可。您可以將下列項目新增至 Amazon EKS 使用者指南中定義的 [AmazonEKSWorkerNodePolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/security-iam-awsmanpol.html#security-iam-awsmanpol-amazoneksworkernodepolicy)，或使用自訂政策。

如果您的 EKS 叢集建立的 eksctl 版本高於 **0.181.0**，AmazonEKSWorkerNodePolicy 會自動連接到節點角色，包括必要的`AssumeRoleForPodIdentity`許可。如果許可不存在，請手動將下列許可新增至 AmazonEKSWorkerNodePolicy，以允許擔任 Pod 身分的角色。EKS Pod 身分代理程式需要此許可，才能擷取 Pod 的登入資料。

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

****  

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

------

### 建立 EKS Pod 身分代理程式附加元件
<a name="setting-up-enable-IAM-pod-eks-cluster-agent"></a>

使用下列命令，以最新版本建立 EKS Pod Identity Agent 附加元件：

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

使用下列步驟，從 Amazon EKS 主控台建立 EKS Pod Identity Agent 附加元件：

1. 開啟 Amazon EKS 主控台：[Amazon EKS 主控台](https://console.aws.amazon.com/eks/home#/clusters)。

1. 在左側導覽窗格中，選取**叢集**，然後選取您要為其設定 EKS Pod 身分識別代理程式附加元件之叢集的名稱。

1. 選擇**附加元件**索引標籤。

1. 選擇**取得更多附加元件**。

1. 選取 EKS Pod 身分識別代理程式之附加元件方塊右上方的方塊，然後選擇**下一步**。

1. 在**設定選取的附加元件設定**頁面上，在版本下拉式清單中選取任何**版本**。

1. (選用) 展開**選用組態設定**以輸入其他組態。例如，您可以提供替代容器映像位置和 `ImagePullSecrets`。具有已接受索引鍵的 JSON 結構描述會顯示在**附加元件組態結構描述**中。

   在**組態值**中輸入組態金鑰和值。

1. 選擇**下一步**。

1. 確認代理程式 Pod 透過 CLI 在叢集上執行。

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

輸出範例如下：

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

這會在`kube-system`命名空間中設定新的 DaemonSet。在每個 EKS 節點上執行的 Amazon EKS Pod Identity Agent 會使用 [AssumeRoleForPodIdentity](https://docs.aws.amazon.com/eks/latest/APIReference/API_auth_AssumeRoleForPodIdentity.html) 動作，從 EKS 身分驗證 API 擷取臨時憑證。然後，這些登入資料可供您在容器內執行 AWS SDKs 使用。

如需詳細資訊，請參閱公有文件中的先決條件：[設定 Amazon EKS Pod Identity Agent](https://docs.aws.amazon.com/eks/latest/userguide/pod-id-agent-setup.html)。

## 建立任務執行角色
<a name="setting-up-enable-IAM-pod-create-job-role"></a>

### 建立或更新允許 EKS Pod Identity 的任務執行角色
<a name="setting-up-enable-IAM-pod-create-job-role-update"></a>

若要使用 Amazon EMR on EKS 執行工作負載，您需要建立 IAM 角色。在本文件中，我們將此角色稱為作業執行角色。如需如何建立 IAM 角色的詳細資訊，請參閱《 使用者指南》中的[建立 IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html)。

此外，您必須建立指定任務執行角色必要許可的 IAM 政策，然後將此政策連接至角色以啟用 EKS Pod Identity。

例如，您有下列任務執行角色。如需詳細資訊，請參閱[建立任務執行角色](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html)。

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

**重要**  
Amazon EMR on EKS 會根據您的任務執行角色名稱自動建立 Kubernetes 服務帳戶。請確定角色名稱不會太長，因為如果 `cluster_name`、 和 的組合`service_account_name`超過長度限制`pod_name`，您的任務可能會失敗。

**任務執行角色組態** – 確保使用下列 EKS Pod 身分的信任許可建立任務執行角色。若要更新現有的任務執行角色，請將其設定為信任下列 EKS 服務委託人，做為信任政策中的額外許可。此信任許可可以與現有的 IRSA 信任政策共存。

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

**使用者許可**：使用者需要執行 `StartJobRun` API 呼叫或提交任務的`iam:PassRole`許可。此許可可讓使用者將任務執行角色傳遞至 EMR on EKS。根據預設，任務管理員應該具有 許可。

以下是使用者所需的許可：

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

若要進一步限制使用者存取特定 EKS 叢集，請將 AssociatedResourceArn 屬性篩選條件新增至 IAM 政策。它將角色假設限制為授權的 EKS 叢集，加強您的資源層級安全控制。

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

## 設定 EKS Pod 身分關聯
<a name="setting-up-enable-IAM-pod-identity-asociations"></a>

### 先決條件
<a name="setting-up-enable-IAM-pod-identity-asociations-prereq"></a>

請確定建立 Pod 身分關聯的 IAM 身分，例如 EKS 管理員使用者，具有 許可`eks:CreatePodIdentityAssociation`和 `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"
    }
  ]
}
```

------

### 建立角色和 EMR 服務帳戶的關聯
<a name="setting-up-enable-IAM-pod-identity-asociations-emr-service"></a>

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

當您將任務提交至 Kubernetes 命名空間時，管理員必須在任務執行角色與 EMR 受管服務帳戶的身分之間建立關聯。請注意，會在提交作業時自動建立 EMR 受管服務帳戶，範圍限定在提交作業的命名空間。

使用 AWS CLI （高於 2.24.0 版），執行下列命令來建立與 Pod 身分的角色關聯。

執行下列命令來建立與 Pod 身分的角色關聯：

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

請注意：
+ 每個叢集最多可以有 1，000 個關聯。每個任務執行角色 - 命名空間映射將需要任務提交者、驅動程式和執行器 Pod 的 3 個關聯。
+ 您只能關聯與叢集位於相同 AWS 帳戶中的角色。您可以將存取權從另一個帳戶委派給此帳戶 (您為要使用的 EKS Pod 身分識別所設定) 中的角色。如需委派存取權和 的教學課程`AssumeRole`，請參閱 [IAM 教學課程：使用 IAM 角色在 AWS 帳戶之間委派存取權](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html)。

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

提交任務時，EMR 會建立具有特定命名模式的服務帳戶。若要建立手動關聯或將此工作流程與 AWS SDK 整合，請遵循下列步驟：

建構服務帳戶名稱：

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

以下範例會為範例任務執行角色 JobExecutionRoleIRSAv2 建立角色關聯。

**角色關聯範例：**

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

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

------

完成 EKS Pod 身分所需的所有步驟後，您可以略過下列步驟進行 IRSA 設定：
+ [在 EKS 叢集上啟用服務帳戶的 IAM 角色 (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html)
+ [建立任務執行角色](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html)
+ [更新任務執行角色的信任政策](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-trust-policy.html)

您可以直接跳至下列步驟：[授予使用者對 Amazon EMR on EKS 的存取權](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-iam.html)

## 刪除角色關聯
<a name="setting-up-enable-IAM-pod-identity-asociations-delete-associations"></a>

每當您刪除虛擬叢集或任務執行角色，而且您不想再將 EMR 的存取權授予其服務帳戶時，您應該刪除該角色的關聯。這是因為 EKS 允許與不存在的資源 （命名空間和服務帳戶） 建立關聯。如果命名空間已刪除或角色不再使用，Amazon EMR on EKS 建議刪除關聯，以釋放空間給其他關聯。

**注意**  
如果您不刪除關聯，保留關聯可能會影響您擴展的能力，因為 EKS 對您可以建立的關聯數量有限制 （軟性限制：每個叢集 1000 個關聯）。您可以在指定的命名空間中列出 Pod 身分關聯，以檢查是否有任何需要清除的保留關聯：

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

使用 AWS CLI (2.24.0 版或更新版本），執行下列 emr-containers 命令來刪除 EMR 的角色關聯：

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

## 自動將現有 IRSA 遷移至 Pod 身分
<a name="setting-up-enable-IAM-pod-identity-auto-migrate"></a>

您可以使用工具 eksctl 將現有的 IAM 角色服務帳戶 (IRSA) 遷移至 Pod 身分關聯：

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

在沒有`--approve`旗標的情況下執行命令只會輸出反映遷移步驟的計劃，而且不會發生實際的遷移。

## 疑難排解
<a name="setting-up-enable-IAM-pod-identity-troubleshooting"></a>

### 我的任務無法使用登入資料提供者的 NoClassDefinitionFound 或 ClassNotFound 例外狀況，或無法取得登入資料提供者。
<a name="setting-up-enable-IAM-pod-identity-troubleshooting-no-class"></a>

EKS Pod 身分使用容器登入資料提供者來擷取必要的登入資料。如果您已指定自訂登入資料提供者，請確定其正常運作。或者，請確定您使用的是支援 EKS Pod Identity 的正確 AWS SDK 版本。如需詳細資訊，請參閱[開始使用 Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html)。

### 任務失敗，因為 eks-pod-identity-agent 日誌中顯示的「因 【x】 大小限制而無法擷取登入資料」錯誤。
<a name="setting-up-enable-IAM-pod-identity-troubleshooting-creds"></a>

EMR on EKS 會根據任務執行角色名稱建立 Kubernetes 服務帳戶。如果角色名稱太長，EKS 身分驗證將無法擷取登入資料`pod_name`，因為 `cluster_name`、 和 的組合`service_account_name`超過長度限制。識別哪個元件佔用的空間最多，並相應地調整大小。

### 任務失敗，出現 eks-pod-identity 日誌中顯示的「無法擷取登入資料 xxx」錯誤。
<a name="setting-up-enable-IAM-pod-identity-troubleshooting-creds-error"></a>

此問題的一個可能原因可能是 EKS 叢集是在私有子網路下設定，但未正確設定叢集的 PrivateLink。檢查您的叢集是否位於私有網路中，並設定 AWS PrivateLink 以解決問題。如需詳細說明，請參閱[開始使用 Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html)。

# 選項 2：在 EKS 叢集上啟用服務帳戶的 IAM 角色 (IRSA)
<a name="setting-up-enable-IAM-service-accounts"></a>

服務帳戶的 IAM 角色功能適用於 Amazon EKS 1.14 版和更高版本，以及在 2019 年 9 月 3 日或之後更新至第 1.13 版或更高版本的 EKS 叢集。若要使用此功能，可將現有 EKS 叢集更新至 1.14 版或更新版本。如需詳細資訊，請參閱[更新 Amazon EKS 叢集 Kubernetes 版本](https://docs.aws.amazon.com/eks/latest/userguide/update-cluster.html)。

如果您的叢集支援服務帳戶的 IAM 角色，則會有相關聯的 [OpenID Connect](https://openid.net/connect/) 發行者 URL。您可以在 Amazon EKS 主控台中檢視此 URL，也可以使用下列 AWS CLI 命令進行擷取。

**重要**  
您必須使用最新版本的 AWS CLI ，才能從此命令接收適當的輸出。

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

預期輸出如下。

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

若要在叢集中使用服務帳戶的 IAM 角色，則必須使用 [eksctl](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html#create-oidc-eksctl) 或 [AWS 管理主控台](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html#create-oidc-console) 來建立 OIDC 身分提供者。

## 使用 `eksctl` 為您的叢集建立 IAM OIDC 身分提供者
<a name="setting-up-OIDC-eksctl"></a>

使用以下命令檢查您的 `eksctl` 版本。此程序假設您已安裝 `eksctl`，且您的 `eksctl` 版本為 0.32.0 或更高版本。

```
eksctl version
```

如需有關安裝或升級 eksctl 的詳細資訊，請參閱[安裝或升級 eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl)。

使用下列命令為您的叢集建立 OIDC 身分提供者。使用自己的值取代 *cluster\$1name*。

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

## 使用 為您的叢集建立 IAM OIDC 身分提供者 AWS 管理主控台
<a name="setting-up-OIDC-console"></a>

從叢集的 Amazon EKS 主控台描述擷取 OIDC 發行者 URL，或使用下列 AWS CLI 命令。

使用下列命令，從 AWS CLI中擷取 OIDC 發行者 URL。

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

使用下列命令，從 Amazon EKS 主控台中擷取 OIDC 發行者 URL。

1. 前往 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 開啟 IAM 主控台。

1. 在導覽面板中，選擇**身分提供者**，然後選擇**建立提供者**。

   1. 處理 **Provider Type (提供者類型)** 時，請選擇 **Choose a provider type (選擇提供者類型)**，然後選擇 **OpenID Connect**。

   1. 針對 **Provider URL (提供者 URL)**，貼上叢集的 OIDC 發行者 URL。

   1. 如果為「對象」，則輸入 sts.amazonaws.com，然後選擇**下一步**。

1. 確認供應商資訊是否正確，然後選擇 **Create (建立)** 來建立您的身分提供者。

# 建立作業執行角色
<a name="creating-job-execution-role"></a>

若要在 Amazon EMR on EKS 上執行工作負載，您需要建立 IAM 角色。在本文件中，我們將此角色稱為*作業執行角色*。如需有關如何建立 IAM 角色的詳細資訊，請參閱《IAM 使用者指南》中的[建立 IAM 角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html)。

您還必須建立 IAM 政策來指定作業執行角色的許可，然後將 IAM 政策附接至作業執行角色。

作業執行角色的下列政策允許存取資源目標、Amazon S3 和 CloudWatch。這些許可是監控作業和存取日誌所必需的。若要使用 遵循相同的程序 AWS CLI：

建立任務執行的 IAM 角色：讓我們建立 EMR 將用於任務執行的角色。這是 角色，EMR 任務將在 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
```

接下來，我們需要將必要的 IAM 政策連接到角色，以便它可以將日誌寫入 s3 和 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
```

**注意**  
應適當確定存取權限的範圍，而不是授予給作業執行角色中的所有 S3 物件。

------
#### [ 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"
    }
  ]
}
```

------

如需詳細資訊，請參閱[使用作業執行角色](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/iam-execution-role.html)、[設定作業執行以使用 S3 日誌](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-s3)以及[設定作業執行以使用 CloudWatch 日誌](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-cloudwatch)。

# 更新作業執行角色的信任政策
<a name="setting-up-trust-policy"></a>

當您使用服務帳戶的 IAM 角色 (IRSA)，在 Kubernetes 命名空間上執行作業時，系統管理員必須在作業執行角色與 EMR 受管服務帳戶的身分之間建立信任關係。可以透過更新作業執行角色的信任政策來建立信任關係。請注意，會在提交作業時自動建立 EMR 受管服務帳戶，範圍限定在提交作業的命名空間。

執行下列命令來更新信任政策。

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

如需詳細資訊，請參閱[搭配使用作業執行角色與 Amazon EMR on EKS](iam-execution-role.md)。

**重要**  
執行上述命令的運算子必須具有以下許可：`eks:DescribeCluster`、`iam:GetRole`、`iam:UpdateAssumeRolePolicy`。

# 授予使用者對 Amazon EMR on EKS 的存取權
<a name="setting-up-iam"></a>

對於您在 Amazon EMR on EKS 上執行的任何動作，您需要該動作的對應 IAM 許可。必須建立 IAM 政策，以便執行 Amazon EMR on EKS 動作，並將政策附接至您使用的 IAM 使用者或角色。

本主題提供建立新政策並將其附接至使用者的步驟。它還涵蓋了設定 Amazon EMR on EKS 環境所需的基本許可。建議您根據業務需求，盡可能完善特定資源的許可。

## 在 IAM 主控台中建立新的 IAM 政策並將其附接至使用者
<a name="setting-up-iam-console"></a>

**建立新的 IAM 政策**

1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 的 IAM 主控台。

1. 在 IAM 主控台的左側導覽窗格中，選擇**政策**。

1. 在 **Policies** (政策) 頁面上，選擇 **Create a policy** (建立政策)。

1. 在**建立政策**視窗中，導覽至**編輯 JSON** 索引標籤。建立具有一個或多個 JSON 陳述式的政策文件，如此程序後面的範例所示。接下來，選擇**檢閱政策**。

1. 在 **Review Policy** (檢閱政策) 畫面上，輸入 **Policy Name** (政策名稱)，例如 `AmazonEMROnEKSPolicy`。輸入選用描述，然後選擇**建立政策**。

**將政策附接至使用者或角色**

1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 的 IAM 主控台 

1. 在導覽窗格中，選擇**政策**。

1. 在政策清單中，選取在上一節中建立的政策旁的核取方塊。您可用**篩選**功能表和搜尋方塊來篩選政策清單。

1. 選擇**政策動作**，再選擇**附加**。

1. 選擇要與政策附接的使用者或角色。您可用**篩選**功能表和搜尋方塊來篩選主體實體清單。選擇要與政策附接的使用者或角色後，選擇**附接政策**。

## 用於管理虛擬叢集的許可
<a name="permissions-virtual-cluster"></a>

若要管理 AWS 帳戶中的虛擬叢集，請使用下列許可建立 IAM 政策。這些許可可讓您在 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 已與 Amazon EKS 叢集存取管理 (CAM) 整合，因此您可以自動設定必要的 AuthN 和 AuthZ 政策，以在 Amazon EKS 叢集命名空間中執行 Amazon EMR Spark 任務。若要這樣做，您必須具有下列許可：

```
{
  "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/*"
}
```

如需詳細資訊，請參閱[自動啟用 Amazon EMR on EKS 的叢集存取](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html#setting-up-cluster-access-cam-integration)。

第一次從 AWS 帳戶叫用 `CreateVirtualCluster`操作時，您也需要`CreateServiceLinkedRole`許可才能為 Amazon EMR on EKS 建立服務連結角色。如需詳細資訊，請參閱[使用 Amazon EMR on EKS 的服務連結角色](using-service-linked-roles.md)。

## 用於提交作業的許可
<a name="permissions-submitting-jobs"></a>

若要在 AWS 帳戶中的虛擬叢集上提交任務，請使用下列許可建立 IAM 政策。這些許可可讓您啟動、列出、描述和取消帳戶中所有虛擬叢集的作業執行。應該考慮新增許可以列出或描述虛擬叢集，這可讓您在提交作業之前檢查虛擬叢集的狀態。

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

****  

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

------

## 用於偵錯和監控的許可
<a name="permissions-debugging-monitoring"></a>

若要存取推送到 Amazon S3 和 CloudWatch 的日誌，或在 Amazon EMR 主控台中檢視應用程式事件日誌，請建立具有下列許可的 IAM 政策。建議您根據業務需求，盡可能完善特定資源的許可。

**重要**  
如果尚未建立 Amazon S3 儲存貯體，則需要將 `s3:CreateBucket` 許可新增至政策陳述式。如果尚未建立日誌群組，則需要將 `logs:CreateLogGroup` 新增至政策陳述式。

------
#### [ 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"
    }
  ]
}
```

------

如需有關如何設定作業執行以將日誌推入 Amazon S3 和 CloudWatch 的詳細資訊，請參閱[設定作業執行以使用 S3 日誌](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-s3)和[設定作業執行以使用 CloudWatch 日誌](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks-jobs-CLI.html#emr-eks-jobs-cloudwatch)。

# 向 Amazon EMR 註冊 Amazon EKS 叢集
<a name="setting-up-registration"></a>

註冊叢集是設定 Amazon EMR on EKS 以執行工作負載的最後一個必要步驟。

使用下列命令為您在先前步驟中設定的 Amazon EKS 叢集和命名空間建立具有您所選名稱的虛擬叢集。

**注意**  
每個虛擬叢集在所有 EKS 叢集中都必須具有唯一的名稱。如果兩個虛擬叢集具有相同名稱，即使兩個虛擬叢集屬於不同的 EKS 叢集，部署程序也會失敗。

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

或者，您可以建立包含虛擬叢集所需參數的 JSON 檔案，然後使用 JSON 檔案的路徑執行 `create-virtual-cluster` 命令。如需詳細資訊，請參閱[管理虛擬叢集](virtual-cluster.md)。

**注意**  
若要驗證虛擬叢集是否成功建立，請使用 `list-virtual-clusters` 操作或前往 Amazon EMR 主控台中的**虛擬叢集**頁面來檢視虛擬叢集的狀態。

# 使用 `StartJobRun` 提交作業執行
<a name="emr-eks-jobs-submit"></a>

**使用具有指定參數的 JSON 檔案來提交作業執行**

1. 建立 `start-job-run-request.json` 檔案並指定作業執行所需的參數，如下列範例 JSON 檔案所示。如需這些參數的詳細資訊，請參閱 [用於設定作業執行的選項](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. 搭配使用 `start-job-run` 命令與儲存在本機的 `start-job-run-request.json` 檔案路徑。

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

**使用 `start-job-run` 命令啟動作業執行**

1. 請在 `StartJobRun` 命令中提供所有指定的參數，如下列範例所示。

   ```
   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. 對於 Spark SQL，請在 `StartJobRun` 命令中提供所有指定的參數，如下列範例所示。

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

# 使用作業提交器分類
<a name="emr-eks-job-submitter"></a>

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

Amazon EMR on EKS `StartJobRun` 請求會建立*作業提交器* Pod (也稱為 *job-runner* Pod) 以產生 Spark 驅動程式。您可以使用 `emr-job-submitter`分類來設定節點選取器、新增容錯、自訂記錄，以及對任務提交器 Pod 進行其他修改。

`emr-job-submitter` 分類下提供下列設定：

** `jobsubmitter.node.selector.[selectorKey]` **  
將 新增至任務提交器 Pod 的節點選取器，並以金鑰 *selectorKey* 和 值做為組態值。例如，您可以將 ` jobsubmitter.node.selector.identifier` 設定為 ，`myIdentifier`而任務提交者 Pod 會有節點選擇器，其中包含索引鍵`identifier`和值 `myIdentifier`。這可用來指定任務提交器 Pod 可以放置在哪個節點上。要新增多個節點選取器索引鍵，請使用此字首設定多個組態。

** `jobsubmitter.label.[labelKey]` **  
將 新增至任務提交者 Pod 的標籤，並以金鑰 *labelKey* 和 值做為組態值。若要新增多個標籤，請使用此字首設定多個組態。

** `jobsubmitter.annotation.[annotationKey]` **  
將 新增至任務提交器 Pod 的註釋，並以金鑰 *annotationKey* 和 值做為組態值。若要新增多個註釋，請使用此字首設定多個組態。

** `jobsubmitter.node.toleration.[tolerationKey]` **  
將[容錯](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/)新增至任務提交器 Pod。根據預設，不會將任何容錯新增至 Pod。公差的金鑰將是 *tolerationKey*，而公差的值將是組態值。如果組態值設定為非空白字串，則運算子將為 `Equals`。如果組態值設定為 `""`，則運算子將為 `Exists`。

** `jobsubmitter.node.toleration.[tolerationKey].[effect]` **  
將容錯效果新增至字首 *tolerationKey*。新增容錯時，此欄位為必要欄位。效果欄位的允許值為 ` NoExecute`、 `NoSchedule`和 `PreferNoSchedule`。

** `jobsubmitter.node.toleration.[tolerationKey].[tolerationSeconds]` **  
將 tolerationSeconds 新增至字首 *tolerationKey*。選用欄位。僅適用於效果為 時`NoExecute`。

** `jobsubmitter.scheduler.name` **  
設定任務提交器 Pod 的自訂schedulerName。

** `jobsubmitter.logging` **  
啟用或停用任務提交器 Pod 上的記錄。將此設定為` DISABLED`記錄容器時，會從任務提交器 Pod 中移除，這會停用 中指定的此 Pod 的任何記錄`monitoringConfiguration`，例如 `s3MonitoringConfiguration`或 `cloudWatchMonitoringConfiguration`。當此設定未設定或設定為任何其他值時，會啟用任務提交器 Pod 上的記錄。

** `jobsubmitter.logging.image` **  
設定要用於任務提交器 Pod 上記錄容器的自訂映像。

** `jobsubmitter.logging.request.cores` **  
為任務提交者 Pod 上的記錄容器設定 CPUs 數量的自訂值，以 CPU 單位為單位。根據預設，這會設定為 **100 公尺**。

** `jobsubmitter.logging.request.memory` **  
設定任務提交者 Pod 上記錄容器的記憶體量自訂值，以位元組為單位。根據預設，這會設定為 **200Mi**。MB 是類似於 MB 的度量單位。

** `jobsubmitter.container.image` **  
設定任務提交者 Pod 容器的自訂映像`job-runner`。

** `jobsubmitter.container.image.pullPolicy` **  
設定任務提交器 Pod 容器的 [imagePullPolicy](https://kubernetes.io/docs/concepts/containers/images/#image-pull-policy)。

我們建議將任務提交者 Pod 放置在隨需執行個體上。如果任務提交者 Pod 執行的執行個體發生 Spot 執行個體中斷，則將任務提交者 Pod 放置在 Spot 執行個體上可能會導致任務失敗。您也可以[將任務提交者 Pod 放在單一可用區域中，或使用套用至節點的任何 Kubernetes 標籤](#emr-eks-job-submitter-ex-ec2)。

## 作業提交器分類範例
<a name="emr-eks-job-submitter-examples"></a>

**Topics**
+ [適用於作業提交器 Pod 的具有隨需節點放置的 `StartJobRun` 請求](#emr-eks-job-submitter-ex-od)
+ [`StartJobRun` 任務提交器 Pod 具有單一可用區節點置放和 Amazon EC2 執行個體類型置放的請求](#emr-eks-job-submitter-ex-ec2)
+ [`StartJobRun` 具有任務提交器 Pod 的標籤、註釋和自訂排程器的請求](#emr-eks-job-submitter-label-annotation-scheduler)
+ [`StartJobRun` 將容錯套用至具有索引鍵 `dedicated`、值 `graviton_machines`、效果 `NoExecute`和 60 秒之任務提交者 Pod `tolerationSeconds`的請求](#emr-eks-job-submitter-tolerations)
+ [`StartJobRun` 任務提交者 Pod 停用記錄的 請求](#emr-eks-job-submitter-logging-disabled)
+ [`StartJobRun` 具有任務提交器 Pod 的自訂記錄容器映像、CPU 和記憶體的 請求](#emr-eks-job-submitter-custom)
+ [`StartJobRun` 具有自訂任務提交者容器映像和提取政策的請求](#emr-eks-job-submitter-custom-container)

### 適用於作業提交器 Pod 的具有隨需節點放置的 `StartJobRun` 請求
<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` 任務提交器 Pod 具有單一可用區節點置放和 Amazon EC2 執行個體類型置放的請求
<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` 具有任務提交器 Pod 的標籤、註釋和自訂排程器的請求
<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` 將容錯套用至具有索引鍵 `dedicated`、值 `graviton_machines`、效果 `NoExecute`和 60 秒之任務提交者 Pod `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` 任務提交者 Pod 停用記錄的 請求
<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` 具有任務提交器 Pod 的自訂記錄容器映像、CPU 和記憶體的 請求
<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` 具有自訂任務提交者容器映像和提取政策的請求
<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"
      }
    }
  ]
}
```

# 使用 Amazon EMR 容器預設分類
<a name="emr-eks-job-submitter-container-defaults"></a>

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

`emr-containers-defaults` 分類下提供下列設定：

** `job-start-timeout` **  
根據預設，如果任務無法啟動且等待` SUBMITTED`狀態為 15 分鐘，則會逾時。此組態會變更任務逾時前要等待的秒數。

** `executor.logging` **  
啟用或停用執行器 Pod 上的記錄。將此設定為` DISABLED`記錄容器時，會從執行器 Pod 中移除，這會停用 中指定之這些 Pod 的任何記錄`monitoringConfiguration`，例如 `s3MonitoringConfiguration`或 `cloudWatchMonitoringConfiguration`。當此設定未設定或設定為任何其他值時，會啟用執行器 Pod 上的記錄。

** `logging.image` **  
設定要用於驅動程式和執行器 Pod 上記錄容器的自訂映像。

** `logging.request.cores` **  
為驅動程式和執行器 Pod 上的記錄容器設定 CPUs 數量的自訂值，以 CPU 單位為單位。根據預設，不會設定此選項。

** `logging.request.memory` **  
設定驅動程式和執行器 Pod 上記錄容器的記憶體量自訂值，以位元組為單位。根據預設，這會設定為 **512Mi**。MB 是類似於 MB 的度量單位。

## 作業提交器分類範例
<a name="emr-eks-job-submitter-container-examples"></a>

**Topics**
+ [`StartJobRun` 具有自訂任務逾時的 請求](#emr-eks-job-submitter-container-custom-timeout)
+ [`StartJobRun` 針對執行器 Pod 停用記錄的 請求](#emr-eks-executor-logging-disabled)
+ [`StartJobRun` 具有驅動程式和執行器 Pod 的自訂記錄容器映像、CPU 和記憶體的 請求](#emr-eks-job-submitter-container-custom-image-cpu)

### `StartJobRun` 具有自訂任務逾時的 請求
<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` 針對執行器 Pod 停用記錄的 請求
<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` 具有驅動程式和執行器 Pod 的自訂記錄容器映像、CPU 和記憶體的 請求
<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"
    }
  }
}
```

# 使用 Spark Operator 執行 Spark 作業
<a name="spark-operator"></a>

Amazon EMR 6.10.0 版及更高版本支援 Kubernetes Operator for Apache Spark 或 *Spark Operator*，作為 Amazon EMR on EKS 的作業提交模型。透過 Spark Operator，可以使用 Amazon EMR 發行執行期在您自己的 Amazon EKS 叢集上部署和管理 Spark 應用程式。在 Amazon EKS 叢集中部署 Spark Operator 之後，即可直接向 Operator 提交 Spark 應用程式。Operator 可管理 Spark 應用程式的生命週期。

**注意**  
Amazon EMR 會根據 vCPU 和記憶體使用量計算 Amazon EKS 定價。此計算適用於驅動程式和執行器 Pod。此計算會從您下載 Amazon EMR 應用程式映像時開始，直到 Amazon EKS Pod 終止且四捨五入至最接近的秒數為止。

**Topics**
+ [為 Amazon EMR on EKS 設定 Spark Operator](spark-operator-setup.md)
+ [開始針對 Amazon EMR on EKS 使用 Spark Operator](spark-operator-gs.md)
+ [搭配適用於 Amazon EMR on EKS 的 Spark Operator 使用垂直自動擴展](spark-operator-vas.md)
+ [為 Amazon EMR on EKS 解除安裝 Spark Operator](spark-operator-uninstall.md)
+ [使用監控組態來監控 Spark Kubernetes 運算子和 Spark 任務](spark-operator-monitoring-configuration.md)
+ [Amazon EMR on EKS 的安全性和 Spark Operator](spark-operator-security.md)

# 為 Amazon EMR on EKS 設定 Spark Operator
<a name="spark-operator-setup"></a>

先完成下列任務，然後在 Amazon EKS 上安裝 Spark Operator。如果已經註冊 Amazon Web Services (AWS) 且已在使用 Amazon EKS，則您幾乎可使用 Amazon EMR on EKS。完成下列任務，即可在 Amazon EKS 上設定 Spark Operator。如果已經完成任何先決條件，則可以跳過這些先決條件，然後繼續進行下一個。
+ **[安裝或更新至最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)**- 如果您已安裝 AWS CLI，請確認您擁有最新版本。
+ **[設定 kubectl 和 eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) ** – eksctl 是您用來與 Amazon EKS 通訊的命令列工具。
+ **[安裝 Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)** – Kubernetes 的 Helm 套件管理工具可協助您安裝和管理 Kubernetes 叢集上的應用程式。
+ **[開始使用 Amazon EKS – eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) ** – 請依照步驟在 Amazon EKS 中建立具有節點的新 Kubernetes 叢集。
+ **[選擇 Amazon EMR 基礎映像 URI](docker-custom-images-tag.md) (6.10.0 版或更高版本)** - Amazon EMR 6.10.0 版及更高版本支援 Spark Operator。

# 開始針對 Amazon EMR on EKS 使用 Spark Operator
<a name="spark-operator-gs"></a>

本主題協助您透過部署 Spark 應用程式和 Schedule Spark 應用程式，開始在 Amazon EKS 上使用 Spark Operator。

## 安裝 Spark Operator
<a name="spark-operator-install"></a>

請使用下列步驟來安裝 Kubernetes Operator for Apache Spark。

1. 如果您尚未這麼做，請完成 [為 Amazon EMR on EKS 設定 Spark Operator](spark-operator-setup.md) 中的步驟。

1. 向 Amazon ECR 登錄檔驗證 Helm 用戶端。在下列命令中，將 *region-id* 值取代為您偏好的 AWS 區域，以及 [按區域劃分的 Amazon ECR 登錄檔帳戶](docker-custom-images-tag.md#docker-custom-images-ECR) 頁面中區域的對應 *ECR-registry-account* 值。

   ```
   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. 使用以下命令安裝 Spark Operator。

   對於 Helm Chart `--version` 參數，請使用移除了 `emr-` 字首和日期尾碼的 Amazon EMR 版本標籤。例如，對於 `emr-6.12.0-java17-latest` 發行版本，請指定 `6.12.0-java17`。下列命令中的範例使用 `emr-7.12.0-latest` 版本，因此它會為 Helm Chart `--version` 指定 `7.12.0`。

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

   根據預設，命令會為 Spark Operator 建立服務帳戶 `emr-containers-sa-spark-operator`。若要使用不同的服務帳戶，請提供引數 `serviceAccounts.sparkoperator.name`。例如：

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

   如果想要[搭配使用垂直自動擴展與 Spark Operator]()，請在安裝命令中新增以下命令列，以允許 Operator 使用 Webhook：

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

1. 請確認已使用 `helm list` 命令安裝 Helm Chart：

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

   `helm list` 命令應傳回新部署的 Helm Chart 版本資訊：

   ```
   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. 使用您需要的任何其他選項完成安裝。如需詳細資訊，請參閱 GitHub 上的 [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) 文件。

## 執行 Spark 應用程式
<a name="spark-operator-run"></a>

Amazon EMR 6.10.0 或更高版本支援 Spark Operator。當您安裝 Spark Operator 時，它會預設建立服務帳戶 `emr-containers-sa-spark` 以執行 Spark 應用程式。使用以下步驟在 Amazon EMR on EKS 6.10.0 或更高版本上透過 Spark Operator 執行 Spark 應用程式。

1. 在使用 Spark Operator 執行 Spark 應用程式之前，請先完成 [為 Amazon EMR on EKS 設定 Spark Operator](spark-operator-setup.md) 和 [安裝 Spark Operator](#spark-operator-install) 中的步驟。

1. 使用以下範例內容，建立 `SparkApplication` 定義檔案 `spark-pi.yaml`：

   ```
   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. 現在，使用下列命令提交 Spark 應用程式。這也將建立名為 `spark-pi` 的 `SparkApplication` 物件：

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

1. 使用下列命令檢查 `SparkApplication` 物件的事件：

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

如需有關透過 Spark Operator 將應用程式提交至 Spark 的詳細資訊，請參閱 GitHub 上 `spark-on-k8s-operator` 文件中的[使用 `SparkApplication`](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/)。

## 使用 Amazon S3 進行儲存
<a name="spark-operator-s3-storage"></a>

若要使用 Amazon S3 做為檔案儲存選項，請將下列組態新增至 YAML 檔案。

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

 如果您使用 Amazon EMR 7.2.0 版及更高版本，預設會包含組態。在這種情況下，您可以將檔案路徑設定為 ，`s3://<bucket_name>/<file_path>`而不是`local://<file_path>`在 Spark 應用程式 YAML 檔案中。

然後正常提交 Spark 應用程式。

# 搭配適用於 Amazon EMR on EKS 的 Spark Operator 使用垂直自動擴展
<a name="spark-operator-vas"></a>

從 Amazon EMR 7.0 開始，您可以使用 Amazon EMR on EKS 垂直自動擴展來簡化資源管理。它會自動調整記憶體和 CPU 資源，以適應您為 Amazon EMR Spark 應用程式提供的工作負載需求。如需詳細資訊，請參閱[搭配使用垂直自動擴展與 Amazon EMR Spark 作業](jobruns-vas.md)。

本章節描述了如何設定 Spark Operator 以使用垂直自動擴展。

## 先決條件
<a name="spark-operator-vas-prereqs"></a>

設定監控之前，請務必完成下列設定任務：
+ 完成「[為 Amazon EMR on EKS 設定 Spark Operator](spark-operator-setup.md)」中的步驟。
+ （選用） 如果您先前已安裝較舊版本的 Spark 運算子，請刪除 SparkApplication/ScheduledSparkApplication CRD。

  ```
  kubectl delete crd sparkApplication
  kubectl delete crd scheduledSparkApplication
  ```
+ 完成「[安裝 Spark Operator](spark-operator-gs.md#spark-operator-install)」中的步驟。在步驟 3 中，將以下命令列新增至安裝命令，以允許該 Operator 使用 Webhook：

  ```
  --set webhook.enable=true
  ```
+ 完成「[設定 Amazon EMR on EKS 的垂直自動擴展](jobruns-vas-setup.md)」中的步驟。
+ 允許存取 Amazon S3 位置中的檔案：

  1. 使用具有 S3 許可`JobExecutionRole`的 標註您的驅動程式和運算子服務帳戶。

     ```
     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. 更新該命名空間中任務執行角色的信任政策。

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

  1. 編輯任務執行角色的 IAM 角色信任政策，並將 `serviceaccount` 從 更新`emr-containers-sa-spark-*-*-xxxx`為 `emr-containers-sa-*`。

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

  1. 如果您使用 Amazon S3 做為檔案儲存體，請將下列預設值新增至 yaml 檔案。

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

## 在 Spark Operator 上使用垂直自動擴展來執行作業
<a name="spark-operator-vas-run"></a>

在使用 Spark Operator 執行 Spark 應用程式之前，必須先完成 [先決條件](#spark-operator-vas-prereqs) 中的步驟。

若要搭配 Spark 運算子使用垂直自動調整規模，請將下列組態新增至 Spark 應用程式規格的驅動程式，以開啟垂直自動調整規模：

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

此組態會啟用垂直自動擴展，並且是必要的簽章組態，可讓您為任務選擇簽章。

如需組態和參數值的詳細資訊，請參閱[設定 Amazon EMR on EKS 的垂直自動調整規模](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/jobruns-vas-configure.html)。依預設，您的作業在垂直自動擴展的僅監控**關閉**模式下提交。此監控狀態可讓您計算和檢視資源建議，而無需執行自動擴展。如需詳細資訊，請參閱[垂直自動調整規模模式](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/jobruns-vas-configure.html#jobruns-vas-parameters-opt-mode)。

以下是名為 的範例`SparkApplication`定義檔案，`spark-pi.yaml`其中包含使用垂直自動擴展所需的組態。

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

現在，使用下列命令提交 Spark 應用程式。這也將建立名為 `spark-pi` 的 `SparkApplication` 物件：

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

如需有關透過 Spark Operator 將應用程式提交至 Spark 的詳細資訊，請參閱 GitHub 上 `spark-on-k8s-operator` 文件中的[使用 `SparkApplication`](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/)。

## 驗證垂直自動擴展功能
<a name="spark-operator-vas-verify"></a>

若要確認垂直自動擴展適用於已提交的作業，請使用 kubectl 取得 `verticalpodautoscaler` 自訂資源並檢視您的擴展建議。

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

此查詢的輸出應如下所示：

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

如果您的輸出看起來不相似或包含錯誤碼，請參閱 [對 Amazon EMR on EKS 垂直自動擴展進行疑難排解](troubleshooting-vas.md) 以取得協助解決問題的步驟。

若要移除 Pod 和應用程式，請執行下列命令：

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

# 為 Amazon EMR on EKS 解除安裝 Spark Operator
<a name="spark-operator-uninstall"></a>

使用下列步驟解除安裝 Spark Operator。

1. 使用正確的命名空間刪除 Spark Operator。針對此範例，命名空間為 `spark-operator-demo`。

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

1. 刪除 Spark Operator 服務帳戶：

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

1. 刪除 Spark Operator `CustomResourceDefinitions` (CRD)：

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

# 使用監控組態來監控 Spark Kubernetes 運算子和 Spark 任務
<a name="spark-operator-monitoring-configuration"></a>

監控組態可讓您輕鬆地將 Spark 應用程式和運算子日誌的日誌封存設定到 Amazon S3 或 Amazon CloudWatch。您可以選擇其中一個或兩者。這樣做會將日誌代理程式附屬項目新增至您的 Spark 運算子 Pod、驅動程式和執行器 Pod，然後將這些元件的日誌轉送到您設定的接收器。

## 先決條件
<a name="spark-operator-monitoring-configuration-prereqs"></a>

設定監控之前，請務必完成下列設定任務：

1. （選用） 如果您先前已安裝較舊版本的 Spark 運算子，請刪除 *SparkApplication/ScheduledSparkApplication* CRD。

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

1. 如果您還沒有運算子/任務執行角色，請在 IAM 中建立該角色。

1. 執行下列命令來更新您剛建立之運算子/任務執行角色的信任政策：

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

1. 將運算子/任務執行角色的 IAM 角色信任政策編輯如下：

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

1. 在具有下列許可的 IAM 中建立 *monitoringConfiguration* 政策：

------
#### [ 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. 將上述政策連接至您的運算子/任務執行角色。

# Spark 運算子日誌
<a name="spark-operator-monitoring-configuration-logs"></a>

您可以在執行 時，以下列方式定義監控組態`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
```

**監控組態**

以下是 **monitoringConfiguration** 下的可用組態選項。
+ **映像 ** （選用） – 日誌代理程式映像 URL。如果未提供， 將依 emrReleaseLabel 擷取。
+ **s3MonitoringConfiguration** – 將此選項設定為封存至 Amazon S3。
  + **logUri** – （必要） – 您要存放日誌的 Amazon S3 儲存貯體路徑。
  + 以下是上傳日誌後 Amazon S3 儲存貯體路徑的範例格式。第一個範例顯示未啟用日誌輪換。

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

    預設啟用日誌輪換。您可以同時看到具有遞增索引的輪換檔案，以及與先前範例相同的目前檔案。

    ```
    s3://${logUri}/${POD NAME}/operator/stdout_YYYYMMDD_index.gz
    s3://${logUri}/${POD NAME}/operator/stderr_YYYYMMDD_index.gz
    ```
+ **cloudWatchMonitoringConfiguration** – 要設定轉送的組態金鑰 Amazon CloudWatch。
  + **logGroupName** （必要） – 您要傳送 Amazon CloudWatch 日誌的日誌群組名稱。如果群組不存在，則會自動建立群組。
  + **logStreamNamePrefix** （選用） – 您要將日誌傳送到其中的日誌串流名稱。預設值為空字串。中的格式 Amazon CloudWatch 如下：

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
+ **sideCarResources** （選用） – 設定已啟動 Fluentd 附屬容器資源限制的組態金鑰。
  + **memoryLimit** （選用） – 記憶體限制。根據需要進行調整。預設值為 512Mi。
  + **cpuLimit** （選用） – CPU 限制。根據需要進行調整。預設值為 500 公尺。
+ **containerLogRotationConfiguration** （選用） – 控制容器日誌輪換行為。依預設會啟用此功能。
  + **rotationSize** （必要） – 指定日誌輪換的檔案大小。可能的值範圍為 2KB 至 2GB。rotationSize 參數的數值單位部分會以整數形式傳遞。由於不支援小數值，因此可以使用值 1500MB 來指定 1.5GB 的輪換大小。預設值為 2GB。
  + **maxFilesToKeep** （必要） – 指定輪換發生後要在容器中保留的檔案數量上限。下限值是 1，上限值是 50。預設為 10。

設定 *monitoringConfiguration* 之後，您應該能夠檢查 Amazon S3 儲存貯體 Amazon CloudWatch 或 或兩者上的 Spark Operator Pod 日誌。對於 Amazon S3 儲存貯體，您需要等待 2 分鐘，第一個日誌檔案才能排清。

若要尋找 中的日誌 Amazon CloudWatch，您可以導覽至下列項目：**CloudWatch** > **日誌群組** > ***日誌群組名稱*** > *Pod 名稱***/操作員/stderr**

或者，您可以導覽至：**CloudWatch** > **日誌群組** > ***日誌群組名稱*** > *Pod 名稱***/操作員/stdout**

# Spark 應用程式日誌
<a name="spark-operator-monitoring-application-logs"></a>

可採用以下方法定義此設定。

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

以下是 **monitoringConfiguration** 下的可用組態選項。
+ **映像** （選用） – 日誌代理程式映像 URL。如果未提供， 將依 emrReleaseLabel 擷取。
+ **s3MonitoringConfiguration** – 將此選項設定為封存至 Amazon S3。
  + **logUri** （必要） – 您要存放日誌的 Amazon S3 儲存貯體路徑。第一個範例顯示未啟用日誌輪換：

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

    日誌輪換預設為啟用。您可以同時使用輪換的檔案 （含遞增索引） 和目前的檔案 （不含日期戳記的檔案）。

    ```
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout_YYYYMMDD_index.gz
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr_YYYYMMDD_index.gz
    ```
+ **cloudWatchMonitoringConfiguration** – 要設定轉送的組態金鑰 Amazon CloudWatch。
  + **logGroupName** （必要） – 您要傳送日誌的 Cloudwatch 日誌群組名稱。如果群組不存在，則會自動建立該群組。
  + **logStreamNamePrefix** （選用） – 您要將日誌傳送到其中的日誌串流名稱。預設值為空字串。CloudWatch 的格式如下所示：

    ```
    ${logStreamNamePrefix}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout
    ${logStreamNamePrefix}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr
    ```
+ **sideCarResources** （選用） – 設定已啟動 Fluentd 附屬容器資源限制的組態金鑰。
  + **memoryLimit** （選用） – 記憶體限制。根據需要進行調整。預設值為 250Mi。
  + **cpuLimit** – CPU 限制。根據需要進行調整。預設值為 500 公尺。
+ **containerLogRotationConfiguration** （選用） – 控制容器日誌輪換行為。依預設會啟用此功能。
  + **rotationSize** （必要） – 指定日誌輪換的檔案大小。可能的值範圍為 2KB 至 2GB。rotationSize 參數的數值單位部分會以整數形式傳遞。由於不支援小數值，因此可以使用值 1500MB 來指定 1.5GB 的輪換大小。預設值為 2GB。
  + **maxFilesToKeep** （必要） – 指定輪換發生後要在容器中保留的檔案數量上限。最小值為 1。最大值為 50。預設為 10。

設定 monitoringConfiguration 之後，您應該能夠在 Amazon S3 儲存貯體或 CloudWatch 或兩者上檢查 Spark 應用程式驅動程式和執行器日誌。對於 Amazon S3 儲存貯體，您需要等待 2 分鐘才能排清第一個日誌檔案。例如，在 Amazon S3 中，儲存貯體路徑如下所示：

**Amazon S3** > **儲存貯體** > ***儲存貯體名稱*** > *Spark 應用程式名稱 - UUID* > *Pod 名稱* > **stderr.gz**

或者：

**Amazon S3** > **儲存貯體** > ***儲存貯體名稱*** > *Spark 應用程式名稱 - UUID* > *Pod 名稱* > **stdout.gz**

在 CloudWatch 中，路徑如下所示：

**CloudWatch** > **日誌群組** > ***日誌群組名稱*** > *Spark 應用程式名稱 - UUID*/*Pod 名稱***/stderr**

或者：

**CloudWatch** > **日誌群組** > ***日誌群組名稱*** > *Spark 應用程式名稱 - UUID*/*Pod 名稱***/stdout**

# Amazon EMR on EKS 的安全性和 Spark Operator
<a name="spark-operator-security"></a>

當您使用 Spark 運算子時，有幾種方式可以設定叢集存取許可。首先是使用角色型存取控制，角色型存取控制 (RBAC) 會根據人員在組織內的角色來限制存取。它已成為處理存取的主要方式。第二個存取方法是擔任 AWS Identity and Access Management 角色，透過特定指派的許可提供資源存取。

**Topics**
+ [使用角色型存取控制 (RBAC) 設定叢集存取許可](spark-operator-security-rbac.md)
+ [使用服務帳戶的 IAM 角色 (IRSA) 來設定叢集存取許可](spark-operator-security-irsa.md)

# 使用角色型存取控制 (RBAC) 設定叢集存取許可
<a name="spark-operator-security-rbac"></a>

為了部署 Spark Operator，Amazon EMR on EKS 會為 Spark Operator 和 Spark 應用程式建立了兩個角色和服務帳戶。

**Topics**
+ [Operator 服務帳戶和角色](#spark-operator-sa-oper)
+ [Spark 服務帳戶和角色](#spark-operator-sa-spark)

## Operator 服務帳戶和角色
<a name="spark-operator-sa-oper"></a>

Amazon EMR on EKS 會建立 **Operator 服務帳戶和角色**，以管理適用於 Spark 作業和其他資源 (例如服務) 的 `SparkApplications`。

此服務帳戶的預設名稱為 `emr-containers-sa-spark-operator`。

下列規則適用於此服務角色：

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

## Spark 服務帳戶和角色
<a name="spark-operator-sa-spark"></a>

Spark 驅動程式 Pod 需要與該 Pod 位於相同命名空間的 Kubernetes 服務帳戶。此服務帳戶需要許可才能建立、取得、列出、修補和刪除執行程式 Pod，以及為驅動程式建立 Kubernetes 無頭服務。如果沒有服務帳戶，驅動程式會失敗並結束，除非 Pod 命名空間中的預設服務帳戶具有所需許可。

此服務帳戶的預設名稱為 `emr-containers-sa-spark`。

下列規則適用於此服務角色：

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

# 使用服務帳戶的 IAM 角色 (IRSA) 來設定叢集存取許可
<a name="spark-operator-security-irsa"></a>

本節使用範例示範如何設定 Kubernetes 服務帳戶以擔任 AWS Identity and Access Management 角色。然後，使用服務帳戶的 Pod 可以存取角色有權存取的任何 AWS 服務。

下列範例會執行 Spark 應用程式，以計算 Amazon S3 中檔案的字數。為此，您可以設定服務帳戶的 IAM 角色 (IRSA)，以驗證和授權 Kubernetes 服務帳戶。

**注意**  
此範例將 "spark-operator" 命名空間用於 Spark Operator 以及您在其中提交 Spark 應用程式的命名空間。

## 先決條件
<a name="spark-operator-security-irsa-prereqs"></a>

嘗試此頁面的範例之前，請先完成下列先決條件：
+ [設定 Spark Operator]()。
+ [安裝 Spark Operator](spark-operator-gs.md#spark-operator-install).
+ [建立 Amazon S3 儲存貯體](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html)。
+ 將您最喜愛的詩歌儲存在名為 `poem.txt` 的文字檔案中，然後將檔案上傳到 S3 儲存貯體。在此頁面中建立的 Spark 應用程式將讀取文字檔案的內容。如需有關將檔案上傳到 S3 的詳細資訊，請參閱 *Amazon Simple Storage Service 使用者指南*中的[上傳物件至儲存貯體](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html)。

## 設定要擔任 IAM 角色的 Kubernetes 服務帳戶
<a name="spark-operator-security-irsa-config"></a>

使用下列步驟來設定 Kubernetes 服務帳戶，以擔任 IAM 角色，讓 Pod 可用來存取該角色有權存取 AWS 的服務。

1. 完成 後[先決條件](#spark-operator-security-irsa-prereqs)，請使用 AWS Command Line Interface 建立 `example-policy.json` 檔案，允許唯讀存取您上傳至 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. 然後，建立 IAM 政策 `example-policy`：

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

1. 接下來，建立 IAM 角色 `example-role`，並將其與 Spark 驅動程式的 Kubernetes 服務帳戶建立關聯：

   ```
   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. 使用 Spark 驅動程式服務帳戶所需的叢集角色連結來建立 yaml 檔案：

   ```
   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. 套用叢集角色連結組態：

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

kubectl 命令應該確認成功建立帳戶：

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

## 從 Spark Operator 中執行應用程式
<a name="spark-operator-security-irsa-run"></a>

[設定 Kubernetes 服務帳戶]()之後，可以執行 Spark 應用程式來計算作為 [先決條件](#spark-operator-security-irsa-prereqs) 的一部分上傳的文字檔案中的字數。

1. 根據 Amazon EMR 第 6 版`word-count.yaml`，使用文字計數應用程式`SparkApplication`的定義建立新的檔案 。

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

   如果您使用版本 7 的 spark Operator，請調整一些組態值：

   ```
   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. 提交 Spark 應用程式。

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

   kubectl 命令應該傳回您已成功建立名為 `word-count` 的 `SparkApplication` 物件的確認資訊。

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

1. 若要檢查 `SparkApplication` 物件的事件，請執行下列命令：

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

   kubectl 命令應傳回 `SparkApplication` 的描述和事件：

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

應用程式現在正在計算 S3 檔案中的單詞。要尋找字數，請參閱驅動程式的日誌檔案：

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

kubectl 命令應傳回日誌檔案的內容及字數統計應用程式的結果。

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

如需有關如何透過 Spark Operator 將應用程式提交至 Spark 的詳細資訊，請參閱 GitHub 上 *Kubernetes Operator for Apache Spark (spark-on-k8s-operator)* 文件中的[使用 SparkApplication](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/)。

# 使用 spark-submit 執行 Spark 作業
<a name="spark-submit"></a>

Amazon EMR 6.10.0 版及更高版本支援 `spark-submit` 作為命令列工具，可以使用它向 Amazon EMR on EKS 叢集提交 Spark 應用程式並執行。

**注意**  
Amazon EMR 會根據 vCPU 和記憶體使用量計算 Amazon EKS 定價。此計算適用於驅動程式和執行器 Pod。此計算從您下載 Amazon EMR 應用程式映像時開始，直到 Amazon EKS Pod 終止且四捨五入至最接近的秒數。

**Topics**
+ [為 Amazon EMR on EKS 設定 spark-submit](spark-submit-setup.md)
+ [開始針對 Amazon EMR on EKS 使用 spark-submit](spark-submit-gs.md)
+ [驗證 spark-submit 的 Spark 驅動程式服務帳戶安全需求](spark-submit-security.md)

# 為 Amazon EMR on EKS 設定 spark-submit
<a name="spark-submit-setup"></a>

完成下列任務進行設定，然後才能在 Amazon EMR on EKS 上使用 spark-submit 執行應用程式。如果已經註冊 Amazon Web Services (AWS) 且已在使用 Amazon EKS，則您幾乎可使用 Amazon EMR on EKS。如果已經完成任何先決條件，則可以跳過這些先決條件，然後繼續進行下一個。
+ **[安裝或更新至最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)**- 如果您已安裝 AWS CLI，請確認您擁有最新版本。
+ **[設定 kubectl 和 eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) ** – eksctl 是您用來與 Amazon EKS 通訊的命令列工具。
+ **[開始使用 Amazon EKS – eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) ** – 請依照步驟在 Amazon EKS 中建立具有節點的新 Kubernetes 叢集。
+ **[選擇 Amazon EMR 基礎映像 URI](docker-custom-images-tag.md) (6.10.0 版或更高版本)** - Amazon EMR 6.10.0 版及更高版本支援 `spark-submit` 命令。
+ 確認驅動程式服務帳戶具有建立和監控執行程式 Pod 的適當許可。如需詳細資訊，請參閱[驗證 spark-submit 的 Spark 驅動程式服務帳戶安全需求](spark-submit-security.md)。
+ 設定本機 [AWS 憑證設定檔](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html)。
+ 從 Amazon EKS 主控台中，選擇您的 EKS 叢集，然後尋找位於**概觀**、**詳細資訊**，以及 **API 伺服器端點下的 EKS 叢集端點**。

# 開始針對 Amazon EMR on EKS 使用 spark-submit
<a name="spark-submit-gs"></a>

Amazon EMR 6.10.0 及更高版本支援 spark-submit，可在 Amazon EKS 叢集上執行 Spark 應用程式。以下章節說明如何提交 Spark 應用程式的命令。

## 執行 Spark 應用程式
<a name="spark-submit-run"></a>

完成以下步驟，以執行 Spark 應用程式：

1. 在使用 `spark-submit` 命令執行 Spark 應用程式之前，請先完成 [為 Amazon EMR on EKS 設定 spark-submit](spark-submit-setup.md) 中的步驟。

1. 使用 Amazon EMR on EKS 基礎映像執行容器。如需詳細資訊[，請參閱如何選取基礎映像 URI](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html)。

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

1. 設定以下環境變數的值：

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

1. 現在，使用下列命令提交 Spark 應用程式：

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

如需有關將應用程式提交到 Spark 的詳細資訊，請參閱 Apache Spark 文件中的[提交應用程式](https://spark.apache.org/docs/latest/submitting-applications.html)。

**重要**  
`spark-submit` 僅支援叢集模式作為提交機制。

# 驗證 spark-submit 的 Spark 驅動程式服務帳戶安全需求
<a name="spark-submit-security"></a>

Spark 驅動程式 Pod 使用 Kubernetes 服務帳戶來存取 Kubernetes API 伺服器，以建立和監控執行程式 Pod。驅動程式服務帳戶必須具有適當的許可，才能列出、建立、編輯、修補及刪除叢集中的 Pod。透過執行以下命令，可確認您可列出這些資源：

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

執行每個命令，確認您具有必要的許可。

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

下列規則適用於此服務角色：

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

# 為 spark-submit 設定服務帳戶 (IRSA) 的 IAM 角色
<a name="spark-submit-security-irsa"></a>

下列各節說明如何為服務帳戶 (IRSA) 設定 IAM 角色來驗證和授權 Kubernetes 服務帳戶，以便您可以執行存放在 Amazon S3 中的 Spark 應用程式。

## 先決條件
<a name="spark-submit-security-irsa-prereqs"></a>

在嘗試本文件中的任何範例之前，請確定您已完成下列先決條件：
+ [已完成設定 spark-submit](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/spark-submit-setup.html)
+ [建立 S3 儲存貯](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html)體並[上傳](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) Spark 應用程式 jar

## 設定 Kubernetes 服務帳戶以擔任 IAM 角色
<a name="spark-submit-security-irsa-configure-kubernetes"></a>

下列步驟說明如何設定 Kubernetes 服務帳戶以擔任 AWS Identity and Access Management (IAM) 角色。將 Pod 設定為使用服務帳戶後，他們可以存取 AWS 服務 角色有權存取的任何 。

1. 建立政策檔案以允許唯讀存取您[上傳](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html)的 Amazon S3 物件：

   ```
   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. 建立 IAM 政策。

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

1. 建立 IAM 角色，並將其與 Spark 驅動程式的 Kubernetes 服務帳戶建立關聯

   ```
   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. 建立具有 Spark 驅動程式服務帳戶所需[許可](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/spark-submit-security.html)的 YAML 檔案：

   ```
   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. 套用叢集角色繫結組態。

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

1. `kubectl` 命令應該會傳回已建立帳戶的確認。

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

## 執行 Spark 應用程式
<a name="spark-submit-security-irsa-app-run"></a>

Amazon EMR 6.10.0 及更高版本支援 spark-submit，可在 Amazon EKS 叢集上執行 Spark 應用程式。完成以下步驟，以執行 Spark 應用程式：

1. 請確定您已完成[設定 Amazon EMR on EKS 的 spark-submit ](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/spark-submit-setup.html)中的步驟。

1. 設定以下環境變數的值：

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

1. 現在，使用下列命令提交 Spark 應用程式：

   ```
   $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. 在 Spark 驅動程式完成 Spark 任務後，您應該會在提交結束時看到日誌行，指出 Spark 任務已完成。

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

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

執行應用程式完成後，您可以使用下列命令執行清除。

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

# 搭配 Amazon EMR on EKS 使用 Apache Livy
<a name="job-runs-apache-livy"></a>

透過 Amazon EMR 7.1.0 版和更新版本，您可以使用 Apache Livy 在 Amazon EMR on EKS 上提交任務。使用 Apache Livy，您可以設定自己的 Apache Livy REST 端點，並使用它在 Amazon EKS 叢集上部署和管理 Spark 應用程式。在 Amazon EKS 叢集中安裝 Livy 之後，您可以使用 Livy 端點將 Spark 應用程式提交到您的 Livy 伺服器。伺服器會管理 Spark 應用程式的生命週期。

**注意**  
Amazon EMR 會根據 vCPU 和記憶體使用量計算 Amazon EKS 定價。此計算適用於驅動程式和執行器 Pod。此計算從您下載 Amazon EMR 應用程式映像時開始，直到 Amazon EKS Pod 終止且四捨五入至最接近的秒。

**Topics**
+ [為 Amazon EMR on EKS 設定 Apache Livy](job-runs-apache-livy-setup.md)
+ [Apache Livy on Amazon EMR on EKS 入門](job-runs-apache-livy-install.md)
+ [使用適用於 Amazon EMR on EKS 的 Apache Livy 執行 Spark 應用程式](job-runs-apache-livy-run-spark.md)
+ [使用 Amazon EMR on EKS 解除安裝 Apache Livy](job-runs-apache-livy-uninstall.md)
+ [Apache Livy 搭配 Amazon EMR on EKS 的安全性](job-runs-apache-livy-security.md)
+ [Amazon EMR on EKS 版本上 Apache Livy 的安裝屬性](job-runs-apache-livy-installation-properties.md)
+ [疑難排解常見的環境變數格式錯誤](job-runs-apache-livy-troubleshooting.md)

# 為 Amazon EMR on EKS 設定 Apache Livy
<a name="job-runs-apache-livy-setup"></a>

您必須先安裝和設定一組先決條件工具，才能在 Amazon EKS 叢集上安裝 Apache Livy。其中包括 AWS CLI，這是使用 AWS 資源的基本命令列工具、使用 Amazon EKS 的命令列工具，以及在此使用案例中使用的控制器，讓您的叢集應用程式可供網際網路使用，以及路由網路流量。
+ **[安裝或更新至最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)**- 如果您已安裝 AWS CLI，請確認您擁有最新版本。
+ **[設定 kubectl 和 eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) ** – eksctl 是您用來與 Amazon EKS 通訊的命令列工具。
+ **[安裝 Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)** – Kubernetes 的 Helm 套件管理工具可協助您安裝和管理 Kubernetes 叢集上的應用程式。
+ **[開始使用 Amazon EKS – eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) ** – 請依照步驟在 Amazon EKS 中建立具有節點的新 Kubernetes 叢集。
+ **[選取 Amazon EMR 發行標籤](docker-custom-images-tag.md)** – Amazon EMR 7.1.0 及更高版本支援 Apache Livy。
+ **[安裝 ALB 控制器](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html)** – ALB 控制器管理 Kubernetes 叢集的 AWS Elastic Load Balancing。當您在設定 Apache Livy 時建立 Kubernetes 輸入時，它會建立 AWS Network Load Balancer (NLB)。

# Apache Livy on Amazon EMR on EKS 入門
<a name="job-runs-apache-livy-install"></a>

完成下列步驟以安裝 Apache Livy。其中包括設定套件管理員、建立執行 Spark 工作負載的命名空間、安裝 Livy、設定負載平衡和驗證步驟。您必須完成這些步驟，才能使用 Spark 執行批次任務。

1. 如果您尚未設定 [Amazon EMR on EKS 的 Apache Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html)。

1. 向 Amazon ECR 登錄檔驗證 Helm 用戶端。您可以從 AWS 區域 [Amazon ECR 登錄帳戶依區域](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR)尋找 的對應`ECR-registry-account`值。

   ```
   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. 設定 Livy 會為 Livy 伺服器建立服務帳戶，並為 Spark 應用程式建立另一個帳戶。若要設定服務帳戶的 IRSA，請參閱[使用服務帳戶 (IRSA) 的 IAM 角色設定存取許可](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)。

1. 建立命名空間來執行 Spark 工作負載。

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

1. 使用下列命令來安裝 Livy。

   此 Livy 端點只能在內部供 EKS 叢集中的 VPC 使用。若要啟用 VPC 以外的存取，請在 Helm 安裝命令`—-set loadbalancer.internal=false`中設定 。
**注意**  
根據預設，在此 Livy 端點內不會啟用 SSL，而且端點僅在 EKS 叢集的 VPC 內可見。如果您設定 `loadbalancer.internal=false`和 `ssl.enabled=false`，則會將不安全的端點公開到 VPC 外部。若要設定安全 Livy 端點，請參閱[使用 TLS/SSL 設定安全 Apache Livy 端點](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html)。

   ```
   helm install livy-demo \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-ns \
     --set image=ECR-registry-account.dkr.ecr.region-id.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=<spark-ns> \
     --create-namespace
   ```

   您應該會看到下列輸出。

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

   Livy 伺服器和 Spark 工作階段的預設服務帳戶名稱為 `emr-containers-sa-livy`和 `emr-containers-sa-spark-livy`。若要使用自訂名稱，請使用 `serviceAccounts.name`和 `sparkServiceAccount.name` 參數。

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

1. 確認您已安裝 Helm Chart。

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

   `helm list` 命令應會傳回新 Helm Chart 的相關資訊。

   ```
   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. 確認 Network Load Balancer 處於作用中狀態。

   ```
   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. 現在驗證 Network Load Balancer 中的目標群組是否正常運作。

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

   以下是顯示目標群組狀態的範例輸出：

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

   一旦 NLB 狀態變為 `active` 且目標群組為 `healthy`，您就可以繼續。可能需要幾分鐘的時間。

1. 從 Helm 安裝擷取 Livy 端點。您的 Livy 端點是否安全取決於您是否啟用 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. 從 Helm 安裝擷取 Spark 服務帳戶

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

   您應該會看到類似下列的輸出內容：

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

1. 如果您`internalALB=true`將 設定為從 VPC 外部啟用存取，請建立 Amazon EC2 執行個體，並確保 Network Load Balancer 允許來自 EC2 執行個體的網路流量。您必須這樣做，執行個體才能存取您的 Livy 端點。如需在 VPC 外部安全地公開端點的詳細資訊，請參閱[使用 TLS/SSL 設定安全的 Apache Livy 端點](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html)。

1. 安裝 Livy 會建立服務帳戶`emr-containers-sa-spark`以執行 Spark 應用程式。如果您的 Spark 應用程式使用任何 AWS 資源，例如 S3 或呼叫 AWS API 或 CLI 操作，您必須將具有必要許可的 IAM 角色連結至您的 Spark 服務帳戶。如需詳細資訊，請參閱[使用服務帳戶 (IRSA) 的 IAM 角色設定存取許可。](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)

Apache Livy 支援您可以在安裝 Livy 時使用的其他組態。如需詳細資訊，請參閱 Amazon EMR on EKS 版本上 Apache Livy 的安裝屬性。

# 使用適用於 Amazon EMR on EKS 的 Apache Livy 執行 Spark 應用程式
<a name="job-runs-apache-livy-run-spark"></a>

在使用 Apache Livy 執行 Spark 應用程式之前，請確定您已完成設定適用於 [Amazon EMR on EKS 的 Apache Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) 和[適用於 Amazon EMR on EKS 的 Apache Livy 入門](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html)中的步驟。

您可以使用 Apache Livy 來執行兩種類型的應用程式：
+ 批次工作階段 – 一種 Livy 工作負載，用於提交 Spark 批次任務。
+ 互動式工作階段 – 一種 Livy 工作負載，提供程式設計和視覺化界面來執行 Spark 查詢。

**注意**  
來自不同工作階段的驅動程式和執行器 Pod 可以互相通訊。命名空間不保證 Pod 之間的任何安全性。Kubernetes 不允許特定命名空間內 Pod 子集的選擇性許可。

## 執行批次工作階段
<a name="job-runs-apache-livy-run-spark-batch"></a>

若要提交批次任務，請使用下列命令。

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

若要監控您的批次任務，請使用下列命令。

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

## 執行互動式工作階段
<a name="job-runs-apache-livy-run-spark-interactive"></a>

若要使用 Apache Livy 執行互動式工作階段，請參閱下列步驟。

1. 請確定您能夠存取自我託管或受管 Jupyter 筆記本，例如 SageMaker AI Jupyter 筆記本。您的 jupyter 筆記本必須已安裝 [Sparkmagic](https://github.com/jupyter-incubator/sparkmagic/blob/master/README.md)。

1. 建立 Spark 組態 的儲存貯體`spark.kubernetes.file.upload.path`。確定 Spark 服務帳戶具有對儲存貯體的讀取和寫入存取權。如需如何設定 Spark 服務帳戶的詳細資訊，請參閱使用服務帳戶 (IRSA) 的 IAM 角色設定存取許可

1. 使用命令 在 Jupyter 筆記本中載入 Sparkmagic`%load_ext sparkmagic.magics`。

1. 執行 命令`%manage_spark`，使用 Jupyter 筆記本設定您的 Livy 端點。選擇**新增端點**索引標籤，選擇設定的身分驗證類型，將 Livy 端點新增至筆記本，然後選擇**新增端點**。

1. `%manage_spark` 再次執行 以建立 Spark 內容，然後前往**建立工作階段**。選擇 Livy 端點，指定唯一的工作階段名稱選擇語言，然後新增下列屬性。

   ```
   {
     "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. 提交應用程式並等待它建立 Spark 內容。

1. 若要監控互動式工作階段的狀態，請執行下列命令。

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

## 監控 Spark 應用程式
<a name="job-runs-apache-livy-run-ui"></a>

若要使用 Livy UI 監控 Spark 應用程式的進度，請使用連結 `http://<livy-endpoint>/ui`。

# 使用 Amazon EMR on EKS 解除安裝 Apache Livy
<a name="job-runs-apache-livy-uninstall"></a>

請依照下列步驟解除安裝 Apache Livy。

1. 使用命名空間名稱和應用程式名稱刪除 Livy 設定。在此範例中，應用程式名稱為 `livy-demo`，命名空間為 `livy-ns`。

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

1. 解除安裝時，Amazon EMR on EKS 會刪除 Livy 中的 Kubernetes 服務、 AWS 負載平衡器，以及您在安裝期間建立的目標群組。刪除資源可能需要幾分鐘的時間。再次在命名空間上安裝 Livy 之前，請確定已刪除資源。

1. 刪除 Spark 命名空間。

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

# Apache Livy 搭配 Amazon EMR on EKS 的安全性
<a name="job-runs-apache-livy-security"></a>

請參閱下列主題，進一步了解如何使用 Amazon EMR on EKS 設定 Apache Livy 的安全性。這些選項包括使用傳輸層安全性、角色型存取控制，這是根據個人在組織內的角色進行存取，以及使用 IAM 角色，根據授予的許可提供對資源的存取。

**Topics**
+ [使用 TLS/SSL 設定安全的 Apache Livy 端點](job-runs-apache-livy-secure-endpoint.md)
+ [使用角色型存取控制 (RBAC) 設定 Apache Livy 和 Spark 應用程式許可](job-runs-apache-livy-rbac.md)
+ [使用服務帳戶的 IAM 角色設定存取許可 (IRSA)](job-runs-apache-livy-irsa.md)

# 使用 TLS/SSL 設定安全的 Apache Livy 端點
<a name="job-runs-apache-livy-secure-endpoint"></a>

請參閱下列各節，進一步了解如何使用end-to-end TLS 和 SSL 加密為 Amazon EMR on EKS 設定 Apache Livy。

## 設定 TLS 和 SSL 加密
<a name="job-runs-apache-livy-security-tls"></a>

若要在 Apache Livy 端點上設定 SSL 加密，請遵循下列步驟。
+ [安裝 Secrets Store CSI 驅動程式和 AWS Secrets and Configuration Provider (ASCP)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_csi_driver.html) – Secrets Store CSI Driver 和 ASCP 安全地存放 Livy 伺服器裝置啟用 SSL 所需的 Livy 的 JKS 憑證和密碼。您也可以僅安裝 Secrets Store CSI Driver，並使用任何其他支援的秘密提供者。
+ [建立 ACM 憑證](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html) – 需要此憑證才能保護用戶端與 ALB 端點之間的連線。
+ 為 - 設定 JKS 憑證、金鑰密碼和金鑰存放區密碼 AWS Secrets Manager ，以保護 ALB 端點與 Livy 伺服器之間的連線。
+ 將許可新增至 Livy 服務帳戶以從中擷取秘密 AWS Secrets Manager – Livy 伺服器需要這些許可才能從 ASCP 擷取秘密，並新增 Livy 組態以保護 Livy 伺服器。若要將 IAM 許可新增至服務帳戶，請參閱使用服務帳戶 (IRSA) 的 IAM 角色設定存取許可。

### 使用 的金鑰和金鑰存放區密碼設定 JKS 憑證 AWS Secrets Manager
<a name="job-runs-apache-livy-jks-certificate"></a>

請依照下列步驟，使用金鑰和金鑰存放區密碼來設定 JKS 憑證。

1. 產生 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. 建立憑證。

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

1. 建立信任存放區檔案。

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

1. 將 JKS 憑證儲存在其中 AWS Secrets Manager。將 取代`livy-jks-secret`為您的秘密，並將 `fileb://mykeystore.jks` 取代為金鑰存放區 JKS 憑證的路徑。

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

1. 在 Secrets Manager 中儲存金鑰存放區和金鑰密碼。請務必使用您自己的參數。

   ```
   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. 使用下列命令建立 Livy 伺服器命名空間。

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

1. 為具有 JKS 憑證和密碼的 Livy 伺服器建立 `ServiceProviderClass` 物件。

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

## 啟用 SSL 的 Apache Livy 入門
<a name="job-runs-apache-livy-ssl-enabled-getting-started"></a>

在 Livy 伺服器上啟用 SSL 之後，您必須設定 `serviceAccount` 才能存取 `keyStore`和 `keyPasswords`秘密 AWS Secrets Manager。

1. 建立 Livy 伺服器命名空間。

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

1. 設定 Livy 服務帳戶以存取 Secrets Manager 中的秘密。如需設定 IRSA 的詳細資訊，請參閱在[安裝 Apache Livy 時設定 IRSA](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html#job-runs-apache-livy-irsa)。

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

1. 安裝 Livy。對於 Helm Chart --version 參數，請使用您的 Amazon EMR 發行標籤，例如 `7.1.0`。您也必須將 Amazon ECR 登錄帳戶 ID 和區域 ID 取代為您自己的 IDs。您可以從 AWS 區域 [Amazon ECR 登錄帳戶依區域](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR)尋找 的對應`ECR-registry-account`值。

   ```
   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. 從[在 Amazon EMR on EKS 上安裝 Apache Livy 的步驟 ](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html#job-runs-apache-livy-install)5 繼續。

# 使用角色型存取控制 (RBAC) 設定 Apache Livy 和 Spark 應用程式許可
<a name="job-runs-apache-livy-rbac"></a>

若要部署 Livy，Amazon EMR on EKS 會建立伺服器服務帳戶和角色，以及 Spark 服務帳戶和角色。這些角色必須具備必要的 RBAC 許可，才能完成設定並執行 Spark 應用程式。

**伺服器服務帳戶和角色的 RBAC 許可**

Amazon EMR on EKS 會建立 Livy 伺服器服務帳戶和角色，以管理 Spark 任務的 Livy 工作階段，以及將流量路由到輸入和其他資源或從中路由。

此服務帳戶的預設名稱為 `emr-containers-sa-livy`。它必須具有下列許可。

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

**Spark 服務帳戶和角色的 RBAC 許可**

Spark 驅動程式 Pod 需要與該 Pod 位於相同命名空間的 Kubernetes 服務帳戶。此服務帳戶需要管理執行器 Pod 和驅動程式 Pod 所需任何資源的許可。除非命名空間中的預設服務帳戶具有必要的許可，否則驅動程式會失敗並結束。需要下列 RBAC 許可。

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

# 使用服務帳戶的 IAM 角色設定存取許可 (IRSA)
<a name="job-runs-apache-livy-irsa"></a>

根據預設，Livy 伺服器和 Spark 應用程式的驅動程式和執行程式無法存取 AWS 資源。伺服器服務帳戶和 Spark 服務帳戶控制對 Livy 伺服器和 Spark 應用程式 Pod AWS 資源的存取。若要授予存取權，您需要將服務帳戶對應至具有必要 AWS 許可的 IAM 角色。

您可以在安裝 Apache Livy 之前、安裝期間或完成安裝之後設定 IRSA 映射。

## 在安裝 Apache Livy 時設定 IRSA （適用於伺服器服務帳戶）
<a name="job-runs-apache-livy-irsa"></a>

**注意**  
只有伺服器服務帳戶才支援此映射。

1. 請確定您已完成[為 Amazon EMR on EKS 設定 Apache Livy，](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html)並且正在[搭配 Amazon EMR on EKS 安裝 Apache Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html)。

1. 為 Livy 伺服器建立 Kubernetes 命名空間。在此範例中，命名空間的名稱為 `livy-ns`。

1. 建立 IAM 政策，其中包含您希望 Pod 存取 AWS 服務 的 許可。下列範例會建立 IAM 政策，以取得 Spark 進入點的 Amazon S3 資源。

   ```
   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. 使用下列命令將您的 AWS 帳戶 ID 設定為變數。

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

1. 將叢集的 OpenID Connect (OIDC) 身分提供者設定為 環境變數。

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

1. 設定命名空間和服務帳戶名稱的變數。請務必使用您自己的值。

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

1. 使用下列命令建立信任政策檔案。如果您想要將角色的存取權授予命名空間中的所有服務帳戶，請複製下列命令，並將 取代`StringEquals`為 `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. 建立角色。

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

1. 使用下列 Helm 安裝命令來設定 `serviceAccount.executionRoleArn`以對應 IRSA。以下是 Helm 安裝命令的範例。您可以從 AWS 區域 [Amazon ECR 登錄帳戶依區域](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR)尋找 的對應`ECR-registry-account`值。

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

## 將 IRSA 映射至 Spark 服務帳戶
<a name="job-runs-apache-livy-irsa-spark"></a>

將 IRSA 映射至 Spark 服務帳戶之前，請確定您已完成下列項目：
+ 請確定您已完成[為 Amazon EMR on EKS 設定 Apache Livy，](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html)並且正在[搭配 Amazon EMR on EKS 安裝 Apache Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html)。
+ 您必須為叢集擁有現有的 IAM OpenID Connect (OIDC) 提供者。若要查看您是否已經擁有或如何建立，請參閱[為您的叢集建立 IAM OIDC 提供者](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html)。
+ 請確定您已安裝 或 的 `eksctl` CLI 版本 0.171.0 或更新版本 AWS CloudShell。若要安裝或更新 `eksctl`，請參閱[安裝](https://eksctl.io/installation/) `eksctl` 文件。

請依照下列步驟將 IRSA 映射到您的 Spark 服務帳戶：

1. 使用下列命令來取得 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. 為服務帳戶的命名空間和名稱設定變數。

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

1. 使用下列命令為 IAM 角色建立信任政策檔案。下列範例會授予 命名空間內所有服務帳戶的許可，以使用 角色。若要這樣做，請將 取代`StringEquals`為 `StringLike`，並將 取代`$service_account`為 \$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. 建立角色。

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

1. 使用下列`eksctl`命令對應伺服器或 Spark 服務帳戶。請務必使用您自己的值。

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

# Amazon EMR on EKS 版本上 Apache Livy 的安裝屬性
<a name="job-runs-apache-livy-installation-properties"></a>

Apache Livy 安裝可讓您選取 Livy Helm Chart 的版本。Helm Chart 提供各種屬性，可自訂您的安裝和設定體驗。Amazon EMR on EKS 7.1.0 版及更新版本支援這些屬性。

**Topics**
+ [Amazon EMR 7.1.0 安裝屬性](#job-runs-apache-livy-installation-properties-710)

## Amazon EMR 7.1.0 安裝屬性
<a name="job-runs-apache-livy-installation-properties-710"></a>

下表說明所有支援的 Livy 屬性。安裝 Apache Livy 時，您可以選擇 Livy Helm Chart 版本。若要在安裝期間設定屬性，請使用命令 `--set <property>=<value>`。


| 屬性 | 描述 | 預設 | 
| --- | --- | --- | 
| image | Livy 伺服器的 Amazon EMR 版本 URI。這是必要的組態。 | "" | 
| sparkNamespace | 執行 Livy Spark 工作階段的命名空間。例如，指定「livy」。這是必要的組態。 | "" | 
| nameOverride | 提供名稱而非 livy。名稱會設定為所有 Livy 資源的標籤 | "livy" | 
| fullnameOverride | 提供要使用的名稱，而非資源的完整名稱。 | "" | 
| ssl.enabled | 啟用從 Livy 端點到 Livy 伺服器的end-to-end SSL。 | FALSE | 
| ssl.certificateArn | 如果啟用 SSL，這是服務所建立 NLB 的 ACM 憑證 ARN。 | "" | 
| ssl.secretProviderClassName | 如果啟用 SSL，這是使用 SSL 保護 Livy 伺服器連線 NLB 的秘密提供者類別名稱。 | "" | 
| ssl.keyStoreObjectName | 如果啟用 SSL，則秘密提供者類別中金鑰存放區憑證的物件名稱。 | "" | 
| ssl.keyPasswordsObjectName | 如果已啟用 SSL，則具有金鑰存放區和金鑰密碼之秘密的物件名稱。 | "" | 
| rbac.create | 如果為 true， 會建立 RBAC 資源。 | FALSE | 
| serviceAccount.create | 如果為 true， 會建立 Livy 服務帳戶。 | TRUE | 
| serviceAccount.name | 用於 Livy 的服務帳戶名稱。如果您未設定此屬性並建立服務帳戶，Amazon EMR on EKS 會使用fullname覆寫屬性自動產生名稱。 | 「emr-containers-sa-livy」 | 
| serviceAccount.executionRoleArn | Livy 服務帳戶的執行角色 ARN。 | "" | 
| sparkServiceAccount.create | 如果為 true， 會在 中建立 Spark 服務帳戶 .Release.Namespace | TRUE | 
| sparkServiceAccount.name | 用於 Spark 的服務帳戶名稱。如果您未設定此屬性並建立 Spark 服務帳戶，Amazon EMR on EKS -spark-livy 會自動產生帶有尾碼fullnameOverride屬性的名稱。 | 「emr-containers-sa-spark-livy」 | 
| service.name | Livy 服務的名稱 | "emr-containers-livy" | 
| service.annotations | Livy 服務註釋 | \$1\$1 | 
| loadbalancer.enabled | 是否要為用於在 Amazon EKS 叢集外部公開 Livy 端點的 Livy 服務建立負載平衡器。 | FALSE | 
| loadbalancer.internal | 是否要將 Livy 端點設定為 VPC 內部或外部。 將此屬性設定為向 VPC 外部的來源`FALSE`公開端點。我們建議您使用 TLS/SSL 保護您的端點。如需詳細資訊，請參閱[設定 TLS 和 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 | 用於從私有儲存庫提取 Livy 映像imagePullSecret的名稱清單。 | [] | 
| resources | Livy 容器的資源請求和限制。 | \$1\$1 | 
| nodeSelector | 排程 Livy Pod 的節點。 | \$1\$1 | 
| 容差 | 包含要定義的 Livy Pod 容錯的清單。 | [] | 
| 親和性 | Livy Pod 親和性規則。 | \$1\$1 | 
| persistence.enabled | 如果為 true， 會啟用工作階段目錄的持久性。 | FALSE | 
| persistence.subPath | 掛載至工作階段目錄的 PVC 子路徑。 | "" | 
| persistence.existingClaim | 要使用的 PVC，而不是建立新的 PVC。 | \$1\$1 | 
| persistence.storageClass | 要使用的儲存體方案。若要定義此參數，請使用格式 storageClassName: <storageClass>。將此參數設定為 會"-"停用動態佈建。如果您將此參數設定為 null 或未指定任何項目，Amazon EMR on EKS 不會設定 storageClassName 並使用預設佈建器。 | "" | 
| persistence.accessMode | PVC 存取模式。 | ReadWriteOnce | 
| persistence.size | PVC 大小。 | 20Gi | 
| persistence.annotations | PVC 的其他註釋。 | \$1\$1 | 
| env.\$1 | 要設定為 Livy 容器的其他 env。如需詳細資訊，請參閱在[安裝 Livy 時輸入您自己的 Livy 和 Spark 組態](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-troubleshooting.html)。 | \$1\$1 | 
| envFrom.\$1 | 從 Kubernetes 組態映射或秘密設定為 Livy 的其他 env。 | [] | 
| livyConf.\$1 | 從掛載的 Kubernetes 組態映射或秘密設定的其他 livy.conf 項目。 | \$1\$1 | 
| sparkDefaultsConf.\$1 | 從掛載的 Kubernetes 組態映射或秘密設定的其他spark-defaults.conf項目。 | \$1\$1 | 

# 疑難排解常見的環境變數格式錯誤
<a name="job-runs-apache-livy-troubleshooting"></a>

當您輸入 Livy 和 Spark 組態時，不支援環境變數格式，並可能導致錯誤。此程序會引導您完成一系列步驟，以協助確保您使用正確的格式。

**在安裝 Livy 時輸入您自己的 Livy 和 Spark 組態**

您可以使用 `env.*` Helm 屬性設定任何 Apache Livy 或 Apache Spark 環境變數。請依照下列步驟，將範例組態轉換為`example.config.with-dash.withUppercase`支援的環境變數格式。

1. 使用 1 和小寫字母取代大寫字母。例如，`example.config.with-dash.withUppercase` 會變成 `example.config.with-dash.with1uppercase`。

1. 將破折號 (-) 取代為 0。例如， `example.config.with-dash.with1uppercase`會變成 `example.config.with0dash.with1uppercase`

1. 以底線 (\$1) 取代點 (.)。例如，`example.config.with0dash.with1uppercase` 會變成 `example_config_with0dash_with1uppercase`。

1. 以大寫字母取代所有小寫字母。

1. 將 字首`LIVY_`新增至變數名稱。

1. 使用格式 --set env.*YOUR\$1VARIABLE\$1NAME*.value=*yourvalue* 透過 Helm Chart 安裝 Livy 時，請使用 變數

例如，若要設定 Livy 和 Spark 組態 `livy.server.recovery.state-store = filesystem` 和 `spark.kubernetes.executor.podNamePrefix = my-prefix`，請使用下列 Helm 屬性：

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

# 管理 Amazon EMR on EKS 作業執行
<a name="emr-eks-jobs-manage"></a>

以下各章節涵蓋可協助您管理 Amazon EMR on EKS 作業執行的主題。這包括在使用 時設定任務執行參數 AWS CLI、設定日誌資料的儲存方式、執行 Spark SQL 指令碼來執行查詢、了解任務執行狀態，以及了解如何監控任務。如果您想要設定並完成任務執行來處理資料，通常可以依序處理這些主題。

**Topics**
+ [使用 管理任務執行 AWS CLI](emr-eks-jobs-CLI.md)
+ [透過 StartJobRun API 執行 Spark SQL 指令碼](emr-eks-jobs-spark-sql-parameters.md)
+ [作業執行狀態](emr-eks-jobs-states.md)
+ [在 Amazon EMR 主控台中檢視作業](emr-eks-jobs-console.md)
+ [執行作業時的常見錯誤](emr-eks-jobs-error.md)

# 使用 管理任務執行 AWS CLI
<a name="emr-eks-jobs-CLI"></a>

本主題說明如何使用 AWS Command Line Interface () 管理任務執行AWS CLI。它詳細介紹了屬性，例如安全參數、驅動程式和各種覆寫設定。它還包含子主題，涵蓋各種設定記錄的方式。

**Topics**
+ [用於設定作業執行的選項](#emr-eks-jobs-parameters)
+ [設定作業執行以使用 Amazon S3 日誌](emr-eks-jobs-s3.md)
+ [設定作業執行以使用 Amazon CloudWatch Logs](emr-eks-jobs-cloudwatch.md)
+ [停止作業執行](#emr-eks-jobs-list)
+ [描述作業執行](#emr-eks-jobs-describe)
+ [取消作業執行](#emr-eks-jobs-cancel)

## 用於設定作業執行的選項
<a name="emr-eks-jobs-parameters"></a>

使用下列選項來設定作業執行參數：
+ `--execution-role-arn`：必須提供用於執行作業的 IAM 角色。如需詳細資訊，請參閱[搭配使用作業執行角色與 Amazon EMR on EKS](iam-execution-role.md)。
+ `--release-label`：可以使用 Amazon EMR 5.32.0 和 6.2.0 及更高版本來部署 Amazon EMR on EKS。舊版 Amazon EMR 不支援 Amazon EMR on EKS。如需詳細資訊，請參閱[Amazon EMR on EKS 發行版本](emr-eks-releases.md)。
+ `--job-driver`：作業驅動程式用於提供主要作業的輸入。這是一個聯合類型欄位，只能在其中傳遞您要執行之作業類型的其中一個值。支援的作業類型包括：
  + Spark 提交作業 - 用於透過 Spark 提交來執行命令。可以使用此作業類型，透過 Spark Submit 來執行 Scala、PySpark、SparkR、SparkSQL 以及其他支援的作業。此作業類型具有下列參數：
    + Entrypoint - 這是對您要執行的主要 jar/py 檔案的 HCFS (Hadoop 相容檔案系統) 參考。
    + EntryPointArguments - 這是您要傳遞給主要 jar/py 檔案的引數陣列。應使用 entrypoint 程式碼讀取這些參數。陣列中的每個引數應該以逗號分隔。EntryPointArguments 不能包含括號或圓括號，例如 ()、\$1\$1 或 []。
    + SparkSubmitParameters - 這些是您要傳送到作業的其他 spark 參數。使用此參數可覆寫預設 Spark 屬性，例如驅動程式記憶體或 -conf 或 -class 等執行程式的數量。如需其他資訊，請參閱透過 [spark-submit 啟動應用程式](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit)。
  + Spark SQL 作業 - 用於透過 Spark SQL 執行 SQL 查詢檔案。可以使用此作業類型來執行 SparkSQL 作業。此作業類型具有下列參數：
    + Entrypoint - 這是對您要執行的 SQL 查詢檔案的 HCFS (Hadoop 相容檔案系統) 參考。

      如需可用於 Spark SQL 作業的其他 Spark 參數清單，請參閱 [透過 StartJobRun API 執行 Spark SQL 指令碼](emr-eks-jobs-spark-sql-parameters.md)。
+ `--configuration-overrides`：可以透過提供組態物件來覆寫應用程式的預設組態。您可以使用速記語法，以提供組態或參考 JSON 檔案中物件的組態。組態物件是由分類、屬性和選用的巢狀組態所組成。屬性由您想要在檔案中覆寫的設定組成。您可以在單一 JSON 物件中，為多個應用程式指定多個分類。可用的組態分類隨 Amazon EMR 發行版本而有所不同。如需每個 Amazon EMR 發行版本可用的組態分類清單，請參閱 [Amazon EMR on EKS 發行版本](emr-eks-releases.md)。

  如果在應用程式中覆寫和 Spark 提交參數中傳遞相同的組態，會優先採用 Spark 提交參數。完整的組態優先順序清單如下，以最高優先順序到最低優先順序排列。
  + 建立 `SparkSession` 時提供的組態。
  + 使用 `—conf`，作為 `sparkSubmitParameters` 的一部分提供的組態。
  + 作為應用程式覆寫的一部分提供的組態。
  + 由 Amazon EMR 針對發行版本選擇的優化組態。
  + 應用程式的預設開放原始碼組態。

  若要使用 Amazon CloudWatch 或 Amazon S3 監控作業執行，必須提供 CloudWatch 的組態詳細資訊。如需詳細資訊，請參閱[設定作業執行以使用 Amazon S3 日誌](emr-eks-jobs-s3.md)及[設定作業執行以使用 Amazon CloudWatch Logs](emr-eks-jobs-cloudwatch.md)。如果 S3 儲存貯體或 CloudWatch 日誌群組不存在，則 Amazon EMR 會在將日誌上傳到儲存貯體之前先建立。
+ 如需 Kubernetes 組態選項的其他清單，請參閱 [Kubernetes 上的 Spark 屬性](https://spark.apache.org/docs/latest/running-on-kubernetes.html#configuration)。

  不支援以下 Spark 組態。
  + `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`
**注意**  
可以將 `spark.kubernetes.container.image` 用於自訂 Docker 映像檔。如需詳細資訊，請參閱[自訂 Amazon EMR on EKS 的 Docker 映像檔](docker-custom-images.md)。

# 設定作業執行以使用 Amazon S3 日誌
<a name="emr-eks-jobs-s3"></a>

為了能夠監控作業進度並對失敗進行疑難排解，必須設定作業，以便將日誌資訊傳送到 Amazon S3、Amazon CloudWatch Logs 或兩者。本主題可協助您開始在透過 Amazon EMR on EKS 啟動的作業上將應用程式日誌發布到 Amazon S3。

**S3 日誌 IAM 政策**

在您的作業可以傳送日誌資料到 Amazon S3 之前，必須在作業執行角色的許可政策中包含下列許可。將 *amzn-s3-demo-logging-bucket* 取代為您的記錄儲存貯體名稱。

------
#### [ 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"
    }
  ]
}
```

------

**注意**  
Amazon EMR on EKS 也可以建立 Amazon S3 儲存貯體。如果無法使用 Amazon S3 儲存貯體，請在 IAM 政策中包含 `“s3:CreateBucket”` 許可。

在授予執行角色適當許可以便將日誌傳送到 Amazon S3 之後，當在 `start-job-run` 請求的 `monitoringConfiguration` 區段中傳遞 `s3MonitoringConfiguration` 時，會將日誌資料傳送到以下 Amazon S3 位置，如 [使用 管理任務執行 AWS CLI](emr-eks-jobs-CLI.md) 中所示。
+ 提交者日誌 - /*logUri*/*virtual-cluster-id*/jobs/*job-id*/containers/*pod-name*/(stderr.gz/stdout.gz)
+ 驅動程式日誌 - /*logUri*/*virtual-cluster-id*/jobs/*job-id*/containers/*spark-application-id*/spark-*job-id*-driver/(stderr.gz/stdout.gz)
+ 執行程式日誌 - /*logUri*/*virtual-cluster-id*/jobs/*job-id*/containers/*spark-application-id*/*executor-pod-name*/(stderr.gz/stdout.gz)

# 設定作業執行以使用 Amazon CloudWatch Logs
<a name="emr-eks-jobs-cloudwatch"></a>

若要監控作業進度並對失敗進行疑難排解，必須設定作業，以便將日誌資訊傳送到 Amazon S3、Amazon CloudWatch Logs 或兩者。本主題可協助您開始在透過 Amazon EMR on EKS 啟動的作業上使用 CloudWatch Logs。如需有關 CloudWatch Logs 的詳細資訊，請參閱《Amazon CloudWatch 使用者指南》中的[監控日誌檔案](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatchLogs.html)。

**CloudWatch Logs IAM 政策**

為了讓作業將日誌資料傳送到 CloudWatch Logs，必須在作業執行角色的許可政策中包含下列許可。將 *my\$1log\$1group\$1name* 和 *my\$1log\$1stream\$1prefix* 分別取代為 CloudWatch 日誌群組名稱和日誌串流名稱。如果日誌群組和日誌串流不存在，只要執行角色 ARN 具有適當的許可，Amazon EMR 就會建立它們。

------
#### [ 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"
    }
  ]
}
```

------

**注意**  
Amazon EMR on EKS 也可以建立日誌串流。如果日誌串流不存在，IAM 政策應包含 `"logs:CreateLogGroup"` 許可。

在為執行角色提供適當的許可之後，當在 `start-job-run` 請求的 `monitoringConfiguration` 區段中傳遞 `cloudWatchMonitoringConfiguration` 時，應用程式會將其日誌資料傳送至 CloudWatch Logs，如 [使用 管理任務執行 AWS CLI](emr-eks-jobs-CLI.md) 中所示。

在 `StartJobRun` API 中，*log\$1group\$1name* 是 CloudWatch 的日誌群組名稱，而 *log\$1stream\$1prefix* 是 CloudWatch 的日誌串流名稱字首。您可以在 AWS 管理主控台中檢視及搜尋這些日誌。
+ 提交者日誌 - *logGroup*/*logStreamPrefix*/*virtual-cluster-id*/jobs/*job-id*/containers/*pod-name*/(stderr/stdout)
+ 驅動程式日誌 - *logGroup*/*logStreamPrefix*/*virtual-cluster-id*/jobs/*job-id*/containers/*spark-application-id*/spark-*job-id*-driver/(stderrstdout)
+ 執行程式日誌 - *logGroup*/*logStreamPrefix*/*virtual-cluster-id*/jobs/*job-id*/containers/*spark-application-id*/*executor-pod-name*/(stderr/stdout)

## 停止作業執行
<a name="emr-eks-jobs-list"></a>

可以執行 `list-job-run` 以顯示作業執行的狀態，如下列範例所示。

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

## 描述作業執行
<a name="emr-eks-jobs-describe"></a>

可以執行 `describe-job-run` 以取得有關作業的詳細資訊，例如作業狀態、狀態詳細資料和作業名稱，如下列範例所示。

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

## 取消作業執行
<a name="emr-eks-jobs-cancel"></a>

可以執行 `cancel-job-run` 以取消執行中的作業，如下列範例所示。

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

# 透過 StartJobRun API 執行 Spark SQL 指令碼
<a name="emr-eks-jobs-spark-sql-parameters"></a>

Amazon EMR on EKS 6.7.0 版及更高版本包含 Spark SQL 作業驅動程式，以便可以透過 `StartJobRun` API 來執行 Spark SQL 指令碼。您可以提供 SQL 進入點檔案，以使用 `StartJobRun` API 在 Amazon EMR on EKS 上執行 Spark SQL 查詢，而無需對現有的 Spark SQL 指令碼進行任何修改。下表列出了 Spark SQL 作業透過 StartJobRun API 支援的 Spark 參數。

可以從下面的 Spark 參數中選擇，以傳送到 Spark SQL 作業。使用這些參數來覆寫預設的 Spark 屬性。


| 選項 | Description | 
| --- | --- | 
|  --name NAME  | Application Name (應用程式名稱) | 
| --jars JARS | 驅動程式和執行程式 classpath 隨附的以逗號分隔的 jar 清單。 | 
| --packages | 驅動程式和執行程式 classpath 中包含以逗號分隔的 jar 的 maven 座標清單。 | 
| --exclude-packages | 以逗號分隔的 groupId:artifactId 清單，在解決 –packages 中提供的相依性時排除，以避免相依性衝突。 | 
| --repositories | 以逗號分隔的其他遠端儲存庫清單，用於搜尋 –packages 提供的 maven 座標。 | 
| --files FILES | 要放置在每個執行程式的工作目錄中的以逗號分隔的檔案清單。 | 
| --conf PROP=VALUE | Spark 組態屬性。 | 
| --properties-file FILE | 要從中載入額外屬性的檔案路徑。 | 
| --driver-memory MEM | 驅動程式的記憶體。預設值為 1024MB。 | 
| --driver-java-options | 用於傳遞給驅動程式的額外 Java 選項。 | 
| --driver-library-path | 用於傳遞給驅動程式的額外程式庫路徑條目。 | 
| --driver-class-path | 用於傳遞給驅動程式的額外 classpath 條目。 | 
| --executor-memory MEM | 每個執行程式的記憶體。預設值為 1 GB。 | 
| --driver-cores NUM | 驅動程式使用的核心數目。 | 
| --total-executor-cores NUM | 所有執行程式的核心總數。 | 
| --executor-cores NUM | 每個執行程式使用的核心數量。 | 
| --num-executors NUM | 要啟動的執行程式數量。 | 
| -hivevar <key=value> | 套用於 Hive 命令的變數替換，例如，-hivevar A=B | 
| -hiveconf <property=value> | 用於指定屬性的值。 | 

若為 Spark SQL 作業，請建立 start-job-run-request.json 檔案，並指定作業執行所需的參數，如下列範例所示：

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

# 作業執行狀態
<a name="emr-eks-jobs-states"></a>

將作業執行提交到 Amazon EMR on EKS 作業佇列時，作業執行會進入 `PENDING` 狀態。工作將經過以下狀態，直到其失敗 (以 `0` 代碼結束) 或失敗 (以與非零代碼結束) 為止。

作業執行可能有以下狀態：
+ `PENDING` – 將作業執行提交至 Amazon EMR on EKS 時的初始作業狀態。作業正在等待提交至虛擬叢集，而 Amazon EMR on EKS 正在提交此作業。
+ `SUBMITTED` – 已成功提交至虛擬叢集的作業執行。然後，叢集排程器會嘗試在叢集上執行此作業。
+ `RUNNING` – 在虛擬叢集中執行的作業執行。在 Spark 應用程式中，這意味著 Spark 驅動程式進程處於 `running` 狀態。
+ `FAILED` – 無法提交至虛擬叢集或未成功完成的作業執行。查看 StateDetails 和 FailureReason，以尋找有關此作業失敗的其他資訊。
+ `COMPLETED` – 已成功完成的作業執行。
+ `CANCEL_PENDING` – 已請求取消的作業執行。Amazon EMR on EKS 正在嘗試取消虛擬叢集上的作業。
+ `CANCELLED` – 已成功取消的作業執行。

# 在 Amazon EMR 主控台中檢視作業
<a name="emr-eks-jobs-console"></a>

任務執行資料可供檢視，因此您可以在每個任務通過狀態時對其進行監控。若要在 Amazon EMR 主控台中檢視作業，請執行以下步驟。

1. 在 Amazon EMR 主控台左側功能表中，在 Amazon EMR on EKS 下，選擇**虛擬叢集**。

1. 從虛擬叢集清單中，選取要檢視其作業的虛擬叢集。

1. 在**作業執行**資料表中，選取**檢視日誌**以檢視作業執行的詳細資訊。

**注意**  
預設啟用對單鍵體驗的支援 在作業提交期間，在 `monitoringConfiguration` 中將 `persistentAppUI` 設定為 `DISABLED` 可關閉此功能。如需詳細資訊，請參閱[檢視持續應用程式使用者界面](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html)。

# 執行作業時的常見錯誤
<a name="emr-eks-jobs-error"></a>

執行 `StartJobRun` API 時，可能會發生下列錯誤。資料表會列出每個錯誤並提供緩解步驟，讓您可以快速解決問題。


| 錯誤訊息 | 錯誤情況 | 建議的後續步驟 | 
| --- | --- | --- | 
|  error: argument --*argument* is required  | 缺少必要參數。 | 將缺少的引數新增到 API 請求。 | 
| 呼叫 StartJobRun 操作時發生錯誤 (AccessDeniedException)：User: ARN is not authorized to perform: emr-containers:StartJobRun | 缺少執行角色。 | 請參閱「使用 [搭配使用作業執行角色與 Amazon EMR on EKS](iam-execution-role.md)」。 | 
|  呼叫 StartJobRun 操作時發生錯誤 (AccessDeniedException)：User: *ARN* is not authorized to perform: emr-containers:StartJobRun  |  呼叫者沒有透過條件金鑰存取執行角色的許可 [有效/無效格式]。  | 請參閱 [搭配使用作業執行角色與 Amazon EMR on EKS](iam-execution-role.md)。 | 
|  呼叫 StartJobRun 操作時發生錯誤 (AccessDeniedException)：User: *ARN* is not authorized to perform: emr-containers:StartJobRun  |  作業提交者和執行角色 ARN 來自不同的帳戶。  | 確定作業提交者和執行角色 ARN 來自相同的 AWS 帳戶。 | 
|  偵測到 1 個驗證錯誤：'executionRoleArn' 的*角色*值無法滿足 ARN 規則表達式模式：^arn:(aws[a-zA-Z0-9-]\$1):iam::(\$1d\$112\$1)?:(role((\$1u002F)\$1(\$1u002F[\$1u0021-\$1u007F]\$1\$1u002F))[\$1w\$1=,.@-]\$1)  |  呼叫者透過條件金鑰擁有執行角色的許可，但角色不符合 ARN 格式的限制。  | 提供遵循 ARN 格式的執行角色。請參閱 [搭配使用作業執行角色與 Amazon EMR on EKS](iam-execution-role.md)。 | 
|  呼叫 StartJobRun 操作時發生錯誤 (ResourceNotFoundException)：虛擬叢集 *Virtual Cluster ID* 不存在。  |  找不到虛擬叢集 ID。  | 提供向 Amazon EMR on EKS 註冊的虛擬叢集 ID。 | 
|  呼叫 StartJobRun 操作時發生錯誤 (ValidationException)：虛擬叢集 *state* 無效，無法建立資源 JobRun。  |  虛擬叢集尚未準備好執行作業。  | 請參閱 [虛擬叢集狀態](virtual-cluster.md#virtual-cluster-states)。 | 
|  呼叫 StartJobRun 操作時發生錯誤 (ResourceNotFoundException)：版本 *RELEASE* 不存在。  |  作業提交中指定的版本不正確。  | 請參閱 [Amazon EMR on EKS 發行版本](emr-eks-releases.md)。 | 
|  呼叫 StartJobRun 操作時發生錯誤 (AccessDeniedException)：User: *ARN* is not authorized to perform: emr-containers:StartJobRun on resource: *ARN* with an explicit deny。 呼叫 StartJobRun 操作時發生錯誤 (AccessDeniedException)：User: *ARN* is not authorized to perform: emr-containers:StartJobRun on resource: *ARN*  | 未授權使用者呼叫 StartJobRun。 | 請參閱 [搭配使用作業執行角色與 Amazon EMR on EKS](iam-execution-role.md)。 | 
|  呼叫 StartJobRun 操作時發生錯誤 (ValidationException)：configurationOverrides.monitoringConfiguration.s3MonitoringConfiguration.logUri failed to satisfy constraint : %s  |  S3 路徑 URI 語法無效。  | logUri 應採用 s3://... 的格式  | 

在作業執行之前執行 `DescribeJobRun` API 時，可能會發生下列錯誤。


| 錯誤訊息 | 錯誤情況 | 建議的後續步驟 | 
| --- | --- | --- | 
|  狀態詳細資訊：JobRun 提交失敗。 不支援 *classification* 分類。 失敗原因：VALIDATION\$1ERROR 狀態：FAILED。  | StartJobRun 中的參數無效。 | 請參閱 [Amazon EMR on EKS 發行版本](emr-eks-releases.md)。 | 
|  狀態詳細資訊：叢集 *EKS Cluster ID* 不存在。 失敗原因：CLUSTER\$1UNAVAILABLE 狀態：FAILED  | EKS 叢集無法使用。 | 檢查 EKS 叢集是否存在並具有正確的許可。如需詳細資訊，請參閱[設定 Amazon EMR on EKS](setting-up.md)。 | 
|  狀態詳細資訊：叢集 *EKS Cluster ID* 沒有足夠的許可。 失敗原因：CLUSTER\$1UNAVAILABLE 狀態：FAILED  |  Amazon EMR 沒有存取 EKS 叢集的許可。  | 確認已在註冊的命名空間中為 Amazon EMR 設定許可。如需詳細資訊，請參閱[設定 Amazon EMR on EKS](setting-up.md)。 | 
|  狀態詳細資訊：叢集 *EKS Cluster ID* 目前無法連線。 失敗原因：CLUSTER\$1UNAVAILABLE 狀態：FAILED  |  無法連線到 EKS 叢集。  | 檢查 EKS 叢集是否存在並具有正確的許可。如需詳細資訊，請參閱[設定 Amazon EMR on EKS](setting-up.md)。 | 
|  狀態詳細資訊：由於內部錯誤，JobRun 提交失敗。 失敗原因：INTERNAL\$1ERROR 狀態：FAILED  |  EKS 叢集發生內部錯誤。  | N/A | 
|  狀態詳細資訊：叢集 *EKS Cluster ID* 沒有足夠的資源。 失敗原因：USER\$1ERROR 狀態：FAILED  |  EKS 叢集中的資源不足，無法執行作業。  | 為 EKS 節點群組新增更多容量，或設定 EKS Autoscaler。如需詳細資訊，請參閱 [Cluster Autoscaler](https://docs.aws.amazon.com/eks/latest/userguide/cluster-autoscaler.html)。 | 

在作業執行之後執行 `DescribeJobRun` API 時，可能會發生下列錯誤。


| 錯誤訊息 | 錯誤情況 | 建議的後續步驟 | 
| --- | --- | --- | 
|  狀態詳細資訊：監控 JobRun 時出現問題。 叢集 *EKS Cluster ID* 不存在。 失敗原因：CLUSTER\$1UNAVAILABLE 狀態：FAILED  | EKS 叢集不存在。 | 檢查 EKS 叢集是否存在並具有正確的許可。如需詳細資訊，請參閱[設定 Amazon EMR on EKS](setting-up.md)。 | 
|  狀態詳細資訊：監控 JobRun 時出現問題。 叢集 *EKS Cluster ID* 沒有足夠的許可。 失敗原因：CLUSTER\$1UNAVAILABLE 狀態：FAILED  | Amazon EMR 沒有存取 EKS 叢集的許可。 | 確認已在註冊的命名空間中為 Amazon EMR 設定許可。如需詳細資訊，請參閱[設定 Amazon EMR on EKS](setting-up.md)。 | 
|  狀態詳細資訊：監控 JobRun 時出現問題。 叢集 *EKS Cluster ID* 目前無法連線。 失敗原因：CLUSTER\$1UNAVAILABLE 狀態：FAILED  |  無法連線到 EKS 叢集。  | 檢查 EKS 叢集是否存在並具有正確的許可。如需詳細資訊，請參閱[設定 Amazon EMR on EKS](setting-up.md)。 | 
|  狀態詳細資訊：由於內部錯誤，無法監控 JobRun 失敗原因：INTERNAL\$1ERROR 狀態：FAILED  |  發生內部錯誤，正在阻止 JobRun 監控。  | N/A | 

當作業無法啟動且作業處於 SUBMITTED 狀態 15 分鐘時，可能會發生下列錯誤。這可能是由於缺少叢集資源所致。


| 錯誤訊息 | 錯誤情況 | 建議的後續步驟 | 
| --- | --- | --- | 
|  叢集逾時  | 作業已處於 SUBMITTED 狀態 15 分鐘或更長時間。 | 可以使用如下所示的組態來覆寫此參數的 15 分鐘預設設定。 | 

使用下列組態將叢集逾時設定變更為 30 分鐘。請注意，提供的新 `job-start-timeout` 值的單位應為秒：

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

# 使用作業範本
<a name="job-templates"></a>

作業範本會儲存在開始作業執行時可跨 `StartJobRun` API 調用來共用的值。它支援兩種使用案例：
+ 防止重複出現 `StartJobRun` API 請求值。
+ 強制執行必須透過 `StartJobRun` API 請求提供特定值的規則。

作業範本可讓您為作業執行定義可重複使用的範本，以套用其他自訂項目，例如：
+ 設定執行程式和驅動程式運算容量
+ 設定安全性和控管屬性，例如 IAM 角色
+ 自訂要跨多個應用程式和資料管道使用的 Docker 映像檔

下列主題提供使用 範本的詳細資訊，包括如何使用它們來啟動任務執行，以及如何變更範本參數。

**Topics**
+ [建立並使用任務範本來啟動任務執行](create-job-template.md)
+ [定義作業範本參數](use-job-template-parameters.md)
+ [控制對作業範本的存取](iam-job-template.md)

# 建立並使用任務範本來啟動任務執行
<a name="create-job-template"></a>

本節說明建立任務範本，並使用 範本以 AWS Command Line Interface () 開始任務執行AWS CLI。

**建立作業範本**

1. 建立 `create-job-template-request.json` 檔案並指定作業範本所需的參數，如下列範例 JSON 檔案所示。如需所有可用參數的資訊，請參閱 [CreateJobTemplate](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/Welcome.html) API。

   `StartJobRun` API 所需的大多數值也是 `jobTemplateData` 所必需的。如果您想在使用作業範本調用 StartJobRun 時為任何參數使用預留位置並提供值，請參閱作業範本參數的下一節。

   ```
   {
      "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. 搭配使用 `create-job-template` 命令與儲存在本機的 `create-job-template-request.json` 檔案路徑。

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

**使用作業範本來啟動作業執行**

在 `StartJobRun` 命令中提供虛擬叢集 ID、作業範本 ID 以及作業名稱，如以下範例所示。

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

# 定義作業範本參數
<a name="use-job-template-parameters"></a>

作業範本參數可讓您指定作業範本中的變數。使用該作業範本啟動作業執行時，需要指定這些參數變數的值。作業範本參數會以 `${parameterName}` 格式指定。可以選擇將 `jobTemplateData` 欄位中的任何值指定為作業範本參數。針對每個作業範本參數變數，請指定其資料類型 (`STRING` 或 `NUMBER`)，並選擇性地指定預設值。以下範例顯示如何為進入點位置、主類別和 S3 日誌位置值指定作業範本參數。

**將進入點位置、主類別和 Amazon S3 日誌位置指定為作業範本參數**

1. 建立 `create-job-template-request.json` 檔案並指定作業範本所需的參數，如下列範例 JSON 檔案所示。如需有關參數的詳細資訊，請參閱 [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. 搭配使用 `create-job-template` 命令與儲存在本機或 Amazon S3 中的 `create-job-template-request.json` 檔案路徑。

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

**使用具有作業範本參數的作業範本開始作業執行**

若要使用包含作業範本參數的作業範本開始作業執行，請在 `StartJobRun` API 請求中指定作業範本 ID 以及作業範本參數值，如下所示。

```
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/"}'
```

# 控制對作業範本的存取
<a name="iam-job-template"></a>

`StartJobRun` 政策可讓您強制使用者或角色只能使用您指定的作業範本來執行作業，而且如果不使用指定的作業範本，就無法執行 `StartJobRun` 操作。為此，首先確保為使用者或角色授予對指定作業範本的讀取許可，如下所示。

------
#### [ 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"
    }
  ]
}
```

------

若要強制使用者或角色只能在使用指定的作業範本時調用 `StartJobRun` 操作，可將下列 `StartJobRun` 政策許可指派給指定的使用者或角色。

------
#### [ 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"
    }
  ]
}
```

------

如果作業範本在執行角色 ARN 欄位中指定作業範本參數，則使用者將能夠提供此參數的值，因此可以使用任意執行角色來調用 `StartJobRun`。若要限制使用者可以提供的執行角色，請參閱 [搭配使用作業執行角色與 Amazon EMR on EKS](iam-execution-role.md) 中的**控制對執行角色的存取**。

如果上述 `StartJobRun` 動作政策中未針對指定的使用者或角色指定任何條件，則將允許使用者或角色使用他們具有讀取權限的任意作業範本或使用任意執行角色，在指定虛擬叢集上調用 `StartJobRun` 動作。

# 使用 Pod 範本
<a name="pod-templates"></a>

從 Amazon EMR 5.33.0 或 6.3.0 版開始，Amazon EMR on EKS 支援 Spark 的 Pod 範本功能。Pod 是一個或多個容器群組，其中包含共用儲存和網路資源，以及如何執行容器的規範。Pod 範本是決定如何執行每個 Pod 的規範。可以使用 Pod 範本檔案來定義 Spark 組態不支援的驅動程式或執行程式 Pod 組態。如需有關 Spark 的 Pod 範本功能的詳細資訊，請參閱 [Pod 範本](https://spark.apache.org/docs/latest/running-on-kubernetes.html#pod-template)。

**注意**  
Pod 範本功能僅適用於驅動程式和執行程式 Pod。您無法使用 Pod 範本設定任務提交者 Pod。

## 常用案例
<a name="pod-template-use-cases"></a>

透過搭配使用 Pod 範本與 Amazon EMR on EKS，可定義如何在共用的 EKS 叢集上執行 Spark 作業，並節省成本及改善資源使用率和效能。
+ 為了降低成本，可以排程 Spark 驅動程式任務在 Amazon EC2 隨需執行個體上執行，同時排程 Spark 執行程式任務在 Amazon EC2 Spot 執行個體上執行。
+ 若要提高資源使用率，您可以支援多個團隊在相同 EKS 叢集上執行其工作負載。每個團隊都會獲得一個指定的 Amazon EC2 節點群組，以便在其中執行工作負載。可以使用 Pod 範本，將對應的容差套用至其工作負載。
+ 若要改善監控，可以執行單獨的日誌容器，將日誌轉寄至現有的監控應用程式。

例如，下列 Pod 範本檔案示範常見的使用案例。

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

Pod 範本會完成下列任務：
+ 新增一個在 Spark 主容器啟動之前執行的[初始化容器](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/)。初始化容器與 Spark 主容器共用稱為 `source-data-volume` 的 [EmptyDir 磁碟區](https://kubernetes.io/docs/concepts/storage/volumes/#emptydir)。可以讓初始化容器執行初始化步驟，例如下載相依性或產生輸入資料。然後，Spark 主容器會消耗資料。
+ 新增與 Spark 主容器一起執行的另一個[附屬容器](https://kubernetes.io/docs/concepts/workloads/pods/#how-pods-manage-multiple-containers)。這兩個容器正在共用另一個稱為的 `metrics-files-volume` 的 `EmptyDir` 磁碟區。您的 Spark 作業可以產生指標，例如 Prometheus 指標。然後，Spark 作業可以將指標放入檔案中，並讓附屬容器將檔案上傳到您自己的 BI 系統，以供將來分析。
+ 將新環境變數新增至 Spark 主容器。可以讓作業消耗環境變數。
+ 定義[節點選取器](https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/)，以便僅在 `emr-containers-nodegroup` 節點群組上排程 Pod。這有助於隔離作業和團隊的運算資源。

## 使用 Amazon EMR on EKS 啟用 Pod 範本
<a name="use-pod-templates"></a>

若要使用 Amazon EMR on EKS 啟用 Pod 範本功能，請設定 Spark 屬性 `spark.kubernetes.driver.podTemplateFile` 和 `spark.kubernetes.executor.podTemplateFile`，以指向 Amazon S3 中的 Pod 範本檔案。然後，Spark 會下載 Pod 範本檔案，並使用它來建構驅動程式和執行程式 Pod。

**注意**  
Spark 使用作業執行角色來載入 Pod 範本，因此作業執行角色必須有權存取 Amazon S3 以載入 Pod 範本。如需詳細資訊，請參閱[建立作業執行角色](creating-job-execution-role.md)。

您可以使用 `SparkSubmitParameters` 來指定 Pod 範本的 Amazon S3 路徑，如下列作業執行 JSON 檔案所示。

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

或者，可以使用 `configurationOverrides` 來指定 Pod 範本的 Amazon S3 路徑，如下列作業執行 JSON 檔案所示。

```
{
  "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"
         }
      }
    ]
  }
}
```

**注意**  
搭配使用 Pod 範本功能與 Amazon EMR on EKS 時，需要遵循安全準則，例如隔離不受信任的應用程式碼。如需詳細資訊，請參閱[Amazon EMR on EKS 安全最佳實務](security-best-practices.md)。
無法使用 `spark.kubernetes.driver.podTemplateContainerName` 和 `spark.kubernetes.executor.podTemplateContainerName` 來變更 Spark 主容器名稱 ，因為這些名稱硬編碼為 `spark-kubernetes-driver` 和 `spark-kubernetes-executors`。如果想要自訂 Spark 主容器，則必須使用這些硬編碼名稱在 Pod 範本中指定容器。

## Pod 範本欄位
<a name="pod-templates-fields"></a>

使用 Amazon EMR on EKS 設定 Pod 範本時，請考慮下列欄位限制。
+ Amazon EMR on EKS 僅允許 Pod 範本中的下列欄位啟用適當的作業排程。

  以下是允許的 Pod 層級欄位：
  + `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`

  以下是允許的 Spark 主容器層級欄位：
  + `env`
  + `envFrom`
  + `name`
  + `lifecycle`
  + `livenessProbe`
  + `readinessProbe`
  + `resources`
  + `startupProbe`
  + `stdin`
  + `stdinOnce`
  + `terminationMessagePath`
  + `terminationMessagePolicy`
  + `tty`
  + `volumeDevices`
  + `volumeMounts`
  + `workingDir`

  當您在 Pod 範本中使用任何不允許的欄位時，Spark 會擲出例外狀況，且作業失敗。下列範例會顯示 Spark 控制器日誌中的錯誤訊息，因為存在不允許的欄位。

  ```
  Executor pod template validation failed.
  Field container.command in Spark main container not allowed but specified.
  ```
+  Amazon EMR on EKS 會在 Pod 範本中預先定義下列參數。在 Pod 範本中指定的欄位不得與這些欄位重疊。

  以下是預先定義的磁碟區名稱：
  + `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`

  以下是僅適用於 Spark 主容器的預定義磁碟區掛載：
  + 名稱：`emr-container-communicate`；掛載路徑：`/var/log/fluentd`
  + 名稱：`emr-container-application-log-dir`；掛載路徑：`/var/log/spark/user`
  + 名稱：`emr-container-event-log-dir`；掛載路徑：`/var/log/spark/apps`
  + 名稱：`mnt-dir`；掛載路徑：`/mnt`
  + 名稱：`temp-data-dir`；掛載路徑：`/tmp`
  + 名稱：`home-dir`；掛載路徑：`/home/hadoop`

  這些是僅適用於 Spark 主容器的預定義環境變數：
  + `SPARK_CONTAINER_ID`
  + `K8S_SPARK_LOG_URL_STDERR`
  + `K8S_SPARK_LOG_URL_STDOUT`
  + `SIDECAR_SIGNAL_FILE`
**注意**  
您仍然可以使用這些預先定義的磁碟區，並將其掛載至額外的附屬容器中。例如，您可以使用 `emr-container-application-log-dir` 並將其掛接到 Pod 範本中定義的您自己的附屬容器。

  如果您指定的欄位與 Pod 範本中的任何預定義欄位衝突，Spark 會擲出例外狀況，而作業會失敗。下列範例會顯示 Spark 應用程式日誌中的錯誤訊息，因為與預定義的欄位衝突。

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

## 附屬容器的考量
<a name="pod-template-sidecar"></a>

Amazon EMR 控制由 Amazon EMR on EKS 佈建的 Pod 的生命週期。附屬容器應遵循 Spark 主容器的相同生命週期。如果將額外的附屬容器插入至 Pod，建議與 Amazon EMR 定義的 Pod 生命週期管理整合，以便 Spark 主容器結束時，附屬容器可以自行停止。

為了降低成本，建議您實施一個程序，以防止具有附屬容器的驅動程式 Pod 在作業完成後繼續執行。當執行程式完成時，Spark 驅動程式會刪除執行程式 Pod。但是，當驅動程式完成時，其他附屬容器會繼續執行。Pod 會計費，直到 Amazon EMR on EKS 清理驅動程式 Pod 為止，通常在驅動程式 Spark 主容器完成後不到一分鐘。為了降低成本，可以將其他附屬容器與 Amazon EMR on EKS 為驅動程式和執行程式 Pod 定義的生命週期管理機制整合，如下節所述。

驅動程式和執行程式 Pod 中的 Spark 主容器每兩秒向檔案 `/var/log/fluentd/main-container-terminated` 傳送一次 `heartbeat`。透過將 Amazon EMR 預先定義的 `emr-container-communicate` 磁碟區掛載新增至附屬容器，可以定義附屬容器的子流程，以定期追蹤此檔案的上次修改時間。然後，如果子流程發現 Spark 主容器長時間停止 `heartbeat`，則子流程會自行停止。

下列範例示範追蹤活動訊號檔案並自行停止的子流程。將 *your\$1volume\$1mount* 取代為掛載預定義磁碟區的路徑。指令碼綁定在附屬容器使用的映像內。在 Pod 範本檔案中，可以使用下列命令 `sub_process_script.sh` 和 `main_command` 來指定附屬容器。

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

# 使用作業重試政策
<a name="jobruns-using-retry-policies"></a>

在 Amazon EMR on EKS 6.9.0 版及更新版本中，可為作業執行設定重試政策。重試政策會導致作業驅動程式 Pod 在失敗或遭到刪除時自動重新啟動。這讓長時間執行的 Spark 串流作業對故障更具彈性。

## 設定作業的重試政策
<a name="setting-retry-policy"></a>

若要設定重試政策，可以使用 [StartJobRun](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html) API 提供 `RetryPolicyConfiguration` 欄位。`retryPolicyConfiguration` 範例如下所示：

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

**注意**  
`retryPolicyConfiguration` 僅適用於 AWS CLI 1.27.68 之後的版本。若要將 更新 AWS CLI 至最新版本，請參閱[安裝或更新最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)

將 `maxAttempts` 欄位設定為您希望作業驅動程式 Pod 在失敗或遭到刪除時重新啟動的次數上限。兩次作業驅動程式重試嘗試之間的執行間隔為指數重試間隔 (10 秒、20 秒、40 秒...)，上限為 6 分鐘，如 [Kubernetes](https://kubernetes.io/docs/concepts/workloads/controllers/job/#pod-backoff-failure-policy) 文件所述。

**注意**  
每個額外的作業驅動程式執行將按照另一個作業執行計費，且將受到 [Amazon EMR on EKS](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS) 定價的約束。

### 重試政策組態值
<a name="retry-config"></a>
+ **作業的預設重試政策：**根據預設，`StartJobRun` 包含設定為最多 1 次的重試政策。可以視需要設定重試政策。
**注意**  
如果 `retryPolicyConfiguration` 的 `maxAttempts` 設定為 1，則表示在失敗時不會進行重試來啟動驅動程式 Pod。
+ **停用作業的重試政策：**若要停用重試政策，請將 retryPolicyConfiguration 中的嘗試次數上限設為 1。

  ```
  "retryPolicyConfiguration": {
      "maxAttempts": 1
  }
  ```
+ **將作業的 maxAttempts 設定在有效範圍內：**如果 `maxAttempts` 值超出有效範圍，`StartJobRun` 呼叫將失敗。有效 `maxAttempts` 範圍介於 1 到 2,147,483,647 (32 位元整數) 之間，這是 Kubernetes 的 `backOffLimit` 組態設定所支援的範圍。如需詳細資訊，請參閱 Kubernetes 文件的 [Pod 退避失敗政策](https://kubernetes.io/docs/concepts/workloads/controllers/job/#pod-backoff-failure-policy)。如果 `maxAttempts` 值無效，則會傳回下列錯誤訊息：

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

## 擷取作業的重試政策狀態
<a name="retrieve-policy"></a>

可以使用 [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) 和 [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) API 檢視作業的重試嘗試狀態。一旦請求具有已啟用重試政策組態的作業，`ListJobRun` 和 `DescribeJobRun` 回應就會在 `RetryPolicyExecution` 欄位中包含重試政策的狀態。此外，`DescribeJobRun` 回應將包含在作業的 `StartJobRun` 請求中輸入的 `RetryPolicyConfiguration`。

**回應範例**

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

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

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

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

------

在作業中停用重試政策後，將不會顯示這些欄位，如下面的 [重試政策組態值](#retry-config) 中所述。

## 使用重試政策監控作業
<a name="monitoring-retry"></a>

啟用重試政策時，會為建立的每個作業驅動程式產生 CloudWatch 事件。若要訂閱這些事件，請使用下列命令設定 CloudWatch 事件規則：

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

此事件將傳回作業驅動程式的 `newDriverPodName`、`newDriverCreatedAt` 時間戳記、`previousDriverFailureMessage` 和 `currentAttemptCount` 的相關資訊。如果停用重試政策，將不會建立這些事件。

如需有關如何使用 CloudWatch 事件監控作業的詳細資訊，請參閱 [使用 Amazon CloudWatch Events 監控作業](monitoring.md#monitoring-cloudwatch-events)。

## 尋找驅動程式和執行程式的日誌
<a name="finding-logs"></a>

驅動程式 Pod 名稱遵循 `spark-<job id>-driver-<random-suffix>` 格式。相同的 `random-suffix` 會新增至驅動程式產生的執行程式 Pod 名稱。使用此 `random-suffix` 時，可尋找驅動程式及其關聯執行程式的日誌。只有在為作業[啟用重試政策](#retry-config)時，才會顯示 `random-suffix`；否則，`random-suffix` 就不存在。

如需有關如何使用日誌的監控組態來設定作業的詳細資訊，請參閱 [執行 Spark 應用程式](getting-started.md#getting-started-run-spark-app)。

# 使用 Spark 事件日誌輪換
<a name="emr-eks-log-rotation"></a>

使用 Amazon EMR 6.3.0 及更高版本，可以為 Amazon EMR on EKS 開啟 Spark 事件日誌輪換功能。此功能不會產生單一事件日誌檔案，而是會根據您設定的時間間隔來輪換檔案，並移除最舊的事件日誌檔案。

輪換 Spark 事件日誌可協助您避免長時間執行或串流作業所產生的大型 Spark 事件日誌檔案可能發生的問題。例如，使用透過 `persistentAppUI` 參數啟用的事件日誌來開始長時間執行的 Spark 作業。Spark 驅動程式會產生事件日誌檔案。如果作業執行數小時或數天，且 Kubernetes 節點上的磁碟空間有限，則事件日誌檔案可能會耗用所有可用的磁碟空間。開啟 Spark 事件日誌輪換功能可解決此問題，方法是將日誌檔案分割為多個檔案並移除最舊的檔案。

**注意**  
此功能僅適用於 Amazon EMR on EKS。在 Amazon EC2 執行的 Amazon EMR 不支援 Spark 事件日誌輪換。

若要開啟 Spark 事件日誌輪換功能，請設定下列 Spark 參數：
+ `spark.eventLog.rotation.enabled`‐開啟日誌輪換。依預設，它在 Spark 組態檔案中被停用。設定為 true 可開啟此功能。
+ `spark.eventLog.rotation.interval`‐指定日誌輪換的時間間隔。最小值為 60 秒。預設值為 300 秒。
+ `spark.eventLog.rotation.minFileSize`‐指定最小檔案大小以輪換日誌檔案。最小且預設值為 1 MB。
+ `spark.eventLog.rotation.maxFilesToRetain`‐指定在清理期間要保留多少個已輪換的日誌檔案。有效範圍為 1 到 10。預設值為 2。

可以在 [`StartJobRun`](emr-eks-jobs-submit.md) API 的 `sparkSubmitParameters` 區段中指定這些參數，如下列範例所示。

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

# 使用 Spark 容器日誌輪換
<a name="emr-eks-log-rotation-container"></a>

使用 Amazon EMR 6.11.0 及更高版本，可以為 Amazon EMR on EKS 開啟 Spark 容器日誌輪換功能。此功能不會產生單一 `stdout` 或 `stderr` 日誌檔案，而是會根據您設定的輪換大小來輪換檔案，並從容器中移除最舊的日誌檔案。

輪換 Spark 容器日誌可協助您避免長時間執行或串流作業所產生的大型 Spark 日誌檔案可能發生的問題。例如，可以啟動長時間執行的 Spark 作業，而 Spark 驅動程式會產生容器日誌檔案。如果作業執行數小時或數天，且 Kubernetes 節點上的磁碟空間有限，則容器日誌檔案可能會耗用所有可用的磁碟空間。當您開啟 Spark 容器日誌輪換時，您會將日誌檔案分割成多個檔案，然後移除最舊的檔案。

若要開啟 Spark 容器日誌輪換功能，請設定下列 Spark 參數：

**`containerLogRotationConfiguration`**  
在 `monitoringConfiguration` 中包含此參數以開啟日誌輪換。預設為停用。除了 `s3MonitoringConfiguration` 之外，還必須使用 `containerLogRotationConfiguration`。

**`rotationSize`**  
`rotationSize` 參數指定日誌輪換的檔案大小。可能的值範圍為 `2KB` 至 `2GB`。`rotationSize` 參數的數值單位部分會以整數形式傳遞。由於不支援小數值，因此可以使用值 `1500MB` 來指定 1.5GB 的輪換大小。

**`maxFilesToKeep`**  
`maxFilesToKeep` 參數會指定輪換發生後，要在容器中保留的檔案數上限。下限值是 1，上限值是 50。

可以在 `StartJobRun` API 的 `monitoringConfiguration` 區段中指定這些參數，如下列範例所示。在此範例中，使用 `rotationSize = "10 MB"` 和 `maxFilesToKeep = 3`，Amazon EMR on EKS 在 10 MB 時輪換日誌，產生新的日誌檔案，然後在日誌檔案數量達到 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"
      }
    }
  }
}
```

若要使用 Spark 容器日誌輪換開始執行作業，請在 [`StartJobRun`](emr-eks-jobs-submit.md) 命令中包含使用這些參數設定的 json 檔案的路徑。

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

# 搭配使用垂直自動擴展與 Amazon EMR Spark 作業
<a name="jobruns-vas"></a>

Amazon EMR on EKS 垂直自動擴展功能會自動調整記憶體和 CPU 資源，以適應您為 Amazon EMR Spark 應用程式提供的工作負載需求。這可簡化資源管理。

為了追蹤 Amazon EMR Spark 應用程式的即時和歷史資源使用情況，垂直自動擴展功能可利用 Kubernetes [Vertical Pod Autoscaler (VPA)](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler)。垂直自動擴展功能使用 VPA 收集的資料，自動調整指派給 Spark 應用程式的記憶體和 CPU 資源。這種簡化流程可提高可靠性並優化成本。

**Topics**
+ [設定](jobruns-vas-setup.md)
+ [開始使用](jobruns-vas-gs.md)
+ [Configuration](jobruns-vas-configure.md)
+ [監控建議](jobruns-vas-monitor.md)
+ [解除安裝](jobruns-vas-uninstall-operator.md)

# 設定 Amazon EMR on EKS 的垂直自動擴展
<a name="jobruns-vas-setup"></a>

本主題可協助您讓 Amazon EKS 叢集準備好提交具有垂直自動擴展功能的 Amazon EMR Spark 作業。設定程序會要求您確認或完成下列各章節中的任務：

**Topics**
+ [先決條件](#jobruns-vas-prereqs)
+ [在 Amazon EKS 叢集上安裝 Operator Lifecycle Manager (OLM)](#jobruns-vas-install-olm)
+ [安裝 Amazon EMR on EKS 垂直自動擴展運算子](#jobruns-vas-install-operator)

## 先決條件
<a name="jobruns-vas-prereqs"></a>

在叢集上安裝可垂直自動擴展的 Kubernetes Operator 之前，請先完成下列任務。如果已經完成任何先決條件，則可以跳過這些先決條件，然後繼續進行下一個。
+ **[安裝或更新至最新版本的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)**- 如果您已安裝 AWS CLI，請確認您擁有最新版本。
+ **[安裝 kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)** – kubectl 是一種命令列工具，可用來與 Kubernetes API 伺服器進行通訊。您需要 kubectl 才能在 Amazon EKS 叢集上安裝和監控垂直自動擴展相關成品。
+ **[安裝 Operator SDK](https://sdk.operatorframework.io/docs/installation/)** – Amazon EMR on EKS 使用 Operator SDK 作為您在叢集上安裝的垂直自動擴展運算子使用壽命的套件管理工具。
+ **[安裝 Docker](https://docs.docker.com/get-docker/)** – 您需要存取 Docker CLI 來驗證和擷取要安裝在 Amazon EKS 叢集上的垂直自動擴展相關 Docker 映像檔。
+ **[安裝 Kubernetes 指標伺服器](https://docs.aws.amazon.com/eks/latest/userguide/metrics-server.html)** – 您必須先安裝指標伺服器，垂直 Pod 自動擴展器才能從 Kubernetes API 伺服器擷取指標。
+ **[開始使用 Amazon EKS – eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) (1.24 版或更新版本）** – Amazon EKS 1.24 版及更高版本支援垂直自動擴展。建立叢集後，[請進行註冊以與 Amazon EMR 搭配使用](setting-up-registration.md)。
+ **[選擇 Amazon EMR 基礎映像 URI](docker-custom-images-tag.md) (6.10.0 版或更高版本)** - Amazon EMR 6.10.0 版及更高版本支援垂直自動擴展。

## 在 Amazon EKS 叢集上安裝 Operator Lifecycle Manager (OLM)
<a name="jobruns-vas-install-olm"></a>

使用 Operator SDK CLI 在想要設定垂直自動擴展的 Amazon EMR on EKS 叢集上安裝 Operator Lifecycle Manager (OLM)，如下列範例所示。設定完成後，可以使用 OLM 來安裝和管理 [Amazon EMR 垂直自動擴展運算子的生命週期](#jobruns-vas-install-operator)。

```
operator-sdk olm install
```

若要驗證安裝，請執行 `olm status` 命令：

```
operator-sdk olm status
```

請確認命令傳回成功結果，與以下範例輸出類似：

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

如果安裝未成功，請參閱 [對 Amazon EMR on EKS 垂直自動擴展進行疑難排解](troubleshooting-vas.md)。

## 安裝 Amazon EMR on EKS 垂直自動擴展運算子
<a name="jobruns-vas-install-operator"></a>

使用下列步驟在 Amazon EKS 叢集上安裝垂直自動擴展運算子：

1. 設定下列將用於完成安裝的環境變數：
   + **`$REGION`** 指向叢集的 AWS 區域 。例如 `us-west-2`。
   + **`$ACCOUNT_ID`** 指向您所在區域的 Amazon ECR 帳戶 ID。如需詳細資訊，請參閱[按區域劃分的 Amazon ECR 登錄檔帳戶](docker-custom-images-tag.md#docker-custom-images-ECR)。
   + **`$RELEASE`** 指向要用於叢集的 Amazon EMR 版本。對於垂直自動擴展，必須使用 Amazon EMR 6.10.0 或更高版本。

1. 接下來，取得運算子的 [Amazon ECR 登錄檔](docker-custom-images-tag.md#docker-custom-images-ECR)驗證字符。

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

1. 使用下列命令安裝 Amazon EMR on EKS 垂直自動擴展運算子：

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

   這會在 Amazon EKS 叢集的預設命名空間中建立垂直自動擴展運算子的版本。使用此命令在不同的命名空間中安裝：

   ```
   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
   ```
**注意**  
如果指定的命名空間不存在，則 OLM 將不會安裝運算子。如需詳細資訊，請參閱[找不到 Kubernetes 命名空間](troubleshooting-vas.md)。

1. 確認已使用 kubectl Kubernetes 命令列工具成功安裝 Operator。

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

   `kubectl` 命令應傳回新部署的垂直自動擴展器 Operator，其**階段**狀態為**已成功**。如果遇到安裝或設定問題，請參閱 [對 Amazon EMR on EKS 垂直自動擴展進行疑難排解](troubleshooting-vas.md)。

# Amazon EMR on EKS 垂直自動擴展入門
<a name="jobruns-vas-gs"></a>

如果您想要自動調校記憶體和 CPU 資源以適應 Amazon EMR Spark 應用程式工作負載，請使用 Amazon EMR on EKS 的垂直自動調整規模。如需詳細資訊，請參閱[搭配 Amazon EMR Spark 任務使用垂直自動擴展](jobruns-vas.html)。

## 使用垂直自動擴展功能提交 Spark 作業
<a name="jobruns-vas-spark-submit"></a>

透過 [StartJobRun](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html) API 提交作業時，請將下列兩個組態新增至驅動程式，以便 Spark 作業開啟垂直自動擴展：

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

在上面的代碼中，第一列啟用垂直自動擴展功能。下一列是必要的簽章組態，可讓您為作業選擇簽章。

如需這些組態和可接受參數值的詳細資訊，請參閱 [設定 Amazon EMR on EKS 的垂直自動擴展](jobruns-vas-configure.md)。依預設，您的作業在垂直自動擴展的僅監控**關閉**模式下提交。此監控狀態可讓您計算和檢視資源建議，而無需執行自動擴展。如需詳細資訊，請參閱[垂直自動擴展模式](jobruns-vas-configure.md#jobruns-vas-parameters-opt-mode)。

以下範例示範如何使用垂直自動擴展來完成範例 `start-job-run` 命令：

```
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"
        }
    }]
  }'
```

## 驗證垂直自動擴展功能
<a name="jobruns-vas-verify"></a>

若要確認垂直自動擴展適用於已提交的作業，請使用 kubectl 取得 `verticalpodautoscaler` 自訂資源並檢視您的擴展建議。例如，下列命令會查詢 [使用垂直自動擴展功能提交 Spark 作業](#jobruns-vas-spark-submit) 區段中範例作業的建議：

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

此查詢的輸出應如下所示：

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

如果您的輸出看起來不相似或包含錯誤碼，請參閱 [對 Amazon EMR on EKS 垂直自動擴展進行疑難排解](troubleshooting-vas.md) 以取得協助解決問題的步驟。

# 設定 Amazon EMR on EKS 的垂直自動擴展
<a name="jobruns-vas-configure"></a>

當您透過 [StartJobRun](https://docs.aws.amazon.com/emr-on-eks/latest/APIReference/API_StartJobRun.html) API 提交 Amazon EMR Spark 作業時，可設定垂直自動擴展。在 Spark 驅動程式 Pod 中設定自動擴展相關組態參數，如 [使用垂直自動擴展功能提交 Spark 作業](jobruns-vas-gs.md#jobruns-vas-spark-submit) 中的範例所示。

Amazon EMR on EKS 垂直自動擴展 Operator 會偵聽具有自動擴展功能的驅動程式 Pod，然後透過驅動程式 Pod 中的設定進行與 Kubernetes Vertical Pod Autoscaler (VPA) 的整合。這有助於 Spark 執行程式 Pod 的資源追蹤和自動擴展。

以下各章節描述了為 Amazon EKS 叢集設定垂直自動擴展時可以使用的參數。

**注意**  
將功能切換參數設定為標籤，並將其餘參數設定為 Spark 驅動程式 Pod 中的註釋。自動擴展參數屬於 `emr-containers.amazonaws.com/` 域，並具有 `dynamic.sizing` 字首。

## 必要參數
<a name="jobruns-vas-parameters-req"></a>

提交作業時，必須在 Spark 作業驅動程式中包含下列兩個參數：


| 金錀 | Description | 接受的值 | 預設值 | Type | Spark 參數1 | 
| --- | --- | --- | --- | --- | --- | 
|  `dynamic.sizing`  |  功能切換  |  `true`, `false`  |  未設定  |  label  |  `spark.kubernetes.driver.label.emr-containers.amazonaws.com/dynamic.sizing`  | 
|  `dynamic.sizing.signature`  |  作業簽章  |  *string*  |  未設定  |  註釋  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.signature`  | 

1 `ConfigurationOverride` 在 `StartJobRun` API 中使用此參數作為 `SparkSubmitParameter` 或 。
+ **`dynamic.sizing`** - 可以使用 `dynamic.sizing` 標籤開啟和關閉垂直自動擴展功能。若要開啟垂直自動擴展，請在 Spark 驅動程式 Pod 中將 `dynamic.sizing` 設定為 `true`。如果省略此標籤或將其設定為除 `true` 以外的任何值，垂直自動擴展功能會關閉。
+ **`dynamic.sizing.signature`** - 在驅動程式 Pod 中設定含有 `dynamic.sizing.signature` 注釋的作業簽章。垂直自動擴展可跨 Amazon EMR Spark 作業的不同執行來彙總資源使用量資料，以衍生資源建議。您可以提供唯一識別符，以便將作業繫結在一起。

  
**注意**  
如果作業以固定間隔 (例如每日或每週) 重複出現，則作業簽章對於作業的每個新執行個體都應保持不變。這可確保垂直自動擴展功能可以計算和彙總作業的不同執行中的建議。

1 `ConfigurationOverride` 在 `StartJobRun` API 中使用此參數作為 `SparkSubmitParameter` 或 。

## 選用的參數
<a name="jobruns-vas-parameters-opt"></a>

垂直自動擴展也支援下列選用參數。將它們設定為驅動程式 Pod 中的注釋。


| 金錀 | Description | 接受的值 | 預設值 | Type | Spark 參數1 | 
| --- | --- | --- | --- | --- | --- | 
|  `dynamic.sizing.mode`  |  垂直自動擴展模式  |  `Off`, `Initial`, `Auto`  |  `Off`  |  註釋  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.mode`  | 
|  `dynamic.sizing.scale.memory`  |  啟用記憶體擴展  |  *`true`, `false`*  |  `true`  |  註釋  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.memory`  | 
|  `dynamic.sizing.scale.cpu`  |  開啟或關閉 CPU 擴展  |  *`true`, `false`*  |  `false`  |  註釋  |  `spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.cpu`  | 
|  `dynamic.sizing.scale.memory.min`  |  記憶體擴展的下限  | 字串，[K8s 資源數量](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity)例如：1G |  未設定  |  註釋  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.memory.min | 
|  `dynamic.sizing.scale.memory.max`  |  記憶體擴展的上限  | 字串，[K8s 資源數量](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity)例如：4G |  未設定  |  註釋  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.memory.max | 
|  `dynamic.sizing.scale.cpu.min`  |  CPU 擴展的下限  | 字串，[K8s 資源數量](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity)例如：1 |  未設定  |  註釋  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.cpu.min | 
|  `dynamic.sizing.scale.cpu.max`  |  CPU 擴展的上限  | 字串，[K8s 資源數量](https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity)例如：2 |  未設定  |  註釋  | spark.kubernetes.driver.annotation.emr-containers.amazonaws.com/dynamic.sizing.scale.cpu.max | 

### 垂直自動擴展模式
<a name="jobruns-vas-parameters-opt-mode"></a>

`mode` 參數會映射至 VPA 支援的不同自動擴展模式。使用驅動程式 Pod 上的 `dynamic.sizing.mode` 註釋來設定模式。此參數支援下列值：
+ **關閉** – 試轉模式，您可以在該模式中監控建議，但不會執行自動擴展。這是垂直自動擴展的預設模式。在此模式中，相關聯的垂直 Pod 自動擴展器資源會計算建議，您可以透過 kubectl、Prometheus 和 Grafana 等工具監控建議。
+ **初始** - 在此模式中，如果根據作業的歷史執行 (例如週期性作業) 提供建議，則 VPA 會在作業開始時自動擴展資源。
+ **自動** - 在此模式中，VPA 會移出 Spark 執行程式 Pod，並在 Spark 驅動程式 Pod 重新啟動它們時，使用建議的資源設定來自動擴展它們。有時，VPA 會移出執行中的 Spark 執行程式 Pod，因此當它重試中斷的執行程式時，可能會導致額外的延遲。

### 資源擴展
<a name="jobruns-vas-parameters-opt-rs"></a>

當您設定垂直自動擴展時，可選擇是否擴展 CPU 和記憶體資源。將 `dynamic.sizing.scale.cpu` 和 `dynamic.sizing.scale.memory` 註釋設定為 `true` 或 `false`。根據預設，CPU 擴展設定為 `false`，記憶體擴展設定為 `true`。

### 資源最小值和最大值 (邊界)
<a name="jobruns-vas-parameters-opt-bounds"></a>

或者，也可以在 CPU 和記憶體資源上設定邊界。啟用自動擴展時，請為這些具有 `dynamic.sizing.[memory/cpu].[min/max]` 註釋的資源選擇最小值和最大值。根據預設，資源沒有限制。將註釋設定為代表 Kubernetes 資源數量的字串值。例如，將 `dynamic.sizing.memory.max` 設定為 `4G`，表示 4 GB。

# 監控 Amazon EMR on EKS 的垂直自動擴展
<a name="jobruns-vas-monitor"></a>

您可以使用 **kubectl** Kubernetes 命令列工具，列出叢集上作用中的垂直自動擴展相關建議。也可以檢視追蹤的作業簽章，並清除與簽章相關聯的任何不需要的資源。



## 列出叢集的垂直自動擴展建議
<a name="jobruns-vas-monitor-list"></a>

使用 kubectl 取得 `verticalpodautoscaler` 資源，並檢視目前的狀態和建議。下列範例查詢會傳回 Amazon EKS 叢集中的所有作用中資源。

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

此查詢的輸出如下所示：

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

## 查詢並刪除叢集的垂直自動擴展建議
<a name="jobruns-vas-monitor-query"></a>

刪除 Amazon EMR 垂直自動擴展作業執行資源時，它會自動刪除追蹤並儲存建議的關聯 VPA 物件。

下列範例使用 kubectl 來清除由簽章識別之作業的建議：

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

如果您不知道特定作業簽章，或想要清除叢集中的所有資源，則可以在命令中使用 `--all` 或 `--all-namespaces`，而非唯一的作業 ID，如下列範例所示：

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

# 解除安裝 Amazon EMR on EKS 垂直自動擴展 Operator
<a name="jobruns-vas-uninstall-operator"></a>

如果想要從 Amazon EKS 叢集中移除垂直自動擴展 Operator，請搭配使用 `cleanup` 命令與 Operator SDK CLI，如以下範例所示。這也會刪除與 Operator 一起搭配安裝的上游相依性，例如 Vertical Pod Autoscaler。

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

刪除 Operator 時，如果叢集中有任何正在執行的作業，則這些作業會繼續執行，而不會進行垂直自動擴展。如果在刪除 Operator 後在叢集中提交作業，則 Amazon EMR on EKS 將忽略您在[設定](jobruns-vas-configure.md)期間定義的任何垂直自動擴展相關參數。